深拷贝和浅拷贝是编程中常见的概念,尤其在处理对象复制时尤为重要。
它们之间的主要区别在于复制的深度和对象间的独立性。
浅拷贝(Shallow Copy)
浅拷贝是对象的逐位复制,它会创建一个新对象,该对象具有原始对象中值的精确副本。
但是,如果对象的任何字段是对其他对象的引用(即引用数据类型),则只复制引用地址,即复制内存地址。
这意味着浅拷贝后的两个对象会指向同一个内存地址,因此修改其中一个对象的属性,另一个对象的对应属性也会发生变化。
特点:
- 复制速度快,开销小。
- 修改一个对象的引用类型属性会影响另一个对象。
实现方式:
- 在JavaScript中,使用Object.assign()方法可以实现浅拷贝,但需要注意,如果对象的属性值为引用类型,则实际上是浅拷贝。
- 在Java中,如果类没有定义拷贝构造函数,则默认使用浅拷贝。
深拷贝(Deep Copy)
深拷贝不仅复制对象本身,还复制对象引用的其他对象,即它会为所有引用的对象开辟新的内存空间,实现真正内容上的拷贝。
这样,深拷贝后的两个对象是完全独立的,修改其中一个对象的属性不会影响另一个对象。
特点:
- 复制速度慢,开销大。
- 修改一个对象的属性不会影响另一个对象。
实现方式:
- 
在JavaScript中,可以使用 JSON.parse(JSON.stringify(obj))实现深拷贝,但需要注意,这种方法不能处理循环引用、undefined、function、symbol、Date等特殊对象。
- 
手动实现递归方法也是常见的深拷贝方式,通过递归遍历对象,对每个属性进行拷贝,如果是引用类型则继续递归拷贝。 
- 
在Java中,如果类实现了 Cloneable接口并重写了clone()方法,可以实现深拷贝,但需要注意,在clone()方法内部,也需要对引用类型的成员变量进行深拷贝。
应用场景
- 
深拷贝: - 保留原始数据的完整性,确保修改副本不会影响原始数据。
- 处理含有循环引用的对象,避免在拷贝过程中出现无限循环。
- 避免共享引用导致的意外修改,确保对象的独立性。
 
- 
浅拷贝: - 复制简单的数据结构,如基本数据类型或简单的对象和数组。
- 传递引用而不是副本,减少内存开销。
- 缓存数据,避免频繁获取数据。
 
示例讲解
首先,我们来看一个浅拷贝的例子:
            
            
              java
              
              
            
          
          class Person {
    private String name;
    private Address address;
    public Person(String name, Address address) {
        this.name = name;
        this.address = address;
    }
    // Getters and Setters omitted for brevity
    @Override
    public String toString() {
        return "Person{name='" + name + "', address=" + address + "}";
    }
    // Shallow copy method
    public Person shallowCopy() {
        return new Person(this.name, this.address); // Note: address is copied by reference
    }
}
class Address {
    private String city;
    public Address(String city) {
        this.city = city;
    }
    // Getters and Setters omitted for brevity
    @Override
    public String toString() {
        return "Address{city='" + city + "'}";
    }
}
public class ShallowCopyExample {
    public static void main(String[] args) {
        Address address = new Address("New York");
        Person person1 = new Person("Alice", address);
        Person person2 = person1.shallowCopy(); // Create a shallow copy
        System.out.println("Original: " + person1);
        System.out.println("Shallow Copy: " + person2);
        // Change the address in the shallow copy
        person2.getAddress().setCity("Los Angeles");
        // This will also affect the original because address is shared
        System.out.println("After modifying address in shallow copy:");
        System.out.println("Original: " + person1);
        System.out.println("Shallow Copy: " + person2);
    }
}讲解:
- 在这个例子中,Person类包含了一个Address类的引用。
- shallowCopy()方法创建了一个新的- Person对象,但是- address字段是通过引用复制的,所以- person1和- person2共享同一个- Address对象。
- 当我们修改 person2的address时,person1的address也会受到影响,因为它们指向的是同一个对象。
深拷贝示例代码
接下来,我们看一个深拷贝的例子:
            
            
              java
              
              
            
          
          class Person {
    private String name;
    private Address address;
    public Person(String name, Address address) {
        this.name = name;
        this.address = address;
    }
    // Getters and Setters omitted for brevity
    @Override
    public String toString() {
        return "Person{name='" + name + "', address=" + address + "}";
    }
    // Deep copy method
    public Person deepCopy() {
        // Create a new Address object with the same city as the original
        Address newAddress = new Address(this.address.getCity());
        return new Person(this.name, newAddress); // Note: address is copied by value (i.e., a new object is created)
    }
}
class Address {
    private String city;
    public Address(String city) {
        this.city = city;
    }
    // Getters and Setters omitted for brevity
    @Override
    public String toString() {
        return "Address{city='" + city + "'}";
    }
}
public class DeepCopyExample {
    public static void main(String[] args) {
        Address address = new Address("New York");
        Person person1 = new Person("Alice", address);
        Person person2 = person1.deepCopy(); // Create a deep copy
        System.out.println("Original: " + person1);
        System.out.println("Deep Copy: " + person2);
        // Change the address in the deep copy
        person2.getAddress().setCity("Los Angeles");
        // This will not affect the original because each Person has its own Address object
        System.out.println("After modifying address in deep copy:");
        System.out.println("Original: " + person1);
        System.out.println("Deep Copy: " + person2);
    }
}讲解:
- 在这个例子中,deepCopy()方法不仅创建了一个新的Person对象,还创建了一个新的Address对象,并复制了原始Address对象的city字段。
- 因此,person1和person2拥有不同的Address对象。
- 当我们修改 person2的address时,person1的address不会受到影响,因为它们指向的是不同的对象。
最后
- 
浅拷贝:只复制对象本身,不复制对象中的引用类型字段所指向的对象。因此,浅拷贝后的两个对象会共享一些内部状态。 
- 
深拷贝:不仅复制对象本身,还复制对象中的引用类型字段所指向的对象。因此,深拷贝后的两个对象是完全独立的。