Javatpoint Logo
Javatpoint Logo

Difference Between Shallow and Deep Cloning in Java

Cloning is a fundamental concept in Java that allows developers to create a duplicate copy of an object. This process is essential for various scenarios, such as preserving the state of an object, creating backups, or implementing certain design patterns. However, Java provides two distinct types of cloning mechanisms: shallow cloning and deep cloning. Understanding the differences between these two approaches is crucial for effective object replication and avoiding unexpected behavior in code.

Shallow Cloning

Shallow cloning creates a new object but does not create copies of the objects referenced by the original object. Instead, it copies the references to those objects. As a result, both the original and the cloned object share references to the same objects. Shallow cloning is a quick and efficient process, but it has some limitations, especially when dealing with complex object structures.

Let's consider an example:

In this example, if we perform a shallow clone of a Person object, the name attribute will be copied, but both the original and the cloned Person objects will reference the same Address object. Changes made to the Address object through one instance will be reflected in the other.

Deep Cloning

Deep cloning, on the other hand, creates a completely independent copy of the original object along with copies of all the objects referenced by it. This ensures that changes made to the cloned object or its nested objects do not affect the original object and vice versa. However, deep cloning can be more resource-intensive and may involve complex object traversal.

To implement deep cloning, one commonly used approach is to serialize and deserialize the object, effectively creating a new copy with no shared references. Here's an example using the ObjectOutputStream and ObjectInputStream classes:

It's important to note that for an object to be deep-clonable, all its nested objects must also support cloning or serialization.

Choosing Between Shallow and Deep Cloning

The choice between shallow and deep cloning depends on the specific requirements of our application. Shallow cloning is faster and simpler, suitable for situations where shared references are acceptable. However, if you need a truly independent copy of an object and its nested objects, deep cloning is the safer choice, albeit with a potentially higher performance cost.

File Name:


Original Person: Person{name='UpdatedJohn', address=Address{city='UpdatedCityA', country='CountryA'}}
Shallow Cloned Person: Person{name='John', address=Address{city='UpdatedCityA', country='CountryA'}}
Deep Cloned Person: Person{name='John', address=Address{city='CityA', country='CountryA'}}

Note: The output might vary based on the version of Java we are using. The key point to observe is how changes to the original object affect the cloned objects.


In this example, we have a Person class containing a name and an Address object. The Address class is made serializable for deep cloning. The CloningExample class demonstrates the creation of an original Person object and the generation of shallow and deep clones. The output will showcase the differences between shallow and deep cloning.

Original Person:

The original Person object is modified with a new name ("UpdatedJohn") and an updated city in the Address object ("UpdatedCityA").

Shallow Cloned Person:

The shallow clone (shallowClonePerson) reflects the changes made to the original Person object. Both the original and shallow clone share references to the same Address object, so changes to the Address object are visible in both.

Deep Cloned Person:

The deep clone (deepClonePerson) remains unaffected by the changes made to the original Person object. It has its own copy of the Address object, created through the deep cloning process. Therefore, changes to the original or shallow clone do not impact the deep clone.

This output highlights the differences between shallow and deep cloning, illustrating how changes to nested objects are managed in each scenario.

Shallow Vs. Deep Cloning in Java

Aspect Shallow Cloning Deep Cloning
Copying Approach Creates a new object but shares references to nested objects. Creates a completely independent copy along with copies of nested objects.
Performance Generally faster and more efficient. Can be slower, especially for complex object structures.
Object References Original and clone share references to the same nested objects. Original and clone have independent copies of nested objects.
Changes to Original Object Changes affect the clone and vice versa for shared references. Changes in one object do not affect the other due to independent copies.
Implementation Utilizes the clone() method or manual copying of object fields. Often involves serialization and deserialization for creating deep copies.
Nested Object Requirements No specific requirements for nested objects. All nested objects must support cloning or serialization for deep cloning.

The table summarizes key distinctions between shallow and deep cloning, providing a quick reference for understanding their characteristics and use cases in Java.

In conclusion, understanding the difference between shallow and deep cloning in Java is essential for writing robust and maintainable code. Whether we opt for the efficiency of shallow cloning or the isolation of deep cloning depends on the specific needs of our application and the nature of the objects we are working with.

Youtube For Videos Join Our Youtube Channel: Join Now


Help Others, Please Share

facebook twitter pinterest

Learn Latest Tutorials


Trending Technologies

B.Tech / MCA