java 如何复制对象

在Java中，复制对象的主要方法包括：使用Cloneable接口、通过构造函数复制、使用序列化和反序列化、以及使用第三方库等。 其中，最常用且推荐的方法是通过实现Cloneable接口和重写clone方法来实现对象的浅拷贝。对于深拷贝，可以使用序列化和反序列化或第三方库，如Apache Commons Lang中的SerializationUtils类。下面将详细介绍这些方法。

一、使用Cloneable接口和重写clone方法

1.1 浅拷贝与深拷贝

浅拷贝：复制对象的基本属性（如int、double等基本数据类型）和对象引用，但不复制引用对象本身。这意味着新对象与原对象共享引用对象的实例。

深拷贝：不仅复制对象的基本属性，还要复制所有引用对象，确保新对象与原对象完全独立。

1.2 实现Cloneable接口

实现Cloneable接口并重写clone方法是Java中复制对象的最基本方法。以下是一个简单的示例：

class Person implements Cloneable {
    String name;
    int age;
    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
public class Main {
    public static void main(String[] args) {
        try {
            Person p1 = new Person("John", 25);
            Person p2 = (Person) p1.clone();
            System.out.println(p1.name + " " + p1.age);
            System.out.println(p2.name + " " + p2.age);
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

在这个示例中，Person类实现了Cloneable接口，并重写了clone方法来实现浅拷贝。需要注意的是，如果类中包含引用类型的属性，浅拷贝可能会导致问题。

1.3 深拷贝示例

对于深拷贝，我们可以在clone方法中手动复制引用对象：

class Address implements Cloneable {
    String city;
    Address(String city) {
        this.city = city;
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
class Person implements Cloneable {
    String name;
    int age;
    Address address;
    Person(String name, int age, Address address) {
        this.name = name;
        this.age = age;
        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) {
        try {
            Address address = new Address("New York");
            Person p1 = new Person("John", 25, address);
            Person p2 = (Person) p1.clone();
            p2.address.city = "Los Angeles";
            System.out.println(p1.name + " " + p1.age + " " + p1.address.city);
            System.out.println(p2.name + " " + p2.age + " " + p2.address.city);
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

在这个示例中，Person类不仅实现了Cloneable接口，还在clone方法中手动复制了Address对象，实现了深拷贝。

二、通过构造函数复制

2.1 使用构造函数实现对象复制

另一种复制对象的方法是通过构造函数复制。这个方法不需要实现Cloneable接口，但需要手动在构造函数中复制所有属性：

class Person {
    String name;
    int age;
    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    // 复制构造函数
    Person(Person other) {
        this.name = other.name;
        this.age = other.age;
    }
}
public class Main {
    public static void main(String[] args) {
        Person p1 = new Person("John", 25);
        Person p2 = new Person(p1);
        System.out.println(p1.name + " " + p1.age);
        System.out.println(p2.name + " " + p2.age);
    }
}

2.2 复制包含引用类型的对象

如果类中包含引用类型的属性，需要在复制构造函数中手动复制这些引用对象：

class Address {
    String city;
    Address(String city) {
        this.city = city;
    }
    // 复制构造函数
    Address(Address other) {
        this.city = other.city;
    }
}
class Person {
    String name;
    int age;
    Address address;
    Person(String name, int age, Address address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }
    // 复制构造函数
    Person(Person other) {
        this.name = other.name;
        this.age = other.age;
        this.address = new Address(other.address);
    }
}
public class Main {
    public static void main(String[] args) {
        Address address = new Address("New York");
        Person p1 = new Person("John", 25, address);
        Person p2 = new Person(p1);
        p2.address.city = "Los Angeles";
        System.out.println(p1.name + " " + p1.age + " " + p1.address.city);
        System.out.println(p2.name + " " + p2.age + " " + p2.address.city);
    }
}

三、使用序列化和反序列化

3.1 序列化和反序列化实现深拷贝

通过序列化和反序列化可以轻松实现对象的深拷贝，但需要类实现Serializable接口：

import java.io.*;
class Address implements Serializable {
    String city;
    Address(String city) {
        this.city = city;
    }
}
class Person implements Serializable {
    String name;
    int age;
    Address address;
    Person(String name, int age, Address address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }
    // 深拷贝方法
    public Person deepCopy() throws IOException, ClassNotFoundException {
        ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
        ObjectOutputStream out = new ObjectOutputStream(byteOut);
        out.writeObject(this);
        ByteArrayInputStream byteIn = new ByteArrayInputStream(byteOut.toByteArray());
        ObjectInputStream in = new ObjectInputStream(byteIn);
        return (Person) in.readObject();
    }
}
public class Main {
    public static void main(String[] args) {
        try {
            Address address = new Address("New York");
            Person p1 = new Person("John", 25, address);
            Person p2 = p1.deepCopy();
            p2.address.city = "Los Angeles";
            System.out.println(p1.name + " " + p1.age + " " + p1.address.city);
            System.out.println(p2.name + " " + p2.age + " " + p2.address.city);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

在这个示例中，通过序列化和反序列化实现了对象的深拷贝，确保新对象与原对象完全独立。

3.2 序列化的优缺点

优点：

简单易用，能够轻松实现深拷贝。
不需要手动编写大量的复制代码。

缺点：

序列化和反序列化的性能可能较低，特别是对于大对象。
所有需要复制的类必须实现Serializable接口。

四、使用第三方库

4.1 Apache Commons Lang

Apache Commons Lang提供了一个简单易用的工具类SerializationUtils，可以通过序列化和反序列化来实现对象的深拷贝：

import org.apache.commons.lang3.SerializationUtils;
class Address implements Serializable {
    String city;
    Address(String city) {
        this.city = city;
    }
}
class Person implements Serializable {
    String name;
    int age;
    Address address;
    Person(String name, int age, Address address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }
}
public class Main {
    public static void main(String[] args) {
        Address address = new Address("New York");
        Person p1 = new Person("John", 25, address);
        Person p2 = SerializationUtils.clone(p1);
        p2.address.city = "Los Angeles";
        System.out.println(p1.name + " " + p1.age + " " + p1.address.city);
        System.out.println(p2.name + " " + p2.age + " " + p2.address.city);
    }
}

4.2 优缺点

优点：

简化了深拷贝的实现，代码更加简洁。
提供了更多实用的工具方法，方便开发。

缺点：

需要引入外部库，增加了项目的依赖。
性能可能不如手动实现的深拷贝。

五、总结

在Java中复制对象的方法有多种选择，具体选择哪种方法取决于具体需求和场景：

浅拷贝：适用于对象中没有引用类型属性，或引用类型属性可以共享的场景。可以通过实现Cloneable接口和重写clone方法来实现。
深拷贝：适用于对象中包含引用类型属性，并且需要独立复制的场景。可以通过手动复制引用对象、序列化和反序列化、或使用第三方库来实现。
构造函数复制：适用于需要手动控制复制过程的场景，通过在构造函数中复制所有属性来实现。
第三方库：如Apache Commons Lang提供了简化深拷贝实现的工具类SerializationUtils，适用于需要简洁代码的场景。

无论选择哪种方法，都需要根据具体需求和场景进行权衡，以实现最佳的性能和代码可维护性。