正文

掌握Java引用数据类型复制技巧，轻松实现数据共享与独立！

/0 浏览量
0331

在Java编程语言中，数据类型主要分为两大类：基本数据类型和引用数据类型。基本数据类型（如int、double、char等）直接存储在栈内存中，而引用数据类型（如String、对象等）则存储在堆内存中，并且每个引用数据类型都有一个指向其对象实例的引用。掌握Java引用数据类型的复制技巧，可以帮助我们更好地实现数据共享与独立。下面，我们将深入探讨Java中引用数据类型的复制方法。

一、浅拷贝（Shallow Copy）

浅拷贝是指创建一个新对象，并将原对象的引用类型成员变量值复制到新对象中。需要注意的是，如果引用类型成员变量中的对象是可变的，那么新对象和原对象中的对象会共享这部分数据。

1.1 使用克隆方法实现浅拷贝

在Java中，可以通过实现Cloneable接口并重写clone()方法来创建浅拷贝。以下是一个示例：

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

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    public static void main(String[] args) throws CloneNotSupportedException {
        Person original = new Person();
        original.name = "张三";
        original.address = new Address("北京市");

        Person clone = (Person) original.clone();
        System.out.println("原对象地址：" + original);
        System.out.println("拷贝对象地址：" + clone);
        System.out.println("原对象地址与拷贝对象地址是否相同：" + (original == clone));
        System.out.println("原对象地址与地址成员变量地址是否相同：" + (original.address == clone.address));
    }
}

class Address implements Cloneable {
    private String city;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    public Address(String city) {
        this.city = city;
    }

    @Override
    public String toString() {
        return "Address{" +
                "city='" + city + '\'' +
                '}';
    }
}

从上述代码可以看出，虽然原对象和拷贝对象的地址不同，但地址成员变量中的对象地址是相同的，即共享数据。

1.2 使用序列化实现浅拷贝

除了使用克隆方法，还可以通过序列化和反序列化来实现浅拷贝。以下是一个示例：

import java.io.*;

public class Person implements Serializable {
    private String name;
    private Address address;

    public Person(String name, Address address) {
        this.name = name;
        this.address = address;
    }

    public static Person clone(Person original) throws IOException, ClassNotFoundException {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(baos);
        oos.writeObject(original);

        ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bais);
        return (Person) ois.readObject();
    }

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Person original = new Person("张三", new Address("北京市"));
        Person clone = Person.clone(original);

        System.out.println("原对象地址：" + original);
        System.out.println("拷贝对象地址：" + clone);
        System.out.println("原对象地址与拷贝对象地址是否相同：" + (original == clone));
        System.out.println("原对象地址与地址成员变量地址是否相同：" + (original.address == clone.address));
    }
}

class Address implements Serializable {
    private String city;

    public Address(String city) {
        this.city = city;
    }

    @Override
    public String toString() {
        return "Address{" +
                "city='" + city + '\'' +
                '}';
    }
}

二、深拷贝（Deep Copy）

深拷贝是指创建一个新对象，并将原对象的所有字段值复制到新对象中。对于引用类型成员变量，深拷贝会复制其对象，而不是引用。

2.1 使用构造函数实现深拷贝

在Java中，可以通过创建一个新的构造函数，将原对象的字段值作为参数传递给新构造函数来实现深拷贝。以下是一个示例：

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

    public Person(String name, Address address) {
        this.name = name;
        this.address = new Address(address.getCity());
    }

    public static void main(String[] args) {
        Address originalAddress = new Address("北京市");
        Person original = new Person("张三", originalAddress);

        Address newAddress = new Address("上海市");
        Person clone = new Person("李四", newAddress);

        System.out.println("原对象地址：" + original);
        System.out.println("拷贝对象地址：" + clone);
        System.out.println("原对象地址与拷贝对象地址是否相同：" + (original == clone));
        System.out.println("原对象地址与地址成员变量地址是否相同：" + (original.address == clone.address));
    }
}

class Address {
    private String city;

    public Address(String city) {
        this.city = city;
    }

    public String getCity() {
        return city;
    }

    @Override
    public String toString() {
        return "Address{" +
                "city='" + city + '\'' +
                '}';
    }
}

从上述代码可以看出，原对象和拷贝对象的地址以及地址成员变量地址都是不同的，即实现了深拷贝。

2.2 使用拷贝构造函数实现深拷贝

除了使用构造函数，还可以通过实现拷贝构造函数来实现深拷贝。以下是一个示例：

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

    public Person(Person other) {
        this.name = other.name;
        this.address = new Address(other.address);
    }

    public static void main(String[] args) {
        Address originalAddress = new Address("北京市");
        Person original = new Person("张三", originalAddress);

        Address newAddress = new Address("上海市");
        Person clone = new Person(original);

        System.out.println("原对象地址：" + original);
        System.out.println("拷贝对象地址：" + clone);
        System.out.println("原对象地址与拷贝对象地址是否相同：" + (original == clone));
        System.out.println("原对象地址与地址成员变量地址是否相同：" + (original.address == clone.address));
    }
}

class Address {
    private String city;

    public Address(String city) {
        this.city = city;
    }

    public Address(Address other) {
        this.city = other.city;
    }

    public String getCity() {
        return city;
    }

    @Override
    public String toString() {
        return "Address{" +
                "city='" + city + '\'' +
                '}';
    }
}

三、总结

通过本文的介绍，我们了解了Java中引用数据类型的复制技巧，包括浅拷贝和深拷贝。在实际编程过程中，我们需要根据具体需求选择合适的复制方法，以实现数据共享与独立。希望本文对您有所帮助！

-- 展开阅读全文 --