Services
Technology Web App Development Mobile App Development Windows App Development Database Development UI/UX Development Cloud Development SEO Digital Marketing Guest Posting Content Writing Artificial Intelligence Data Science ERP Development CRM Development CMS Development LMS Development Business Listing Blockchain Technology Startup Promotion AI Tools Integration
Products
Data Converter Cleaner TUC - Unit Converter Import Export Survey Manager Tweet Controller
Developer
Article Blog Forum Interview Beginner News Startup Quiz
Users
Career
Apply Job Internship
Pricing
Login Sign Up Get a Quote

interview

Home Interviews Discuss the differences between deep copy and shallow copy in Java objects. – MindStick
Ask Question

1 Answers

Ravi Vishwakarma
Ravi Vishwakarma 17 Jul 2024
Report Abuse

In Shallow copy, a copy of the original object is stored and only the reference address is finally copied. In Deep copy, the copy of the original object and the repetitive copies both are stored.

Ravi Vishwakarma

Shallow Copy

A shallow copy of an object is a new object whose fields are the same as the original object. However, if the field is a reference to an object, the reference is copied, but the referred object is not. Consequently, both the original object and the shallow copy will reference the same nested objects.

Characteristics of Shallow Copy:

  1. Field-by-Field Copying: The primitive fields (like int, char, etc.) are copied directly.
  2. Shared References: For object fields, only the reference is copied, not the object itself. Therefore, changes to the referred objects affect both the original and the copied objects.
  3. Default Behavior: The default clone method in Java's Object the class performs a shallow copy.

Example:

class Address {
    String city;
    Address(String city) {
        this.city = city;
    }
}

class Person implements Cloneable {
    String name;
    Address address;

    Person(String name, Address address) {
        this.name = name;
        this.address = address;
    }

    protected Object clone() throws CloneNotSupportedException {
        return super.clone(); // Shallow copy
    }
}

public class ShallowCopyExample {
    public static void main(String[] args) throws CloneNotSupportedException {
        Address address = new Address("New York");
        Person person1 = new Person("John", address);
        Person person2 = (Person) person1.clone();

        System.out.println(person1.address.city); // Output: New York
        System.out.println(person2.address.city); // Output: New York

        person2.address.city = "Los Angeles";
        System.out.println(person1.address.city); // Output: Los Angeles
        System.out.println(person2.address.city); // Output: Los Angeles
    }
}

Deep Copy

A deep copy of an object involves creating a new object and then recursively copying all objects referenced by the original object. Consequently, changes to the objects referenced by the original object do not affect the deep copy.

Characteristics of Deep Copy:

  1. Independent Copies: All objects referenced by the original object are also copied, resulting in a completely independent copy.
  2. Recursive Copying: Requires implementing cloning for each referenced object to ensure complete independence.
  3. Custom Implementation: Java does not provide a default deep copy method, so it must be implemented manually.

Example:

class Address implements Cloneable {
    String city;
    Address(String city) {
        this.city = city;
    }

    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

class Person implements Cloneable {
    String name;
    Address address;

    Person(String name, Address address) {
        this.name = name;
        this.address = address;
    }

    protected Object clone() throws CloneNotSupportedException {
        Person cloned = (Person) super.clone();
        cloned.address = (Address) address.clone(); // Deep copy
        return cloned;
    }
}

public class DeepCopyExample {
    public static void main(String[] args) throws CloneNotSupportedException {
        Address address = new Address("New York");
        Person person1 = new Person("John", address);
        Person person2 = (Person) person1.clone();

        System.out.println(person1.address.city); // Output: New York
        System.out.println(person2.address.city); // Output: New York

        person2.address.city = "Los Angeles";
        System.out.println(person1.address.city); // Output: New York
        System.out.println(person2.address.city); // Output: Los Angeles
    }
}

Summary

  • Shallow Copy: Only copies primitive fields and references to objects, leading to shared references.
  • Deep Copy: Recursively copies all objects, resulting in completely independent copies.

Read more

What is the difference between JDK, JRE, and JVM?

Bitwise AND, OR, XOR, and left/right shift operations.

advertising
Markdown for AI

A clean, structured version of this page for AI assistants and LLMs.

Open .md