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 : 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
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 : 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 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 : 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
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 : 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
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 : 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
 
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