java中的三种拷贝方法

大家好，欢迎来到IT知识分享网。

在Java编程中，理解深拷贝（Deep Copy）、浅拷贝（Shallow Copy）和引用拷贝（Reference Copy）是非常重要的。这三种拷贝方式涉及对象复制和内存管理。以下是对它们的详细解释：

1. 引用拷贝（Reference Copy）

引用拷贝是最简单的一种拷贝方式。它只复制对象的引用，而不复制对象本身。换句话说，原始对象和新对象共享同一个内存地址。

Person person1 = new Person("Alice"); Person person2 = person1; // 引用拷贝 person2.setName("Bob"); System.out.println(person1.getName()); // 输出 "Bob" System.out.println(person2.getName()); // 输出 "Bob" 

在上述代码中，person1和person2指向同一个对象，所以改变其中一个对象的属性，另一个对象的属性也会被改变。

2. 浅拷贝（Shallow Copy）

浅拷贝会创建一个新对象，但新对象中的成员变量（如果是对象）仍然是原对象的引用。浅拷贝仅复制对象的第一层属性。

可以通过实现Cloneable接口并重写clone方法来实现浅拷贝：

class Address { 
    String city; public Address(String city) { 
    this.city = city; } } class Person implements Cloneable { 
    String name; Address address; public Person(String name, Address address) { 
    this.name = name; this.address = address; } @Override protected Object clone() throws CloneNotSupportedException { 
    return super.clone(); // 浅拷贝 } } public class Main { 
    public static void main(String[] args) throws CloneNotSupportedException { 
    Address address = new Address("New York"); Person person1 = new Person("Alice", address); Person person2 = (Person) person1.clone(); person2.name = "Bob"; person2.address.city = "Los Angeles"; System.out.println(person1.name); // 输出 "Alice" System.out.println(person1.address.city); // 输出 "Los Angeles" System.out.println(person2.name); // 输出 "Bob" System.out.println(person2.address.city); // 输出 "Los Angeles" } } 

在上述代码中，person1和person2拥有不同的name属性，但是共享同一个Address对象。

3. 深拷贝（Deep Copy）

深拷贝不仅创建一个新对象，还会递归地复制所有成员对象。这样，原对象和新对象完全独立，不共享任何引用。

深拷贝可以通过手动实现clone方法来完成，或者使用序列化。

手动实现深拷贝的示例：

class Address implements Cloneable { 
    String city; public Address(String city) { 
    this.city = city; } @Override protected Object clone() throws CloneNotSupportedException { 
    return super.clone(); } } class Person implements Cloneable { 
    String name; Address address; public Person(String name, Address address) { 
    this.name = name; this.address = address; } @Override protected Object clone() throws CloneNotSupportedException { 
    Person cloned = (Person) super.clone(); cloned.address = (Address) address.clone(); // 深拷贝 return cloned; } } public class Main { 
    public static void main(String[] args) throws CloneNotSupportedException { 
    Address address = new Address("New York"); Person person1 = new Person("Alice", address); Person person2 = (Person) person1.clone(); person2.name = "Bob"; person2.address.city = "Los Angeles"; System.out.println(person1.name); // 输出 "Alice" System.out.println(person1.address.city); // 输出 "New York" System.out.println(person2.name); // 输出 "Bob" System.out.println(person2.address.city); // 输出 "Los Angeles" } } 

在上述代码中，person1和person2的所有属性都是独立的，修改一个对象的属性不会影响另一个对象。
通过序列化和反序列化来实现Java的深拷贝是一种通用且方便的方法。它可以确保对象的完整复制，包括所有嵌套的成员对象。以下是具体的实现步骤：

1. 让类实现Serializable接口：确保需要深拷贝的类和它包含的所有成员类都实现Serializable接口。
2. 使用序列化和反序列化进行深拷贝：将对象写入字节流，然后从字节流中读出对象，从而实现对象的完全复制。

下面是一个具体的例子：

示例代码

import java.io.*; class Address implements Serializable { 
    private static final long serialVersionUID = 1L; String city; public Address(String city) { 
    this.city = city; } @Override public String toString() { 
    return "Address{city='" + city + "'}"; } } class Person implements Serializable { 
    private static final long serialVersionUID = 1L; 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 + "}"; } // 深拷贝方法 public Person deepCopy() { 
    try { 
    // 序列化 ByteArrayOutputStream bos = new ByteArrayOutputStream(); ObjectOutputStream oos = new ObjectOutputStream(bos); oos.writeObject(this); oos.flush(); oos.close(); // 反序列化 ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray()); ObjectInputStream ois = new ObjectInputStream(bis); return (Person) ois.readObject(); } catch (IOException | ClassNotFoundException e) { 
    e.printStackTrace(); return null; } } } public class Main { 
    public static void main(String[] args) { 
    Address address = new Address("New York"); Person person1 = new Person("Alice", address); Person person2 = person1.deepCopy(); person2.name = "Bob"; person2.address.city = "Los Angeles"; System.out.println("Original: " + person1); // 原对象 System.out.println("Copy: " + person2); // 深拷贝后的对象 } } 

代码解释

1. 实现Serializable接口：Address和Person类都实现了Serializable接口，使它们可以被序列化。
2. 深拷贝方法deepCopy：
   • 序列化：使用ObjectOutputStream将对象写入ByteArrayOutputStream。
   • 反序列化：使用ObjectInputStream从ByteArrayInputStream中读出对象，生成一个新的对象副本。
3. 测试深拷贝：
   • 创建原始对象person1，并通过deepCopy方法生成person2。
   • 修改person2的属性，验证原始对象person1不受影响，证明了对象的深拷贝。

这种方法的优点是实现简单，且适用于所有需要深拷贝的情况。然而，它也有一些限制，比如性能较慢（因为涉及IO操作）和必须实现Serializable接口。

总结

• 引用拷贝：只复制引用，原对象和新对象指向同一个对象。
• 浅拷贝：创建新对象，但不递归复制成员对象，成员对象仍然是共享的引用。
• 深拷贝：创建新对象，并递归复制所有成员对象，完全独立。

这些拷贝方式在实际应用中有不同的使用场景和适用性，根据需要选择合适的拷贝方式可以有效管理内存和对象关系。