Java对象深拷贝详解（List深拷贝）

1、Java中拷贝的概念

在Java语言中，拷贝一个对象时，有浅拷贝与深拷贝两种

浅拷贝：只拷贝源对象的地址，所以新对象与老对象共用一个地址，当该地址变化时，两个对象也会随之改变。

深拷贝：拷贝对象的所有值，即使源对象发生任何改变，拷贝的值也不会变化。

在User类的基础上，介绍两种浅拷贝案列

User类：

@Datapublic class User {    private String name;    private Integer age;}

案列①：普通对象的浅拷贝

package com.shuizhu.study;//浅拷贝案例1public class Study01 {    public static void main(String[] args) {        User user1 = new User();        user1.setName("张三");        user1.setAge(18);        User user2 = user1;        System.out.println("user1未改变前，user2的名字为：" + user2.getName());        user1.setName("李四");        System.out.println("user1未改变前，user2的名字为：" + user2.getName());    }}

结果：改变user1后，user2的值也随之变化

案列②：List浅拷贝（这也是我们平时项目中，经常遇到的情况）

package com.shuizhu.study;import java.util.ArrayList;import java.util.List;import java.util.stream.Collectors;//Java浅拷贝案列2public class Study02 {    public static void main(String[] args) {        List list1 = new ArrayList<>();        User user1 = new User();        user1.setName("张三");        user1.setAge(18);        User user2 = new User();        user2.setName("李四");        user2.setAge(19);        list1.add(user1);        list1.add(user2);        //TODO 以下是开发中，经常发生的浅拷贝        //方式1：通过new ArrayList方式，把list01拷贝给list02        List list2 = new ArrayList<>(list1);        System.out.println("list1未改变前，list2的结果为：" + list2);        //方式2：通过addAll方法，把list01拷贝给list02        List list3 = new ArrayList<>();        list3.addAll(list1);        System.out.println("list1未改变前，list3的结果为：" + list3);        //方式3：通过stream流的方式，把list01拷贝给list02        List list4 = list1.stream().collect(Collectors.toList());        System.out.println("list1未改变前，list4的结果为：" + list4);        //改变list1集合中的user1对象        System.out.println("--------------------------------------------");        user1.setName("老六");        user1.setAge(78);        System.out.println("list1改变后，list2的结果为：" + list2);        System.out.println("list1改变后，list3的结果为：" + list3);        System.out.println("list1改变后，list4的结果为：" + list4);    }}

结果：对List的3种拷贝，其实都是浅拷贝，当源集合中对象发生改变时，新的List也会随之变化

2、常见的深拷贝方式

1. 构造函数方式（new的方式）
2. 重写clone方法
3. Apache Commons Lang序列化
4. Gson序列化
5. Jackson序列化

2.1、构造函数方式

这种方式就是创建一个新的对象，然后通过源对象的get方法与新对象set方法，把源对象的值复制新对象，这里就不再演示了。

缺点：在拷贝的对象数量较少时，可以使用，但是对象数量过多时，会大大增加系统开销，开发中应避免使用。

2.2、重写clone方法

步骤：

1>需要拷贝对象的类，去实现Cloneable接口

2>重写clone方法

3>使用"对象.clone()"的方式进行拷贝

根据上面的案列，进行对应的改造：

首先是User实体类 ，如下：

@Datapublic class User implements Cloneable{    private String name;    private Integer age;    @Override    protected User clone() throws CloneNotSupportedException {        return (User) super.clone();    }}

改造案列①：

package com.shuizhu.study;//Java深拷贝案列public class Study03 {    public static void main(String[] args) throws CloneNotSupportedException {        User user1 = new User();        user1.setName("张三");        user1.setAge(18);        User user2 = user1.clone();        System.out.println("user1未改变前，user2的名字为：" + user2.getName());        user1.setName("李四");        System.out.println("user1未改变前，user2的名字为：" + user2.getName());    }}

结果：当user1改变后，user2的值不会改变

改造案列②：List类型深拷贝

package com.shuizhu.study;import java.util.ArrayList;import java.util.List;import java.util.stream.Collectors;//Java深拷贝案列public class Study04 {    public static void main(String[] args) {        List list1 = new ArrayList<>();        User user1 = new User();        user1.setName("张三");        user1.setAge(18);        User user2 = new User();        user2.setName("李四");        user2.setAge(19);        list1.add(user1);        list1.add(user2);        /        //通过clone方式，把list01拷贝给list02        List list2 = new ArrayList<>();          //TODO 当数据量多时，建议使用对象的方式，把List当做属性，然后拷贝哦到一个新的对象中，从而不需要循环，可以见Apache Commons Lang序列化深拷贝方式        list1.forEach(user->{            try {                list2.add(user.clone());            } catch (CloneNotSupportedException e) {                e.printStackTrace();            }        });        System.out.println("list1未改变前，list2的结果为：" + list2);                //改变list1集合中的user1对象        System.out.println("--------------------------------------------");        user1.setName("老六");        user1.setAge(78);        System.out.println("list1改变后，list2的结果为：" + list2);    }}

结果：list1中的每个对象通过clone()添加list2中，当list1中的对象改变时，list2不会改变

2.3 、Apache Commons Lang序列化

步骤：

1>导入Commons包

   org.apache.commons   commons-lang3   3:3.5

2>实体类实现Serializable接口

@Datapublic class User implements Serializable {    private String name;    private Integer age;}

3>调用SerializationUtils工具类，实现深拷贝（注意：SerializationUtils不能直接拷贝List类型）

案列如下：

案列①：对象深拷贝

package com.shuizhu.study2;import org.apache.commons.lang3.SerializationUtils;//Apache Commons Lang序列化实现对象的深拷贝public class Study01 {    public static void main(String[] args) {        User user1 = new User();        user1.setName("张三");        user1.setAge(18);        User user2 = SerializationUtils.clone(user1);        System.out.println("user1未改变前，user2的名字为：" + user2.getName());        user1.setName("李四");        System.out.println("user1改变后，user2的名字为：" + user2.getName());    }}

结果：user1的改变不会导致user2的改变，从而实现深拷贝

案列②：List类型深拷贝

（1）改造开始，我们先创建一个专门用于拷贝List类型的实体类

package com.shuizhu.study2;import java.io.Serializable;import java.util.List;@Datapublic class UserCopyDTO implements Serializable {//必须实现Serializable接口    private List users;}

（2）拷贝List类型

package com.shuizhu.study2;import org.apache.commons.lang3.SerializationUtils;import java.util.ArrayList;import java.util.List;//Apache Commons Lang序列化实现List的深拷贝public class Study02 {    public static void main(String[] args) {        List list1 = new ArrayList<>();        User user1 = new User();        user1.setName("张三");        user1.setAge(18);        User user2 = new User();        user2.setName("李四");        user2.setAge(19);        list1.add(user1);        list1.add(user2);        //使用UserCopyDTO对象，专门用于拷贝List类型数据，不需要再去遍历list1         UserCopyDTO userCopyDTO = new UserCopyDTO();        userCopyDTO.setUsers(list1);        //通过Apache Commons Lang序列化方式，把list01拷贝给list02        UserCopyDTO clone = SerializationUtils.clone(userCopyDTO);        List list2 = clone.getUsers();        System.out.println("list1未改变前，list2的结果为：" + list2);        //改变list1集合中的user1对象        System.out.println("--------------------------------------------");        user1.setName("老六");        user1.setAge(78);        System.out.println("list1改变后，list2的结果为：" + list2);    }}

结果：

 2.4、Gson序列化

步骤：

导入Gson依赖

    com.Google.code.gson    gson    2.8.5

2>创建Gson对象，使用该对象进行深拷贝（实体类不再需要实现Serializable接口）

案例如下：只演示对象的深拷贝，LIst类型的深拷贝与之前的流程是相似的

package com.shuizhu.study3;import com.google.gson.Gson;//Gson序列化实现对象的深拷贝public class Study01 {    public static void main(String[] args) {        User user1 = new User();        user1.setName("张三");        user1.setAge(18);        Gson gson = new Gson();        User user2 = gson.fromJSON(gson.tojson(user1), User.class);        System.out.println("user1未改变前，user2的名字为：" + user2.getName());        user1.setName("李四");        System.out.println("user1改变后，user2的名字为：" + user2.getName());    }}

重点：

结果：

 2.5、Jackson序列化

该方式与Gson原理、使用方式相似，但是Jackson序列化深拷贝，要求拷贝的对象必须有无参构造函数

步骤：

1>导入Jackson依赖

    com.fasterxml.jackson    core    2.2.2    com.fasterxml.jackson    databind    2.2.2

2>创建ObjectMapper对象，进行深拷贝（用法与Gson一致）

package com.shuizhu.study4;import com.fasterxml.jackson.databind.ObjectMapper;import java.io.IOException;//Jackson序列化实现对象的深拷贝public class Study01 {    public static void main(String[] args) {        User user1 = new User();        user1.setName("张三");        user1.setAge(18);        ObjectMapper mapper = new ObjectMapper();        User user2 = null;        try {            user2 = mapper.readValue(mapper.writeValueAsString(user1), User.class);        } catch (IOException e) {            e.printStackTrace();        }        System.out.println("user1未改变前，user2的名字为：" + user2.getName());        user1.setName("李四");        System.out.println("user1改变后，user2的名字为：" + user2.getName());    }}

重点：

结果：

3、总结

来源地址：https://blog.csdn.net/weixin_42675423/article/details/128260074