[Java] Java Clone深拷贝与浅拷贝的两种实现方法

package com.lxk.model;
/**
 * 学生类：有2个属性：1，基本属性-string-name；2，引用类型-car-car。
 * <p>
 * created by lxk on 2017/3/23
 */
public class student implements cloneable {
 private string name;
 private car car;
 public string getname() {
 return name;
 }
 public void setname(string name) {
 this.name = name;
 }
 public car getcar() {
 return car;
 }
 public void setcar(car car) {
 this.car = car;
 }
 @override
 public string tostring() {
 return "student{" +
 "name='" + name + '\'' +
 ", car=" + car +
 '}';
 }
 @override
 public student clone() {
 student student = null;
 try {
 student = (student) super.clone();
 } catch (clonenotsupportedexception ignored) {
 system.out.println(ignored.getmessage());
 }
 return student;
 }
}

package com.lxk.model;
import java.util.list;
public class car implements comparable<car> {
 private string sign;
 private int price;
 private list<dog> mydog;
 private list<string> boys;
 public car() {
 }
 public car(string sign, int price) {
 this.sign = sign;
 this.price = price;
 }
 public car(string sign, int price, list<dog> mydog) {
 this.sign = sign;
 this.price = price;
 this.mydog = mydog;
 }
 public car(string sign, int price, list<dog> mydog, list<string> boys) {
 this.sign = sign;
 this.price = price;
 this.mydog = mydog;
 this.boys = boys;
 }
 public string getsign() {
 return sign;
 }
 public void setsign(string sign) {
 this.sign = sign;
 }
 public int getprice() {
 return price;
 }
 public void setprice(int price) {
 this.price = price;
 }
 public list<dog> getmydog() {
 return mydog;
 }
 public void setmydog(list<dog> mydog) {
 this.mydog = mydog;
 }
 public list<string> getboys() {
 return boys;
 }
 public void setboys(list<string> boys) {
 this.boys = boys;
 }
 @override
 public int compareto(car o) {
 //同理也可以根据sign属性排序，就不举例啦。
 return this.getprice() - o.getprice();
 } 
 @override
 public string tostring() {
 return "car{" +
 "sign='" + sign + '\'' +
 ", price=" + price +
 ", mydog=" + mydog +
 ", boys=" + boys +
 '}';
 }
}

package com.lxk.findbugs;
import com.lxk.model.car;
import com.lxk.model.student;
/**
 * 引用传递也就是地址传递需要注意的地方，引起的bug
 * <p>
 * created by lxk on 2017/3/23
 */
public class bug2 {
 public static void main(string[] args) {
 student student1 = new student();
 car car = new car("oooo", 100);
 student1.setcar(car);
 student1.setname("lxk");
 //克隆完之后，student1和student2应该没关系的，修改student1不影响student2的值，但是完之后发现，你修改car的值，student2也受影响啦。
 student student2 = student1.clone();
 system.out.println("学生2：" + student2);//先输出student2刚刚克隆完之后的值，然后在修改student1的相关引用类型的属性值(car)和基本属性值(name)
 car.setsign("x5");
 student1.setname("xxx");
 system.out.println("学生2：" + student2);//再次输出看修改的结果
 }
}

@override
public student clone() {
student student = null;
try {
student = (student) super.clone();
if (car != null) {
student.setcar(car.clone());
}
} catch (clonenotsupportedexception ignored) {
system.out.println(ignored.getmessage());
}
return student;
}

@override
public car clone() {
car car = null;
try {
car = (car) super.clone();
if (mydog != null) {
car.setmydog(lists.newarraylist(mydog));
}
if (boys != null) {
car.setboys(lists.newarraylist(boys));
}
} catch (clonenotsupportedexception ignored) {
system.out.println(ignored.getmessage());
}
return car;
}

/**
* 对象的深度克隆，此处的对象涉及collection接口和map接口下对象的深度克隆
* 利用序列化和反序列化的方式进行深度克隆对象
*
* @param object 待克隆的对象
* @param <t> 待克隆对象的数据类型
* @return 已经深度克隆过的对象
*/
public static <t extends serializable> t deepcloneobject(t object) {
t deepclone = null;
bytearrayoutputstream baos = null;
objectoutputstream oos = null;
bytearrayinputstream bais = null;
objectinputstream ois = null;
try {
baos = new bytearrayoutputstream();
oos = new objectoutputstream(baos);
oos.writeobject(object);
bais = new bytearrayinputstream(baos
 .tobytearray());
ois = new objectinputstream(bais);
deepclone = (t)ois.readobject();
} catch (ioexception | classnotfoundexception e) {
e.printstacktrace();
} finally {
try {
if(baos != null) {
 baos.close();
}
} catch (ioexception e) {
e.printstacktrace();
}
try {
if(oos != null) {
 oos.close();
}
} catch (ioexception e) {
e.printstacktrace();
}
try{
if(bais != null) {
 bais.close();
}
} catch (ioexception e) {
e.printstacktrace();
}
try{
if(ois != null) {
 ois.close();
}
} catch (ioexception e) {
e.printstacktrace();
}
}
return deepclone;
}

/**
* 使用序列化来实现深拷贝简单。但是，所涉及到的所有对象都的实现序列化接口。
*/
private static void clonebyserializable() {
student student1 = new student();
car car = new car("oooo", 100, lists.newarraylist(new dog("aaa", true, true)));
student1.setcar(car);
student1.setname("lxk");
student student2 = deepcloneobject(student1);
system.out.println("学生2：" + student2);
car.setsign("x5");
car.setmydog(null);
student1.setname("xxx");
system.out.println("学生2：" + student2);
}