Comparer 2 objets JAVA

Version imprimable

Bonjour,

Dans le cadre d'un projet, je dois comparer 2 MAP d'objets (Objet : Employé) et faire ressortir les différences des valeurs de chaque objet.

Citation:

MAP 1 = Key : 1 | Valeur :: Nom : Dupont Prenom : Tony Age : 15
= Key : 2 | Valeur :: Nom : Socle Prenom : Eric Age : 17
= Key : 3 | Valeur :: Nom : Lou Prenom : Sophie Age : 17

MAP 2 = Key : 1 | Valeur :: Nom : Dupont Prenom : Tony Age : 15
= Key : 2 | Valeur :: Nom : Socle Prenom : Eric Age : 15
= Key : 3 | Valeur :: Nom : Lou Prenom : Sophie Age : 17

Résultat que j'ai actuellement :

Citation:

Key : 2
MAP 1 = Valeur :: Nom : Socle Prenom : Eric Age : 17
MAP 2 = Valeur :: Nom : Socle Prenom : Eric Age : 15
ATTRIBUT DIFFERENT = AGE

Cependant dans mon objet Employé, j'ai maintenant une liste d'un autre objet (facture)
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 public static HashMap<String, List<String>> comparaisonMap(HashMap<String,Facture> mapEmp_1, HashMap<String,Facture> mapEmp_2){ HashMap<String, List<String>> resultat = new HashMap<String, List<String>>() ; List<String> difList = new ArrayList<String>(); for (String cle: mapEmp_1.keySet()){ if (mapEmp_2.containsKey(cle)) { difList = mapEmp_1.get(cle).test(mapEmp_2.get(cle)); resultat.put(cle, difList); } } return resultat;
Ma méthode de comparaison actuellement dans l'objet employée :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 public List<String> test(Employe obj) { List<String> difList = new ArrayList<String>(); final Employe other = (Employe) obj; if (nom == null) { if (other.nom != null){ System.out.println("nom"); difList.add(other.nom); } } else if (!nom .equals(other.nom)){ System.out.println("nom"); difList.add(other.nom); }
Comment je peux faire pour pouvoir comparer ma liste d'objet Facture dans ma fonction test ?

Merci d'avance

09/06/2021, 11h12
PhilippeGibault

Après l'employé, la facture et ensuite, le véhicule de service :mouarf:

Plus sérieusement, je pense que le professeur veut le code le plus générique possible;

Pour comparer 2 objets de même type, il s'attend à ce que tu surcharge la méthode equals.
C'est assez complexe, et on arrive vite à des pièges à con.
Tu trouvera des indications ici:
https://docs.jboss.org/hibernate/sta...shashcode.html

A noter que si tu surcharge equals, il faut aussi surcharger hashcode.

On limite le nombre de ligne de code par la classe Objects (Objects.equals et Objects.hash).

Avec eclipse, il est possible de générer ces 2 méthodes.

Enfin, la référence sur le sujet est le Joshua Bloch:
https://www.amazon.fr/gp/product/B07...t_bibl_vppi_i0

Effectivement j'ai surchargé la méthode equals de la classe employe :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 public List<String> equals(Employe obj) { List<String> difList = new ArrayList<String>(); final Employe other = (Employe) obj; if (nom == null) { if (other.nom != null){ System.out.println("nom"); difList.add(other.nom); } } else if (!nom .equals(other.nom)){ System.out.println("nom"); difList.add(other.nom); }
Cependant, j'ai rien fait pour la méthode Hashcode est-ce problématique ? Lors de mes tests la comparaison marche bien.

Ma méthode compare les attributs d'un objet similaire et me stock dans une liste les différences. Désormais dans ma classe employe j'ai une liste d'objet facture.

Je sais pas comment faire pour faire lorsque je compare mes 2 objets employe pendant ma comparaison qu'on compare également mes objets facture dans liste une a une.

Je dois surement surchargé le méthode equals dans ma classe facture, mais pour parcourir la liste ca le fait automatiquement ?
Code:

1 2 3 4 5 6 7 for (String cle : mapFacture.keySet()) { if (other.mapFacture.containsKey(cle)) { } }
j'essaye de faire ça dans la methode equals de employe, mais je bloque

Non!
Je parles de la méthode equals de la classe objet.
https://docs.oracle.com/javase/7/doc...ng/Object.html

Elle retourne un booléen et prend en paramètre un objet.

Ce qui donne (Evidemment, j'essaye de réduire le nombre de ligne de code):
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 @Override public boolean equals(Object obj){ if(this == obj){ return true; } if(obj == null){ return false; } if(getClass() != obj.getClass()){ return false; } Employe other = (Employe)obj; return Objects.equals(this.nom, other.nom) && Objects.equals(this.prenom, other.prenom) && Objects.equals(this.age, other.age); }
Je lis que l'employé a un nom, un prénom et un age...

Pour hashcode, on a:
Code:

1 2 3 4 5 @Override public int hashCode(){ return Objects.hash(nom, prenom, age); }
Les deux méthodes sont dans la classe Employe. Le @Override signale que l'on surcharge les deux méthodes d'une classe mère (en l'occurence Object).

09/06/2021, 17h42
thelvin

Hello,

ça s'appelle redéfinir, pas surcharger. Ce qui en anglais se dirait overload, pas override. Mais la surcharge, ça n'est rien de bien notable. Ce sont des méthodes de même nom (mais pas les mêmes paramètres, ce serait impossible), et le fait qu'elles aient le même nom ne fait rien de particulier.

Et concernant la question, j'ai pas compris ce qui est demandé.

S'il y a des employés de même clé qui n'ont pas le même âge, il faut afficher les employés de cette clé dans les deux maps, et dire que ce qui est différent c'est l'âge. (Au passage, equals() n'aide pas à faire ça. equals() dit si oui ou non ils ont les mêmes valeurs. Quand ce n'est pas le cas equals() ne dit pas pourquoi ce n'est pas le cas.)
Et quand ils n'ont pas les mêmes factures, il faut faire quoi ?
10/06/2021, 14h13
Invité

Pour faire simple :

J'ai un objet Employe qui a comme attribut des String et une Map<String, Acte> et mon objet Acte comporte que des attributs String.

Actuellement j'ai 2 map<String, Employe> que je dois comparer et faire ressortir les différences.

Je compare les attributs String des Employes dans ma map, mais comment je fais pour faire une comparaison entre les MAP se trouvant dans mon objet Employe

Je veux comparer les map<String, Acte> se trouvant dans mes objets employe
10/06/2021, 19h30
thelvin

Citation:

Envoyé par JeuneCodeur

Actuellement j'ai 2 map<String, Employe> que je dois [...] et faire ressortir les différences.

Oui mais comment ? Ça doit donner quoi à la fin ? Je te l'ai déjà demandé, réponds s'il te plaît.

Pour les différences, on verra après.

Mais la méthode est dans le genre:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
private void compareMap(Map<K,V> map1, Map<K,V> map2,Set<K> cleesTraitees){
 
   for(Entry<K,V> entry: map1.entrySet(){
        if(!cleesTraitees.contains(entry.getKey()){
              //On ne traite que les clés non traitées
              if(map2.containsKey(entry.getKey) && !entry.getValue().equals(map2.get(entry.getKey)){
                     //Ici, on ne traite que les différences. On peut adapter pour traiter quand c'est identique.
                     //Importance de redéfinir (désolé pour l'abus de langage avant) equals de la classe de type V
                     //On fera après
              }
 
              //On a traité la clée, on l'ajoute
              cleesTraitees.add(entry.getKey());
        }
   }
 
}

comme il faut le faire pour les deux maps...

Code:

1
2
3
4
5
6
7
8
 
public void compareMap(Map<K,V> map1, Map<K,V> map2){
 
    Set<K> cleesTraitees = new HashSet<>();
    compareMap(map1, map2,cleesTraitees);
    compareMap(map2, map1, cleesTraitees); 
 
}

11/06/2021, 12h03
Invité

1 pièce(s) jointe(s)

J'ai essayé de faire un schéma pour représenter mon besoin :

Pièce jointe 599626

Il y a 2 HashMap avec des key identique, les valeurs qui peuvent changer sont dans les attributs des objets.

Ce que je veux faire :

Comparer Key 1 de la première HashMap avec Key 1 de la seconde HashMap, et que dans cette comparaison je compare également K1 de la map 1 avec le K1 de la map 2 et ainsi de suite...

Si il y a une différence entre les attributs (se sont des Strings) je les stocks dans une List
11/06/2021, 13h27
PhilippeGibault

Ce qui veut dire que l'on a deux Map<K,Map<K,V>> en entré?
Ce n'est pas ce que l'ai compris.
14/06/2021, 09h25
Invité

Oui c'est ça, on a 2 HashMap en entrée de la methode comparaison
14/06/2021, 11h04
PhilippeGibault

1) Ne jamais utilisé en paramètre d'une méthode une HashMap (c'est l'implémentation) mais une Map (c'est l'interface, donc le contrat). Le code doit rester le plus générique possible.
2) Ma question est de savoir si on a Map<K,V> à comparer avec Map<K,V> ou Map<K,Map<K,V>> avec Map<K,Map<K,V> car effectivement, le problème n'est pas le même.
14/06/2021, 11h19
Invité

Je dois comparer Map<K,V> avec Map<K,V>

Bien, les codes suivants (je ne vais quand même pas tout faire) devrait t'aider:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
private void compareMap(Map<K,V> map1, Map<K,V> map2,Set<K> cleesTraitees){
 
   for(Entry<K,V> entry: map1.entrySet(){
        if(!cleesTraitees.contains(entry.getKey()){
              //On ne traite que les clés non traitées
              if(map2.containsKey(entry.getKey) && !entry.getValue().equals(map2.get(entry.getKey)){
                     //Ici, on ne traite que les différences. On peut adapter pour traiter quand c'est identique.
                     //Importance de redéfinir (désolé pour l'abus de langage avant) equals de la classe de type V
                     //On fera après
              }
 
              //On a traité la clée, on l'ajoute
              cleesTraitees.add(entry.getKey());
        }
   }
 
}

Code:

1
2
3
4
5
6
7
8
 
public void compareMap(Map<K,V> map1, Map<K,V> map2){
 
    Set<K> cleesTraitees = new HashSet<>();
    compareMap(map1, map2,cleesTraitees);
    compareMap(map2, map1, cleesTraitees); 
 
}

l'objet de l'exercice est donc bien de comparer des objets, donc la redéfinition de la méthode equals (et de fait hashcode...).

Théoriquement, les 2 maps contiennent exactement les mêmes factures. (Dans les 2 maps les key sont les mêmes).

Les valeurs susceptibles d'être changés sont les attributs à l'intérieur des objets (soit les String).

La typologie simplifié de mon objet :
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 private String a; private String b; private HashMap<String, obj> mapObj; public List<String> equals(Facture obj) { List<String> difList = new ArrayList<String>(); final Obj other = (Facture) obj; if (a == null) { if (other.a != null){ System.out.println("a"); difList.add(other.a); } } else if (!a .equals(other.a)){ System.out.println("a"); difList.add(other.a); } if (b == null) { if (other.b != null){ System.out.println("b"); difList.add(other.b); } } else if (!b .equals(other.b)){ System.out.println("b"); difList.add(other.b); }
Je stock dans une liste les attributs qui sont différents d'un objet à l'autre dans les 2 maps. (Je cherche la key de ma map1 dans la map2, je compare les objets si il y a une différence au niveau des attributs je stock dans une liste).

Mon problème :

Je ne sais pas comment pour comparer ma private HashMap<String, obj> mapObj;

Je dois réaliser une boucle for dans ma méthode ?
Faire une methode dans mon obj ?

Comment surcharger ma méthode equals pour quel compare ma Map ?

14/06/2021, 13h51
PhilippeGibault

Justement, tu fais une fonction générique qui te permet de comparer dans tous les cas le contenu de 2 maps.

Pour comparer, dans ton algorithme, tu dois comparer 2 objets (pour une clé donnée).

Pour comparer 2 objets, on utilise la méthode equals.

Le but de l'exercice, à mon avis, est de faire redéfinir des méthodes equals.

J'ai modifié la methode equals() de ma classe employe :

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
public List<String> equals(Employe obj) {
 
		List<String> difList = new ArrayList<String>();
		final Employe other = (Employe) obj;
 
		if (nom == null) {
			if (other.nom != null){
				System.out.println("nom");
				difList.add(other.nom);
			}
 
		} else if (!nom
				.equals(other.nom)){
			System.out.println("nom");
			difList.add(other.nom);
 
 
		}
 
if (mapFacture== null) {
			if (other.mapFacture != null)
 
			System.out.println("mapFacture");
 
		} else if (!mapActe.facAcomparer(other.mapFacture))
 
			System.out.println("mapFacture");
 
}

j'ai également modifié la methode equals de la classe facture

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 public void facAcomparer(Acte obj) {
 
		final facture other = (Facture) obj;
 
 
		if (codenaturedeprestation == null) {
			if (other.codenaturedeprestation != null)
				System.out.println("codenaturedeprestation");
		} else if (!codenaturedeprestation.equals(other.codenaturedeprestation))
			System.out.println("dcodenaturedeprestation");
 
		if (numeroordredansfacture == null) {
			if (other.numeroordredansfacture != null)
				System.out.println(" numeroordredansfacture");
 
		} else if (!numeroordredansfacture.equals(other.numeroordredansfacture))
			System.out.println(" numeroordredansfacture");
 
 
	}

14/06/2021, 14h31
PhilippeGibault

On parle de redéfinition de méthode.

La méthode equals prend un objet (et non un Employe) et retourne un booléen (et non une List<String>)

Après, on regarde ce que l'on fait si pour une clé, les objets sont différents...
14/06/2021, 14h34
Invité

Je veux pas seulement savoir si les objets sont différents ou pas, je veux savoir quels sont les différences c'est pourquoi j'ai enlevé booleen et mis une liste, pour avoir une liste des differences.

Dans ce cas là, question: dans quoi veux-tu voir les différences de l'objet?

Il y a plusieurs façons de faire. Mais on peut faire comme cela par exemple:

On définit une interface EcrireDifference:
Code:

1 2 3 4 public interface EcrireDifference<V>{ String ecrireDifference(V v1, V v2); }
De fait, ici, on a:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 public class Employe implements EcrireDifference<Employe>{ //Plein de truc avant @Override public String ecrireDifference(Employe e1, Employe e2{ //A implémenter pour écrire la différence } //Et le reste (Getter, Setter, redefinition equals et hascode...) }
De fait, l'algorithme générique n'est plus pour une Map<K,V> mais pour une Map<K,EcrireDifference<V>>.

La valeur de V est de type EcrireDifference...

On va traîner une Map<K,String> pour les différences.

On arrive d'abord à :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 private void compareMap(Map<K,EcrireDifference<V>> map1, Map<K,EcrireDifference<V>>Map<K,V> map2,Set<K> cleesTraitees,Map<K,String> mapDifferences){ for(Entry<K,EcrireDifference<V>> entry: map1.entrySet(){ if(!cleesTraitees.contains(entry.getKey()){ //On ne traite que les clés non traitées if(map2.containsKey(entry.getKey) && !entry.getValue().equals(map2.get(entry.getKey)){ //Ici, on ne traite que les différences. On peut adapter pour traiter quand c'est identique. //Importance de redéfinir (désolé pour l'abus de langage avant) equals de la classe de type V //Nouveauté: on fait la différence mapDifferences.put(entry.getKey,entry.getValue().ecrireDifference(entry.getValue(),map2.get(entry.getKey)); } //On a traité la clée, on l'ajoute cleesTraitees.add(entry.getKey()); } } }
Et pour appeler ce truc:
Code:

1 2 3 4 5 6 7 8 9 10 public Map<K,String> compareMap(Map<K,V> map1, Map<K,V> map2){ Set<K> cleesTraitees = new HashSet<>(); Map<K,String> mapDifferences = new HashMap<>(); compareMap(map1, map2,cleesTraitees,mapDifferences); compareMap(map2, map1, cleesTraitees,mapDifferences); return mapDifferences; }
Evidemment, ce n'est qu'une solution parmi d'autres..., il est sans doute possible de faire mieux.

Mais tu remarquera que je n'ai pas insisté, auparavant, sur "faire la différence entre objet".

En fait, le "faire la différence entre objet, c'est du pipeau.

Le cœur de l'exercice, à mon avis, c'est de comparer 2 objets.

Et pour comparer 2 objets, c'est equals.

Le but de l'exercice est de redéfinir des méthodes equals. et redéfinir equals, c'est casse-gueule, car c'est devoir redéfinir hashcode.
C'est ça ce qui est vraiment important. Le reste, c'est du bidon. On s'en fout.

Donc, conclusion:
1) Pour comparer des objets, c'est la méthode equals de la classe object.
2) Si je veux avoir ma propre façon pour comparer, il faut redéfinir equals.
3) Si on redéfinit equals, il faut redéfinir hascode.

Il y a des règles pour hashcode et equals.
Je t'invite à regarder le livre de références des bonnes pratiques Java, que tous développeur Java se doit de posséder:
https://www.amazon.fr/gp/product/B07...api_taft_p1_i0