1.序列化实现
public class CloneUtils {
@SuppressWarnings("unchecked")
public static <T extends Serializable> T clone(T object){
T cloneObj = null;
try {
ByteArrayOutputStream out = new ByteArrayOutputStream();
ObjectOutputStream obs = new ObjectOutputStream(out);
obs.writeObject(object);
obs.close();
ByteArrayInputStream ios = new ByteArrayInputStream(out.toByteArray());
ObjectInputStream ois = new ObjectInputStream(ios);
cloneObj = (T) ois.readObject();
}catch (Exception e){
e.printStackTrace();
}
return cloneObj;
}
}
2.主代码
public class TestString {
public static void main(String[] args) {
TestString test = new TestString();
System.out.println("-------浅拷贝---------");
test.qianCopyTest();
System.out.println();
System.out.println("--------使用clone深拷贝--------");
test.defaultCloneTest();
System.out.println();
System.out.println("--------使用序列化实现对象的拷贝--------");
test.streamClonrTest();
System.out.println("--------耗时对比--------");
System.out.println("耗时1 : "+ test.qianCopyCost());
System.out.println("耗时2 : "+ test.CloneCopyCost());
System.out.println("耗时3 : "+ test.StreamCopyCost());
}
/*浅拷贝*/
private void qianCopyTest() {
String s = "cd";
change(s);
System.out.println(s);
System.out.println("----------------");
String b = new String("cd");
change(b);
System.out.println(b);
System.out.println("----------------");
int me = 1;
change(me);
System.out.println(me);
System.out.println("----------------");
Person person = new Person("我", 13,new Email("我"));
change(person);
System.out.println(person.toString());
}
/*使用默认的clone方法，需要Person实现Cloneable接口*/
private void defaultCloneTest(){
Person person = new Person("我", 13,new Email("我"));
Person person1 = person.clone();
Person person2 = person.clone();
System.out.println("person : 【"+person+"】");
System.out.println("person1 : 【"+person1+"】");
System.out.println("person2 : 【"+person2+"】");
//改一个就会触动全部！！ 这就是使用默认的clone方法的弊端
/*该clone()方法是使用Object类的clone()方法，但是该方法存在一个缺陷，它并不会将对象的所有属性全部拷贝过来，而是有选择性的拷贝，基本规则如下：
1、 基本类型
如果变量是基本很类型，则拷贝其值，比如int、float等。
2、 对象
如果变量是一个实例对象，则拷贝其地址引用，也就是说此时新对象与原来对象是公用该实例变量。
3、 String字符串
若变量为String字符串，则拷贝其地址引用。但是在修改时，它会从字符串池中重新生成一个新的字符串，原有紫都城对象保持不变。*/
person.getEmail().setContent("你");
System.out.println("之后的person : 【"+person+"】");
System.out.println("之后的person1 : 【"+person1+"】");
System.out.println("之后的person2 : 【"+person2+"】");
}
/*使用序列化实现对象的拷贝，需要对象以及对象中的其他对象都要实现Serializable接口*/
private void streamClonrTest(){
Person person = new Person("我", 13,new Email("我"));
Person person1 = CloneUtils.clone(person);
Person person2 = CloneUtils.clone(person);
System.out.println("person : 【"+person+"】");
System.out.println("person1 : 【"+person1+"】");
System.out.println("person2 : 【"+person2+"】");
person.getEmail().setContent("你");
System.out.println("之后的person : 【"+person+"】");
System.out.println("之后的person1 : 【"+person1+"】");
System.out.println("之后的person2 : 【"+person2+"】");
}
private static void change(String x) {
x = "ab";
}
private static void change(int x) {
x = 2;
}
private static void change(Person x) {
x = new Person("你", 20, new Email("你"));
}
private long qianCopyCost(){
long start = System.currentTimeMillis();
Person person = new Person("我", 13,new Email("我"));
List<Person> list = new ArrayList<>();
for(int i = 0;i<=10000;i++){
list.add(new Person("你", 20, new Email("你")));
}
return System.currentTimeMillis()-start;
}
private long CloneCopyCost(){
long start = System.currentTimeMillis();
Person person = new Person("我", 13,new Email("我"));
List<Person> list = new ArrayList<>();
for(int i = 0;i<=10000;i++){
list.add(person.clone());
}
return System.currentTimeMillis()-start;
}
private long StreamCopyCost(){
long start = System.currentTimeMillis();
Person person = new Person("我", 13,new Email("我"));
List<Person> list = new ArrayList<>();
for(int i = 0;i<=10000;i++){
list.add(CloneUtils.clone(person));
}
return System.currentTimeMillis()-start;
}
}
class Person implements Serializable, Cloneable {
private static final long serialVersionUID = -8584225043397465132L;
private String name;
private int age;
public void setEmail(Email email) {
this.email = email;
}
private Email email;
public Email getEmail() {
return email;
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
public Person(String name, int age, Email email) {
this.name = name;
this.age = age;
this.email = email;
}
@Override
public String toString() {
return "name : " + name + " | age : " + age +" | content : "+email.getContent();
}
@Override
protected Person clone() {
Person person = null;
try {
person = (Person) super.clone();
/*如果加上下一行 “使用clone深拷贝” 就不会改一处其他都改变了*/
person.setEmail(new Email(person.getEmail().getContent()));
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return person;
}
}
class Email implements Serializable {
private static final long serialVersionUID = 1426052929769365539L;
private String content;
public void setContent(String content) {
this.content = content;
}
public String getContent() {
return content;
}
public Email(String content) {
this.content = content;
}
}
测试了一下时间：
输出：
-------浅拷贝---------
cd
cd
1
name : 我 | age : 13 | content : 我
--------使用clone深拷贝--------
person : 【name : 我 | age : 13 | content : 我】
person1 : 【name : 我 | age : 13 | content : 我】
person2 : 【name : 我 | age : 13 | content : 我】
之后的person : 【name : 我 | age : 13 | content : 你】
之后的person1 : 【name : 我 | age : 13 | content : 我】
之后的person2 : 【name : 我 | age : 13 | content : 我】
--------使用序列化实现对象的拷贝--------
person : 【name : 我 | age : 13 | content : 我】
person1 : 【name : 我 | age : 13 | content : 我】
person2 : 【name : 我 | age : 13 | content : 我】
之后的person : 【name : 我 | age : 13 | content : 你】
之后的person1 : 【name : 我 | age : 13 | content : 我】
之后的person2 : 【name : 我 | age : 13 | content : 我】
--------耗时对比--------
耗时1 : 2
耗时2 : 1
耗时3 : 338
以上所述是小编给大家介绍的java中的深拷贝和浅拷贝（clone()方法的重写、使用序列化实现真正的深拷贝）详解整合，希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对呐喊教程网站的支持！
声明：本文内容来源于网络，版权归原作者所有，内容由互联网用户自发贡献自行上传，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任。如果您发现有涉嫌版权的内容，欢迎发送邮件至：notice#nhooo.com（发邮件时，请将#更换为@）进行举报，并提供相关证据，一经查实，本站将立刻删除涉嫌侵权内容。