Comparaison entre 2 objets

Version imprimable

Bonjour,

je nécessite de l'aide pour comparer 2 objets, je m'explique.

J'ai un premier objet instancier, puis l'utilisateur le modifie.
J'aimerai savoir comment connaître quelles modifications l'utilisateur a apporté et les sauvegarder.

Mon objet est composé d'attributs de type primitif (String, float ...) ainsi que d'objet (Polynome, Unites...)

Actuellement j'arrive à obtenir quelque chose qui fonctionne pour mes objets mais pas pour les types primitifs, mais qui est très lourde à mon sens.

Voilà une partie de mon code :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
try {
Field[] ancienAttributsCorps = //objetAvantModification;
Field[] nouveauAttributsCorps = //objetApresModification;
for (int i = 0; i < nouveauAttributsCorps.length; i++){			nouveauAttributsCorps[i].setAccessible(true);
	ancienAttributsCorps[i].setAccessible(true);
 
	if (nouveauAttributsCorps[i].get(nouveauCorps).getClass() == Polynome.class) {
                  Field[] ancienPoly = //ancien attributs du polynome
	     Field[] nouveauPoly = // nouveau attributs du polynome
	for (int j = 0; j < nouveauPoly.length ; j++) {
	     [j].setAccessible(true);
	     ancienPoly[j].setAccessible(true);
                  float ancien = (Float) ancienPoly[j]...;
	      float nouveau = (Float) nouveauPoly[j]...

Je vous épargne tout le reste, qui permet d'indiquer à l'utilisateur les modifications...

Je me doute qu'il va falloir utiliser un fichier log regroupant toutes les modifications, mais avant cela j'aimerai savoir quelle amélioration dois je effectuer dans mon code.

Merci,
Rémy.

Pour ceux qui veulent, voila mon code entier :

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
 
try {
Field[] ancienAttributsCorps = voie.getCorpsEpreuve()[corps].getClass().getSuperclass().getDeclaredFields();
Field[] ancienAttributsGenerique = voie.getCorpsEpreuve()[corps].getClass().getSuperclass().getSuperclass().getDeclaredFields();
Field[] nouveauAttributsCorps = nouveauCorps.getClass().getSuperclass().getDeclaredFields();
Field[] nouveauAttributsGenerique = nouveauCorps.getClass().getSuperclass().getSuperclass().getDeclaredFields();
 
for (int i = 0; i < nouveauAttributsCorps.length; i++){
	nouveauAttributsCorps[i].setAccessible(true);
	ancienAttributsCorps[i].setAccessible(true);
	if (nouveauAttributsCorps[i].get(nouveauCorps).getClass() == Polynome.class) {
	Field[] ancienPoly = ancienAttributsCorps[i].get(voie.getCorpsEpreuve()[corps]).getClass().getDeclaredFields();
	Field[] nouveauPoly = nouveauAttributsCorps[i].get(nouveauCorps).getClass().getDeclaredFields();					for (int j = 0; j < nouveauPoly.length ; j++) {				nouveauPoly[j].setAccessible(true);
	ancienPoly[j].setAccessible(true);
									float ancien = (Float) ancienPoly[j].get(ancienAttributsCorps[i].get(voie.getCorpsEpreuve()[corps]));
	float nouveau = (Float) nouveauPoly[j].get(nouveauAttributsCorps[i].get(nouveauCorps));
									if(ancien != nouveau) {
	System.out.print("\nChangement pour " + ancienPoly[j].getName() + " : " + 	ancienPoly[j].get(ancienAttributsCorps[i].get(voie.getCorpsEpreuve()[corps])) +" -> "+nouveauPoly[j].get(nouveauAttributsCorps[i].get(nouveauCorps)));
 
}else {
	System.out.print("\nIdentique pour " + ancienPoly[j].getName() + " : " + ancienPoly[j].get(ancienAttributsCorps[i].get(voie.getCorpsEpreuve()[corps])) +" = "+nouveauPoly[j].get(nouveauAttributsCorps[i].get(nouveauCorps)));
									nouveauPoly[j].setAccessible(false);
	ancienPoly[j].setAccessible(false);
}
 
} else {
	if (nouveauAttributsCorps[i].get(nouveauCorps) != ancienAttributsCorps[i].get(voie.getCorpsEpreuve()[corps])) 
{
System.out.print("\nChangement pour " + ancienAttributsCorps[i].getName() + " : " + 	ancienAttributsCorps[i].get(voie.getCorpsEpreuve()[corps]) +" -> "+	nouveauAttributsCorps[i].get(nouveauCorps));
} else {	System.out.print("\nIdentique pour " + ancienAttributsCorps[i].getName() + " : " + ancienAttributsCorps[i].get(voie.getCorpsEpreuve()[corps]) +" -> "+	nouveauAttributsCorps[i].get(nouveauCorps));
		}
	}
nouveauAttributsCorps[i].setAccessible(false);
ancienAttributsCorps[i].setAccessible(false);
			}

Bonjour,
je ne sais pas exactement quel est ton objectif, mais s'il s'agit simplement de comparer 2 objets membre à membre, je ne vois pas trop l'intérêt de passer par l'introspection (reflexion), à moins que le nombre des membres à comparer soit vraiment important...

C'est plus à l'objet lui même de savoir se comparer à un autre :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 public class MaClasse { private int member= 0; public List<Modification>getModifications(Object newObject) { List<Modification> result= new ArrayList<>(); if(newObject.getClass().equals(getClass())){ if(member!=newObject.getMember()){ result.add(new Modification("member",member,newObject.getMember())); } } return result; } public int getMember() { return member; } }
La classe gérant les modifications :
Code:

1 2 3 4 5 6 7 8 9 10 11 public class Modification{ private String name; private Object oldValue; private Object newValue; public Modification(String name,Object oldValue,Object newValue){ this.name=name; ... } //Accesseurs
Ou tu peux utiliser la reflexion, mais pour faire par exemple une comparaison plus systématique de tous les membres :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 public List<Modification>getModifications(Object newObject) { List<Modification> result= new ArrayList<>(); if(newObject.getClass().equals(getClass())){ for (Field field : this.getDeclaredFields()) { field.setAccessible(true); if(field.get(this)!=null&&!field.get(this).equals(field.get(newObject)){ result.add(new Modification(field.getName(),field.get(this),field.get(newObject))); } } } return result; }
S'il s'agit de tracer les modifications effectuées, tu peux aussi implémenter Observable sur tes objets, et créer des messages dans les logs en cas de modifications des membres...

Dernière chose, pour des comparaisons de valeurs non primitives, tu devrais utiliser equals plutôt que ==.

26/02/2013, 20h41
lr.remy

Je te remercie, c'est exactement le style de réponse que j'attendais. J'approfondirai ceci demain mais je pense qu'avec ça je serai quoi faire:ccool:
Mille merci,
Rémy.