Discussion :

[jmclej]

Bonjour,
J'ai le code suivant qui fonctionne bien et j'essaye de voir si c'est bien optimisé car lobj sera relativement gros :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
List<List<Object>> lobj = new ArrayList<List<Object>>();
//Remplissage de lobj depuis un fichier
...
innerObj.add(j, Double.valueOf(splitLine1[j]).doubleValue());
...
//Tri des columnes (sauf la 1ère ligne d'en-tête)
List<Double> temp = null;
for (int a = 0; a < lobj.get(0).size(); a++) {
    temp = new ArrayList<Double>(lobj.size() - 1);
    for (int b = 1; b < lobj.size(); b++) {
        temp.add(b - 1, Double.valueOf(lobj.get(b).get(a).toString()));
    }
    Collections.sort(temp);
    for (int c = 1; c < lobj.size(); c++) {
        lobj.get(c).set(a, temp.get(c - 1));//Est-ce que la mémoire de temp est désallouée quand je sors de chaque boucle "int a" ? Ou est-ce que je devrais écrire temp.get(c - 1).doubleValue() à la place ? Ou autre chose ?
    }
}

Je sais que le GC relâche les objets qui ne sont plus référencés et je ne cherche pas à l'appeler moi-même. Ma question est : est-ce que je laisse une référence à temp.get(c - 1) quand je set lobj.get(c).set(a, temp.get(c - 1) ? Parce qu'effectivement, qunad je sors de chaque loop, temp est redéfini mais cela ne veut pas dire que la mémoire allouée ne va pas être libérée par le GC si ses éléments sont encore référencés, ce que je crains que soit le cas qunad j'appelle la méthode set de la manière que je fais. Ou alors est-ce que la méthode set fait sa propre copie de temp.get(c - 1), dans quel cas en effet, temp ne sera plus référencé et automatiquement libéré par le GC.
Merci pour votre aide,

[joel.drigo]

Salut,

1. 1 à la sortie de la boucle, la dernière liste créée (celle créé par la dernière itération) sera toujours non éligible au GC, ainsi que tous les éléments qui s'y trouve. Parce que la variable est déclarée en dehors de la boucle.
2. La mémoire allouée pour une liste le reste tant que la liste elle même n'est pas libérée par le GC, donc si elle n'est pas éligible, la mémoire est toujours réservée (même si on retire les éléments ajoutés)
3. Au besoin, s'il n'y a plus assez mémoire, le GC sera déclenché pour libérer ce qu'il y a de libérable pour donner accès à la mémoire nécessaire

Un moyen d'éviter d'allouer une nouvelle liste à chaque itération :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
List<Double> temp = new ArrayList<>();
for (int a = 0; a < lobj.get(0).size(); a++) {
    ((ArrayList<?>)temp).ensureMinCapacity(lobj.size() - 1); // on agrandi au besoin la taille du tableau interne
    for (int b = 1; b < lobj.size(); b++) {
        temp.add(b - 1, Double.valueOf(lobj.get(b).get(a).toString()));
    }
    Collections.sort(temp);
    for (int c = 1; c < lobj.size(); c++) {
        lobj.get(c).set(a, temp.get(c - 1));//Est-ce que la mémoire de temp est désallouée quand je sors de chaque boucle "int a" ? Ou est-ce que je devrais écrire temp.get(c - 1).doubleValue() à la place ? Ou autre chose ?
    }
    temp.clear(); // on retire tous les éléments, ainsi la liste sera vide pour la prochaine itération
}
temp=null; // la liste devient éligible au GC

Par ailleurs, à quoi sert çà : temp.add(b - 1, Double.valueOf(lobj.get(b).get(a).toString())); ? Pourquoi ne pas écrire ça : temp.add(lobj.get(b).get(a)); ?

[jmclej]

Salut,

1. 1 à la sortie de la boucle, la dernière liste créée (celle créé par la dernière itération) sera toujours non éligible au GC, ainsi que tous les éléments qui s'y trouve. Parce que la variable est déclarée en dehors de la boucle.
2. La mémoire allouée pour une liste le reste tant que la liste elle même n'est pas libérée par le GC, donc si elle n'est pas éligible, la mémoire est toujours réservée (même si on retire les éléments ajoutés)
3. Au besoin, s'il n'y a plus assez mémoire, le GC sera déclenché pour libérer ce qu'il y a de libérable pour donner accès à la mémoire nécessaire

Un moyen d'éviter d'allouer une nouvelle liste à chaque itération :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
List<Double> temp = new ArrayList<>();
for (int a = 0; a < lobj.get(0).size(); a++) {
    ((ArrayList<?>)temp).ensureMinCapacity(lobj.size() - 1); // on agrandi au besoin la taille du tableau interne
    for (int b = 1; b < lobj.size(); b++) {
        temp.add(b - 1, Double.valueOf(lobj.get(b).get(a).toString()));
    }
    Collections.sort(temp);
    for (int c = 1; c < lobj.size(); c++) {
        lobj.get(c).set(a, temp.get(c - 1));//Est-ce que la mémoire de temp est désallouée quand je sors de chaque boucle "int a" ? Ou est-ce que je devrais écrire temp.get(c - 1).doubleValue() à la place ? Ou autre chose ?
    }
    temp.clear(); // on retire tous les éléments, ainsi la liste sera vide pour la prochaine itération
}
temp=null; // la liste devient éligible au GC

Par ailleurs, à quoi sert çà : temp.add(b - 1, Double.valueOf(lobj.get(b).get(a).toString())); ? Pourquoi ne pas écrire ça : temp.add(lobj.get(b).get(a)); ?

Merci pour le retour,
Est-ce vraiment plus rapide de faire à la main temp.clear() plutôt que de faire un new ArrayList à chaque loop? J'imagine que c'est ce que le système doit faire et sûrement de manière plus optimisé que programmatiqueemnt comme ça, non?
Quant au temp déclarer en dehors des boucles, c'était dans l'idée de faire gagner du temps en évitant de lui faire faire une déclaration à chaque boucle, mais de toute manière, vu que je faisais un new (ou un clear avec ta proposition), on ne gagne peut-être pas spécialement de temps ?
Sinon l'idée de Double.valueOf(lobj.get(b).get(a).toString()) plutôt que de faire uniquement lobj.get(b).get(a), c'est pour pouvoir trier (je peux le faire ici car je sasi que je ne prends que des données qui vont être des Double), mais je me trompe peut-être. En effet, comme lobj contient des Object (je ne peux pas spécifier Double car dans mon code complet j'ai également d'autres type de données dans ce tableau), je pensais que le tri ne s'effectuerait pas comme il faut, c'est faux ?

[joel.drigo]

Merci pour le retour,
Est-ce vraiment plus rapide de faire à la main temp.clear() plutôt que de faire un new ArrayList à chaque loop? J'imagine que c'est ce que le système doit faire et sûrement de manière plus optimisé que programmatiqueemnt comme ça, non?

L'avantage de recycler l'ArrayList est qu'on utilise le même tableau interne : ainsi, on alloue pas autant de tableaux différents qu'il y'a d'éléments dans lobj.get(0), d'où moins de consommation de ressources (autant en mémoire qu'en temps).

Quant au temp déclarer en dehors des boucles, c'étati dans l'idée de faire gagner du temps en évitant de lui faire faire une déclaration à chaque boucle, mais de toute manière,

ça n'a strictement aucune influence (c'est depuis longtemps optimisé lors de la compilation)

vu que je faisais un new ou un clear avec ton exemple, on ne gagne peut-être pas spécialement de temps ?

On gagne surtout en mémoire (en particulier sur le tableau interne de stockage). Le clear() parcourt effectivement le tableau en entier pour y mettre des null, ce qui est peut être long si la liste a de nombreux éléments, mais il ne faut pas oublier que le new doit allouer de la mémoire pour les attributs et que c'est consommateur en temps.

Sinon l'idée de Double.valueOf(lobj.get(b).get(a).toString()) plutôt que de faire uniquement lobj.get(b).get(a), c'est pour pouvoir trier, mais je me trompe peut-être. En effet, comme lobj contient des Object, je pensais que le tri ne s'effectuerait pas comme il faut, c'est faux ?

Contient des Object ou est déclarée List<Object> mais contient des Double ? Ce qui n'est pas la même chose. Dans le second cas, il suffit de caster pour traiter le Double :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

(Double) lobj.get(b).get(a)

Pour le premier cas, si ce sont des Objects, ça ne risque pas de donner un String parsable en Double de toute manière.
A noter, qu'il n'y avait pas que la conversion dans le code de remplacement : il y a aussi le premier paramètre de add(), qui est inutile, puisque tu ajoutes toujours à la fin (add(x, ...) avec x variant de 0 à n).