Discussion :

[Glacealeau]

Bonjour au forum !

Je planche actuellement sur un projet, et j'ai un temps d'exécution beaucoup trop élevé.
J'ai identifié la cause comme étant une méthode qui effectue une double boucle sur un ArrayList<List<String>>().

Voici mon code que je vous décrirai ensuite :

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
18
 
public List<List<String>> filteredMaterial(List<List<String>> material) {
        List<String> filteredMaterialTemp = new ArrayList<>();
        FMaterial = new ArrayList<>();
        for (int i = 0; i < material.size(); i++) {
 
// On parcourt material pour éviter les doublons de "valeur" pour un même "name" 
 
            for (int j = i + 1; j < material.size(); j++) {
                if (material.get(i).name.equals(material.get(j).name) && !material.get(i).valeur.equals(material.get(j).valeur)) {
                    FMaterial.add(material.get(i));
                }
            }
        }
        System.out.println("Taille du materiel " + material.size());
// retourne 106 000
        return FMaterial;
    }

Je fais donc une double boucle pour ne garder que les éléments qui existent au moins 2 fois sous le même "name" avec une "valeur" différente.
J'aimerai éviter cette double boucle.
Une idée?

D'avance merci !!!

[joel.drigo]

Salut,

Tout d'abord ton code est étrange : material est une List<List<String>>, or tu fais appel à des attributs name et valeur sur material.get(i), donc sur une List<String>, une interface qui n'a pas (et ne risque pas d'avoir) ces attributs.

Ça me semble difficile de dédoublonner une liste de liste en une seule boucle.

C'est une liste de propriétés (name + valeur), ou une liste de listes de String ?

[professeur shadoko]

commence déjà par faire un seul get(i) dans la première boucle et un seul get(j) dans la deuxième boucle ... il n'y a pas de petits profits (et en plus on comprendra mieux).
ensuite opérer sur une copie triée de material ?

[Glacealeau]

Merci pour vos réponses !

Tout d'abord, oui j'ai mis name et valeur pour simplifier (au lieu de get(3) et get(5)).
Sinon je crois avoir trouver une méthode. Je fais une Hashmap (name, Hashmap(valeur, index de la boucle)).
J'ai fais des tests et ça a résolu mon problème complètement.
Voici le nouveau code si jamais cela peut être d'une quelconque utilité.

Ancien code :

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
 
public List<List<String>> filteredMaterial(List<List<String>> material) {
   List<String> filteredMaterialTemp = new ArrayList<>();
        FMaterial = new ArrayList<>();
        for (int i = 0; i < material.size(); i++) {
            if (!material.get(i).get(5).equals("NA")) {
                for (int j = i + 1; j < material.size(); j++) {
                    if (material.get(i).get(3).equals(material.get(j).get(3))) {
                        if (!material.get(j).get(5).equals("NA")) {
                            if (!material.get(i).get(5).equals(material.get(j).get(5))) {
                                FMaterial.add(material.get(i));
                            }
                        }
                    }
                }
            }
        }

Solution :

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
18
19
20
21
22
23
24
25
26
27
28
 
public List<List<String>> filteredMaterial(List<List<String>> material) {
        Hashtable<String, Hashtable> filteredMaterial = new Hashtable<String, Hashtable>();
        FMaterial = new ArrayList<>();
        for (int i = 0; i < material.size(); i++) {
            String key = material.get(i).get(3);
            String value = material.get(i).get(5);
            if (filteredMaterial.containsKey(key)) {
                filteredMaterial.get(key).put(value, i);
            } else {
                Hashtable temp = new Hashtable();
                temp.put(value, i);
                filteredMaterial.put(key, temp);
            }
        }
        Enumeration keys = filteredMaterial.keys();
        while (keys.hasMoreElements()) {
            String name = (String) keys.nextElement();
            if (filteredMaterial.get(name).size() > 1) {
                Enumeration keys2 = (filteredMaterial.get(name)).keys();
                while (keys2.hasMoreElements()) {
                    int idx = (int) filteredMaterial.get(name).get(keys2.nextElement());
                    FMaterial.add(material.get(idx));
                }
            }
        }
        return FMaterial;
    }

[joel.drigo]

Salut,

Utilises une HashMap, plutôt qu'une HashTable : tu gagneras encore en performances (la HashTable est synchronized, ce qui ne sert à rien ici, et le fait qu'elle interdise les nulls n'a pas d'utilité non plus à priori).

Ensuite, plutôt que de parcourir les clefs et de faire des get(), autant parcourir le EntrySet : tu gagneras aussi en performances (en plus, ça t'évitera de faire plusieurs get sur la même clef).

Pour le reste, çà me semble bien compliqué pour faire du dédoublonage, mais je n'ai fait que survoler le code. La solution par HashMap est en effet une bonne voie, mais c'est cette notion d'index et le (filteredMaterial.get(name).size() > 1 qui m'étonne (sans parler qu'il manque quelque chose pour que ça compile à priori, ou alors c'est pire, la variable FMaterial n'est pas déclarée au bon endroit).