Comment cloner ArrayList et cloner également son contenu?

Comment puis-je cloner un ArrayListet également cloner ses éléments en Java?

Par exemple, j'ai:

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

Et je m'attendrais à ce que les objets clonedListne soient pas les mêmes que dans la liste des chiens.

Vous devrez parcourir les éléments et les cloner un par un, en plaçant les clones dans votre tableau de résultats au fur et à mesure.

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

Pour que cela fonctionne, évidemment, vous devrez demander à votre Dogclasse d'implémenter l' Cloneableinterface et de remplacer la clone()méthode.

Personnellement, j'ajouterais un constructeur à Dog:

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

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

Ensuite, répétez (comme indiqué dans la réponse 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;
}

Je trouve que l'avantage est que vous n'avez pas besoin de faire le tour avec les trucs clonables cassés en Java. Il correspond également à la façon dont vous copiez les collections Java.

Une autre option pourrait être d'écrire votre propre interface ICloneable et de l'utiliser. De cette façon, vous pourriez écrire une méthode générique pour le clonage.

Toutes les collections standard ont des constructeurs de copie. Utilise les.

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

clone()a été conçu avec plusieurs erreurs (voir cette question ), il est donc préférable de l'éviter.

Extrait de Effective Java 2nd Edition , Item 11: Override clone judiciously

Compte tenu de tous les problèmes associés à Cloneable, il est sûr de dire que d'autres interfaces ne devraient pas l'étendre et que les classes conçues pour l'héritage (article 17) ne devraient pas l'implémenter. En raison de ses nombreuses lacunes, certains programmeurs experts choisissent simplement de ne jamais remplacer la méthode de clonage et de ne jamais l'invoquer sauf, peut-être, pour copier des tableaux. Si vous concevez une classe pour l'héritage, sachez que si vous choisissez de ne pas fournir une méthode de clone protégé bien comportée, il sera impossible pour les sous-classes d'implémenter Cloneable.

Ce livre décrit également les nombreux avantages des constructeurs de copie par rapport à Cloneable / clone.

• Ils ne s'appuient pas sur un mécanisme de création d'objets extralinguistiques sujet aux risques
• Ils n'exigent pas l'adhésion inapplicable à des conventions peu documentées
• Ils n'entrent pas en conflit avec la bonne utilisation des champs finaux
• Ils ne lèvent pas d'exceptions vérifiées inutiles
• Ils ne nécessitent pas de lancers.

Considérez un autre avantage de l'utilisation des constructeurs de copie: supposons que vous ayez un HashSet set que vous souhaitiez le copier en tant que TreeSet. La méthode clone ne peut pas offrir cette fonctionnalité, mais il est facile avec un constructeur de conversion: new TreeSet(s).

Java 8 fournit une nouvelle façon d'appeler le constructeur de copie ou la méthode de clonage sur les chiens d'élément de manière élégante et compacte: Streams , lambdas et collectors .

Constructeur de copie:

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

L'expression Dog::newest appelée référence de méthode . Il crée un objet fonction qui appelle un constructeur sur Doglequel prend un autre chien comme argument.

Méthode de clonage [1]:

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

Obtenir un ArrayListrésultat

Ou, si vous devez obtenir un ArrayListretour (au cas où vous voudriez le modifier plus tard):

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

Mettre à jour la liste en place

Si vous n'avez pas besoin de conserver le contenu d'origine de la dogsliste, vous pouvez plutôt utiliser la replaceAllméthode et mettre à jour la liste en place:

dogs.replaceAll(Dog::new);

Tous les exemples supposent import static java.util.stream.Collectors.*;.

Collectionneur pour ArrayLists

Le collecteur du dernier exemple peut être transformé en une méthode util. Comme c'est une chose courante à faire, j'aime personnellement que ce soit court et joli. Comme ça:

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] Remarque sur CloneNotSupportedException:

Pour que cette solution fonctionne, la cloneméthode de Dog ne doit pas déclarer qu'elle lance CloneNotSupportedException. La raison en est que l'argument to mapn'est pas autorisé à lever des exceptions vérifiées.

Comme ça:

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

Cela ne devrait cependant pas être un gros problème, car c'est de toute façon la meilleure pratique. ( Effectice Java par exemple donne ce conseil.)

^{Merci à Gustavo de l'avoir noté.}

PS:

Si vous le trouvez plus joli, vous pouvez utiliser la syntaxe de référence de la méthode pour faire exactement la même chose:

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

Fondamentalement, il existe trois façons sans itérer manuellement,

1 Utilisation du constructeur

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

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

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

3 Utilisation d'une addAll(int index, Collection<? extends E> c)méthode avec intparamètre

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

NB: Le comportement de ces opérations ne sera pas défini si la collection spécifiée est modifiée pendant que l'opération est en cours.

Je pense que la réponse verte actuelle est mauvaise , pourquoi pourriez-vous demander?

• Cela peut nécessiter d'ajouter beaucoup de code
• Il vous oblige à répertorier toutes les listes à copier et à le faire

La façon dont la sérialisation est également mauvaise imo, vous devrez peut-être ajouter Serializable partout.

Alors, quelle est la solution:

Bibliothèque de clonage en profondeur Java La bibliothèque de clonage est une petite bibliothèque java open source (licence Apache) qui clone en profondeur des objets. Les objets n'ont pas à implémenter l'interface Cloneable. Effectivement, cette bibliothèque peut cloner N'IMPORTE QUEL objet java. Il peut être utilisé, par exemple dans les implémentations de cache, si vous ne voulez pas que l'objet mis en cache soit modifié ou chaque fois que vous voulez créer une copie complète des objets.

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

Découvrez-le sur https://github.com/kostaskougios/cloning

J'ai trouvé un moyen, vous pouvez utiliser json pour sérialiser / désérialiser la liste. La liste sérialisée ne contient aucune référence à l'objet d'origine lorsqu'elle n'est pas sérialisée.

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

Vous pouvez le faire en utilisant également jackson et toute autre bibliothèque json.

J'ai toujours utilisé cette option:

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

Vous devrez le cloner à la ArrayListmain (en l'itérant et en copiant chaque élément dans un nouveau ArrayList), car vous clone()ne le ferez pas pour vous. La raison en est que les objets contenus dans le ArrayListpeuvent ne pas s’implémenter Clonable.

Edit : ... et c'est exactement ce que fait le code de Varkhan.

Une façon désagréable est de le faire avec réflexion. Quelque chose comme ça a fonctionné pour moi.

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

Cela copiera en profondeur chaque chien

Les autres affiches sont correctes: vous devez itérer la liste et la copier dans une nouvelle liste.

Cependant ... Si les objets de la liste sont immuables - vous n'avez pas besoin de les cloner. Si votre objet possède un graphique d'objet complexe, il devra également être immuable.

L'autre avantage de l'immuabilité est qu'ils sont également threadsafe.

Voici une solution utilisant un type de modèle générique:

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

pour vous, les objets remplacent la méthode 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;
    }
}

et appelez .clone () pour Vector obj ou ArraiList obj ....

Un moyen facile en utilisant commons-lang-2.3.jar cette bibliothèque de java pour cloner la liste

lien de téléchargement commons-lang-2.3.jar

Comment utiliser

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

J'espère que celui-ci peut être utile.

:RÉ

Le paquet import org.apache.commons.lang.SerializationUtils;

Il existe une méthode SerializationUtils.clone(Object);

Exemple

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

Je viens de développer une bibliothèque capable de cloner un objet entité et un objet java.util.List. Téléchargez simplement le bocal dans https://drive.google.com/open?id=0B69Sui5ah93EUTloSktFUkctN0U et utilisez la méthode statique cloneListObject (List list). Cette méthode clone non seulement la liste mais également tous les éléments d'entité.

Ce qui suit a fonctionné pour moi ..

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

Ici, la nouvelle liste créée à partir de la méthode createCopy est créée via SerializationUtils.clone (). Ainsi, toute modification apportée à la nouvelle liste n'affectera pas la liste d'origine

Je pense avoir trouvé un moyen très simple de créer une copie complète d'ArrayList. En supposant que vous souhaitez copier un tableau String ArrayList arrayA.

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

Faites-moi savoir si cela ne fonctionne pas pour vous.