Liste d'objets fusionnés affichés en double

Version imprimable

Bonjour,

soit une liste, cette liste d'objets <HistoriqueChargement> comporte parfois des objets dont certains ont un attribut identique.
Si cet attribut "code" est donc identique, je souhaite "fusionner" ces objets dans une nouvelle liste.

Cependant, les objets ainsi fusionnés de ma nouvelle liste s'affiche en double. Si vous pouviez m'expliquer mon erreur.

Mon code :

Code:

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
List<HistoriqueFichierFusionne> laNouvelleListe = new ArrayList<HistoriqueFichierFusionne>();
 
        HistoriqueChargement historiqueChargementPrecedent = null;
 
        for (HistoriqueChargement historiqueChargement : laListeDesHistoriqueChargement)
        {
 
            HistoriqueFichierFusionne leNouvelHistorique = new HistoriqueFichierFusionne();
            for (int i = 0; i < laListeDesHistoriqueChargement.size(); i++)
            {
 
                if (historiqueChargementPrecedent == null)
                {
                    historiqueChargementPrecedent = laListeDesHistoriqueChargement.get(0);
 
                }
                else
                {
 
                    historiqueChargementPrecedent = laListeDesHistoriqueChargement.get(i);
 
                }
 
                if (historiqueChargement.getCode().compareTo(historiqueChargementPrecedent.getCode()) == 0)
                {
 
                    leNouvelHistorique.setCode(historiqueChargement.getCode());
                    leNouvelHistorique.setAnnee(leFormulaire.getLesCriteresRechercheSuiviInterface().getAnneeRecherchee());
                    if (historiqueChargement.getLeTypeIntegrationFichier().equals(TypeIntegrationFichier.PREVISIONNELLE))
                    {
                        leNouvelHistorique.setDateIntegrationPrevisionnelle(historiqueChargement.getDateIntegration());
                    }
                    if (historiqueChargement.getLeTypeIntegrationFichier().equals(TypeIntegrationFichier.DEFINITIVE))
                    {
                        leNouvelHistorique.setDateIntegrationDefinitive(historiqueChargement.getDateIntegration());
                    }
                    if (historiqueChargementPrecedent.getLeTypeIntegrationFichier().equals(
                        TypeIntegrationFichier.PREVISIONNELLE))
                    {
                        leNouvelHistorique.setDateIntegrationPrevisionnelle(historiqueChargementPrecedent.getDateIntegration());
                    }
                    if (historiqueChargementPrecedent.getLeTypeIntegrationFichier().equals(TypeIntegrationFichier.DEFINITIVE))
                    {
                        leNouvelHistorique.setDateIntegrationDefinitive(historiqueChargementPrecedent.getDateIntegration());
                    }
                }
 
            }
 
            laNouvelleListe.add(leNouvelHistorique);
        }

Sortie en console :

976 2017 2017-05-01 08:00:00.0 2017-12-01 08:00:00.066
976 2017 2017-05-01 08:00:00.0 2017-12-01 08:00:00.066
B21 2017 2017-05-01 08:00:00.0 2017-12-01 08:00:00.008
B21 2017 2017-05-01 08:00:00.0 2017-12-01 08:00:00.008

Par avance, je vous remercie de votre aide

Salut,

Tu n'exclus de la comparaison dans la deuxième boucle l'élément lui-même.

Supposons qu'on ait cette liste (A, B, C), tel que code de A est égale à code de C (d'ailleurs pourquoi faire un compareTo()==0, alors qu'un equals est plus simple ?), donc d'après ce que je comprends de ton code, à fusionner. Mais avec ton double parcourt tu vas comparer :

A avec A
A avec B
A avec C
B avec A
B avec B
B avec C
C avec A
C avec B
C avec C

Si A comparé à C donne une fusion parce que code de A égal code de C, alors forcément C comparé à A va le faire aussi. Tu auras donc deux "nouvelhistorique" identiques (enfin pas toujours forcément identique selon l'algo de fusion) dont l'un est le résultat de la fusion de A et C et l'autre de C et A.

A noter, que s'il n'y a aucun doublon, tu ajoutes quand même une fusion à la liste à la fin, puisque tu compares un élément forcément avec lui-même, qui donc est forcément égal à lui-même, donc va se fusionner à lui-même. Si cet élément a aussi un doublon, comme tu utilises la même instance (créée avant d'entrer dans la sous-boucle), ça ne pose pas de souci si la fusion est commutative (A fusionné avec B donne la même chose que B fusionné avec A). Mais si un élément n'a pas de doublon tu le retrouves quand même dans la liste de fusion à la fin. Mais c'est peut-être voulu.

Il y a différentes techniques par parcours pour résoudre ce problème de dédoublonnage et de fusion, mais le plus simple est encore d'utiliser un regroupement :

Code:

Map<TypeDuCode,List<HistoriqueChargement >> map = list.stream().collect(Collectors.groupingBy(HistoriqueChargement::getCode));

Tu obtiens une map telle que les valeurs sont les listes des éléments qui ont le même code. Tu n'a plus qu'a parcourir le map.values() pour fusionner les éléments entre eux comme tu le souhaites.

En outre, je ne sais pas pourquoi tu fais ça :
Code:

1 2 3 4 5 6 7 8 9 10 11 if (historiqueChargementPrecedent == null) { historiqueChargementPrecedent = laListeDesHistoriqueChargement.get(0); } else { historiqueChargementPrecedent = laListeDesHistoriqueChargement.get(i); }
Le seul moment ou historiqueChargementPrecedent est null, c'est au tout début, quand i vaut 0.
Donc autant faire simplement :
Code:

1 2 3 4 historiqueChargementPrecedent = laListeDesHistoriqueChargement.get(i); }

11/01/2018, 12h00
veve25

Liste d'objets fusionnés affichés en double

Bonjour,

Merci d'avoir pris le temps d'analyser ma demande et pour tes explications très claires.
Effectivement :

Code:

historiqueChargementPrecedent = laListeDesHistoriqueChargement.get(i);

suffit pleinement, et equals() à la place de compareTo() est plus logique et simple.

L'affichage des objets sans "doublon" dans la liste est effectivement voulu.

Pour ce qui est de :

Code:

Map<TypeDuCode,List<HistoriqueChargement>> map = list.stream().collect(Collectors.groupingBy(HistoriqueChargement::getCode));

eclipse m'indique : "change project compliance and jre to 1.8" et je ne peux changer de version pour diverses raisons.

Dans ta réponse tu fais référence à différentes techniques par parcours pour résoudre ce problème de dédoublonnage et de fusion.
Peux-tu m'en dire plus STP.

Par avance merci et bonne journée.

Citation:

Envoyé par veve25

Pour ce qui est de :

Code:

Map<TypeDuCode,List<HistoriqueChargement>> map = list.stream().collect(Collectors.groupingBy(HistoriqueChargement::getCode));

eclipse m'indique : "change project compliance and jre to 1.8" et je ne peux changer de version pour diverses raisons.

Oui, parce que les streams sont apparus en Java 8. Pour quelle raison ne peux-tu pas changer de version ?

Citation:

Envoyé par veve25

Dans ta réponse tu fais référence à différentes techniques par parcours pour résoudre ce problème de dédoublonnage et de fusion.
Peux-tu m'en dire plus STP.

Une technique peut être de faire une double boucle du type :
Code:

1 2 3 4 5 pour tous les éléments M de la liste pour tous les éléments N de la liste situés strictement après l'élément M si N est doublon de M, fusionner fin pour fin pour
Une autre peut être de copier la liste dans un set ( new LinkedHashSet<>(list), LinkedHashSet pour conserver l'ordre dans la liste ) puis
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 while( !set.isEmpty() ) { Iterator iter = set.iterator() M = iter.next() iter.remove() F = new Fusion(M) while( iter.hasNext()) { N = iter.next() si ( N est doublon de M ) fusionner N dans F iter.remove() fin si } fusions.add( F ) }

Merci pour ta nouvelle réponse,

J'ai donc opté pour LinkedHashSet et les problèmes de doublons et d'ordre sont réglés.
Pas de changement de version car d'autres applications en cause.

Code:

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
Set<HistoriqueFichierFusionne> setHistoriqueFusionne = new LinkedHashSet<HistoriqueFichierFusionne>();
 
        HistoriqueChargement historiqueChargementPrecedent = null;
 
        for (HistoriqueChargement historiqueChargement : laListeDesHistoriqueChargement)
        {
 
            HistoriqueFichierFusionne leNouvelHistorique = new HistoriqueFichierFusionne();
            for (int i = 0; i < laListeDesHistoriqueChargement.size(); i++)
            {
 
                historiqueChargementPrecedent = laListeDesHistoriqueChargement.get(i);
 
                if (historiqueChargement.getCode().equals(historiqueChargementPrecedent.getCode()))
                {
 
                    leNouvelHistorique.setCode(historiqueChargement.getCode());
                    leNouvelHistorique.setAnnee(leFormulaire.getLesCriteresRechercheSuiviInterface().getAnneeRecherchee());
                    if (historiqueChargement.getLeTypeIntegrationFichier().equals(TypeIntegrationFichier.PREVISIONNELLE))
                    {
                        leNouvelHistorique.setDateIntegrationPrevisionnelle(historiqueChargement.getDateIntegration());
                    }
                    if (historiqueChargement.getLeTypeIntegrationFichier().equals(TypeIntegrationFichier.DEFINITIVE))
                    {
                        leNouvelHistorique.setDateIntegrationDefinitive(historiqueChargement.getDateIntegration());
                    }
                    if (historiqueChargementPrecedent.getLeTypeIntegrationFichier().equals(
                        TypeIntegrationFichier.PREVISIONNELLE))
                    {
                        leNouvelHistorique.setDateIntegrationPrevisionnelle(historiqueChargementPrecedent.getDateIntegration());
                    }
                    if (historiqueChargementPrecedent.getLeTypeIntegrationFichier().equals(TypeIntegrationFichier.DEFINITIVE))
                    {
                        leNouvelHistorique.setDateIntegrationDefinitive(historiqueChargementPrecedent.getDateIntegration());
                    }
                }
 
            }
 
            setHistoriqueFusionne.add(leNouvelHistorique);
 
        }
 
        List<HistoriqueFichierFusionne> laNouvelleListeHistoriqueFusionne = new ArrayList<HistoriqueFichierFusionne>();
        laNouvelleListeHistoriqueFusionne.addAll(setHistoriqueFusionne);

Un grand merci pour ta réactivité et ton aide