Deep Copy ArrayList en Java

En langage Java, si nous voulons copier une ArrayList, il peut y avoir deux façons de le faire. Faites une copie complète ou une copie superficielle.

Dans la copie complète, un objet complètement nouveau est créé, et par conséquent, la variation de l’état de l’ancien objet ne reflétera aucun changement dans l’instance nouvellement créée.

Dans la copie superficielle, nous créons un nouvel objet qui a des références à l’objet existant. Ainsi, tout changement dans l’état de l’ancien objet se reflétera dans l’instance nouvellement créée.

Le diagramme qui illustre mieux les deux définitions ci-dessus:

Qu’est-ce que Deep Copy

La création d’un nouvel objet à partir d’un objet existant s’appelle une copie profonde. Ce type de copie n’a aucune référence à l’objet présent. Une copie profonde est une tâche itérative. Il copie de manière récursive les variables et objets membres internes dans la nouvelle instance.

Ce type de clone copie tous les objets imbriqués et ne laisse aucun lien de référence entre la source et la copie. Ce clonage copie exactement tous les types de données primitifs (byte, short, int) et non primitifs (String, Array, Class).

Si nous voulons copier en profondeur un objet, remplacez la méthode clone() de l’interface Cloneable de la classe Object.

Voici l’exemple de code de copie profonde d’une ArrayList en Java:

package deepVsShallowCopy;

public class Car implements Cloneable {
  String name;

  public String getName() {
    return name;
  }

  public void setName(String name) {
    this.name = name;
  }

  public Car(String name) {
    this.name = name;
  }

  @Override
  public Car clone() throws CloneNotSupportedException {
    Car newCar = (Car) super.clone();
    newCar.setName(newCar.getName());
    return newCar;
  }
}

Dans la classe POJO ci-dessus, il faut redéfinir la méthode clone, ainsi que getters et setters. La méthode clone lance CloneNotSupportedException que nous devrions lancer dans la méthode surchargée.

Nous devons implémenter notre version pour faire un clone de l’objet existant. Nous devons copier toutes les variables membres de la classe Car dans une nouvelle instance.

Vous trouverez ci-dessous l’implémentation de la classe de pilote pour la copie profonde d’une ArrayList:

package deepVsShallowCopy;

import java.util.ArrayList;
import java.util.List;

public class DeepCopyArrayList {
  public static void main(String[] args) throws CloneNotSupportedException {
    // instantiate car instance
    Car oldCar = new Car("Ambassador");
    // instantiate an arraylist
    List<Car> oldList = new ArrayList<Car>();
    // add oldCar object into the list
    oldList.add(oldCar);

    // instantiate newList
    List<Car> newList = new ArrayList<Car>();
    // add object created using clone() into list
    newList.add(oldList.get(0).clone());
    // rename field in newList car element
    newList.get(0).setName("Rolls Royce");

    System.out.println("oldName : " + oldList.get(0).getName()); // oldName : Ambassador
    System.out.println("newName : " + newList.get(0).getName()); // newName : Rolls Royce
  }
}

Dans l’implémentation ci-dessus, la méthode clone() surchargée de la classe Car est appelée, ce qui retournera une instance complètement nouvelle. Et cette instance nouvellement créée doit être ajoutée à ArrayList.

Et lorsque nous faisons des manipulations dans l’objet nouvellement créé, cela n’affectera pas l’ancienne référence d’objet.

Aussi, si nous voulons itérer individuellement dans une ArrayList, la méthode clone() doit être appelée sur l’objet de Car.

for (Car c : oldList) {
  newList.add(c.clone());
}