Java当中的深拷贝和浅拷贝

一、前提

在计算机的内存中,每个对象都被赋予一个地址,该地址指向对象在内存中存储的位置。当我们使用一个变量来引用一个对象时,实际上是将该对象的地址赋值给该变量。因此,当我们将一个对象复制到另一个变量中时,实际上是将对象的地址复制给了这个变量。

Java当中的深拷贝和浅拷贝

二、浅拷贝

浅拷贝是一种复制对象到另一个变量的操作,它仅复制对象的地址而非对象本身。换句话说,原始对象和复制对象实际上共享同一个内存地址。因此,若我们修改复制对象中的属性或元素,原始对象中对应的属性或元素也会随之改变。

1. BeanUtils实现浅拷贝

🎏下面是一个使用BeanUtils实现深拷贝不生效的示例:🎏

首先,我们定义两个类,分别是Person和Address:

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

    // getters and setters
}

public class Address {
    private String city;
    private String street;

    // getters and setters
}

然后,我们创建一个Person对象,并设置其属性:

Person person1 = new Person();
person1.setName("John");
person1.setAge(25);

Address address1 = new Address();
address1.setCity("New York");
address1.setStreet("123 Main St");

person1.setAddress(address1);

接下来,我们使用BeanUtils进行深拷贝:

Person person2 = new Person();

try {
    BeanUtils.copyProperties(person2, person1);
} catch (IllegalAccessException | InvocationTargetException e) {
    e.printStackTrace();
}

现在,我们修改person1的属性值,观察person2的属性值是否发生变化:

person1.setName("Mike");
person1.getAddress().setCity("Los Angeles");

最后,我们打印person1和person2的属性值,检查深拷贝是否生效:

System.out.println(person1.getName()); // Output: Mike
System.out.println(person1.getAddress().getCity()); // Output: Los Angeles

System.out.println(person2.getName()); // Output: Mike
System.out.println(person2.getAddress().getCity()); // Output: Los Angeles

从输出结果可以看出,尽管我们使用BeanUtils进行了拷贝,但person1和person2的属性值仍然是相同的,修改其中一个对象的属性值会同时影响另一个对象的属性值。这说明使用BeanUtils进行拷贝时,并没有进行深拷贝,而是进行了浅拷贝。

三、深拷贝

深拷贝是一种复制对象及其所有子对象到另一个变量的操作。它会创建一个全新的对象,并将原始对象中的所有属性或元素都复制到新的对象中。因此,若我们修改复制对象中的属性或元素,原始对象中对应的属性或元素不会受到任何影响。

在Java中实现深拷贝有以下几种方法:

1. 实现Cloneable接口并重写clone()方法:

✨在需要进行深拷贝的类中,实现Cloneable接口并重写clone()方法,在clone()方法中对引用类型进行逐个拷贝。注意,被拷贝的引用类型也需要实现Cloneable接口并重写clone()方法。

下面是一个使用Cloneable接口实现深拷贝的示例代码:

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();
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

public class DeepCopyDemo {
    public static void main(String[] args) {
        Person person1 = new Person("John", 25);

        try {
            // 使用clone()方法进行深拷贝
            Person person2 = (Person) person1.clone();

            System.out.println("person1: " + person1.getName() + ", " + person1.getAge());
            System.out.println("person2: " + person2.getName() + ", " + person2.getAge());

            person2.setName("Tom");
            person2.setAge(30);

            System.out.println("After modifying person2:");
            System.out.println("person1: " + person1.getName() + ", " + person1.getAge());
            System.out.println("person2: " + person2.getName() + ", " + person2.getAge());
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

输出结果:

person1: John, 25
person2: John, 25
After modifying person2:
person1: John, 25
person2: Tom, 30

从输出结果可以看出,person2是通过深拷贝得到的新对象,修改person2的属性不会影响到person1。这说明使用Cloneable接口和clone()方法可以实现深拷贝。需要注意的是,被拷贝的类及其引用类型属性都需要实现Cloneable接口并重写clone()方法。

2. 使用序列化与反序列化:

🎯将对象序列化为字节流,然后再反序列化为新的对象。这种方法需要被拷贝的类实现Serializable接口。🎯

下面是一个使用序列化与反序列化实现深拷贝的示例代码:

import java.io.*;

class Person implements Serializable {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

public class DeepCopyDemo {
    public static void main(String[] args) {
        Person person1 = new Person("John", 25);

        try {
            // 序列化
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bos);
            oos.writeObject(person1);

            // 反序列化
            ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bis);
            Person person2 = (Person) ois.readObject();

            System.out.println("person1: " + person1.getName() + ", " + person1.getAge());
            System.out.println("person2: " + person2.getName() + ", " + person2.getAge());

            person2.setName("Tom");
            person2.setAge(30);

            System.out.println("After modifying person2:");
            System.out.println("person1: " + person1.getName() + ", " + person1.getAge());
            System.out.println("person2: " + person2.getName() + ", " + person2.getAge());
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

输出结果:

person1: John, 25
person2: John, 25
After modifying person2:
person1: John, 25
person2: Tom, 30

从输出结果可以看出,person2是通过反序列化得到的新对象,修改person2的属性不会影响到person1。这说明使用序列化与反序列化可以实现深拷贝。需要注意的是,被拷贝的类及其引用类型属性都需要实现Serializable接口。

  • 0
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Run,boy

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值