个人中心
gpt4 book ai didi

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

转载 作者：qq735679552 更新时间：2022-09-28 22:32:09 27 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章Java Clone深拷贝与浅拷贝的两种实现方法由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

1.首先，你要知道怎么实现克隆：实现cloneable接口，在bean里面重写clone()方法，权限为public。 2.其次，你要大概知道什么是地址传递，什么是值传递。 3.最后，你要知道你为什么使用这个clone方法.

先看第一条，简单的克隆代码的实现。这个也就是我们在没了解清楚这个java的clone的时候，会出现的问题.

看完代码，我再说明这个时候的问题.

先看我要克隆的学生bean的代码:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
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;
  }
}

学生内部引用了car这个bean 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
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 +
  '}' ;
  }
}

最后就是main测试类 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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); //再次输出看修改的结果
  }
}

之后就该是执行的结果图了:

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

对上面执行结果的疑惑，以及解释说明:

我们可能觉得自己在bean里面实现clone接口，重写了这个clone方法，那么学生2是经由学生1clone，复制出来的， 那么学生1和学生2，应该是毫不相干的，各自是各自，然后，在修改学生1的时候，学生2是不会受影响的.

但是结果，不尽人意。从上图执行结果可以看出来，除了名字，这个属性是没有被学生1影响，关于car的sign属性已经因为学生1的变化而变化，这不是我希望的结果.

可见，这个简单的克隆实现也仅仅是个“浅克隆”，也就是基本类型数据，他是会给你重新复制一份新的，但是引用类型的，他就不会重新复制份新的。引用类型包括，上面的其他bean的引用，list集合，等一些引用类型.

那么怎么实现深克隆呢?

对上述代码稍作修改，如下： 学生bean的clone重写方法如下所示:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
@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;
}

然后还要car类实现cloneable接口，复写clone方法:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@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;
}

主测试代码不动，这个时候的执行结果如下:

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

可以看到，这个时候，你再修改学生1的值，就不会影响到学生2的值，这才是真正的克隆，也就是所谓的深克隆.

怎么举一反三?

可以看到，这个例子里面的引用类型就一个car类型的属性，但是实际开发中，除了这个引用其他bean类型的属性外，可能还要list类型的属性值用的最多.

那么要怎么深克隆呢，就像我在car bean类里面做的那样，把所有的引用类型的属性，都在clone一遍。那么你在最上层调用这个clone方法的时候，他就是真的深克隆啦.

我代码里面那么判断是为了避免空指针异常。当然，这个你也得注意咯.

注意 重写clone方法的时候，里面各个属性的null的判断哦.

上面的是override clone()方法来实现深克隆的。如果你这个要克隆的对象很复杂的话，你就不得不去每个引用到的对象去复写这个clone方法，这个太啰嗦来，改的地方，太多啦.

还有个方法就是使用序列化来实现这个深拷贝 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
/**
* 对象的深度克隆，此处的对象涉及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;
}

具体的使用如下:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/**
* 使用序列化来实现深拷贝简单。但是，所涉及到的所有对象都的实现序列化接口。
*/
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);
}

实现的效果，还是和上面的一样的，但是这个就简单多来，只需要给涉及到的每个引用类型，都去实现序列化接口就好啦.

总结 。

以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，谢谢大家对我的支持。如果你想了解更多相关内容请查看下面相关链接 。

原文链接：https://blog.csdn.net/qq_27093465/article/details/65443355 。

最后此篇关于Java Clone深拷贝与浅拷贝的两种实现方法的文章就讲到这里了,如果你想了解更多关于Java Clone深拷贝与浅拷贝的两种实现方法的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

27 4 0
文章推荐： Java拷贝数组方法Arrays.copyOf()是地址传递的证明实例
文章推荐： Golang标准库和外部库的性能比较
文章推荐： Golang开发命令行之flag包的使用方法
文章推荐： maven+springboot打成jar包的方法
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com