Deep Copy vs. Shallow Copy vs. Clone in Java

In Java, "deep copy", "shallow copy", and "clone" are frequently used but poorly defined terms. Each concept requires clarification to ensure proper understanding.

Copying Values vs. Copying Objects

Before discussing copy types, it's essential to differentiate between copying values and copying objects:

• Copying a Value: Copying a value of a reference type involves assigning the object reference, akin to copying an integer.
• Copying an Object: Creating a new object, with its own identity, involves using "new" explicitly or implicitly.

Shallow Copy vs. Deep Copy of Objects

• Shallow Copy: A new object is created with the same values as the original, but references to embedded objects are shared.
• Deep Copy: A new object is created with the same values as the original, but references to embedded objects are also copied, resulting in a complete duplication of the entire object network.

Consider the following example:

class Example {
  int foo;
  int[] bar;
  ...
}

Example eg1 = new Example(1, new int[]{1, 2});
Example eg2 = ...

A shallow copy of eg1 would be:

Example eg2 = new Example(eg1.foo, eg1.bar);

A deep copy of eg1 would be:

Example eg2 = new Example(eg1.foo, Arrays.copy(eg1.bar));

Clone

Unlike shallow and deep copies, clone is a method available in all Java classes and arrays. However, it's important to note:

• The specification of clone does not define whether it produces a shallow or deep copy.
• Clone does not necessarily create a new object.
• The semantics of clone can vary significantly across different classes.

Hence, using clone can be unpredictable and challenging to manage.

Conclusion

While these terms are frequently used in Java, their definitions can vary widely. Understanding the nuances of shallow copy, deep copy, and clone is crucial for accurate object duplication. It's also important to keep in mind the limitations of clone and approach it with caution.