o2o网站建设服务,开源系统有哪些,wordpress响应商城,公司注册新流程文章目录 一、前提二、浅拷贝1. BeanUtils实现浅拷贝 三、深拷贝1. 实现Cloneable接口并重写clone()方法#xff1a;2. 使用序列化与反序列化#xff1a; 一、前提
在计算机的内存中#xff0c;每个对象都被赋予一个地址#xff0c;该地址指向对象在内存中存储的位置。当我… 文章目录 一、前提二、浅拷贝1. BeanUtils实现浅拷贝 三、深拷贝1. 实现Cloneable接口并重写clone()方法2. 使用序列化与反序列化 一、前提
在计算机的内存中每个对象都被赋予一个地址该地址指向对象在内存中存储的位置。当我们使用一个变量来引用一个对象时实际上是将该对象的地址赋值给该变量。因此当我们将一个对象复制到另一个变量中时实际上是将对象的地址复制给了这个变量。 二、浅拷贝
浅拷贝是一种复制对象到另一个变量的操作它仅复制对象的地址而非对象本身。换句话说原始对象和复制对象实际上共享同一个内存地址。因此若我们修改复制对象中的属性或元素原始对象中对应的属性或元素也会随之改变。
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 AngelesSystem.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;}Overrideprotected 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接口。
