Как клонировать ArrayList, а также клонировать его содержимое?

Вам нужно будет перебирать элементы и клонировать их один за другим, по ходу помещая клоны в массив результатов.

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

Очевидно, что для того, чтобы это сработало, вам нужно, чтобы ваш класс Dog реализовал интерфейс Cloneable и переопределил метод clone().

Лично я бы добавил в Dog конструктор:

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

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

Затем просто повторите (как показано в ответе Вархана):

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

Я считаю, что преимущество этого заключается в том, что вам не нужно возиться с неработающим материалом Cloneable в Java. Это также соответствует способу копирования коллекций Java.

Другой вариант - написать собственный интерфейс ICloneable и использовать его. Таким образом можно было бы написать общий метод клонирования.

Все стандартные коллекции имеют конструкторы копирования. Используй их.

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

clone() был разработан с несколькими ошибками (см. этот вопрос), поэтому лучше избегай это.

Из Эффективное 2-е издание Java, пункт 11: Разумно переопределить клон

Учитывая все проблемы, связанные с Cloneable, можно с уверенностью сказать, что другие интерфейсы не должны его расширять и что классы, разработанные для наследования (совет 17), не должны его реализовывать. Из-за его многочисленных недостатков некоторые опытные программисты просто предпочитают никогда не переопределять метод клонирования и никогда не вызывать его, за исключением, возможно, копирования массивов. Если вы разрабатываете класс для наследования, имейте в виду, что если вы решите не предоставлять хорошо работающий защищенный метод клонирования, для подклассов будет невозможно реализовать Cloneable.

В этой книге также описаны многие преимущества конструкторов копирования по сравнению с Cloneable / clone.

• Они не полагаются на подверженный риску механизм создания экстралингвистических объектов.
• Они не требуют необоснованного соблюдения плохо задокументированных соглашений.
• Они не противоречат правильному использованию полей final
• Они не выбрасывают ненужные проверенные исключения
• Они не требуют повязок.

Рассмотрим еще одно преимущество использования конструкторов копирования: предположим, у вас есть HashSet s, и вы хотите скопировать его как TreeSet. Метод clone не может предложить эту функцию, но это легко сделать с помощью конструктора преобразования: new TreeSet(s).

Java 8 предоставляет новый способ элегантного и компактного вызова конструктора копирования или метода клонирования для элемента Dog: Потоки, лямбды и сборщики.

Конструктор копирования:

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

Выражение Dog::new называется справкой по методу . Он создает функциональный объект, который вызывает конструктор Dog, который принимает в качестве аргумента другую собаку.

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

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

dogs.replaceAll(Dog::new);

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

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

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

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

В основном есть три способа без итерации вручную,

1 Использование конструктора

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

2 Использование addAll(Collection<? extends E> c)

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

3 Использование метода addAll(int index, Collection<? extends E> c) с параметром int

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

NB: поведение этих операций будет неопределенным, если указанная коллекция будет изменена во время выполнения операции.

Я думаю, что текущий зеленый ответ плохой, почему вы можете спросить?

• Может потребоваться добавить много кода
• Это требует, чтобы вы перечислили все копируемые списки и сделали это

Способ сериализации также плох, imo, вам, возможно, придется добавлять Serializable повсюду.

Итак, какое решение?

Библиотека глубокого клонирования Java Библиотека клонирования - это небольшая библиотека java с открытым исходным кодом (лицензия apache), которая выполняет глубокое клонирование объектов. Объекты не обязательно должны реализовывать интерфейс Cloneable. Фактически, эта библиотека может клонировать ЛЮБЫЕ объекты Java. Его можно использовать, например, в реализациях кеширования, если вы не хотите, чтобы кешированный объект изменялся или когда вы хотите создать глубокую копию объектов.

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

Проверьте это на https://github.com/kostaskougios/cloning.

Я нашел способ, вы можете использовать json для сериализации / десериализации списка. Сериализованный список не содержит ссылки на исходный объект после десериализации.

Использование 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());

Вы можете сделать это, используя jackson и любую другую библиотеку json.

Я всегда использовал эту опцию:

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

Вам нужно будет клонировать ArrayList вручную (повторяя его и копируя каждый элемент в новый ArrayList), потому что clone() не сделает этого за вас. Причина в том, что объекты, содержащиеся в ArrayList, могут не реализовывать сами Clonable.

Изменить: ... и это именно то, что делает код Вархана.

для вас объекты переопределяют метод 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;
    }
}

и вызовите .clone () для объекта Vector или объекта ArraiList ....

Гадкий способ - делать это с помощью рефлексии. Что-то вроде этого у меня сработало.

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

Это будет глубоко копировать каждую собаку

Некоторые другие альтернативы для копирования ArrayList как глубокой копии

Предупреждение 1 - использование внешнего пакета commons-lang3, метод SerializationUtils.clone ():

SerializationUtils.clone()

Скажем, у нас есть класс-собака, где поля класса изменяемы, и по крайней мере одно поле является объектом типа String и изменяемым, а не примитивным типом данных (в противном случае было бы достаточно неглубокой копии).

Пример мелкой копии:

List<Dog> dogs = getDogs(); // We assume it returns a list of Dogs
List<Dog> clonedDogs = new ArrayList<>(dogs);

А теперь вернемся к глубокой копии собак.

У класса Dog есть только изменяемые поля.

Класс собаки:

public class Dog implements Serializable {
    private String name;
    private int age;

    public Dog() {
        // Class with only mutable fields!
        this.name = "NO_NAME";
        this.age = -1;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

Обратите внимание, что класс Dog реализует Serializable! Это позволяет использовать метод SerializationUtils.clone (dog)

Прочтите комментарии к основному методу, чтобы понять результат. Это показывает, что мы успешно создали глубокую копию ArrayList (). См. Ниже SerializationUtils.clone (dog) в контексте:

public static void main(String[] args) {
    Dog dog1 = new Dog();
    dog1.setName("Buddy");
    dog1.setAge(1);

    Dog dog2 = new Dog();
    dog2.setName("Milo");
    dog2.setAge(2);

    List<Dog> dogs = new ArrayList<>(Arrays.asList(dog1,dog2));

    // Output: 'List dogs: [Dog{name='Buddy', age=1}, Dog{name='Milo', age=2}]'
    System.out.println("List dogs: " + dogs);

    // Let's clone and make a deep copy of the dogs' ArrayList with external package commons-lang3:
    List<Dog> clonedDogs = dogs.stream().map(dog -> SerializationUtils.clone(dog)).collect(Collectors.toList());
    // Output: 'Now list dogs are deep copied into list clonedDogs.'
    System.out.println("Now list dogs are deep copied into list clonedDogs.");

    // A change on dog1 or dog2 can not impact a deep copy.
    // Let's make a change on dog1 and dog2, and test this
    // statement.
    dog1.setName("Bella");
    dog1.setAge(3);
    dog2.setName("Molly");
    dog2.setAge(4);

    // The change is made on list dogs!
    // Output: 'List dogs after change: [Dog{name='Bella', age=3}, Dog{name='Molly', age=4}]'
    System.out.println("List dogs after change: " + dogs);

    // There is no impact on list clonedDogs's inner objects after the deep copy.
    // The deep copy of list clonedDogs was successful!
    // If clonedDogs would be a shallow copy we would see the change on the field
    // "private String name", the change made in list dogs, when setting the names
    // Bella and Molly.
    // Output clonedDogs:
    // 'After change in list dogs, no impact/change in list clonedDogs:\n'
    // '[Dog{name='Buddy', age=1}, Dog{name='Milo', age=2}]\n'
    System.out.println("After change in list dogs, no impact/change in list clonedDogs: \n" + clonedDogs);
}

Вывод:

List dogs: [Dog{name='Buddy', age=1}, Dog{name='Milo', age=2}]
Now list dogs are deep copied into list clonedDogs.
List dogs after change: [Dog{name='Bella', age=3}, Dog{name='Molly', age=4}]
After change in list dogs, no impact/change in list clonedDogs:
[Dog{name='Buddy', age=1}, Dog{name='Milo', age=2}]

Комментарий. Поскольку после изменения списка собак не происходит никаких изменений / изменений в списке clonedDogs, глубокая копия ArrayList успешна!

Alernative 2 - использование внешних пакетов не выполняется:

В классе Dog представлен новый метод clone (), который реализует, что Serializable удален по сравнению с альтернативой 1.

clone()

Класс собаки:

public class Dog {
    private String name;
    private int age;

    public Dog() {
        // Class with only mutable fields!
        this.name = "NO_NAME";
        this.age = -1;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    /**
     * Returns a deep copy of the Dog
     * @return new instance of {@link Dog}
     */
    public Dog clone() {
        Dog newDog = new Dog();
        newDog.setName(this.name);
        newDog.setAge(this.age);
        return newDog;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

Прочтите комментарии к основному методу ниже, чтобы понять результат. Это показывает, что мы успешно создали глубокую копию ArrayList (). См. Ниже метод clone () в контексте:

public static void main(String[] args) {
    Dog dog1 = new Dog();
    dog1.setName("Buddy");
    dog1.setAge(1);

    Dog dog2 = new Dog();
    dog2.setName("Milo");
    dog2.setAge(2);

    List<Dog> dogs = new ArrayList<>(Arrays.asList(dog1,dog2));

    // Output: 'List dogs: [Dog{name='Buddy', age=1}, Dog{name='Milo', age=2}]'
    System.out.println("List dogs: " + dogs);

    // Let's clone and make a deep copy of the dogs' ArrayList:
    List<Dog> clonedDogs = dogs.stream().map(dog -> dog.clone()).collect(Collectors.toList());
    // Output: 'Now list dogs are deep copied into list clonedDogs.'
    System.out.println("Now list dogs are deep copied into list clonedDogs.");

    // A change on dog1 or dog2 can not impact a deep copy.
    // Let's make a change on dog1 and dog2, and test this
    // statement.
    dog1.setName("Bella");
    dog1.setAge(3);
    dog2.setName("Molly");
    dog2.setAge(4);

    // The change is made on list dogs!
    // Output: 'List dogs after change: [Dog{name='Bella', age=3}, Dog{name='Molly', age=4}]'
    System.out.println("List dogs after change: " + dogs);

    // There is no impact on list clonedDogs's inner objects after the deep copy.
    // The deep copy of list clonedDogs was successful!
    // If clonedDogs would be a shallow copy we would see the change on the field
    // "private String name", the change made in list dogs, when setting the names
    // Bella and Molly.
    // Output clonedDogs:
    // 'After change in list dogs, no impact/change in list clonedDogs:\n'
    // '[Dog{name='Buddy', age=1}, Dog{name='Milo', age=2}]\n'
    System.out.println("After change in list dogs, no impact/change in list clonedDogs: \n" + clonedDogs);
}

Вывод:

List dogs: [Dog{name='Buddy', age=1}, Dog{name='Milo', age=2}]
Now list dogs are deep copied into list clonedDogs.
List dogs after change: [Dog{name='Bella', age=3}, Dog{name='Molly', age=4}]
After change in list dogs, no impact/change in list clonedDogs:
[Dog{name='Buddy', age=1}, Dog{name='Milo', age=2}]

Комментарий. Поскольку после изменения списка собак не происходит никаких изменений / изменений в списке clonedDogs, глубокая копия ArrayList успешна!

Примечание 1. Альтернатива 1 намного медленнее, чем Альтернатива 2, но ее легче поддерживать, поскольку вам не нужно обновлять какие-либо методы, такие как clone ().

Примечание 2: для альтернативы 1 для метода SerializationUtils.clone () использовалась следующая зависимость maven:

<!-- https://mvnrepository.com/artifact/org.apache.commons/commons-lang3 -->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.9</version>
</dependency>

Дополнительные выпуски common-lang3 можно найти по адресу:

https://mvnrepository.com/artifact/org.apache.commons/commons-lang3

Остальные плакаты верны: вам нужно перебрать список и скопировать в новый список.

Однако ... Если объекты в списке неизменяемы - их не нужно клонировать. Если ваш объект имеет сложный граф объектов - они также должны быть неизменяемыми.

Другое преимущество неизменяемости заключается в том, что они также являются потокобезопасными.

Вот решение, использующее общий тип шаблона:

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

Простой способ, используя commons-lang-2.3.jar, эту библиотеку java для клонирования списка

ссылка загрузить commons-lang-2.3.jar

Как пользоваться

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

Надеюсь, это может вам помочь.

:D

Пакет import org.apache.commons.lang.SerializationUtils;

Есть способ SerializationUtils.clone(Object);

Пример

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

Я только что разработал библиотеку, которая может клонировать объект сущности и объект java.util.List. Просто загрузите банку в https://drive.google.com/open?id=0B69Sui5ah93EUTloSktFUkctN0U и используйте статический метод cloneListObject (список списка). Этот метод клонирует не только список, но и все элементы сущности.

Ниже сработало для меня ..

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

Здесь новый список, созданный с помощью метода createCopy, создается с помощью SerializationUtils.clone (). Таким образом, любые изменения, внесенные в новый список, не повлияют на исходный список.

Простой способ

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

Думаю, я нашел действительно простой способ сделать полную копию ArrayList. Предполагая, что вы хотите скопировать массив String ArrayList A.

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

Сообщите мне, если это не сработает для вас.