Como clonar ArrayList e também clonar seu conteúdo?

Como posso clonar um ArrayListe também clonar seus itens em Java?

Por exemplo, eu tenho:

ArrayList<Dog> dogs = getDogs();
ArrayList<Dog> clonedList = ....something to do with dogs....

E eu esperaria que os objetos clonedListnão sejam os mesmos da lista de cães.

Você precisará iterar nos itens e cloná-los um por um, colocando os clones em sua matriz de resultados à medida que avança.

public static List<Dog> cloneList(List<Dog> list) {
    List<Dog> clone = new ArrayList<Dog>(list.size());
    for (Dog item : list) clone.add(item.clone());
    return clone;
}

Para que isso funcione, obviamente, você precisará que sua Dogclasse implemente a Cloneableinterface e substitua o clone()método.

Eu, pessoalmente, adicionaria um construtor ao Dog:

class Dog
{
    public Dog()
    { ... } // Regular constructor

    public Dog(Dog dog) {
        // Copy all the fields of Dog.
    }
}

Em seguida, basta iterar (como mostrado na resposta de Varkhan):

public static List<Dog> cloneList(List<Dog> dogList) {
    List<Dog> clonedList = new ArrayList<Dog>(dogList.size());
    for (Dog dog : dogList) {
        clonedList.add(new Dog(dog));
    }
    return clonedList;
}

Acho que a vantagem disso é que você não precisa se meter com o material Cloneable quebrado em Java. Também corresponde à maneira como você copia as coleções Java.

Outra opção poderia ser escrever sua própria interface ICloneable e usá-la. Dessa forma, você pode escrever um método genérico para clonagem.

Todas as coleções padrão têm construtores de cópia. Usa-os.

List<Double> original = // some list
List<Double> copy = new ArrayList<Double>(original); //This does a shallow copy

clone()foi projetado com vários erros (consulte esta pergunta ), por isso é melhor evitá-lo.

Do Effective Java 2nd Edition , item 11: Substituir clone criteriosamente

Dado todos os problemas associados ao Cloneable, é seguro dizer que outras interfaces não devem estendê-lo e que as classes projetadas para herança (Item 17) não devem implementá-lo. Por causa de suas muitas deficiências, alguns programadores especializados simplesmente optam por nunca substituir o método clone e nunca invocá-lo, exceto, talvez, para copiar matrizes. Se você projetar uma classe para herança, esteja ciente de que, se optar por não fornecer um método de clone protegido bem comportado, será impossível para as subclasses implementar o Cloneable.

Este livro também descreve as muitas vantagens que os construtores de cópias têm sobre o Cloneable / clone.

• Eles não contam com um mecanismo de criação de objeto extralinguístico que apresenta riscos
• Eles não exigem adesão inexequível a convenções pouco documentadas
• Eles não entram em conflito com o uso adequado dos campos finais
• Eles não lançam exceções verificadas desnecessárias
• Eles não exigem lançamentos.

Considere outro benefício do uso de construtores de cópia: suponha que você tenha um HashSet se deseje copiá-lo como a TreeSet. O método clone não pode oferecer essa funcionalidade, mas é fácil com um construtor de conversão: new TreeSet(s).

O Java 8 fornece uma nova maneira de chamar o método construtor de cópia ou clone no elemento dog de maneira elegante e compacta: Streams , lambdas e coletores .

Copiar construtor:

List<Dog> clonedDogs = dogs.stream().map(Dog::new).collect(toList());

A expressão Dog::newé chamada de referência de método . Ele cria um objeto de função que chama um construtor no Dogqual leva outro cão como argumento.

Método de clone [1]:

List<Dog> clonedDogs = dogs.stream().map(d -> d.clone()).collect(toList());

Obtendo um ArrayListcomo resultado

Ou, se você precisar receber uma ArrayListresposta (caso queira modificá-lo posteriormente):

ArrayList<Dog> clonedDogs = dogs.stream().map(Dog::new).collect(toCollection(ArrayList::new));

Atualize a lista no local

Se você não precisar manter o conteúdo original da dogslista, poderá usar o replaceAllmétodo e atualizar a lista:

dogs.replaceAll(Dog::new);

Todos os exemplos assumem import static java.util.stream.Collectors.*;.

Coletor para ArrayLists

O coletor do último exemplo pode ser transformado em um método util. Como isso é algo comum, eu pessoalmente gosto de ser curto e bonito. Como isso:

ArrayList<Dog> clonedDogs = dogs.stream().map(d -> d.clone()).collect(toArrayList());

public static <T> Collector<T, ?, ArrayList<T>> toArrayList() {
    return Collectors.toCollection(ArrayList::new);
}

[1] Nota sobre CloneNotSupportedException:

Para que esta solução funcione, o clonemétodo de Dog não deve declarar que é lançado CloneNotSupportedException. O motivo é que o argumento para mapnão tem permissão para lançar nenhuma exceção verificada.

Como isso:

    // Note: Method is public and returns Dog, not Object
    @Override
    public Dog clone() /* Note: No throws clause here */ { ...

No entanto, esse não deve ser um grande problema, pois, de qualquer maneira, essa é a melhor prática. (O Effectice Java, por exemplo, dá esse conselho.)

^{Obrigado a Gustavo por observar isso.}

PS:

Se você achar mais bonito, poderá usar a sintaxe de referência do método para fazer exatamente a mesma coisa:

List<Dog> clonedDogs = dogs.stream().map(Dog::clone).collect(toList());

Basicamente, existem três maneiras sem iterar manualmente,

1 Usando o construtor

ArrayList<Dog> dogs = getDogs();
ArrayList<Dog> clonedList = new ArrayList<Dog>(dogs);

2 Usando addAll(Collection<? extends E> c)

ArrayList<Dog> dogs = getDogs();
ArrayList<Dog> clonedList = new ArrayList<Dog>();
clonedList.addAll(dogs);

3 Usando o addAll(int index, Collection<? extends E> c)método com o intparâmetro

ArrayList<Dog> dogs = getDogs();
ArrayList<Dog> clonedList = new ArrayList<Dog>();
clonedList.addAll(0, dogs);

Nota: O comportamento dessas operações será indefinido se a coleção especificada for modificada enquanto a operação estiver em andamento.

Eu acho que a resposta verde atual é ruim , por que você pode perguntar?

• Pode ser necessário adicionar muito código
• Requer que você liste todas as listas a serem copiadas e faça isso

A maneira como a serialização também é ruim, talvez você precise adicionar Serializable em todo o lugar.

Então qual é a solução:

Biblioteca de Deep Clonagem Java A biblioteca de clonagem é uma pequena biblioteca java de código aberto (licença apache) que clona profundamente objetos. Os objetos não precisam implementar a interface Cloneable. De fato, essa biblioteca pode clonar QUALQUER objeto java. Pode ser usado, por exemplo, em implementações de cache, se você não quiser que o objeto em cache seja modificado ou sempre que desejar criar uma cópia profunda dos objetos.

Cloner cloner=new Cloner();
XX clone = cloner.deepClone(someObjectOfTypeXX);

Confira em https://github.com/kostaskougios/cloning

Eu encontrei uma maneira, você pode usar o json para serializar / desserializar a lista. A lista serializada não contém referência ao objeto original quando não serializada.

Usando o gson:

List<CategoryModel> originalList = new ArrayList<>(); // add some items later
String listAsJson = gson.toJson(originalList);
List<CategoryModel> newList = new Gson().fromJson(listAsJson, new TypeToken<List<CategoryModel>>() {}.getType());

Você pode fazer isso usando jackson e qualquer outra biblioteca json também.

Eu sempre usei essa opção:

ArrayList<Dog> clonedList = new ArrayList<Dog>(name_of_arraylist_that_you_need_to_Clone);

Você precisará clonar ArrayListmanualmente (iterando sobre ele e copiando cada elemento para um novo ArrayList), porque clone()não fará isso por você. A razão para isso é que os objetos contidos no ArrayListpodem não Clonablese implementar .

Edit : ... e é exatamente isso que o código de Varkhan faz.

Uma maneira desagradável é fazê-lo com reflexão. Algo assim funcionou para mim.

public static <T extends Cloneable> List<T> deepCloneList(List<T> original) {
    if (original == null || original.size() < 1) {
        return new ArrayList<>();
    }

    try {
        int originalSize = original.size();
        Method cloneMethod = original.get(0).getClass().getDeclaredMethod("clone");
        List<T> clonedList = new ArrayList<>();

        // noinspection ForLoopReplaceableByForEach
        for (int i = 0; i < originalSize; i++) {
            // noinspection unchecked
            clonedList.add((T) cloneMethod.invoke(original.get(i)));
        }
        return clonedList;
    } catch (NoSuchMethodException | InvocationTargetException | IllegalAccessException e) {
        System.err.println("Couldn't clone list due to " + e.getMessage());
        return new ArrayList<>();
    }
}

List<Dog> dogs;
List<Dog> copiedDogs = dogs.stream().map(dog -> SerializationUtils.clone(dog)).Collectors.toList());

Isso irá copiar profundamente cada cão

Os outros pôsteres estão corretos: você precisa iterar a lista e copiar em uma nova lista.

No entanto ... Se os objetos na lista são imutáveis ​​- você não precisa cloná-los. Se o seu objeto tiver um gráfico complexo, ele também precisará ser imutável.

O outro benefício da imutabilidade é que eles também são seguros para threads.

Aqui está uma solução usando um tipo de modelo genérico:

public static <T> List<T> copyList(List<T> source) {
    List<T> dest = new ArrayList<T>();
    for (T item : source) { dest.add(item); }
    return dest;
}

para você, os objetos substituem o método clone ()

class You_class {

    int a;

    @Override
    public You_class clone() {
        You_class you_class = new You_class();
        you_class.a = this.a;
        return you_class;
    }
}

e chame .clone () para Vector obj ou ArraiList obj ....

Maneira fácil usando commons-lang-2.3.jar que biblioteca de java para clonar lista

link para download commons-lang-2.3.jar

Como usar

oldList.........
List<YourObject> newList = new ArrayList<YourObject>();
foreach(YourObject obj : oldList){
   newList.add((YourObject)SerializationUtils.clone(obj));
}

Espero que este possa ser útil.

: D

O pacote import org.apache.commons.lang.SerializationUtils;

Existe um método SerializationUtils.clone(Object);

Exemplo

this.myObjectCloned = SerializationUtils.clone(this.object);

Acabei de desenvolver uma lib capaz de clonar um objeto de entidade e um objeto java.util.List. Faça o download do jar em https://drive.google.com/open?id=0B69Sui5ah93EUTloSktFUkctN0U e use o método estático cloneListObject (lista de lista). Este método não apenas clona a lista, mas também todos os elementos da entidade.

O abaixo funcionou para mim ..

em Dog.java

public Class Dog{

private String a,b;

public Dog(){} //no args constructor

public Dog(Dog d){ // copy constructor
   this.a=d.a;
   this.b=d.b;
}

}

 -------------------------

 private List<Dog> createCopy(List<Dog> dogs) {
 List<Dog> newDogsList= new ArrayList<>();
 if (CollectionUtils.isNotEmpty(dogs)) {
 dogs.stream().forEach(dog-> newDogsList.add((Dog) SerializationUtils.clone(dog)));
 }
 return newDogsList;
 }

Aqui, a nova lista criada a partir do método createCopy é criada por meio de SerializationUtils.clone (). Portanto, qualquer alteração feita na nova lista não afetará a lista original

Acho que encontrei uma maneira muito fácil de fazer uma cópia profunda do ArrayList. Supondo que você deseja copiar um String ArrayList arrayA.

ArrayList<String>arrayB = new ArrayList<String>();
arrayB.addAll(arrayA);

Deixe-me saber se não funcionar para você.