对象拷贝技术博客

在编程中，对象拷贝是一个常见的操作。当我们需要创建一个与现有对象具有相同状态的新对象时，就会用到对象拷贝。例如，在数据处理、克隆对象等场景中。不同的编程语言有不同的对象拷贝实现方式，本文将以Java为例进行详细讲解。

目录#

  1. 浅拷贝
    • 定义
    • 实现方式（示例代码）
    • 特点
  2. 深拷贝
    • 定义
    • 实现方式（示例代码）
    • 特点
  3. 常见实践场景
    • 数据备份
    • 克隆对象用于并发操作
  4. 最佳实践
    • 选择合适的拷贝方式
    • 注意对象引用的处理
  5. 示例综合应用
  6. 引用

1. 浅拷贝#

1.1 定义#

浅拷贝是指创建一个新对象，新对象的属性和原始对象相同。如果属性是基本数据类型，拷贝的就是基本数据类型的值；如果属性是引用数据类型（如对象、数组等），拷贝的是内存地址（即引用）。

1.2 实现方式（示例代码）#

在Java中，实现浅拷贝可以让类实现Cloneable接口并重写clone()方法。

class Person implements Cloneable {
    private String name;
    private int age;
 
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
 
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
 
    // Getter and Setter methods
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
}
 
public class ShallowCopyExample {
    public static void main(String[] args) {
        Person person1 = new Person("Alice", 25);
        try {
            Person person2 = (Person) person1.clone();
            System.out.println("person1 name: " + person1.getName() + ", age: " + person1.getAge());
            System.out.println("person2 name: " + person2.getName() + ", age: " + person2.getAge());
 
            person2.setName("Bob");
            System.out.println("After modification - person1 name: " + person1.getName() + ", age: " + person1.getAge());
            System.out.println("After modification - person2 name: " + person2.getName() + ", age: " + person2.getAge());
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

1.3 特点#

  • 对于基本数据类型属性，拷贝后修改新对象的该属性不会影响原对象。
  • 对于引用数据类型属性，拷贝后修改新对象引用属性指向的内容会影响原对象（因为它们指向同一块内存地址）。

2. 深拷贝#

2.1 定义#

深拷贝是指创建一个新对象，新对象的属性和原始对象相同，并且对于引用数据类型属性，会递归地创建新的对象，而不是仅仅拷贝引用。

2.2 实现方式（示例代码）#

2.2.1 通过序列化和反序列化实现（适用于可序列化的对象）#

import java.io.*;
 
class Address implements Serializable {
    private String street;
    private String city;
 
    public Address(String street, String city) {
        this.street = street;
        this.city = city;
    }
 
    // Getter and Setter methods
    public String getStreet() {
        return street;
    }
 
    public void setStreet(String street) {
        this.street = street;
    }
 
    public String getCity() {
        return city;
    }
 
    public void setCity(String city) {
        this.city = city;
    }
}
 
class Employee implements Serializable {
    private String name;
    private Address address;
 
    public Employee(String name, Address address) {
        this.name = name;
        this.address = address;
    }
 
    // Getter and Setter methods
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public Address getAddress() {
        return address;
    }
 
    public void setAddress(Address address) {
        this.address = address;
    }
 
    public Object deepClone() throws IOException, ClassNotFoundException {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(this);
 
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        return ois.readObject();
    }
}
 
public class DeepCopyExample {
    public static void main(String[] args) {
        Address address1 = new Address("123 Main St", "New York");
        Employee employee1 = new Employee("John", address1);
        try {
            Employee employee2 = (Employee) employee1.deepClone();
            System.out.println("employee1 name: " + employee1.getName() + ", address: " + employee1.getAddress().getStreet() + ", " + employee1.getAddress().getCity());
            System.out.println("employee2 name: " + employee2.getName() + ", address: " + employee2.getAddress().getStreet() + ", " + employee2.getAddress().getCity());
 
            employee2.getAddress().setStreet("456 Elm St");
            System.out.println("After modification - employee1 address: " + employee1.getAddress().getStreet() + ", " + employee1.getAddress().getCity());
            System.out.println("After modification - employee2 address: " + employee2.getAddress().getStreet() + ", " + employee2.getAddress().getCity());
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

2.2.2 手动递归拷贝（对于复杂对象结构）#

class ComplexObject {
    private int num;
    private AnotherObject anotherObject;
 
    public ComplexObject(int num, AnotherObject anotherObject) {
        this.num = num;
        this.anotherObject = anotherObject;
    }
 
    public ComplexObject deepClone() {
        AnotherObject clonedAnotherObject = anotherObject.deepClone();
        return new ComplexObject(num, clonedAnotherObject);
    }
 
    // Getter and Setter methods
    public int getNum() {
        return num;
    }
 
    public void setNum(int num) {
        this.num = num;
    }
 
    public AnotherObject getAnotherObject() {
        return anotherObject;
    }
 
    public void setAnotherObject(AnotherObject anotherObject) {
        this.anotherObject = anotherObject;
    }
}
 
class AnotherObject {
    private String str;
 
    public AnotherObject(String str) {
        this.str = str;
    }
 
    public AnotherObject deepClone() {
        return new AnotherObject(str);
    }
 
    // Getter and Setter methods
    public String getStr() {
        return str;
    }
 
    public void setStr(String str) {
        this.str = str;
    }
}

2.3 特点#

  • 完全独立于原对象，修改新对象的任何属性都不会影响原对象。
  • 实现相对复杂，特别是对于多层嵌套的引用对象。

3. 常见实践场景#

3.1 数据备份#

在数据库操作中，有时需要对数据对象进行备份。例如，在更新用户信息前，先拷贝一份用户对象作为备份，以便在更新失败时可以恢复。

3.2 克隆对象用于并发操作#

在多线程环境中，为了避免多个线程同时修改同一个对象导致数据不一致，可以先对共享对象进行深拷贝，然后每个线程操作自己的拷贝对象。

4. 最佳实践#

4.1 选择合适的拷贝方式#

  • 如果对象结构简单，且不需要完全独立（如仅对基本数据类型属性操作），可以选择浅拷贝。
  • 如果对象包含引用数据类型属性，且希望新对象完全独立于原对象（如复杂数据结构对象），选择深拷贝。

4.2 注意对象引用的处理#

  • 在深拷贝中，要确保所有引用数据类型属性都被正确递归拷贝。
  • 对于不可变对象（如String在Java中是不可变的），浅拷贝也能保证一定的安全性（因为不可变对象不能被修改）。

5. 示例综合应用#

假设我们有一个学生类Student，包含基本信息（姓名、年龄）和课程列表（引用类型）。我们需要对学生对象进行拷贝用于不同的业务场景。

import java.util.ArrayList;
import java.util.List;
 
class Course {
    private String courseName;
 
    public Course(String courseName) {
        this.courseName = courseName;
    }
 
    // Getter and Setter methods
    public String getCourseName() {
        return courseName;
    }
 
    public void setCourseName(String courseName) {
        this.courseName = courseName;
    }
}
 
class Student implements Cloneable, Serializable {
    private String studentName;
    private int studentAge;
    private List<Course> courses;
 
    public Student(String studentName, int studentAge, List<Course> courses) {
        this.studentName = studentName;
        this.studentAge = studentAge;
        this.courses = courses;
    }
 
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Student shallowClone = (Student) super.clone();
        // 对引用属性进行简单处理（这里只是示例，实际深拷贝需要更复杂操作）
        List<Course> clonedCourses = new ArrayList<>();
        for (Course course : courses) {
            clonedCourses.add(course);
        }
        shallowClone.courses = clonedCourses;
        return shallowClone;
    }
 
    public Object deepClone() throws IOException, ClassNotFoundException {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(this);
 
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        return ois.readObject();
    }
 
    // Getter and Setter methods
    public String getStudentName() {
        return studentName;
    }
 
    public void setStudentName(String studentName) {
        this.studentName = studentName;
    }
 
    public int getStudentAge() {
        return studentAge;
    }
 
    public void setStudentAge(int studentAge) {
        this.studentAge = studentAge;
    }
 
    public List<Course> getCourses() {
        return courses;
    }
 
    public void setCourses(List<Course> courses) {
        this.courses = courses;
    }
}
 
public class StudentCopyExample {
    public static void main(String[] args) {
        List<Course> courses1 = new ArrayList<>();
        courses1.add(new Course("Math"));
        courses1.add(new Course("English"));
        Student student1 = new Student("Tom", 18, courses1);
 
        try {
            // 浅拷贝示例
            Student student2 = (Student) student1.clone();
            System.out.println("student1 name: " + student1.getStudentName() + ", age: " + student1.getStudentAge());
            System.out.println("student2 name: " + student2.getStudentName() + ", age: " + student2.getStudentAge());
 
            // 修改浅拷贝的课程列表（会影响原对象）
            student2.getCourses().add(new Course("Science"));
            System.out.println("student1 courses size: " + student1.getCourses().size());
            System.out.println("student2 courses size: " + student2.getCourses().size());
 
            // 深拷贝示例
            Student student3 = (Student) student1.deepClone();
            student3.getCourses().add(new Course("History"));
            System.out.println("student1 courses size after deep clone modification: " + student1.getCourses().size());
            System.out.println("student3 courses size after deep clone modification: " + student3.getCourses().size());
        } catch (CloneNotSupportedException | IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

6. 引用#

通过以上内容，希望读者能对对象拷贝有更深入的理解，并能在实际编程中正确应用。

2026-08