Shallow Copy vs Deep Copy in Java

In this post, we will learn the difference between Shallow Copy and Deep Copy in Java. This is a frequently asked question in Java interviews for beginners. Let's dive into it.

Difference between Shallow Copy and Deep Copy in Java

Feature	Shallow Copy	Deep Copy
Definition	A shallow copy creates a new object, but it does not create new instances of the object's non-primitive fields. Instead, it copies references to the same objects in memory.	A deep copy creates a new object and also creates new instances of all the object's non-primitive fields. It recursively copies the entire object graph, including all the objects referenced by the original object.
Contents	The shallow copy and the original object share the same non-primitive fields. Changes made to these fields in one object are reflected in the other.	The deep copy and the original object have separate copies of all non-primitive fields. Changes made to these fields in one object do not affect the other.
Memory Allocation	A shallow copy requires less memory because it only duplicates references to existing objects.	A deep copy requires more memory because it creates new instances of all the non-primitive fields.
Performance	A shallow copy is faster to create than a deep copy because it involves copying only references.	A deep copy can be slower to create, especially for complex object graphs, as it involves recursively copying multiple objects.
Nested Objects	A shallow copy does not create copies of nested objects. It only copies references to them.	A deep copy creates separate copies of all nested objects, including those nested multiple levels deep.
Dependency on Object Structure	A shallow copy depends on the structure of the object. If an object contains references to other objects, those references will also be shared.	A deep copy is independent of the object's structure. It creates new copies of all objects in the object graph, regardless of how they are referenced.
Implementation	A shallow copy can be achieved using the Object.clone() method or manually copying references to fields.	A deep copy usually requires custom implementation using serialization, copy constructors, or third-party libraries.