Shallow copy and deep copy is related with cloning process so before go into the deep of shallow and deep copy we need to understand what is clone in java. Clone is nothing but the process of copying one object to produce the exact object, which is not guaranteed. We all know in Java object is referred by reference we can not copy one object directly to another object. So we have cloning process to achieve this objective. Now one question arise in mind why we need this process so the answer is whenever we need local copy of the object to modify the object in some method but not in method caller. So we can define Cloning as “create a copy of object “ .I think now we are some how clear about the cloning but there is more on it depending upon how we are doing this copy, we can divide cloning in two types.
- Shallow Copy
- Deep Copy
Before going into the deep of shallow and deep copy we need to understand how we achieve cloning in java.
How will you achieve cloning in java?
In Java everything is achieved through class, object and interface .By default no Java class support cloning but Java provide one interface called Cloneable, which is a marker interface and by implementing this interface we can make duplicate copy of our object by calling clone() method of java.lang.Object class. This Method is protected inside the object class and Cloneable interface is a marker interface and this method also throw CloneNotSupportedException if we have not implement this interface and try to call clone() method of Object class. By default any clone() method gives shallow copy of the object i.e. if we invoke super. clone() then it’s a shallow copy but if we want to deep copy we have to override the clone() method and make it public and give own definition of making copy of object. Now we let’s see what is shallow and deep copy of object in Java programming language.
Whenever we use default implementation of clone method we get shallow copy of object means it create new instance and copy all the field of object to that new instance and return it as object type we need to explicitly cast it back to our original object. This is shallow copy of the object. clone() method of the object class support shallow copy of the object. If the object contains primitive as well as non primitive or reference type variable In shallow copy, the cloned object also refers to the same object to which the original object refers as only the object references gets copied and not the referred objects themselves. That's why the name shallow copy or shallow cloning in Java. If only primitive type fields or Immutable objects are there then there is no difference between shallow and deep copy in Java.
Deep CopyWhenever we need own meaning of copy not to use default implementation we call it as deep copy, whenever we need deep copy of the object we need to implement according to our need. So for deep copy we need to ensure all the member class also implement the Cloneable interface and override the clone() method of the object class. After that we override the clone() method in all those classes even in the classes where we have only primitive type members otherwise we would not be able to call the protected clone() method of Object class on the instances of those classes inside some other class. It’s typical restriction of the protected access.
Difference between Shallow and Deep Copy in Java
I think now we know what is deep and shallow copy of object in Java, let see some difference between them so that we can get some more clarity on them.
- When we call Object.clone(), this method
performs a shallow copy of object, by copying data field by field, and if we
override this method and by convention first call super.clone(), and then modify
some fields to "deep" copy, then we get deep copy of object. This
modification is done to ensure that original and cloned object are independent
to each other.
- In shallow copy main or parent object is copied, but
they share same fields or children if fields are modified in one parent object
other parent fields have automatic same changes occur,but in deep copy this is
not the case.
- If our parent object contains only primitive value
then shallow copy is good for making clone of any object because in new object
value is copied but if parent object contains any other object then only reference value is copied in new parent object and both will point to same
object so in that case according to our need we can go for deep copy.
- Deep copy is expensive as compare to shallow copy in terms of object creation, because it involves recursive copying of data from other mutable objects, which is part of original object.
This is all about deep copy and shallow copy of objects in Java. Now the question comes when we use shallow copy and when go for deep copy , so answer would be simple that if the object has only primitive fields or Immutable objects, then obviously we will go for shallow copy, but if the object has references to other mutable objects, then based on the requirement, shallow copy or deep copy can be chosen. Means if the references are not modified anytime, then there is no point in going for deep copy, We can go for shallow copy. But if the references are modified often, then you need to go for deep copy. Again there is no hard and fast rule, it all depends on the requirement.
Hope this article will help to make clear about deep and shallow copy of cloning process.
Related Java Interview Questions articles from Java67 BlogDifference between ConcurrentHashMap vs HashMap in Java