对象的深度克隆原理:将对象序列化后写在输出流里,因为写在流里面的对象是一份拷贝,原对象仍然在JVM里;然后再把输出流转换为输入流,把对象反序列化后写出来!这样就实现了对象的深度克隆,克隆后的两个对象完全独立开来,互不影响!
你会发现对象的深度克隆其实是利用的对象的序列化和反序列化,所以要进行深度克隆的对象都要实现Serializable接口!
package com.test;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
public class StudentClone implements Cloneable,Serializable
{
String name;
int age;
List<String> list = new ArrayList<String>(){{
add("A");
add("B");
add("C");
}};
StudentClone(String name,int age)
{
this.name=name;
this.age=age;
}
/*public Object clone()
{
Object o=null;
try
{
o=(StudentClone)super.clone();//Object 中的clone()识别出你要复制的是哪一个对象。
}
catch(CloneNotSupportedException e)
{
System.out.println(e.toString());
}
return o;
} */
/*public StudentClone clone() {
ByteArrayOutputStream byteOut = null;
ObjectOutputStream objOut = null;
ByteArrayInputStream byteIn = null;
ObjectInputStream objIn = null;
try {
byteOut = new ByteArrayOutputStream();
objOut = new ObjectOutputStream(byteOut);
objOut.writeObject(prototype);
byteIn = new ByteArrayInputStream(byteOut.toByteArray());
objIn = new ObjectInputStream(byteIn);
return (ContretePrototype) objIn.readObject();
} catch (IOException e) {
throw new RuntimeException("Clone Object failed in IO.",e);
} catch (ClassNotFoundException e) {
throw new RuntimeException("Class not found.",e);
} finally{
try{
byteIn = null;
byteOut = null;
if(objOut != null) objOut.close();
if(objIn != null) objIn.close();
}catch(IOException e){
}
}
}*/
public Object copy() throws IOException, ClassNotFoundException{
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(this);
ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(bos.toByteArray()));
return ois.readObject();
}
public static void main(String[] args) throws IOException, ClassNotFoundException
{
StudentClone s1= new StudentClone("zhangsan",50);
StudentClone s2=(StudentClone)s1.copy();
s2.list.add("D");
s2.name="lisi";
s2.age=20;
System.out.println("name="+s1.name+","+"age="+s1.age);//修改学生2后,不影响学生1的值。
System.out.println("name="+s2.name+","+"age="+s2.age);
System.out.println("name="+s1.name+","+"age="+s1.age);
System.out.println(s1.list.size()+"hhhhhhh");
System.out.println(s2.list.size()+"uuuuuuu");
}
}
程序运行的结果如下图:两个List中的对象个数不相同了,也就是对克隆后的对象进行更改不影响原对象的List了,即实现了深度克隆