Difference Between Shallow Copy and Deep Copy in Java

When working with Java, you often need to duplicate objects. This is where shallow copy and deep copy come into play. Understanding the difference between shallow copy and deep copy in Java is essential for managing object references and ensuring correct behavior in your programs. Let’s dive into what these concepts mean and how to implement them effectively.

Shallow Copy in Java

A shallow copy of an object creates a new instance, but it only duplicates the references to the fields of the original object. If the object contains references to other objects (e.g., arrays or other classes), those references are shared between the original and the copy. This can lead to unexpected behavior if the referenced objects are modified.

Characteristics of Shallow Copy:

1. Only the top-level fields of the object are copied.
2. Fields that reference other objects point to the same instances as in the original object.
3. Changes to referenced objects affect both the original and the copy.

import java.util.Arrays;

class ShallowCopyExample implements Cloneable {
    int[] numbers;

    ShallowCopyExample(int[] numbers) {
        this.numbers = numbers;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    public static void main(String[] args) throws CloneNotSupportedException {
        int[] nums = {1, 2, 3};
        ShallowCopyExample original = new ShallowCopyExample(nums);
        ShallowCopyExample shallowCopy = (ShallowCopyExample) original.clone();

        // Modify the original object's array
        original.numbers[0] = 10;

        // Both the original and the shallow copy reflect the change
        System.out.println("Original: " + Arrays.toString(original.numbers)); // [10, 2, 3]
        System.out.println("Shallow Copy: " + Arrays.toString(shallowCopy.numbers)); // [10, 2, 3]
    }
}

Deep Copy in Java

A deep copy duplicates the object as well as all the objects it references. In other words, it creates a completely independent copy of the original object. Changes made to the original or its nested objects do not affect the deep copy, and vice versa.

Characteristics of Deep Copy:

1. The entire object graph is duplicated.
2. Fields that reference other objects are also cloned.
3. The original and the deep copy are completely independent.

import java.util.Arrays;

class DeepCopyExample implements Cloneable {
    int[] numbers;

    DeepCopyExample(int[] numbers) {
        this.numbers = numbers;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        DeepCopyExample copy = (DeepCopyExample) super.clone();
        // Clone the numbers array to create a deep copy
        copy.numbers = numbers.clone();
        return copy;
    }

    public static void main(String[] args) throws CloneNotSupportedException {
        int[] nums = {1, 2, 3};
        DeepCopyExample original = new DeepCopyExample(nums);
        DeepCopyExample deepCopy = (DeepCopyExample) original.clone();

        // Modify the original object's array
        original.numbers[0] = 10;

        // Only the original reflects the change
        System.out.println("Original: " + Arrays.toString(original.numbers)); // [10, 2, 3]
        System.out.println("Deep Copy: " + Arrays.toString(deepCopy.numbers)); // [1, 2, 3]
    }
}

Understanding the difference between shallow copy and deep copy in Java comes down to whether referenced objects are duplicated or shared.

When to Use Each

Shallow Copy is suitable for simple objects or when you don’t expect modifications to nested objects.

Deep Copy is necessary for complex objects with multiple levels of references, especially when the original and the copy need to operate independently.

Choose the appropriate copy mechanism based on your use case and remember that creating a deep copy might require custom cloning logic for objects with complex structures.