How to Deep Copy an ArrayList in Java

1. Introduction

In this short tutorial, we’ll learn how to copy an ArrayList in Java, focusing on the different ways to create a deep copy of the elements in the list.

2. Shallow Copy vs. Deep Copy

The shallow copy technique replicates the original object but copies only the references for mutable fields, not the actual objects. On the other hand, deep copy creates an independent copy of all mutable fields, including deeply nested objects. For a detailed guide, refer to our article Differences Between a Deep Copy and a Shallow Copy.

3. Model

Let’s create two classes: Course and Student. The Student class has an instance of the Course object as a mutable dependency:

public class Course {
    private Integer courseId;
    private String courseName;

    // standard getters and setters
}

public class Student {
    private int studentId;
    private String studentName;
    private Course course;

    // standard getters and setters
}

4. Deep Copy Using Cloneable Interface

Let’s implement the marker interface Cloneable and override the clone method in our model classes to create deep copies:

@Override
public Course clone() {
    try {
        return (Course) super.clone();
    } catch (CloneNotSupportedException e) {
        throw new IllegalStateException(e);
    }
}

Note that super.clone() always returns a shallow copy of the object. In the Course class, we don’t have any mutable fields, whereas in the Student class, we need to explicitly set the mutable field to create a deep copy:

@Override
public Student clone() {
    Student student;
    try {
        student = (Student) super.clone();
    } catch (CloneNotSupportedException e) {
        throw new IllegalStateException(e);
    }
    student.course = this.course.clone();
    return student;
}

Now, let’s iterate over the items and use the clone method and verify that a deep copy was created:

public static List<Student> deepCopyUsingCloneable(List<Student> students){
    return students.stream().map(Student::clone).collect(Collectors.toList());
}

@Test
public void whenCreatingCopyWithCloneable_thenObjectsShouldNotBeSame() {
    Course course = new Course(1, "Spring Masterclass");
    Student student1 = new Student(1, "John", course);
    Student student2 = new Student(2, "David", course);
    List<Student> students = new ArrayList<>();
    students.add(student1);
    students.add(student2);

    List<Student> deepCopy = Student.deepCopyUsingCloneable(students);

    Assertions.assertEquals(students.get(0), deepCopy.get(0));
    Assertions.assertNotSame(students.get(0),deepCopy.get(0));
    Assertions.assertEquals(students.get(1), deepCopy.get(1));
    Assertions.assertNotSame(students.get(1),deepCopy.get(1));

}

5. Deep Copy Using Copy Constructor

A copy constructor is a special constructor that takes an argument of its class type and returns a new class instance with the passed values.

Let’s create a copy constructor for the Student object and use it to make a deep copy of each item in the list:

public Student(Student student) {
    this.studentId = student.getStudentId();
    this.studentName = student.getStudentName();
    this.course = new Course(student.getCourse()
      .getCourseId(), student.getCourse()
      .getCourseName());
}

Next, let’s iterate through the items in the list and use the copy constructor created above to make a deep copy of each item in the list and return a new list:

public static List<Student> deepCopyUsingCopyConstructor(List<Student> students){
    return students.stream().map(Student::new).collect(Collectors.toList());
}

In this case, modifying the original ArrayList or the elements in the list doesn’t have any impact on the copied list and vice versa:

@Test
public void whenCreatingDeepCopyWithCopyConstructor_thenObjectsShouldNotBeSame() {

    Course course = new Course(1, "Spring Masterclass");
    Student student1 = new Student(1, "John", course);
    Student student2 = new Student(2, "David", course);

    List<Student> students = new ArrayList<>();
    students.add(student1);
    students.add(student2);

    List<Student> deepCopy = Student.deepCopyUsingCopyConstructor(students);

    Assertions.assertEquals(students.get(0), deepCopy.get(0));
    Assertions.assertNotSame(students.get(0),deepCopy.get(0));
    Assertions.assertEquals(students.get(1), deepCopy.get(1));
    Assertions.assertNotSame(students.get(1),deepCopy.get(1));
}

6. Deep Copy Using Apache Commons Library

The Apache Commons library provides a utility method SerializationUtils.clone() that helps make a deep copy of the objects using serialization and deserialization. For a detailed guide on serialization, refer to our article Java Serialization.

Using this approach ensures that all fields, including deeply nested objects, are duplicated, resulting in a completely independent deep copy:

public static List<Student> deepCopyUsingSerialization(List<Student> students){
    return students.stream().map(SerializationUtils::clone).collect(Collectors.toList());
}

All objects in the object graph must implement the Serializable interface for this to be successful. Otherwise, an exception will be thrown:

@Test
public void whenCreatingDeepCopyWithSerializationUtils_thenObjectsShouldNotBeSame() {

    Course course = new Course(1, "Spring Masterclass");
    Student student1 = new Student(1, "John", course);
    Student student2 = new Student(2, "David", course);

    List<Student> students = new ArrayList<>();
    students.add(student1);
    students.add(student2);

    List<Student> deepCopy = Student.deepCopyUsingSerialization(students);

    Assertions.assertEquals(students.get(0), deepCopy.get(0));
    Assertions.assertNotSame(students.get(0),deepCopy.get(0));
    Assertions.assertEquals(students.get(1), deepCopy.get(1));
    Assertions.assertNotSame(students.get(1),deepCopy.get(1));
}

This saves us from creating cloning logic for complex object structures. However, it’s slightly slower than the other approaches due to the overhead of doing serialization and deserialization.

The latest version of the apache-commons-lang3 library can be found in the Maven Central repository.

7. Deep Copy Using Jackson Library

Jackson is another library that creates a deep copy of the original object using serialization and deserialization. It serializes the object into a JSON string and deserializes it back into a new independent copy:

public static Student createDeepCopy(Student student) {
    ObjectMapper objectMapper = new ObjectMapper();
    try {
        return objectMapper.readValue(objectMapper.writeValueAsString(student), Student.class);
    } catch (JsonProcessingException e) {
        throw new IllegalArgumentException(e);
    }
}

public static List<Student> deepCopyUsingJackson(List<Student> students) {
    return students.stream().map(Student::createDeepCopy).collect(Collectors.toList());
}

Note that Jackson needs a default constructor to be present to serialize and deserialize any given object:

@Test
public void whenCreatingDeepCopyWithJackson_thenObjectsShouldNotBeSame() {

    Course course = new Course(1, "Spring Masterclass");
    Student student1 = new Student(1, "John", course);
    Student student2 = new Student(2, "David", course);

    List<Student> students = new ArrayList<>();
    students.add(student1);
    students.add(student2);

    List<Student> deepCopy = Student.deepCopyUsingJackson(students);

    Assertions.assertEquals(students.get(0), deepCopy.get(0));
    Assertions.assertNotSame(students.get(0),deepCopy.get(0));
    Assertions.assertEquals(students.get(1), deepCopy.get(1));
    Assertions.assertNotSame(students.get(1),deepCopy.get(1));
}

The latest version of the jackson-databind library can be found in the Maven Central repository.

8. Conclusion

In this tutorial, we covered various ways of copying an ArrayList, including both native approaches and the usage of third-party libraries.