Java Cloning Interview Questions

Java supports two type of cloning: - Deep and shallow cloning. By default shallow clone is used in Java. Object class has a method clone() which does shallow cloning.
Shallow clone is copying the reference pointer to the object, which means the new object is pointing to the same memory
reference of the old object. The memory usage is lower. 

The shallow copy is done for obj and new object obj1 is created but contained objects of obj are not copied. 

It can be seen that no new objects are created for obj1 and it is referring to the same old contained objects. If either of 
the contained Obj contain any other object than no new reference is created.
Deep copy is the copy of object itself. A new memory is allocated for the object and contents are copied. When a deep copy of the object is done new references are created. One solution is to simply implement your own custom method (e.g., deepCopy()) that returns a deep copy of an instance of one of your classes. This may be the best solution if you need a complex mixture of deep and shallow copies for different fields, but has a few significant drawbacks:
  • You must be able to modify the class (i.e., have the source code) or implement a subclass.If you have a third-party class for which you do not have the source and which is marked final, you are out of luck.
  • You must be able to access all of the fields of the class's superclasses. If significant parts of the object's state are contained in private fields of a superclass, you will not be able to access them.
  • You must have a way to make copies of instances of all of the other kinds of objects that the object references. This is particularly problematic if the exact classes of referenced objects cannot be known until runtime.
  • Custom deep copy methods are tedious to implement, easy to get wrong, and difficult to maintain. The method must be revisited any time a change is made to the class or to any of its superclasses. Other common solution to the deep copy problem is to use Java Object Serialization (JOS). The idea is simple: Write the object to an array using ObjectOutputStream and then use ObjectInputStream to reconsistute a copy of the object. The result will be a completely distinct object, with completely distinct referenced objects. JOS takes care of all of the details: superclass fields,following object graphs, and handling repeated references to the same object within the graph.
  • It will only work when the object being copied,as well as all of the other objects references directly or indirectly by the object,are serializable. (In other words, they must implement Fortunately it is often sufficient to simply declare that a given class implements and let Java's default serialization mechanisms do their thing. Java Object Serialization is slow, and using it to make a deep copy requires both serializing and deserializing.
There are ways to speed it up (e.g., by pre-computing serial version ids and defining custom readObject() and writeObject() methods),but this will usually be the primary bottleneck. The byte array stream implementations included in the package are designed to be general enough to perform reasonable well for data of different sizes and to be safe to use in a multi-threaded environment. These characteristics, however, slow down ByteArrayOutputStream and (to a lesser extent) ByteArrayInputStream.
The differences are as follows: Consider a class: public class MyData { String id; Map myData; } The shallow copying of this object will be pointing to the same memory reference as the original object. So a change in myData by either original or cloned object will be reflected in other also. But in deep copying there will memory allocated and values assigned to the property will be same. Any change in object will not be reflected in other. Shallow copying is default cloning in Java which can be achieved using Object.clone() method of Object class. For deep copying override the clone method to create new object and copy its values.
Disadvantages of using Serialization to achieve deep cloning –
  • Serialization is more expensive than using object.clone().
  • Not all objects are serializable.
  • Serialization is not simple to implement for deep cloned object.