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拷贝给list02List list2 = new ArrayList(list1);System.out.println("list1未改变前，list2的结果为：" + list2);//方式2：通过addAll方法，把list01拷贝给list02List list3 = new ArrayList();list3.addAll(list1);System.out.println("list1未改变前，list3的结果为：" + list3);//方式3：通过stream流的方式，把list01拷贝给list02List 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;@Overrideprotected 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拷贝给list02List 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;/** * @author 睡竹 * @date 2022/12/10 * 用于深拷贝时，不需要去遍历List集合，只需要拷贝UserCopyDTO 对象就可以 * 获取到新的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拷贝给list02UserCopyDTO 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序列化

步骤：

1、导入Gson依赖

com.google.code.gsongson2.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.jacksoncore2.2.2com.fasterxml.jacksondatabind2.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、总结