使用序列化实现对象的拷贝至少有三种方法：
1、使用引用 2、基本类型的拷贝 3、对象类型级别的拷贝
1、使用引用
使用对象引用来构建实例化对象，实际上只是引用上的别名，所有对象的地址只有一个。其中一个对象的属性改变，其它的对象的属性也改变了
Email类：
public class Email implements Serializable {
private String title;
private String content;
public Email(String title,String content){
this.title =title;
this.content=content;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
}Person类：
public class Person implements Cloneable{
/** 姓名 **/
private String name;
/** 电子邮件 **/
private Email email;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Email getEmail() {
return email;
}
public void setEmail(Email email) {
this.email = email;
}
public Person(String name,Email email){
this.name = name;
this.email = email;
}
public Person(String name){
this.name = name;
}
}testMain类：
public class testMain {
public static void main(String[] args ){
System.out.println("进入了main方法了");
//写封邮件
Email email = new Email("请参加会议","请与今天12:30到二会议室参加会议...");
Person person1 = new Person("张三",email);
Person person2 = person1;
person2.setName("李四");
Person person3 = person1;
person3.setName("王五");
System.out.println(person1.getName() + "的邮件内容是：" + person1.getEmail().getContent());
System.out.println(person2.getName() + "的邮件内容是：" + person2.getEmail().getContent());
System.out.println(person3.getName() + "的邮件内容是：" + person3.getEmail().getContent());
}
}运行testMain类的结果：
进入了main方法了
王五的邮件内容是：请与今天12:30到二会议室参加会议...
王五的邮件内容是：请与今天12:30到二会议室参加会议...
王五的邮件内容是：请与今天12:30到二会议室参加会议...从结果上分析：使用对象引用来构建实例化对象，实际上只是引用上的别名，所有对象的地址只有一个。其中一个对象的属性改变，其它的对象的属性也改变了，person3是最后改变的，所有的对象属性都是和person3的对象相同。
2、基本类型的拷贝
java中有Cloneable，这个接口实现该接口的类都会具备拷贝的能力，同时拷贝clone比我们的new生成对象来的快，特别是在大对象的生成上，使得性能提升非常明显提高。然而它只是拷贝出基本类型，比如int,String，但是像对象这种类型只是引用之前的对象，没有创建出新的对象。
person类：
public class Person implements Cloneable{
/** 姓名 **/
private String name;
/** 电子邮件 **/
private Email email;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Email getEmail() {
return email;
}
public void setEmail(Email email) {
this.email = email;
}
public Person(String name,Email email){
this.name = name;
this.email = email;
}
public Person(String name){
this.name = name;
}
//Cloneable接口的方法，克隆出新的对象
protected Person clone() {
Person person = null;
try {
person = (Person) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return person;
}
}testMain类：
public class testMain {
public static void main(String[] args ){
System.out.println("进入了main方法了");
//写封邮件
Email email = new Email("请参加会议","张三请与今天12:30到二会议室参加会议...");
Person person1 = new Person("张三",email);
Person person2 = person1.clone();
person2.setName("李四");
person2.getEmail().setContent( "李四请与今天12:30到二会议室参加会议...");
Person person3 = person1.clone();
person3.getEmail().setContent( "王五请与今天12:30到二会议室参加会议...");
person3.setName("王五");
System.out.println(person1.getName() + "的邮件内容是：" + person1.getEmail().getContent());
System.out.println(person2.getName() + "的邮件内容是：" + person2.getEmail().getContent());
System.out.println(person3.getName() + "的邮件内容是：" + person3.getEmail().getContent());
}
}运行testMain类的结果：
进入了main方法了
张三的邮件内容是：王五请与今天12:30到二会议室参加会议...
李四的邮件内容是：王五请与今天12:30到二会议室参加会议...
王五的邮件内容是：王五请与今天12:30到二会议室参加会议...从结果上分析：Cloneable这个接口只是拷贝出基本类型，比如int,String，但是像对象这种类型只是引用之前的对象，没有创建出新的对象。邮件的内容是王五的最后修改，所以所有对象的邮件内容都和王五的一样。
3、对象类型级别的拷贝：如何利用序列化来完成对象的拷贝呢？在内存中通过字节流的拷贝是比较容易实现的。把母对象写入到一个字节流中，再从字节流中将其读出来，这样就可以创建一个新的对象了，并且该新对象与母对象之间并不存在引用共享的问题，真正实现对象的深拷贝。
person类：
public class Person implements Serializable{
private static final long serialVersionUID = 2631590509760908280L;
/** 姓名 **/
private String name;
/** 电子邮件 **/
private Email email;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Email getEmail() {
return email;
}
public void setEmail(Email email) {
this.email = email;
}
public Person(String name,Email email){
this.name = name;
this.email = email;
}
public Person(String name){
this.name = name;
}
}CloneUtils 类：所以使用该工具类的对象只要实现 Serializable 接口就可实现对象的克隆，无须继承 Cloneable 接口实现 clone() 方法。
public class CloneUtils {
@SuppressWarnings("unchecked")
public static <T extends Serializable> T clone(T obj){
T cloneObj = null;
try {
//写入字节流
ByteArrayOutputStream out = new ByteArrayOutputStream();
ObjectOutputStream obs = new ObjectOutputStream(out);
obs.writeObject(obj);
obs.close();
//分配内存，写入原始对象，生成新对象
ByteArrayInputStream ios = new ByteArrayInputStream(out.toByteArray());
ObjectInputStream ois = new ObjectInputStream(ios);
//返回生成的新对象
cloneObj = (T) ois.readObject();
ois.close();
} catch (Exception e) {
e.printStackTrace();
}
return cloneObj;
}
}testMain类：
public class testMain {
public static void main(String[] args ){
System.out.println("进入了main方法了");
//写封邮件
Email email = new Email("请参加会议","请与今天12:30到二会议室参加会议...");
Person person1 = new Person("张三",email);
Person person2 = CloneUtils.clone(person1);
person2.setName("李四");
person2.getEmail().setContent("李四请与今天12:10到二会议室参加会议...");
Person person3 = CloneUtils.clone(person1);
person3.setName("王五");
person3.getEmail().setContent("王五请与今天12:00到二会议室参加会议...");
System.out.println(person1.getName() + "的邮件内容是：" + person1.getEmail().getContent());
System.out.println(person2.getName() + "的邮件内容是：" + person2.getEmail().getContent());
System.out.println(person3.getName() + "的邮件内容是：" + person3.getEmail().getContent());
}
}运行testMain类的结果：
进入了main方法了
张三的邮件内容是：请与今天12:30到二会议室参加会议...
李四的邮件内容是：李四请与今天12:10到二会议室参加会议...
王五的邮件内容是：王五请与今天12:00到二会议室参加会议...结果分析：在内存中通过字节流的拷贝是比较容易实现的。把母对象写入到一个字节流中，再从字节流中将其读出来，这样就可以创建一个新的对象了，并且该新对象与母对象之间并不存在引用共享的问题，真正实现对象的深拷贝。李四和王五的邮件修改也只是对他们各自的邮件的修改，对其他人没有影响，这个克隆是对象级别的克隆，可以做到修改自己独立的对象了。
扫一扫
166
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
