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:

class Person {
    String name;
    Address address;
// Constructor and other methods...
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
class Address {
    String city;
    String country;
    // Constructor and other methods...
}

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:

import java.io.*;
class DeepCopy {
    public static <T> T deepClone(T object) throws IOException, ClassNotFoundException {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(object);
        oos.flush();
        ByteArrayInputStream bin = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bin);
        return (T) ois.readObject();
    }
}

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: CloningExample.java

import java.io.*;
class Address implements Serializable {
    String city;
    String country;
    public Address(String city, String country) {
        this.city = city;
        this.country = country;
    }
    @Override
    public String toString() {
        return "Address{" +
                "city='" + city + '\'' +
                ", country='" + country + '\'' +
                '}';
    }
}
class Person implements Cloneable, Serializable {
    String name;
    Address address;
    public Person(String name, Address address) {
        this.name = name;
        this.address = address;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", address=" + address +
                '}';
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
public class CloningExample {
    public static <T> T deepClone(T object) throws IOException, ClassNotFoundException {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(object);
        oos.flush();
        ByteArrayInputStream bin = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bin);
        return (T) ois.readObject();
    }
    public static void main(String[] args) {
        // Creating objects
        Address address = new Address("CityA", "CountryA");
        Person originalPerson = new Person("John", address);
        try {
            // Shallow cloning
            Person shallowClonePerson = (Person) originalPerson.clone();
            // Deep cloning
            Person deepClonePerson = deepClone(originalPerson);
            // Modifying the original objects
            originalPerson.name = "UpdatedJohn";
            originalPerson.address.city = "UpdatedCityA";
            // Displaying original, shallow cloned, and deep cloned objects
            System.out.println("Original Person: " + originalPerson);
            System.out.println("Shallow Cloned Person: " + shallowClonePerson);
            System.out.println("Deep Cloned Person: " + deepClonePerson);
        } catch (CloneNotSupportedException | IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

Output:

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.

Explanation

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.

Next TopicDots and Boxes Game Java Source code

← prev next →