189 8069 5689
这篇文章将为大家详细讲解有关java中如何实现深拷贝和浅拷贝，小编觉得挺实用的，因此分享给大家做个参考，希望大家阅读完这篇文章后可以有所收获。
创新互联公司专注于东乡族网站建设服务及定制，我们拥有丰富的企业做网站经验。 热诚为您提供东乡族营销型网站建设，东乡族网站制作、东乡族网页设计、东乡族网站官网定制、小程序开发服务，打造东乡族网络公司原创品牌,更为您提供东乡族网站排名全网营销落地服务。
1.序列化实现
public class CloneUtils {
@SuppressWarnings("unchecked")
public static 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 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 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 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中如何实现深拷贝和浅拷贝”这篇文章就分享到这里了，希望以上内容可以对大家有一定的帮助，使各位可以学到更多知识，如果觉得文章不错，请把它分享出去让更多的人看到。