Shallow Copy vs Deep Copy in Java

JavaMidjava

The Question

What is the difference between shallow copy and deep copy in Java?

What a Strong Answer Covers

• shallow copy = new object shares nested object references
• deep copy = new object with independent copies of nested objects
• default clone() is shallow
• deep copy requires manual implementation
• changes to nested affect both in shallow

Senior-Level Answer

A shallow copy creates a new object and copies the top-level field values from the original. For primitive fields, this means the value itself is copied. For reference-type fields, only the reference (memory address) is copied — both the original and the copy point to the same nested objects. Modifying a mutable nested object through the copy will therefore affect the original and vice versa.

A deep copy creates a new object and recursively copies all referenced objects as well, producing a completely independent object graph. The copy shares no mutable state with the original. Modifying any nested object in the copy has no effect on the original.

Java's Object.clone() method performs a shallow copy by default when you override it and call super.clone(). To perform a deep copy via clone(), you must override clone() in each referenced class and explicitly clone each reference field.

Practical approaches for deep copying: override clone() with manual deep copy logic; use copy constructors where each class provides a constructor that takes an instance and copies all fields recursively; use serialization (serialize the object to a byte array and deserialize it back — produces a fully disconnected copy, but requires Serializable and is relatively slow); or use a library like Apache Commons Lang's SerializationUtils.clone() or ModelMapper.

Immutable objects change the calculus. String, Integer, and other immutable types are safe to share — a shallow copy of a field pointing to an immutable object is functionally equivalent to a deep copy because neither party can mutate the shared object.

The right choice depends on your use case. Shallow copies are fast and sufficient for read-only scenarios or objects with only primitive/immutable fields. Deep copies are required when you need fully independent state, such as when storing a snapshot of a mutable object or preventing unintended aliasing bugs.

Key Differences

What Separates a 2/3 from a 3/3

Common Mistakes

• Thinking Object.clone() does a deep copy — it is a shallow copy by default.
• Not mentioning copy constructors as a common, clean alternative to clone() for deep copying.
• Ignoring immutable types: shallow copying a reference to an immutable object is perfectly safe and doesn't require deep copy treatment.

Follow-Up Questions

• What are the problems with using clone() for deep copying? — It requires Cloneable marker interface, throws checked CloneNotSupportedException, every referenced class must also override clone(), and the pattern is error-prone and non-idiomatic.
• How would you implement a deep copy of an object graph using serialization? — Serialize the object to a ByteArrayOutputStream, then deserialize from a ByteArrayInputStream — the deserialized object is completely independent. All types must be Serializable.
• If an object only has primitive fields and String fields, do you need a deep copy? — No — primitives are copied by value, and String is immutable, so a shallow copy is functionally equivalent to a deep copy for such objects.

Related Questions

• JVM vs JRE vs JDK
• Java Platform Independence
• How JVM Works
• Main Features of Java
• public static void main