What is the difference between shallow copy and deep copy in Java?

The difference between shallow copy and deep copy: Shallow copy: Create an object that references the same data, and changing the copy will also affect the original object. Deep copy: Create an object that contains a copy of the original object's data. Changing the copy will not affect the original object.

Shallow copy and deep copy in Java

Introduction

In Java , understanding the concepts of shallow copy and deep copy is crucial for object operations. This tutorial details the differences between the two and illustrates them with code examples.

Shallow copy

• Creates a new object that references the same underlying data of the original object.
• Any changes to the shallow copy will also be reflected on the original object, and vice versa.
• Follow the "reference to the same " principle.

Code example:

class Person {
    private String name;
    private Address address;
}

public class ShallowCopyDemo {

    public static void main(String[] args) {
        Person p1 = new Person();
        p1.setName("John Doe");
        Address addr = new Address();
        addr.setStreet("123 Main St.");
        p1.setAddress(addr);

        // Shallow copy
        Person p2 = p1;

        // 更改 p2 的地址
        p2.getAddress().setStreet("456 Elm St.");

        // p1 的地址也发生了变化
        System.out.println(p1.getAddress().getStreet()); // 输出：456 Elm St.
    }
}

In this example, p2 is a shallow copy of p1, they References the same Address object. Therefore, changes to the address of p2 will also affect p1.

Deep copy

• Creates a new object that has an independent copy of the underlying data of the original object.
• Changing the deep copy will not affect the original object and vice versa.
• Follow the principle of "same content".

Code example:

Use the clone() method or a third-party library (such as Apache Commons Lang) to implement deep copy.

Using the clone() method:

class Person implements Cloneable {
    private String name;
    private Address address;

    @Override
    public Person clone() {
        try {
            // 使用 super.clone() 创建新对象
            return (Person) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return null;
    }
}

public class DeepCopyDemo {

    public static void main(String[] args) {
        Person p1 = new Person();
        p1.setName("John Doe");
        Address addr = new Address();
        addr.setStreet("123 Main St.");
        p1.setAddress(addr);

        // Deep copy
        Person p2 = p1.clone();

        // 更改 p2 的地址
        p2.getAddress().setStreet("456 Elm St.");

        // p1 的地址保持不变
        System.out.println(p1.getAddress().getStreet()); // 输出：123 Main St.
    }
}

In this example, the clone() method is created for p1 A deep copy. Changing the address of p2 will not affect p1 because they refer to different Address objects.

When to use deep copy or shallow copy?

• Shallow copy: Shallow copy can be performed when there are no side effects on modifying the copy of the object.
• Deep copy: When modifying the copy of the object may affect the original object, a deep copy must be made.

For example, be sure to use deep copies when caching objects or passing them to untrusted code.

The above is the detailed content of What is the difference between shallow copy and deep copy in Java?. For more information, please follow other related articles on the PHP Chinese website!