Problème de copie d'un tableau d'objets

Version imprimable

Bonjour,

je crée des objets (complexes) d'une classe C1 pour les mettre dans deux ArrayList différents AL1 et AL2 (je veux avoir des objets séparés).
J'applique ensuite des modifications aux objets de AL1, le résultat est que même les objets de AL2 sont modifiés c'est comme si les objets sont les même.
J'ai consulté le Net, j'ai trouvé que c'était un problème de référence à cause de la copie "superficielle". J'ai alors utilisé Clone comme solution tout en faisant le nécessaire pour mes classes : Clonable et redéfinition de la méthode clone(). Malheureusement, le problème est toujours le même; les objets de AL2 sont modifiés. Je me suis cassé les dents ... mais rien :(

Voici mes déclarations de classes et ArrayList :

Classe 1

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class A implements Cloneable{
 
	private double a1;
	private int a2 = 1;
 
        //Constructeur 
	public EnergyProfile (double enerC){
		this.a1 = enerC;
	}
 
	@Override
	public A clone() throws CloneNotSupportedException {
		// TODO Auto-generated method stub
		return new A(a1, a2);
	}
 
      // Constructeur par défaut  
      ....
 
}

Classe 2

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class B implements Cloneable {
	private String b1;
	private double b2;
 
	public B(String b1) {
		this.b1 = b1;
	}
 
	@Override
	public B clone() throws CloneNotSupportedException {
		return new B(b1, b2);
	}
 
       // Constructeur par défaut 
      ...
 
}

Classe 3

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
public class C implements Cloneable{
 
	private int c1;
	private String c2;
 
	private A  c3= new A();	
	private ArrayList<B> c4 = new ArrayList <B> ();
 
	private double c5= 0;
 
	public C (int x, String y, A z, ArrayList<B> t) {
		c1= x;
		c2= y;
		c3= z;
		c4= t;	
	}
 
	@Override
	public C clone() throws CloneNotSupportedException {
		// TODO Auto-generated method stub
		return new C(x, y, z.clone(), (ArrayList<B>) t.clone(), u) ;
	}
 
     // Constructeur par défaut 
       ...
}

Classe 4

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 class D implements Cloneable{ 
 
	private int d1;
	private ArrayList<C> d2 = new ArrayList<C>();
 
	private C d3;	
	private ArrayList<Double> d4= new ArrayList<Double>();
 
        // Constructeur 
	public D(int x, ArrayList<C> y) {
		d1= x;
		d2 = y;
                d3 = new C();    
		d4= new ArrayList<>();
	}
 
	@Override
	public D clone() throws CloneNotSupportedException {
		// TODO Auto-generated method stub
 
		ArrayList<C> copyd2 = new ArrayList<C>();		
		for (C c : d2) {
			copyd2.add(c.clone());
		}	
		return new D (d1, d2, d3.clone(), (ArrayList<Double>) d4.clone());		
	}
 
.....
}

Déclaration et remplissage des tableaux d'objets

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
ArrayList<D> AL1= new ArrayList<D>();
 
ArrayList<D> AL2= new ArrayList<D>();
 
dElement = new D(.....);
 
AL1.add(dElement);
 
try {AL2.add(dElement.clone());
      } catch (CloneNotSupportedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
Modification des objets dans AL1 (aucune modification n'est effectuée sur les objets de AL2).
......
 
Affichage des objets AL2 (ils sont modifiés comme pour les objets de AL1).

Merci pour votre aide

29/04/2015, 10h09
hwoarang
Il faut bien comprendre le concept de reference. Si tu as utilisé des langages comme le C/C++, en java, tous les objets peuvent etre vus comme des pointeurs (sauf que la libération mémoire est gérée automatiquement).

Exemple:
Code:

1 2 MaClasse c1 = new MaClass(); MaClasse c2 = c1; // c1 et c2 pointent sur le meme objet. Ca veut dire que si je modifie l'objet référencé par c1, je modifie l'objet référencé par c2.
Concernant ce que tu appelles "copie", elle n'a rien de superficielle. C'est juste une référence, pas une copie.

Pour revenir à ton probleme, clone est bien une solution. Après une lecture un peu en diagonal de ton code, je pense que le probleme vient des arraylist. Une arraylist est un simple tableau d'objets, la cloner ne clone pas les objets qu'elle contient. C'est à mon avis l'origine de ton probleme.

Cloner une arraylist te permet de pouvoir modifier la liste des elements de celle-ci dans l'un des objets sans impacter la liste dans l'autre (tu peux par exemple vider la liste de l'objet 1 et cela ne changera pas celle de 2). En revanche, si tu modifies les objets contenus dans l'arraylist, ils seront bien modifiés sur les 2 (et je suppose que c'est ca le bug que tu observes).

Bref, pour conclure, la solution est de cloner non pas l'arraylist mais sont contenu. Ca revient à remplacer (partout ou tu clones les arraylist):

Code:

return new C(x, y, z.clone(), (ArrayList) t.clone(), u) ;

par:
Code:

1 2 3 4 5 6 ArrayList newList = new ArrayList(t.size()); for(B b : t) { newList.add(b.clone()); } return new C(x, y, z.clone(), newList, u) ;
PS: evite de poster des messages taggés "Urgent", c'est souvent peu apprécié sur les forums. Et tu n'obtiendras pas de réponse plus rapide.
29/04/2015, 10h25
kolodz
On va la faire rapide :

En premier lieu, merci d'utiliser la balise code !
En suite, il est préférable que le code que tu fournissent compile. Dans ton cas, il manque un constructeur sur deux !

Tes erreurs :

1. Tu utilise le clone de ArrayList qui précisent ceci dans la documentation :

Citation:

Envoyé par javadoc

Returns a shallow copy of this ArrayList instance. (The elements themselves are not copied.)

Si tu veux ne pas avoir les mêmes entités, il faut faire une copie profonde. Comme tu l'as réalisé sur certaines listes...

2. Tu ne vérifie pas la non nullité de tes objets avant de faire tes clones...
Code:

1 2 3 4 public C clone() throws CloneNotSupportedException { // TODO Auto-generated method stub return new C(x, y, z.clone(), (ArrayList) t.clone(), u) ; }
Si tu fait un clone sur un objet C qui a z null ? (Au passage, il n'y a pas de propriété z sur l'objet, mais ça doit être ton code que tu nous à offusqué à l’arrache !)
Il faudrait donc que tu réalise un test :

Code:

return new C(x, y, z!= null ? z.clone(): null, (ArrayList) t.clone(), u) ;

Ici, c'est la version ternaire du test de non nullité.

Cordialement,
Patrick Kolodziejczyk.

source :
http://docs.oracle.com/javase/7/docs...ml#clone%28%29

Citation:

Envoyé par saimer

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class A implements Cloneable{
 
	private double a1;
	private int a2 = 1;
 
        //Constructeur 
	public EnergyProfile (double enerC){
		this.a1 = enerC;
	}
 
	@Override
	public A clone() throws CloneNotSupportedException {
		// TODO Auto-generated method stub
		return new A(a1, a2);
	}
 
      // Constructeur par défaut  
      ....
 
}

Classe 2

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class B implements Cloneable {
	private String b1;
	private double b2;
 
	public B(String b1) {
		this.b1 = b1;
	}
 
	@Override
	public B clone() throws CloneNotSupportedException {
		return new B(b1, b2);
	}
 
       // Constructeur par défaut 
      ...
 
}

Classe 3

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
public class C implements Cloneable{
 
	private int c1;
	private String c2;
 
	private A  c3= new A();	
	private ArrayList<B> c4 = new ArrayList <B> ();
 
	private double c5= 0;
 
	public C (int x, String y, A z, ArrayList<B> t) {
		c1= x;
		c2= y;
		c3= z;
		c4= t;	
	}
 
	@Override
	public C clone() throws CloneNotSupportedException {
		// TODO Auto-generated method stub
		return new C(x, y, z.clone(), (ArrayList<B>) t.clone(), u) ;
	}
 
     // Constructeur par défaut 
       ...
}

Classe 4

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 class D implements Cloneable{ 
 
	private int d1;
	private ArrayList<C> d2 = new ArrayList<C>();
 
	private C d3;	
	private ArrayList<Double> d4= new ArrayList<Double>();
 
        // Constructeur 
	public D(int x, ArrayList<C> y) {
		d1= x;
		d2 = y;
                d3 = new C();    
		d4= new ArrayList<>();
	}
 
	@Override
	public D clone() throws CloneNotSupportedException {
		// TODO Auto-generated method stub
 
		ArrayList<C> copyd2 = new ArrayList<C>();		
		for (C c : d2) {
			copyd2.add(c.clone());
		}	
		return new D (d1, d2, d3.clone(), (ArrayList<Double>) d4.clone());		
	}
 
.....
}

Déclaration et remplissage des tableaux d'objets

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
ArrayList<D> AL1= new ArrayList<D>();
 
ArrayList<D> AL2= new ArrayList<D>();
 
dElement = new D(.....);
 
AL1.add(dElement);
 
try {AL2.add(dElement.clone());
      } catch (CloneNotSupportedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
Modification des objets dans AL1 (aucune modification n'est effectuée sur les objets de AL2).
......
 
Affichage des objets AL2 (ils sont modifiés comme pour les objets de AL1).

Merci pour votre aide

MERCI beaucoup hwoarang, ça marche très bien.

Salut,
Citation:
Envoyé par hwoarang
Bref, pour conclure, la solution est de cloner non pas l'arraylist mais sont contenu. Ca revient à remplacer (partout ou tu clones les arraylist):

Code:

return new C(x, y, z.clone(), (ArrayList) t.clone(), u) ;

par:
Code:

1 2 3 4 5 6 ArrayList newList = new ArrayList(t.size()); for(B b : t) { newList.add(b.clone()); } return new C(x, y, z.clone(), newList, u) ;
J'ai un problème avec ce genre de code pour clone(), car il ne respecte pas les conventions de la méthode qui disent que l'instance retourné doit être celle reçu depuis l'appel à super.clone() !
En effet cela peut "casser" le cloneage pour les éventuelles classes filles...

Bref il faut toujours appeler super.clone() !

Cela donnerait quelque chose comme cela :
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 @Override public C clone() { try { // 1. On appelle la méthode super.clone() // qui se chargera de créer le bon type // et de faire la copie des primitifs/références C copy = (C) super.clone(); // 2. On clone manuellement les attributs qui doivent l'être // (en général les objets mutables) if (copy.z != null) { copy.z = copy.z.clone(); } if (copy.t != null) { copy.t = (ArrayList) copy.t.clone(); // On clone tous les éléments de la liste // (ici encore ce n'est utile que s'ils sont mutable) ListIterator iterator = copy.t.listIterator(); while (iterator.hasNext()) { iterator.set(iterator.next().clone()); } } return copy; } catch (CloneNotSupportedException e) { throw new IllegalStateException(e); } }
a++

29/04/2015, 16h50
hwoarang

Citation:

Envoyé par adiGuba

J'ai un problème avec ce genre de code pour clone(), car il ne respecte pas les conventions de la méthode qui disent que l'instance retourné doit être celle reçu depuis l'appel à super.clone() !
En effet cela peut "casser" le cloneage pour les éventuelles classes filles...

Bref il faut toujours appeler super.clone() !

Ah, merci, je ne connaissais pas cette regle (je n'ai jamais eu besoin de clone pour l'instant). Je me suis contenté de reprendre le code posté originalement en clonant les objets mutables.