1、什么是深拷贝、什么是浅拷贝
浅拷贝：浅拷贝不会生成新的对象，只会在原对象上增加了一个新的对象引用，两个引用指向的对象是同一个；
深拷贝：深拷贝是重新生成一个新的对象，然后把原来对象的值拷贝到新对象的一个过程，新的对象和原来的对象是没有任何关系的。
2、浅拷贝场景：
java 对象默认的对象拷贝方式都为浅拷贝，下面我们来看一下我们程序里面常见的例子：
（1）首先定义一个User类
public classUser {private int age;//年龄privateStringname;//姓名public intgetAge() {return age;
}public voidsetAge(intage) {this.age= age;
}publicString getName() {return name;
}public voidsetName(String name) {this.name= name;
}
@OverridepublicString toString() {return "User{"+"age="+age+", name='"+name+'\''+'}';
}
}
（2）测试代码：
public static voidmain(String[] args) {//1、实例化一个user1对象，并对属性赋值User user1=newUser();
user1.setName("我是user1");
user1.setAge(18);//2、把user1对象放到一个List里面List userList=newArrayList();
userList.add(user1);//3、然后创建user2 对象并从List里面拿出user1对象赋值给user2User user2= userList.get(0);//4、给user2的属性值user2.setAge(1);
user2.setName("我是user2");//5、这个的时候我们再输出user1的对应属性值System.out.println(user1);
}
最后我们看看打印结果：
举了一个比较绕的例子是想更好的提现出浅拷贝可能会给我们带来的问题；
结合浅拷贝的图解我想我们不难理解这个结果是怎么出现的，因为user1和user2其实指向的是同一个对象,所以当我们修改user2的属性时其实修改的也是user1这个对象。
程序中如果像这种在一个对象上多次浅拷贝并使用其实是很危险的，有时候调用的层次多了被传递的使用者修改了对象属性会造成业务逻辑上的错误（想想上面的例子，如果在user2修改属性值之后，还有业务代码要拿user1来进行业务操作的话，那么此时的user1属性值都已经被修改了，这样势必会产生业务上的错误），而这样的问题又比较难发现，并且这样也会造成代码的理解成本变高，可读性也会变差。
总结：因为浅拷贝的特性我们要尽少对浅拷贝的对象进行属性值的修改，如果有需要拷贝对象的时候，我们可以考虑用对象克隆的方式来把对象进行深度拷贝。
3、如何对对象进行深度拷贝
方式一：实现Cloneable接口
（1）需要拷贝的对象实现Cloneable 接口
public classUserimplementsCloneable {privateStringname;privateIntegerage;publicString getName() {return name;
}public voidsetName(String name) {this.name= name;
}publicInteger getAge() {return age;
}public voidsetAge(Integer age) {this.age= age;
}
@OverrideprotectedObject clone()throwsCloneNotSupportedException {return super.clone();
}
@OverridepublicString toString() {return "User{"+"name='"+name+'\''+", age="+age+'}';
}
}
（2）然后我们按上面的流程测试
public static voidmain(String[] args) {try{
User user1 =newUser();
user1.setName("我是user11");
user1.setAge(188);
List userList =newArrayList();
userList.add(user1);//克隆user1对象User user2 = (User) userList.get(0).clone();
user2.setAge(11);
user2.setName("我是user22");
System.out.println(user1);
System.out.println(user2);
}catch(Exception e) {
e.printStackTrace();
}
}
（3）打印结果
注意： 如果User 里有一个Class 对象的属性，此时需要完全深度克隆的话，那么Class这个类也要实现Cloneable 接口，否则只有user其他的属性值深度拷贝了，但class这个对象还是进行浅拷贝；
方式二：把对象进行序列化后再反序列化
（1）对象实现序列化接口
public classUserimplementsSerializable{privateStringname;privateIntegerage;publicString getName() {return name;
}public voidsetName(String name) {this.name= name;
}publicInteger getAge() {return age;
}public voidsetAge(Integer age) {this.age= age;
}
@OverridepublicString toString() {return "User{"+"name='"+name+'\''+", age="+age+'}';
}
}
（1）把对象进行序列化后再反序列化
public static voidmain(String[] args) {try{
User user1 =newUser();
user1.setName("我是user111");
user1.setAge(1888);//序列化写入到流里ByteOutputStream bots=newByteOutputStream();
ObjectOutputStream oos =newObjectOutputStream(bots);
oos.writeObject(user1);//反序列化成user2对象ObjectInputStream ois=newObjectInputStream(newByteArrayInputStream(bots.toByteArray()));
User user2 = (User) ois.readObject();
user2.setAge(111);
user2.setName("我是user222");
System.out.println(user1);
System.out.println(user2);
}catch(Exception e) {
e.printStackTrace();
}
}
最后看结果：
4、最后找了一个深度拷贝工具类供大家使用
public abstract classBeanUtil {public static T cloneTo(T src)throwsRuntimeException {
ByteArrayOutputStream memoryBuffer =newByteArrayOutputStream();
ObjectOutputStream out =null;
ObjectInputStream in =null;
T dist =null;try{
out =newObjectOutputStream(memoryBuffer);
out.writeObject(src);
out.flush();
in =newObjectInputStream(newByteArrayInputStream(memoryBuffer.toByteArray()));
dist = (T) in.readObject();
}catch(Exception e) {throw newRuntimeException(e);
}finally{if(out !=null) {try{
out.close();
out =null;
}catch(IOException e) {throw newRuntimeException(e);
}
}if(in !=null) {try{
in.close();
in =null;
}catch(IOException e) {throw newRuntimeException(e);
}
}
}returndist;
}
}
,
