Java: how to clone ArrayList but also clone its items?

Question

Hello,

How can I clone Array List but also clone its items in Java 1.5?

For example I have:

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

And I would expect that objects in clonedList are not the same as in dogs list.

Thanks for any answer!

Answer 1

You will need to iterate on the items, and clone them one by one, putting the clones in your result array as you go.

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

For that to work, obviously, you will have to get your Dog object to implement the Cloneable interface, and the clone() method.

Answer 2

You will need to clone the ArrayList by hand (by iterating over it and copying each element to a new ArrayList), because clone() will not do it for you. Reason for this is that the objects contained in the ArrayList may not implement Clonable themselves.

Edit: ... and that is exactly what Varkhan's code does.

Answer 3

Here's yet another approach, presumably a fast approach: http://javatechniques.com/blog/faster-deep-copies-of-java-objects/

Answer 4

I, personally, would add a constructor to Dog:

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

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

Then just iterate (as shown in Varkhan's answer):

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

I find the advantage of this is you don't need to screw around with the broken Cloneable stuff in Java. It also matches the way that you copy Java collections.

Another option could be to write your own ICloneable interface and use that. That way you could write a generic method for cloning.

Answer 5

It was already discussed in Deep clone utility recomendation question

Answer 6

The other posters are correct: you need to iterate the list and copy into a new list.

However... If the objects in the list are immutable - you don't need to clone them. If your object has a complex object graph - they will need to be immutable as well.

The other benefit of immutability is that they are threadsafe as well.

Answer 7

I think the current green answer is bad , why you might ask?

• It can require to add a lot of code
• It requires you to list all Lists to be copied and do this

The way serialization is also bad imo, you might have to add Serializable all over the place.

So what is the solution:

Java Deep-Cloning library The cloning library is a small, open source (apache licence) java library which deep-clones objects. The objects don't have to implement the Cloneable interface. Effectivelly, this library can clone ANY java objects. It can be used i.e. in cache implementations if you don't want the cached object to be modified or whenever you want to create a deep copy of objects.

Cloner cloner=new Cloner();
cloner.deepClone(someObject);

Check it out at http://robust-it.co.uk/clone/index.php

Answer 8

In addition to the "Java Deep Cloning Library", there's also the utility at http://www.genericdeepcopy.com/. It's aim is to deep copy any Java object (non-Serializable objects), which it does, and which as cdmckay mentioned is slower than custom code.