湫枫染墨

深浅拷贝

2/11/2022 面试题Java

文章来源

5张图搞懂Java引用拷贝、深拷贝、浅拷贝 (opens new window)

# 一：前言

将一个对象的属性赋值到另一个对象，这种情况就叫做拷贝。拷贝与Java内存结构息息相关。

# 二：引用拷贝

引用拷贝会生成一个新的对象引用地址，但是两个最终指向依然是同一个对象。就拿人来说，通常有个姓名，但是不同场合、人物对我们的叫法可能不同，但我们很清楚哪些名称都是属于"我"的

引用拷贝

# 2.1 案例演示

Son.java

import lombok.*;

@AllArgsConstructor
@Getter
@Setter
public class Son {
    private String name;
    private int age;
}
1
2
3
4
5
6
7
8
9

QuoteTest.java(测试)

public class QuoteTest {

    public static void main(String[] args) {
        Son s1 = new Son("son1", 12);
        Son s2 = s1;
        s1.setAge(22);
        System.out.println(s1); // com.ccjjltx.Son@1b6d3586
        System.out.println(s2); // com.ccjjltx.Son@1b6d3586
        System.out.println("s1的age：" + s1.getAge()); // s1的age：22
        System.out.println("s2的age：" + s2.getAge()); // s2的age：22
        System.out.println("s1==s2：" + (s1 == s2));   // s1==s2：true
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

运行结果

运行结果

# 三：浅拷贝

如何创建一个对象，将目标对象的内容复制过来而不是直接拷贝引用呢？

浅拷贝会创建一个新对象，新对象和原对象本身没有任何关系，新对象和原对象不等，但是新对象的属性和老对象相同。具体可以看如下区别：

  • 如果属性是基本类型（int，double，long，boolean等)，拷贝的就是基本类型的值；
  • 如果属性是引用类型，拷贝的就是内存地址（即复制引用但不复制引用的对象），因此如果其中一个对象改变了这个地址，就会影响到另一个对象。

浅拷贝

如何实现浅拷贝？在需要拷贝的类上实现Cloneable接口并重写其clone()方法

部分源码

Cloneable源码

package java.lang;
public interface Cloneable {
}
1
2
3

Object部分源码

package java.lang;
public class Object {
    protected native Object clone() throws CloneNotSupportedException;
}
1
2
3
4

# 3.1 案例演示

Father.java

import lombok.AllArgsConstructor;
import lombok.Data;


@AllArgsConstructor
@Data
public class Father implements Cloneable {

    private String name;

    private Son son;

    @Override
    protected Father clone() throws CloneNotSupportedException {
        return (Father) super.clone();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

ShallowTest.java(测试)

public class ShallowTest {

    public static void main(String[] args) throws CloneNotSupportedException {
        Son son1 = new Son("son1", 13);
        Father f1 = new Father("f1", son1);
        Father f2 = f1.clone();

        System.out.println(f1); // Father{name='f1', son=com.ccjjltx.Son@1b6d3586}
        System.out.println(f2); // Father{name='f1', son=com.ccjjltx.Son@1b6d3586}
        System.out.println("f1==f2：" + (f1 == f2)); // f1==f2：false
        System.out.println("f1.name==f2.name：" + (f1.getName() == f2.getName())); // f1.name==f2.name：true
        System.out.println("f1.son==f2.son：" + (f1.getSon() == f2.getSon())); // f1.son==f2.son：true
        System.out.println("son1.age==son1.age：" + (f1.getSon().getAge() == f2.getSon().getAge())); // son1.age==son1.age：true
        System.out.println("son1.name==son1.name：" + (f1.getSon().getName() == f2.getSon().getName())); // son1.name==son1.name：true

        son1.setAge(12);
        son1.setName("son2");
        f1.setName("ff");
        System.out.println("f1.name==f2.name：" + (f1.getName() == f2.getName())); // f1.name=f=2.name：false
        System.out.println(f1); // Father{name='ff', son=com.ccjjltx.Son@1b6d3586}
        System.out.println(f2); // Father{name='f1', son=com.ccjjltx.Son@1b6d3586}
        System.out.println("f1.son==f2.son：" + (f1.getSon() == f2.getSon())); // f1.son==f2.son：true
        System.out.println("son1.age==son1.age：" + (f1.getSon().getAge() == f2.getSon().getAge())); // son1.age==son1.age：true
        System.out.println("son1.name==son1.name：" + (f1.getSon().getName() == f2.getSon().getName())); // son1.name==son1.name：true
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

运行结果

name初始 == 是相等的，是因为初始浅拷贝它们指向一个相同的String，而后 f1.setName("ff"); 则改变了引用指向

结果

# 四：深拷贝

浅拷贝虽然拷贝的两个对象不同，但其内部的一些引用还是相同的，怎么样绝对的拷贝这个对象，使这个对象完全独立于原对象呢？就需要使用深拷贝。

深拷贝：在对引用数据类型进行拷贝的时候，创建了一个新的对象，并且复制其内的成员变量。

结果

在具体实现深拷贝上，这里提供两个方式，重写 clone()方法 和 序列法

# 4.1 重写clone()方法

对于上述代码，Son类实现Cloneable接口并重写clone()方法。Father的clone()方法需要对各个引用都拷贝一遍。

// son clone()方法
@Override
protected Son clone() throws CloneNotSupportedException {
	return (Son) super.clone();
}

// Father clone()方法
@Override
protected Father clone() throws CloneNotSupportedException {
    Father father = (Father) super.clone();
    father.setName(new String(father.getName()));
    father.son = son.clone();
    return father;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

DeepTest.java(测试)

public class DeepTest {

    public static void main(String[] args) throws CloneNotSupportedException {
        Son son1 = new Son("son1", 13);
        Father f1 = new Father("f1", son1);
        Father f2 = f1.clone();

        System.out.println(f1); // Father{name='f1', son=com.ccjjltx.Son@1b6d3586}
        System.out.println(f2); // Father(name=f1, son=com.ccjjltx.Son@4554617c)
        System.out.println("f1==f2：" + (f1 == f2)); // f1==f2：false
        System.out.println("f1.name==f2.name：" + (f1.getName() == f2.getName())); // f1.name==f2.name：false
        System.out.println("f1.son==f2.son：" + (f1.getSon() == f2.getSon())); // f1.son==f2.son：false
        System.out.println("son1.age==son1.age：" + (f1.getSon().getAge() == f2.getSon().getAge())); // son1.age==son1.age：true
        System.out.println("son1.name==son1.name：" + (f1.getSon().getName() == f2.getSon().getName())); // son1.name==son1.name：true

        son1.setAge(12);
        son1.setName("son2");
        f1.setName("ff");
        System.out.println("f1.name==f2.name：" + (f1.getName() == f2.getName())); // f1.name=f=2.name：false
        System.out.println(f1); // Father{name='ff', son=com.ccjjltx.Son@1b6d3586}
        System.out.println(f2); // Father(name=f1, son=com.ccjjltx.Son@4554617c)
        System.out.println("f1.son==f2.son：" + (f1.getSon() == f2.getSon())); // f1.son==f2.son：false
        System.out.println("son1.age==son1.age：" + (f1.getSon().getAge() == f2.getSon().getAge())); // son1.age==son1.age：false
        System.out.println("son1.name==son1.name：" + (f1.getSon().getName() == f2.getSon().getName())); // son1.name==son1.name：false
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

运行结果

# 4.2 序列化

虽然方法一，能实现深拷贝，但是这种情况有个问题，如果引用数量或者层数太多了怎么办呢？不可能去每个对象挨个写clone()吧？那怎么办呢？此时就得借助序列化

因为序列化后：将二进制字节流内容写到一个媒介（文本或字节数组），然后是从这个媒介读取数据，原对象写入这个媒介后拷贝给clone对象，原对象的修改不会影响clone对象，因为clone对象是从这个媒介读取。

熟悉对象缓存的知道我们经常将Java对象缓存到Redis中，然后还可能从Redis中读取生成Java对象，这就用到序列化和反序列化。一般可以将Java对象存储为字节流或者json串然后反序列化成Java对象。因为序列化会储存对象的属性但是不会也无法存储对象在内存中地址相关信息。所以在反序列化成Java对象时候会重新创建所有的引用对象。

在具体实现上，自定义的类需要实现Serializable接口。在需要深拷贝的类(Father)中定义一个函数返回该类对象：

Son.java

import lombok.*;

import java.io.Serializable;

@AllArgsConstructor
@Getter
@Setter
public class Son implements Serializable {
    private String name;
    private int age;
}
1
2
3
4
5
6
7
8
9
10
11

Father.java

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.ToString;

import java.io.*;


@AllArgsConstructor
@Data
@ToString
public class Father implements Serializable {

    private String name;

    private Son son;

    public Father deepClone() throws IOException, ClassNotFoundException {
        //在内存中创建一个字节数组缓冲区，所有发送到输出流的数据保存在该字节数组中
        //默认创建一个大小为32的缓冲区
        ByteArrayOutputStream byOut = new ByteArrayOutputStream();
        //对象的序列化输出
        ObjectOutputStream outputStream = new ObjectOutputStream(byOut);//通过字节数组的方式进行传输
        outputStream.writeObject(this);  //将当前student对象写入字节数组中

        //在内存中创建一个字节数组缓冲区，从输入流读取的数据保存在该字节数组缓冲区
        ByteArrayInputStream byIn = new ByteArrayInputStream(byOut.toByteArray()); //接收字节数组作为参数进行创建
        ObjectInputStream inputStream = new ObjectInputStream(byIn);
        return (Father) inputStream.readObject();//从字节数组中读取
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

DeepTest2.java

import java.io.IOException;

public class DeepTest2 {

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Son son1 = new Son("son1", 13);
        Father f1 = new Father("f1", son1);
        Father f2 = f1.deepClone();

        System.out.println(f1); // Father(name=f1, son=com.ccjjltx.Son@4b67cf4d)
        System.out.println(f2); // Father(name=f1, son=com.ccjjltx.Son@15aeb7ab)
        System.out.println("f1==f2：" + (f1 == f2)); // f1==f2：false
        System.out.println("f1.name==f2.name：" + (f1.getName() == f2.getName())); // f1.name==f2.name：false
        System.out.println("f1.son==f2.son：" + (f1.getSon() == f2.getSon())); // f1.son==f2.son：false
        System.out.println("son1.age==son1.age：" + (f1.getSon().getAge() == f2.getSon().getAge())); // son1.age==son1.age：true
        System.out.println("son1.name==son1.name：" + (f1.getSon().getName() == f2.getSon().getName())); // son1.name==son1.name：false

        son1.setAge(12);
        son1.setName("son2");
        f1.setName("ff");
        System.out.println("f1.name==f2.name：" + (f1.getName() == f2.getName())); // f1.name=f=2.name：false
        System.out.println(f1); // Father(name=ff, son=com.ccjjltx.Son@4b67cf4d)
        System.out.println(f2); // Father(name=f1, son=com.ccjjltx.Son@15aeb7ab)
        System.out.println("f1.son==f2.son：" + (f1.getSon() == f2.getSon())); // f1.son==f2.son：false
        System.out.println("son1.age==son1.age：" + (f1.getSon().getAge() == f2.getSon().getAge())); // son1.age==son1.age：false
        System.out.println("son1.name==son1.name：" + (f1.getSon().getName() == f2.getSon().getName())); // son1.name==son1.name：false
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

运行结果

# 五：文章来源

最后更新: 2/6/2023, 8:44:43 PM

静动态代理