深拷贝
在Java中，深拷贝是指创建一个完全独立的对象，包括其所有的成员变量的值。深拷贝是通过复制对象和其所有相关对象的所有内容来实现的。
深拷贝的实现原理：
- 对于基本数据类型的成员变量，直接拷贝其值；
- 对于引用类型的成员变量，创建一个新的对象，并将原对象引用的对象进行深拷贝。
存在深拷贝的原因：
- 避免多个对象共享同一个引用类型的成员变量，避免因一个对象的修改导致其他对象的状态变化；
- 在传递对象实例时，可以独立地操作副本而不影响原始对象；
- 在克隆对象时，可以避免对原始对象产生意外的修改。
实例
在Java中，可以通过实现Cloneable接口来实现对象的深拷贝。具体步骤如下：
- 在要进行深拷贝的类上实现
Cloneable接口。
public class MyClass implements Cloneable {
// 类的成员变量和方法省略
}
- 重写
clone()方法，在方法中进行深拷贝操作。
public class MyClass implements Cloneable {
private int[] array;
// 类的构造方法和其他方法省略
@Override
protected Object clone() throws CloneNotSupportedException {
MyClass cloned = (MyClass) super.clone();
// 对于数组等引用类型的成员变量，也要进行深拷贝
cloned.array = array.clone();
return cloned;
}
}
在上述代码中，我们首先调用super.clone()来创建cloned对象，这是浅拷贝，即只拷贝了对象的引用。然后，我们使用array.clone()来创建array的副本，实现对数组的深拷贝。
需要注意的是，如果MyClass类中还包含其他引用类型的成员变量，也需要在clone()方法中进行相应的深拷贝操作。
使用深拷贝时，可以使用clone()方法创建对象的副本，而不是直接复制引用。例如：
MyClass original = new MyClass();
MyClass cloned = (MyClass) original.clone();
浅拷贝
在Java中，浅拷贝是一种对象复制方式，它创建了一个新的对象，该对象与原始对象共享相同的状态。浅拷贝将原始对象的字段复制到新对象中，但对于对象的引用字段，它只复制引用而不复制引用指向的对象。
浅拷贝的实现原理是通过Object类中的clone()方法进行的。当调用一个对象的clone()方法时，它会创建一个新的对象，并将原始对象中的字段复制到新对象中。
浅拷贝存在的原因是提高代码的效率和性能。通过共享相同的对象状态，可以节省内存和处理时间。此外，浅拷贝还可以在某些情况下引入对象的可变性，因为多个对象共享相同的引用字段。这可以用来简化代码逻辑和减少资源消耗。
但是，浅拷贝也有一些潜在的问题。由于多个对象共享相同的引用字段，对其中一个对象的修改可能会影响其他对象。这可能导致意外的行为和错误。因此，在需要保持对象状态独立性和完整性的场景中，浅拷贝可能不适用。
为了解决这个问题，还有一种更复杂的对象复制方式叫做深拷贝。深拷贝会复制对象的所有字段，包括引用字段指向的对象。这样，每个新对象都有自己的独立状态，从而避免了副作用和意外修改的问题。但深拷贝可能会消耗更多的内存和处理时间。
实例
浅拷贝是创建一个对象的副本，副本和原对象共享相同的引用类型字段的地址，但是引用类型字段的改变不会影响原对象。下面是一个使用浅拷贝的代码示例：
public class Person implements Cloneable {
private String name;
private int age;
private Address address;
public Person(String name, int age, Address address) {
this.name = name;
this.age = age;
this.address = address;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public Address getAddress() {
return address;
}
public void setAddress(Address address) {
this.address = address;
}
@Override
public Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
public class Address {
private String street;
private String city;
public Address(String street, String city) {
this.street = street;
this.city = city;
}
public String getStreet() {
return street;
}
public String getCity() {
return city;
}
}
public class Main {
public static void main(String[] args) {
Address address = new Address("123 Main St", "City");
Person person1 = new Person("John", 30, address);
try {
Person person2 = (Person) person1.clone();
System.out.println("person1: " + person1.getName() + ", " + person1.getAge() + ", " + person1.getAddress().getStreet() + ", " + person1.getAddress().getCity());
System.out.println("person2: " + person2.getName() + ", " + person2.getAge() + ", " + person2.getAddress().getStreet() + ", " + person2.getAddress().getCity());
address.setStreet("456 New St");
address.setCity("New City");
System.out.println("person1: " + person1.getName() + ", " + person1.getAge() + ", " + person1.getAddress().getStreet() + ", " + person1.getAddress().getCity());
System.out.println("person2: " + person2.getName() + ", " + person2.getAge() + ", " + person2.getAddress().getStreet() + ", " + person2.getAddress().getCity());
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
}
}
运行结果：
person1: John, 30, 123 Main St, City
person2: John, 30, 123 Main St, City
person1: John, 30, 456 New St, New City
person2: John, 30, 456 New St, New City
从结果可以看出，当修改了address对象的属性时，原对象person1和副本对象person2的address字段都发生了改变，这是因为浅拷贝只是复制了引用类型字段的地址，没有创建新的引用对象。因此，修改一个对象的引用类型字段会影响到另一个对象。
区别
在Java中，深拷贝和浅拷贝是两种不同的对象拷贝方式。
浅拷贝是指创建一个新对象，该新对象的属性值和原对象的属性值相同。但是，如果对象中包含引用类型的属性，那么新对象和原对象将共享这些引用类型的属性，即新对象和原对象中的引用类型属性指向同一块内存地址。
深拷贝是创建一个新对象，并且递归地复制原对象的所有属性，包括引用类型的属性。这意味着，新对象和原对象中的引用类型属性指向不同的内存地址。
简而言之，浅拷贝只复制对象本身和一层属性，而深拷贝会递归地复制对象的所有属性，包括多层的引用类型属性。
下面是一个示例代码，用于说明深拷贝和浅拷贝的区别：
public class Person implements Cloneable {
private String name;
private Address address;
// 构造函数和getter/setter方法省略
@Override
protected Object clone() throws CloneNotSupportedException {
Person cloned = (Person) super.clone();
cloned.address = (Address) address.clone();
return cloned;
}
}
public class Address implements Cloneable {
private String city;
// 构造函数和getter/setter方法省略
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
public class Main {
public static void main(String[] args) throws CloneNotSupportedException {
Address address = new Address("Beijing");
Person person1 = new Person("John", address);
// 浅拷贝
Person person2 = (Person) person1.clone();
System.out.println(person1 == person2); // false
System.out.println(person1.getAddress() == person2.getAddress()); // true
// 深拷贝
Person person3 = new Person(person1.getName(), new Address(person1.getAddress().getCity()));
System.out.println(person1 == person3); // false
System.out.println(person1.getAddress() == person3.getAddress()); // false
}
}
在上述示例中，Person类中有一个Address属性，Address类也实现了Cloneable接口。通过浅拷贝，person1和person2是不同的对象，但是它们的address属性指向同一块内存地址。而通过深拷贝，person1和person3是不同的对象，并且它们的address属性也指向不同的内存地址。
总结
-
浅拷贝：
- 在浅拷贝中，只复制对象的引用，而不复制对象本身。
- 新对象和原对象仍然共享相同的内存地址，修改一个对象会影响到另一个对象。
- 使用
Object类的clone()方法可以实现浅拷贝。
-
深拷贝：
- 在深拷贝中，复制对象本身，包括对象内部的所有引用对象。
- 新对象和原对象具有相同的值，但是内存地址是不同的，修改一个对象不会影响到另一个对象。
- 可以通过序列化、反序列化、递归复制等方式实现深拷贝。
-
如何实现深拷贝：
- 序列化/反序列化：通过将对象序列化为字节流，然后再反序列化为新的对象，实现深拷贝。需要注意的是，被序列化的对象及其引用对象都需要实现
Serializable接口。 - 递归复制：递归复制对象及其引用对象，直到所有引用对象都被复制。这种方式需要手动编写深拷贝的代码，并且要小心处理循环引用的情况。
- 序列化/反序列化：通过将对象序列化为字节流，然后再反序列化为新的对象，实现深拷贝。需要注意的是，被序列化的对象及其引用对象都需要实现
注意:Java中的基本数据类型是直接复制其值，而不是引用，因此无需考虑深拷贝和浅拷贝的问题。
扫一扫
1493
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
