java基础对象浅复制和深复制(基础知识)

约定不等于承诺〃 2023-06-10 11:28 21阅读 0赞

### 1、创建对象的5种方式 ###

**①、通过 new 关键字**

这是最常用的一种方式，通过 new 关键字调用类的有参或无参构造方法来创建对象。比如 Object obj = new Object();

**②、通过 Class 类的 newInstance() 方法**

这种默认是调用类的无参构造方法创建对象。比如 Person p2 = (Person) Class.forName("com.ys.test.Person").newInstance();

**③、通过 Constructor 类的 newInstance 方法**

这和第二种方法类时，都是通过反射来实现。通过 java.lang.relect.Constructor 类的 newInstance() 方法指定某个构造器来创建对象。

Person p3 = (Person) Person.class.getConstructors()\[0\].newInstance();

实际上第二种方法利用 Class 的 newInstance() 方法创建对象，其内部调用还是 Constructor 的 newInstance() 方法。

**④、利用 Clone 方法**

Clone 是 Object 类中的一个方法，通过 对象A.clone() 方法会创建一个内容和对象 A 一模一样的对象 B，clone 克隆，顾名思义就是创建一个一模一样的对象出来。

Person p4 = (Person) p3.clone();

**⑤、反序列化**

序列化是把堆内存中的 Java 对象数据，通过某种方式把对象存储到磁盘文件中或者传递给其他网络节点（在网络上传输）。而反序列化则是把磁盘文件中的对象数据或者把网络节点上的对象数据，恢复成Java对象模型的过程。

### 2、Clone 方法 ###

本篇博客我们讲解的是 Java 的深拷贝和浅拷贝，其实现方式正是通过调用 Object 类的 clone() 方法来完成。在 Object.class 类中，源码为：

protected native Object clone() throws CloneNotSupportedException;

这是一个用 native 关键字修饰的方法，关于native关键字有一篇[博客][Link 1]专门有介绍，不理解也没关系，只需要知道用 native 修饰的方法就是告诉操作系统，这个方法我不实现了，让操作系统去实现。具体怎么实现我们不需要了解，只需要知道 clone方法的作用就是复制对象，产生一个新的对象。那么这个新的对象和原对象是什么关系呢？

### 3、基本类型和引用类型 ###

这里再给大家普及一个概念，在 Java 中基本类型和引用类型的区别。

在 Java 中数据类型可以分为两大类：基本类型和引用类型。

基本类型也称为值类型，分别是字符类型 char，布尔类型 boolean以及数值类型 byte、short、int、long、float、double。

引用类型则包括类、接口、数组、枚举等。

Java 将内存空间分为堆和栈。基本类型直接在栈中存储数值，而引用类型是将引用放在栈中，实际存储的值是放在堆中，通过栈中的引用指向堆中存放的数据。

上图定义的 a 和 b 都是基本类型，其值是直接存放在栈中的；而 c 和 d 是 String 声明的，这是一个引用类型，引用地址是存放在 栈中，然后指向堆的内存空间。

下面 d = c；这条语句表示将 c 的引用赋值给 d，那么 c 和 d 将指向同一块堆内存空间。

### 4、浅拷贝 ###

实现对象拷贝的类，需要实现 `Cloneable` 接口，并覆写 `clone()` 方法。

示例如下：

public class Subject {
    
        private String name;
    
        public Subject(String name) {
            this.name = name;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        @Override
        public String toString() {
            return "[Subject: " + this.hashCode() + ",name:" + name + "]";
        }
    }

public class Student implements Cloneable {
    
        //引用类型
        private Subject subject;
        //基础数据类型
        private String name;
        private int age;
    
        public Subject getSubject() {
            return subject;
        }
    
        public void setSubject(Subject subject) {
            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;
        }
    
        /**
         *  重写clone()方法
         * @return
         */
        @Override
        public Object clone() {
            //浅拷贝
            try {
                // 直接调用父类的clone()方法
                return super.clone();
            } catch (CloneNotSupportedException e) {
                return null;
            }
        }
    
        @Override
        public String toString() {
            return "[Student: " + this.hashCode() + ",subject:" + subject + ",name:" + name + ",age:" + age + "]";
        }
    }

public class ShallowCopy {
        public static void main(String[] args) {
            Subject subject = new Subject("yuwen");
            Student studentA = new Student();
            studentA.setSubject(subject);
            studentA.setName("Lynn");
            studentA.setAge(20);
            Student studentB = (Student) studentA.clone();
            studentB.setName("Lily");
            studentB.setAge(18);
            Subject subjectB = studentB.getSubject();
            subjectB.setName("lishi");
            System.out.println("studentA:" + studentA.toString());
            System.out.println("studentB:" + studentB.toString());
        }
    }

输出的结果：

studentA:[Student: 460141958,subject:[Subject: 1163157884,name:lishi],name:Lynn,age:20]
    studentB:[Student: 1956725890,subject:[Subject: 1163157884,name:lishi],name:Lily,age:18]

由输出的结果可见，通过 `studentA.clone()` 拷贝对象后得到的 `studentB`，和 `studentA` 是两个不同的对象。`studentA` 和 `studentB` 的基础数据类型的修改互不影响，而引用类型 `subject` 修改后是会有影响的。

**浅拷贝和对象拷贝的区别：**

public static void main(String[] args) {
            Subject subject = new Subject("yuwen");
            Student studentA = new Student();
            studentA.setSubject(subject);
            studentA.setName("Lynn");
            studentA.setAge(20);
            Student studentB = studentA;
            studentB.setName("Lily");
            studentB.setAge(18);
            Subject subjectB = studentB.getSubject();
            subjectB.setName("lishi");
            System.out.println("studentA:" + studentA.toString());
            System.out.println("studentB:" + studentB.toString());
        }

这里把 `Student studentB = (Student) studentA.clone()` 换成了 `Student studentB = studentA`。  
输出的结果：

studentA:[Student: 460141958,subject:[Subject: 1163157884,name:lishi],name:Lily,age:18]
    studentB:[Student: 460141958,subject:[Subject: 1163157884,name:lishi],name:Lily,age:18]

可见，对象拷贝后没有生成新的对象，二者的对象地址是一样的；而浅拷贝的对象地址是不一样的。

# 5、深拷贝 #

## 深拷贝介绍 ##

通过上面的例子可以看到，浅拷贝会带来数据安全方面的隐患，例如我们只是想修改了 `studentB` 的 `subject`，但是 `studentA` 的 `subject` 也被修改了，因为它们都是指向的同一个地址。所以，此种情况下，我们需要用到深拷贝。

> 深拷贝，在拷贝引用类型成员变量时，为引用类型的数据成员另辟了一个独立的内存空间，实现真正内容上的拷贝。

## 深拷贝特点 ##

(1) 对于基本数据类型的成员对象，因为基础数据类型是值传递的，所以是直接将属性值赋值给新的对象。基础类型的拷贝，其中一个对象修改该值，不会影响另外一个（和浅拷贝一样）。  
(2) 对于引用类型，比如数组或者类对象，深拷贝会新建一个对象空间，然后拷贝里面的内容，所以它们指向了不同的内存空间。改变其中一个，不会对另外一个也产生影响。  
(3) 对于有多层对象的，每个对象都需要实现 `Cloneable` 并重写 `clone()` 方法，进而实现了对象的串行层层拷贝。  
(4) 深拷贝相比于浅拷贝速度较慢并且花销较大。

结构图如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly96eWM4OC5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70][]

## 深拷贝的实现 ##

对于 `Student` 的引用类型的成员变量 `Subject` ，需要实现 `Cloneable` 并重写 `clone()` 方法。

public class Subject implements Cloneable {
    
        private String name;
    
        public Subject(String name) {
            this.name = name;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        @Override
        protected Object clone() throws CloneNotSupportedException {
            //Subject 如果也有引用类型的成员属性，也应该和 Student 类一样实现
            return super.clone();
        }
    
        @Override
        public String toString() {
            return "[Subject: " + this.hashCode() + ",name:" + name + "]";
        }
    }

在 `Student` 的 `clone()` 方法中，需要拿到拷贝自己后产生的新的对象，然后对新的对象的引用类型再调用拷贝操作，实现对引用类型成员变量的深拷贝。

public class Student implements Cloneable {
    
        //引用类型
        private Subject subject;
        //基础数据类型
        private String name;
        private int age;
    
        public Subject getSubject() {
            return subject;
        }
    
        public void setSubject(Subject subject) {
            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;
        }
    
        /**
         *  重写clone()方法
         * @return
         */
        @Override
        public Object clone() {
            //深拷贝
            try {
                // 直接调用父类的clone()方法
                Student student = (Student) super.clone();
                student.subject = (Subject) subject.clone();
                return student;
            } catch (CloneNotSupportedException e) {
                return null;
            }
        }
    
        @Override
        public String toString() {
            return "[Student: " + this.hashCode() + ",subject:" + subject + ",name:" + name + ",age:" + age + "]";
        }
    }

一样的使用方式

输出结果：

studentA:[Student: 460141958,subject:[Subject: 1163157884,name:yuwen],name:Lynn,age:20]
    studentB:[Student: 1956725890,subject:[Subject: 356573597,name:lishi],name:Lily,age:18]

由输出结果可见，深拷贝后，不管是基础数据类型还是引用类型的成员变量，修改其值都不会相互造成影响。

### 6、深拷贝 ###

弄清楚了浅拷贝，那么深拷贝就很容易理解了。

**深拷贝：创建一个新对象，然后将当前对象的非静态字段复制到该新对象，无论该字段是值类型的还是引用类型，都复制独立的一份。当你修改其中一个对象的任何内容时，都不会影响另一个对象的内容。**

**Object 类提供的 clone 是只能实现 浅拷贝的。**

但是这种做法有个弊端，这里我们Person 类只有一个 Address 引用类型，而 Address 类没有，所以我们只用重写 Address 类的clone 方法，但是如果 Address 类也存在一个引用类型，那么我们也要重写其clone 方法，这样下去，有多少个引用类型，我们就要重写多少次，如果存在很多引用类型，那么代码量显然会很大，所以这种方法不太合适。

## 利用序列化实现深复制 ##

## **　　**序列化是将对象写到流中便于传输，而反序列化则是把对象从流中读取出来。这里写到流中的对象则是原始对象的一个拷贝，因为原始对象还存在 JVM 中，所以我们可以利用对象的序列化产生克隆对象，然后通过反序列化获取这个对象。 ##

注意每个需要序列化的类都要实现 Serializable 接口，如果有某个属性不需要序列化，可以将其声明为 transient，即将其排除在克隆属性之外。

//深度拷贝
    public Object deepClone() throws Exception{
        // 序列化
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
    
        oos.writeObject(this);
    
        // 反序列化
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
    
        return ois.readObject();
    }

因为序列化产生的是两个完全独立的对象，所有无论嵌套多少个引用类型，序列化都是能实现深拷贝的。

方式二：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly96eWM4OC5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 1][]

方式三：使用MapStruct等工具包

[Link 1]: https://www.cnblogs.com/ysocean/p/8476933.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly96eWM4OC5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70]: /images/20230531/2857f2dc20854110828dc329c0b4677d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly96eWM4OC5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 1]: /images/20230531/e9568881867e4603aade8b1e9bce4265.png