先定义一个标准的javabean对象,并实现持久化接口
请看代码:
再写个类实现二进制克隆对象:
发现两个克隆的对象包含的对象都不是引用对象。这样就实现了深度克隆,不敢想象。
请看代码:
package com.ben.clone;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class Person implements Serializable
{
private int age;
private String name;
private char sex;
private List sth = new ArrayList();
private Map bt = new HashMap();
public int getAge()
{
return age;
}
public void setAge(int age)
{
this.age = age;
}
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
public char getSex()
{
return sex;
}
public void setSex(char sex)
{
this.sex = sex;
}
public List getSth()
{
return sth;
}
public void setSth(List sth)
{
this.sth = sth;
}
public Map getBt()
{
return bt;
}
public void setBt(Map bt)
{
this.bt = bt;
}
}
再写个类实现二进制克隆对象:
package com.ben.clone;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.StreamCorruptedException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class ByteCloneTest
{
/**
* <pre>
* 以二进制方式克隆对象
* </pre>
* @param src 被克隆的对象
* @return 克隆的对象
*/
public static final Object byteClone(Object src)
{
try
{
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream out = new ObjectOutputStream(baos);
out.writeObject(src);
out.close();
ByteArrayInputStream bin = new ByteArrayInputStream(baos.toByteArray());
ObjectInputStream in = new ObjectInputStream(bin);
Object clone = in.readObject();
in.close();
return (clone);
}
catch (ClassNotFoundException e)
{
throw new InternalError(e.toString());
}
catch (StreamCorruptedException e)
{
throw new InternalError(e.toString());
}
catch (IOException e)
{
throw new InternalError(e.toString());
}
}
public static void main(String[] args)
{
Person p = new Person();
p.setAge(80);
p.setName("jerry");
p.setSex('F');
List list = new ArrayList();
list.add("apple");
list.add("orange");
list.add("banana");
Map map = new HashMap();
map.put("哥哥", "liuliu");
map.put("姐姐", "linlin");
map.put("李李", "lili");
p.setBt(map);
p.setSth(list);
Person ps = (Person)ByteCloneTest.byteClone(p);
ps.setName("benlsoft");
System.out.println("p----"+p.getName());
System.out.println("ps---"+ps.getName());
}
}
发现两个克隆的对象包含的对象都不是引用对象。这样就实现了深度克隆,不敢想象。