Deep Copy ArrayList em Java

Na linguagem Java, se quisermos copiar uma ArrayList, pode haver duas maneiras de fazer isso. Faça uma cópia profunda ou uma cópia superficial.

Na cópia profunda, um objeto completamente novo é criado e, portanto, a variação no estado do objeto antigo não refletirá nenhuma alteração na instância recém-criada.

Na cópia superficial, criamos um novo objeto que possui referências ao objeto existente. Portanto, qualquer mudança no estado do objeto antigo refletirá na instância recém-criada.

O diagrama que melhor ilustra as duas definições acima:

O que é Deep Copy

A criação de um novo objeto a partir de um existente é chamada de cópia profunda. Este tipo de cópia não possui nenhuma referência ao objeto presente. Uma cópia profunda é uma tarefa iterativa. Ele copia recursivamente as variáveis ​​de membro interno e objetos para a nova instância.

Esse tipo de clone copia todos os objetos aninhados e não deixa nenhum link de referência entre a origem e a cópia. Esta clonagem copia exatamente todos os tipos de dados primitivos (byte, short, int) e não primitivos (String, Array, Class).

Se quisermos copiar um objeto em profundidade, substitua o método clone() da interface clonável da classe Object.

Aqui está o exemplo de código de cópia profunda de um ArrayList em 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;
  }
}

Na classe POJO acima, deve-se substituir o método clone, junto com getters e setters. O método clone() lança CloneNotSupportedException que devemos lançar no método sobrescrito.

Devemos implementar nossa versão para fazer um clone do objeto existente. Temos que copiar todas as variáveis ​​de membro da classe Car em uma nova instância.

Abaixo está a implementação da classe de driver para uma cópia profunda de um 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
  }
}

Na implementação acima, o método clone() sobrescrito da classe Car é chamado, o que retornará uma instância completamente nova. E essa instância recém-criada deve ser adicionada à ArrayList.

E quando fazemos algumas manipulações no objeto recém-criado, isso não afetará a referência do objeto antigo.

Além disso, se quisermos iterar em um ArrayList individualmente, o método clone() deve ser chamado sobre o objeto Car.

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