Come clonare ArrayList e anche clonarne il contenuto?

Come posso clonare un ArrayList e clonare anche i suoi elementi in Java?

Ad esempio ho:

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

E mi aspetto che gli oggetti in clonedListnon siano gli stessi dell'elenco dei cani.

Dovrai iterare gli oggetti e clonarli uno per uno, inserendo i cloni nell'array dei risultati mentre procedi.

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;
}

Perché funzioni, ovviamente, dovrai far sì che la tua Dogclasse implementi l' Cloneableinterfaccia e sovrascriva il clone()metodo.

Personalmente aggiungerei un costruttore a Dog:

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

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

Quindi ripeti (come mostrato nella risposta di 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;
}

Trovo il vantaggio di questo è che non hai bisogno di rovistare con le cose rotte di Cloneable in Java. Corrisponde anche al modo in cui copi le raccolte Java.

Un'altra opzione potrebbe essere quella di scrivere la tua interfaccia ICloneable e usarla. In questo modo potresti scrivere un metodo generico per la clonazione.

Tutte le raccolte standard hanno costruttori di copie. Usali.

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

clone()è stato progettato con diversi errori (vedi questa domanda ), quindi è meglio evitarlo.

Da Effective Java 2nd Edition , Item 11: Override clone giudiziosamente

Dati tutti i problemi associati a Cloneable, è sicuro dire che altre interfacce non dovrebbero estenderlo e che le classi progettate per l'ereditarietà (Articolo 17) non dovrebbero implementarlo. A causa delle sue numerose carenze, alcuni programmatori esperti scelgono semplicemente di non sovrascrivere mai il metodo clone e di non invocarlo mai tranne, forse, per copiare array. Se si progetta una classe per ereditarietà, tenere presente che se si sceglie di non fornire un metodo clone protetto ben educato, sarà impossibile per le sottoclassi implementare Cloneable.

Questo libro descrive anche i numerosi vantaggi che i costruttori di copie hanno su Cloneable / clone.

• Non si basano su un meccanismo di creazione di oggetti extralinguistici incline al rischio
• Non richiedono l'adesione inapplicabile alle convenzioni sottilmente documentate
• Non sono in conflitto con l'uso corretto dei campi finali
• Non generano eccezioni controllate non necessarie
• Non richiedono cast.

Considera un altro vantaggio dell'uso dei costruttori di copie: supponi di avere un HashSet se che tu voglia copiarlo come un TreeSet. Il metodo clone non può offrire questa funzionalità, ma è facile con un costruttore di conversione: new TreeSet(s).

Java 8 fornisce un nuovo modo di chiamare il costruttore di copie o il metodo clone sugli elementi cani in modo elegante e compatto: stream , lambda e collezionisti .

Copia costruttore:

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

L'espressione Dog::newè chiamata riferimento al metodo . Crea un oggetto funzione che chiama un costruttore su Dogcui accetta un altro cane come argomento.

Metodo clone [1]:

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

Ottenere un ArrayListrisultato

Oppure, se devi ArrayListrecuperarlo (nel caso in cui desideri modificarlo in seguito):

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

Aggiorna l'elenco in atto

Se non è necessario mantenere il contenuto originale dogsdell'elenco, è possibile invece utilizzare il replaceAllmetodo e aggiornare l'elenco in posizione:

dogs.replaceAll(Dog::new);

Tutti gli esempi assumono import static java.util.stream.Collectors.*;.

Collezionista per ArrayLists

Il raccoglitore dell'ultimo esempio può essere trasformato in un metodo util. Dal momento che questa è una cosa così comune da fare, mi piace che sia breve e carina. Come questo:

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

Perché questa soluzione funzioni, il clonemetodo di Dog non deve dichiarare che genera CloneNotSupportedException. Il motivo è che all'argomento mapnon è consentito generare eccezioni verificate.

Come questo:

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

Questo non dovrebbe essere un grosso problema, dato che comunque è la migliore pratica. ( Effectice Java, ad esempio, fornisce questo consiglio.)

^{Grazie a Gustavo per averlo notato.}

PS:

Se lo trovi più carino puoi invece usare la sintassi di riferimento del metodo per fare esattamente la stessa cosa:

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

Fondamentalmente ci sono tre modi senza iterare manualmente,

1 Utilizzando il costruttore

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

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

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

3 Utilizzo del addAll(int index, Collection<? extends E> c)metodo con intparametro

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

NB: il comportamento di queste operazioni sarà indefinito se la raccolta specificata viene modificata mentre l'operazione è in corso.

Penso che l'attuale risposta verde sia negativa , perché potresti chiedere?

• Può richiedere l'aggiunta di molto codice
• Richiede di elencare tutti gli elenchi da copiare e di farlo

Anche il modo in cui la serializzazione è male, potresti dover aggiungere Serializable ovunque.

Quindi qual è la soluzione:

Libreria Java di clonazione profonda La libreria di clonazione è una piccola libreria java open source (licenza apache) che esegue la clonazione di oggetti. Gli oggetti non devono implementare l'interfaccia Cloneable. In effetti, questa libreria può clonare QUALSIASI oggetto Java. Può essere utilizzato, ad esempio, nelle implementazioni della cache se non si desidera modificare l'oggetto memorizzato nella cache o quando si desidera creare una copia profonda degli oggetti.

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

Dai un'occhiata a https://github.com/kostaskougios/cloning

Ho trovato un modo, è possibile utilizzare JSON per serializzare / annullare la serializzazione dell'elenco. L'elenco serializzato non contiene alcun riferimento all'oggetto originale quando non serializzato.

Usando 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());

Puoi farlo usando anche jackson e qualsiasi altra libreria json.

Ho usato questa opzione sempre:

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

Dovrai clonare ArrayListmanualmente (iterando su di esso e copiando ogni elemento in un nuovo ArrayList), perché clone()non lo farà per te. La ragione di ciò è che gli oggetti contenuti in ArrayListpotrebbero non implementarsi da Clonablesoli.

Modifica : ... ed è esattamente ciò che fa il codice di Varkhan.

Un modo brutto è farlo con la riflessione. Qualcosa del genere ha funzionato per me.

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());

Questo copierà profondamente ogni cane

Gli altri poster sono corretti: è necessario iterare l'elenco e copiarli in un nuovo elenco.

Tuttavia ... Se gli oggetti nell'elenco sono immutabili, non è necessario clonarli. Se il tuo oggetto ha un grafico a oggetti complesso, dovrà anche essere immutabile.

L'altro vantaggio dell'immutabilità è che sono anche sicuri per il filo.

Ecco una soluzione che utilizza un tipo di modello generico:

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

per te gli oggetti hanno la precedenza sul metodo 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 chiama .clone () per Vector obj o ArraiList obj ....

Modo semplice usando commons-lang-2.3.jar quella libreria di java per clonare l'elenco

collegamento download commons-lang-2.3.jar

Come usare

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

Spero che questo possa essere utile.

: D

Il pacchetto import org.apache.commons.lang.SerializationUtils;

C'è un metodo SerializationUtils.clone(Object);

Esempio

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

Ho appena sviluppato una libreria in grado di clonare un oggetto entità e un oggetto java.util.List. Basta scaricare il vaso in https://drive.google.com/open?id=0B69Sui5ah93EUTloSktFUkctN0U e utilizzare il metodo statico cloneListObject (Elenco elenco). Questo metodo non solo clona l'Elenco ma anche tutti gli elementi di entità.

Il seguito ha funzionato per me ..

in 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;
 }

Qui il nuovo elenco che è stato creato dal metodo createCopy viene creato tramite SerializationUtils.clone (). Pertanto, qualsiasi modifica apportata al nuovo elenco non influirà sull'elenco originale

Penso di aver trovato un modo davvero semplice per creare una copia profonda di ArrayList. Supponendo di voler copiare un array ArrayList StringA.

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

Fammi sapere se non funziona per te.