Java深拷贝详细总结
文章目录
- 浅拷贝
- 深拷贝
- 无法重写clone()时
- 遍历复制
- 使用构造方法传参复制
- 使用list.addAll复制
- 遍历new
- 序列化深拷贝
- 参考
浅拷贝
直接看例子
package domain;
public class Subject {
private String name;
private int score;
public Subject(String name, int score) {
this.name = name;
this.score = score;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
@Override
public String toString() {
return "Subject{" +
"name='" + name + '\'' +
", score=" + score +
'}';
}
}
package domain;
public class Student implements Cloneable {
//基础类型和String不可变对象
private String name;
private int age;
//引用类型
private Subject subject;
public Student(String name, int age, Subject subject) {
this.name = name;
this.age = age;
this.subject = subject;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Subject getSubject() {
return subject;
}
public void setSubject(Subject subject) {
this.subject = subject;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", subject=" + subject +
'}';
}
@Override
public Object clone() throws CloneNotSupportedException {
//直接拷贝
return super.clone();
}
}
import domain.Student;
import domain.Subject;
class Main {
public static void main(String[] args) throws CloneNotSupportedException {
Subject subject = new Subject("math", 90);
Student student = new Student("pjq", 25, subject);//原对象
Student student_copy = (Student) student.clone();//拷贝对象
//修改原对象
student.setName("jqp");
student.setAge(26);
subject.setName("english");
subject.setScore(95);
student.setSubject(subject);
System.out.println(student);
System.out.println(student_copy);
}
}
输出结果：
Student{name=‘jqp’, age=26, subject=Subject{name=‘english’, score=95}}
Student{name=‘pjq’, age=25, subject=Subject{name=‘english’, score=95}}
对于引用类型，如果是浅拷贝，那么更改其中一个会影响多个。基本类型是值传递的，更改一个不会影响拷贝的。而字符串类型是存在常量池StringTable中的，更改相当于在StringTable中新创建一个字符串，其实就是深拷贝。
深拷贝
自己编写的类，如何实现深拷贝呢？一种方法是重写clone方法。
package domain;
public class Subject implements Cloneable{
private String name;
private int score;
public Subject(String name, int score) {
this.name = name;
this.score = score;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
@Override
public String toString() {
return "Subject{" +
"name='" + name + '\'' +
", score=" + score +
'}';
}
@Override
public Object clone() throws CloneNotSupportedException {
//Subject 如果也有引用类型的成员属性，也应该和 Student 类一样实现
return super.clone();
}
}
package domain;
public class Student implements Cloneable {
//基础类型和String不可变对象
private String name;
private int age;
//引用类型
private Subject subject;
public Student(String name, int age, Subject subject) {
this.name = name;
this.age = age;
this.subject = subject;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Subject getSubject() {
return subject;
}
public void setSubject(Subject subject) {
this.subject = subject;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", subject=" + subject +
'}';
}
@Override
public Object clone() throws CloneNotSupportedException {
//深拷贝
Student student = (Student) super.clone();
student.subject = (Subject) subject.clone();
return student;
}
}
import domain.Student;
import domain.Subject;
class Main {
public static void main(String[] args) throws CloneNotSupportedException {
Subject subject = new Subject("math", 90);
Student student = new Student("pjq", 25, subject);//原对象
Student student_copy = (Student) student.clone();//拷贝对象
//修改原对象
student.setName("jqp");
student.setAge(26);
subject.setName("english");
subject.setScore(95);
student.setSubject(subject);
System.out.println(student);
System.out.println(student_copy);
}
}
输出结果：
Student{name=‘jqp’, age=26, subject=Subject{name=‘english’, score=95}}
Student{name=‘pjq’, age=25, subject=Subject{name=‘math’, score=90}}
通过结果可以看出此时是深拷贝
无法重写clone()时
上文给出了一种深拷贝的方法，即通过重写clone的方式，但是如果不是我们自己写的类，例如，想要深拷贝一个容器内的所有内容，怎么实现？以下先展示几种错误方式。
遍历复制
import domain.Student;
import domain.Subject;
import java.util.ArrayList;
import java.util.List;
class Main {
public static void main(String[] args) throws CloneNotSupportedException {
Subject subject = new Subject("math", 90);
Student student = new Student("pjq", 25, subject);
List<Student> students = new ArrayList<>();//原始List
students.add(student);
List<Student> students_copy = new ArrayList<>();//拷贝的List
for (int i = 0; i < students.size(); ++i) {
students_copy.add(students.get(i));
}
//修改原始List
students.get(0).setName("jqp");
students.get(0).setAge(26);
students.get(0).getSubject().setName("english");
students.get(0).getSubject().setScore(95);
System.out.println(students);
System.out.println(students_copy);
}
}
输出结果：
[Student{name=‘jqp’, age=26, subject=Subject{name=‘english’, score=95}}]
[Student{name=‘jqp’, age=26, subject=Subject{name=‘english’, score=95}}]
从结果看出，毫无疑问是浅拷贝。
使用构造方法传参复制
class Main {
public static void main(String[] args) throws CloneNotSupportedException {
Subject subject = new Subject("math", 90);
Student student = new Student("pjq", 25, subject);
List<Student> students = new ArrayList<>();//原始List
students.add(student);
List<Student> students_copy = new ArrayList<>(students);//拷贝的List
//修改原始List
students.get(0).setName("jqp");
students.get(0).setAge(26);
students.get(0).getSubject().setName("english");
students.get(0).getSubject().setScore(95);
System.out.println(students);
System.out.println(students_copy);
}
}
输出结果：
[Student{name=‘jqp’, age=26, subject=Subject{name=‘english’, score=95}}]
[Student{name=‘jqp’, age=26, subject=Subject{name=‘english’, score=95}}]
同样是浅拷贝
使用list.addAll复制
class Main {
public static void main(String[] args) throws CloneNotSupportedException {
Subject subject = new Subject("math", 90);
Student student = new Student("pjq", 25, subject);
List<Student> students = new ArrayList<>();//原始List
students.add(student);
List<Student> students_copy = new ArrayList<>();//拷贝的List
students_copy.addAll(students);
//修改原始List
students.get(0).setName("jqp");
students.get(0).setAge(26);
students.get(0).getSubject().setName("english");
students.get(0).getSubject().setScore(95);
System.out.println(students);
System.out.println(students_copy);
}
}
输出结果：
[Student{name=‘jqp’, age=26, subject=Subject{name=‘english’, score=95}}]
[Student{name=‘jqp’, age=26, subject=Subject{name=‘english’, score=95}}]
还是浅拷贝。
其实查看源码就知道，list.addAll()是使用的System.arraycopy，而System.arraycopy是一个浅拷贝，那么Array.copyOf显然也是浅拷贝，它底层也是调用的System.arraycopy。
那么到底如何深拷贝呢？
遍历new
显然，深拷贝要为容器中的每个元素重新分配内存。
import domain.Student;
import domain.Subject;
import java.util.ArrayList;
import java.util.List;
class Main {
public static void main(String[] args) throws CloneNotSupportedException {
Subject subject = new Subject("math", 90);
Student student = new Student("pjq", 25, subject);
List<Student> students = new ArrayList<>();//原始List
students.add(student);
List<Student> students_copy = new ArrayList<>();//拷贝的List
for (int i = 0; i < students.size(); ++i) {
//不仅student对象要分配内存，它student对象内部的subject对象也要重新分配，否则还是subject对象还是浅拷贝
Subject sbuject_temp = new Subject(students.get(i).getSubject().getName(), students.get(i).getSubject().getScore());
Student student_temp = new Student(students.get(i).getName(), students.get(i).getAge(), sbuject_temp);
students_copy.add(student_temp);
}
//修改原始List
students.get(0).setName("jqp");
students.get(0).setAge(26);
students.get(0).getSubject().setName("english");
students.get(0).getSubject().setScore(95);
System.out.println(students);
System.out.println(students_copy);
}
}
输出结果：
[Student{name=‘jqp’, age=26, subject=Subject{name=‘english’, score=95}}]
[Student{name=‘pjq’, age=25, subject=Subject{name=‘math’, score=90}}]
实现了深拷贝，但是还存在一个明显的问题：不仅要为List内部的每一个Student重新分配内存，每一个Student内部的每一个Subject还要重新分配内存，如果Subject内部还有其他引用类型，显然也要重新分配内存，太麻烦了。
序列化深拷贝
import domain.Student;
import domain.Subject;
import java.io.*;
import java.util.ArrayList;
import java.util.List;
class Main {
public static List<Student> deepCopy(List<Student> students) throws IOException, ClassNotFoundException {
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
objectOutputStream.writeObject(students);
ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
return (List<Student>) objectInputStream.readObject();
}
public static void main(String[] args) throws CloneNotSupportedException, IOException, ClassNotFoundException {
Subject subject = new Subject("math", 90);
Student student = new Student("pjq", 25, subject);
List<Student> students = new ArrayList<>();//原始List
students.add(student);
List<Student> students_copy = deepCopy(students);//拷贝的List
//修改原始List
students.get(0).setName("jqp");
students.get(0).setAge(26);
students.get(0).getSubject().setName("english");
students.get(0).getSubject().setScore(95);
System.out.println(students);
System.out.println(students_copy);
}
}
输出结果：
[Student{name=‘jqp’, age=26, subject=Subject{name=‘english’, score=95}}]
[Student{name=‘pjq’, age=25, subject=Subject{name=‘math’, score=90}}]
注意：这种方法需要Student类和Subject类实现Serializable接口。
参考
Java 浅拷贝和深拷贝