java对象克隆和序列化

最新推荐文章于 2021-02-16 20:35:06 发布
转载 最新推荐文章于 2021-02-16 20:35:06 发布 · 452 阅读 · 0

转载自http://www.cnblogs.com/rollenholt/archive/2011/09/09/2172094.html


先用一个例子来说明假克隆吧，也就是用“=”之后的效果、。

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
public class Employee{
    public Employee(){
 
    }
 
    public Employee(String name, int age){
        this.age = age;
        this.name = name;
    }
 
    @Override
    public String toString(){
        return "姓名： " + name + "年龄： " + age;
    }
 
    public String getName(){
        return name;
    }
 
    public void setName(String name){
        this.name = name;
    }
 
    public int getAge(){
        return age;
    }
 
    public void setAge(int age){
        this.age = age;
    }
 
    public static void main(String[] args){
        Employee demo1 = new Employee("rollen", 20);
        System.out.println(demo1);
        Employee demo2 = demo1;
        demo2.setAge(100);
        demo2.setName("hello world");
        System.out.println(demo1);
        System.out.println(demo2);
    }
 
    private String name;
    private int age;
}

【运行结果】：

【运行结果】

姓名： rollen年龄： 20

姓名： hello world年龄： 100

姓名： hello world年龄： 100


下面看看java中的浅拷贝

对于类中的每个域，如果只包含基本类型或者不可变的引用类型，如String,或者对象在其生命周期内不会发生变化，则可以使用浅拷贝来复制对象，但是一般使用深拷贝。

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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
class Address{
    public Address(){
 
    }
 
    public Address(String state, int number){
        this.number = number;
        this.state = state;
    }
 
    @Override
    public String toString(){
        return "state: " + state + " munber: " + number;
    }
 
    public String getState(){
        return state;
    }
 
    public void setState(String state){
        this.state = state;
    }
 
    public int getNumber(){
        return number;
    }
 
    public void setNumber(int number){
        this.number = number;
    }
 
    private String state;
    private int number;
}
 
public class Employee implements Cloneable{
    public Employee(){
 
    }
 
    public Employee(String name, int age, Address address){
        this.address = address;
        this.age = age;
        this.name = name;
    }
 
    public String getName(){
        return name;
    }
 
    public void setName(String name){
        this.name = name;
    }
 
    public int getAge(){
        return age;
    }
 
    public void setAge(int age){
        this.age = age;
    }
 
    public Address getAddress(){
        return address;
    }
 
    public void setAddress(Address address){
        this.address = address;
    }
 
    @Override
    public String toString(){
        StringBuilder sb = new StringBuilder();
        sb.append("name:" + name + ", ");
        sb.append("age:" + age + " \n");
        sb.append("Address: " + address);
        return sb.toString();
    }
 
    @Override
    protected Employee clone(){
        Employee employee = null;
        try{
            employee = (Employee) super.clone();
        }catch(CloneNotSupportedException e){
            e.printStackTrace();
        }
        return employee;
    }
 
    public static void main(String[] args){
        System.out.println("克隆之前：");
        Address add1 = new Address("中国", 1);
        Employee emp1 = new Employee("rollen", 20, add1);
        System.out.println(emp1);
        System.out.println("克隆之后");
        Employee emp2 = emp1.clone();
        emp2.setName("hello world");
        emp2.setAge(100);
        emp2.address.setNumber(2);
        emp2.address.setState("美国");
        System.out.println(emp1);
        System.out.println("-----");
        System.out.println(emp2);
    }
 
    private String name;
    private int age;
    private Address address;
}

【运行结果】：

克隆之前：

name:rollen, age:20

Address: state: 中国 munber: 1

克隆之后

name:rollen, age:20

Address: state: 美国 munber: 2

-----

name:hello world, age:100

Address: state: 美国 munber: 2

 

但是上面的主函数中的：

1
2
// emp2.address.setNumber(2);
// emp2.address.setState("美国");

替换为：

1
emp2.setAddress(new Address("美国", 2));

运行结果为：

克隆之前：

name:rollen, age:20

Address: number: 1state中国

 

克隆之后

name:rollen, age:20

Address: number: 1state中国

 

-----

name:hello world, age:100

Address: number: 2state美国

 

这里我有点不明白了，为什么这种情况下克隆之后两个address会不一样呢?

谁帮忙指点一下，谢谢了、

现在看看java对象的深克隆

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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
class Address implements Cloneable{
    public Address(){
 
    }
 
    public Address(String state, int number){
        this.number = number;
        this.state = state;
    }
 
    @Override
    public String toString(){
        return "state: " + state + " munber: " + number;
    }
 
    @Override
    protected Address clone() throws CloneNotSupportedException{
        Address address = null;
        address = (Address) super.clone();
        return address;
    }
 
    public String getState(){
        return state;
    }
 
    public void setState(String state){
        this.state = state;
    }
 
    public int getNumber(){
        return number;
    }
 
    public void setNumber(int number){
        this.number = number;
    }
 
    private String state;
    private int number;
}
 
public class Employee implements Cloneable{
    public Employee(){
 
    }
 
    public Employee(String name, int age, Address address){
        this.address = address;
        this.age = age;
        this.name = name;
    }
 
    public String getName(){
        return name;
    }
 
    public void setName(String name){
        this.name = name;
    }
 
    public int getAge(){
        return age;
    }
 
    public void setAge(int age){
        this.age = age;
    }
 
    public Address getAddress(){
        return address;
    }
 
    public void setAddress(Address address){
        this.address = address;
    }
 
    @Override
    public String toString(){
        StringBuilder sb = new StringBuilder();
        sb.append("name:" + name + ", ");
        sb.append("age:" + age + " \n");
        sb.append("Address: " + address);
        return sb.toString();
    }
 
    @Override
    protected Employee clone(){
        Employee employee = null;
        try{
            employee = (Employee) super.clone();
            employee.address = address.clone();     }catch(CloneNotSupportedException e){
            e.printStackTrace();
        }
        return employee;
    }
 
    public static void main(String[] args){
        System.out.println("克隆之前：");
        Address add1 = new Address("中国", 1);
        Employee emp1 = new Employee("rollen", 20, add1);
        System.out.println(emp1);
        System.out.println("克隆之后");
        Employee emp2 = emp1.clone();
        emp2.setName("hello world");
        emp2.setAge(100);
        emp2.setAddress(new Address("美国", 2));
        System.out.println(emp1);
        System.out.println("-----");
        System.out.println(emp2);
    }
 
    private String name;
    private int age;
    private Address address;
}

【运行结果】：

【运行结果】：

克隆之前：

name:rollen, age:20

Address: state: 中国 munber: 1

克隆之后

name:rollen, age:20

Address: state: 中国 munber: 1

-----

name:hello world, age:100

Address: state: 美国 munber: 2

序列化接口和对象克隆

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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
 
class Address implements Serializable{
    public Address(){
 
    }
 
    public Address(String state, int number){
        this.number = number;
        this.state = state;
    }
 
    @Override
    public String toString(){
        StringBuilder sb = new StringBuilder();
        sb.append("number: " + number);
        sb.append("state" + state + "\n");
        return sb.toString();
    }
 
    public String getState(){
        return state;
    }
 
    public void setState(String state){
        this.state = state;
    }
 
    public int getNumber(){
        return number;
    }
 
    public void setNumber(int number){
        this.number = number;
    }
 
    private String state;
    private int number;
}
 
public class Employee implements Cloneable, Serializable{
    public Employee(){
 
    }
 
    public Employee(String name, int age, Address address){
        this.address = address;
        this.age = age;
        this.name = name;
    }
 
    public String getName(){
        return name;
    }
 
    public void setName(String name){
        this.name = name;
    }
 
    public int getAge(){
        return age;
    }
 
    public void setAge(int age){
        this.age = age;
    }
 
    public Address getAddress(){
        return address;
    }
 
    public void setAddress(Address address){
        this.address = address;
    }
 
    @Override
    public String toString(){
        StringBuilder sb = new StringBuilder();
        sb.append("name:" + name + ", ");
        sb.append("age:" + age + " \n");
        sb.append("Address: " + address);
        return sb.toString();
    }
 
    @Override
    protected Employee clone(){
        Employee employee = null;
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        try{
            ObjectOutputStream oos = new ObjectOutputStream(baos);
            oos.writeObject(this);
            oos.close();
 
            ByteArrayInputStream bais = new ByteArrayInputStream(
                    baos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bais);
            employee = (Employee) ois.readObject();
            ois.close();
        }catch(Exception e){
            e.printStackTrace();
        }
        return employee;
    }
 
    public static void main(String[] args){
        System.out.println("克隆之前：");
        Address add1 = new Address("中国", 1);
        Employee emp1 = new Employee("rollen", 20, add1);
        System.out.println(emp1);
        System.out.println("克隆之后");
        Employee emp2 = emp1.clone();
 
        emp2.setName("hello world");
        emp2.setAge(100);
        emp2.address.setNumber(2);
        emp2.address.setState("美国");
        System.out.println(emp1);
        System.out.println("-----");
        System.out.println(emp2);
    }
 
    private String name;
    private int age;
    private Address address;
}

【运行结果】：

克隆之前：

name:rollen, age:20

Address: number: 1state中国

 

克隆之后

name:rollen, age:20

Address: number: 1state中国

 

-----

name:hello world, age:100

Address: number: 2state美国


 

对于任何一个序列化的对象，都必须要求实现Serializable接口。其次，如果这个类的域中也有引用对象，则也有要求这个引用类型也实现这个接口，。最后，序列化方式实现克隆效率不高，没有直接深度克隆的效率高。有兴趣的朋友 可以测试一下。





==============================================================================
我喜欢程序员，他们单纯、固执、容易体会到成就感；面对压力，能够挑灯夜战不眠不休；面对困难，能够迎难而上挑战自我。他
们也会感到困惑与傍徨，但每个程序员的心中都有一个比尔盖茨或是乔布斯的梦想“用智慧开创属于自己的事业”。我想说的是，其
实我是一个程序员
克隆和序列化(Java )
09-12
克隆和序列化(Java )实例和源代码
Java中对象的序列化方式克隆详解
08-31
总的来说，Java的对象序列化和克隆是两个重要的概念，它们在数据持久化、网络通信等方面有着广泛的应用。通过理解这些技术，开发者可以更好地设计和实现复杂的系统，提高代码的可维护性和复用性。
Java序列化和克隆
make0739的博客
06-07 178
转载：http://hi.baidu.com/en_wan/item/32bf32140b1baafcdceeca92 序列化 Java 序列化技术可以使你将一个对象的状态写入一个Byte 流里，并且可以从其它地方把该Byte 流里的数据读出来，重新构造一个相同的对象。 当两个进程在进行远程通信时，彼此可以发送各种类型的数据。无论是何种类型的数据，都会以二进制序列的形式在网络上传送。...
java对象序列化克隆_java对象克隆和序列化
weixin_35724794的博客
02-13 178
先用一个例子来说明假克隆吧，也就是用“=”之后的效果、。public class Employee{public Employee(){}public Employee(String name, int age){this.age = age;this.name = name;}@Overridepublic String toString(){return "姓名： " + name + "年龄...
java对象序列化克隆_Java对象的序列化方式克隆
weixin_39566593的博客
02-13 142
简述：用字节流的方式，复制Java对象代码：流克隆复制函数public static Object deepClone(Object obj){if(obj == null){return null;}try {ByteArrayOutputStream byteOut = new ByteArrayOutputStream();Object cloneObj = null;ObjectOutpu...
Java克隆与对象序列化
a810373329的博客
12-15 264
Object类的clone()方法 浅克隆 //浅克隆 /* * 1.Object类中的clone()方法为protected的 * 2.需要实现克隆功能的类必须实现Cloneable接口 * */ class Kid{ public int age = 10; } class Person implements Cloneable{ public int age = 10...
java中对象的序列化与反序列化深入讲解
08-26
总的来说，Java对象的序列化和反序列化是一种强大的工具，能够帮助开发者在多种场景下管理对象的状态，提高程序的灵活性和可维护性。然而，使用时也需谨慎，尤其是在涉及敏感数据和跨版本兼容性问题时。
实例分析java对象的序列化和反序列化
08-26
Java对象的序列化和反序列化是编程中常见的任务，主要目的是为了持久化对象的状态或者在网络间传递对象。本文将详细解析如何在Java中实现这一过程，并探讨其具体用途。 首先，要理解序列化的基本概念。序列化是将...
关于Java对象序列化您不知道的5件事Java开发Java
11-25
序列化和对象的浅复制（克隆）都是保存对象状态的方式，但两者有本质区别。序列化是将整个对象转换为字节流，而克隆是创建对象的一个副本，通常只复制对象的直接属性，不涉及深层引用。 了解以上知识点后，Java...
Java对象的序列化方式克隆
霖林烟雨
04-26 1223
简述： 用字节流的方式，复制Java对象 代码： 流克隆复制函数 public static Object deepClone(Object obj){ if(obj == null){ return null; } try { ByteArrayOutputStream byt
Java序列化ID的作用
qq_44918331的博客
01-05 1379
序列化ID的作用： 其实，这个序列化ID起着关键的作用，它决定着是否能够成功反序列化！简单来说，java的序列化机制是通过在运行时判断类的serialVersionUID来验证版本一致性的。在进行反序列化时，JVM会把传来的字节流中的serialVersionUID与本地实体类中的serialVersionUID进行比较，如果相同则认为是一致的，便可以进行反序列化，否则就会报序列化版本不一致的异常。 序列化ID如何产生： 当我们一个实体类中没有显示的定义一个名为“serialVersionUID”、类
克隆（浅复制与深复制），序列化
m0_38110784的博客
09-20 300
克隆需实现ICloneable接口 class Program { static void Main(string[] args) { ArrayList array =new ArrayList(); Person a = new Person(); a.name = "aaa"...
java序列化深克隆_克隆可序列化和不可序列化的Java对象
最佳 Java 编程
05-31 355
java序列化深克隆 开发人员经常依靠3d方库来避免重新发明轮子，尤其是在Java世界中，Apache和Spring这样的项目如此盛行。 在处理这些框架时，我们通常很少或根本无法控制其类的行为。 这有时会导致问题。 例如，如果您想深克隆一个不提供合适克隆方法的对象，除了编写大量代码之外，您还有什么选择？ 通过序列化克隆 最简单的方法是通过利用对象可序列化进行克隆。 Apache Co...
java 对象的 克隆 （clone）
个人博客
11-08 154
克隆需要实现Cloneable,Serializable 两个接口。   事例如下：     import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.ObjectInputStream; import ...
Java - 【序列化】序列化与克隆
⚡
10-08 376
序列化与克隆 → 推荐：《刀剑神域-序列之争》 序列化 反序列化 serialversionUID 作用 IDEA配置警告 序列化中常见的两类异常 java.io.NotSerializableException java.io.InvalidClassException 克隆 浅克隆 深克隆（序列化） 一：序列化 /** * 序列化指定Person对象 * * @param p 待序列化对象 * @throws IOException */ public static
序列化&克隆
dcxmaozi的博客
06-25 292
分享总结：序列化与克隆 序列化： 如何实现人类的瞬间转移： 比如实现人类活着物体的瞬间转移也就是所谓的乾坤大挪移！哈哈！其实这种大法在理论上是可以实现的，物体是由物质组成的，物质是原子和电子组成的，而原子和电子也就是物质在宇宙中的每一个星球上都有存在的，如果我们将人类数据化（何为数据化？也就是用数据描述物质的形态位置）然后利用光速（光速还不够快）或者量子纠缠现象传播数据信息然后在另一端将数据...
java对象序列化克隆_Java克隆与对象序列化
weixin_28972665的博客
02-13 108
Object类的clone()方法浅克隆//浅克隆/** 1.Object类中的clone()方法为protected的* 2.需要实现克隆功能的类必须实现Cloneable接口* */class Kid{public int age = 10;}class Person implements Cloneable{public int age = 10;public Kid kid = new K...
java对象序列化克隆_Java对象浅克隆、深克隆及序列化
weixin_39957805的博客
02-16 161
这里我们就可以引入两个专业的术语：浅克隆(shallow clone)和深克隆(deep clone)。所谓的浅克隆，顾名思义就是很表面的很表层的克隆，如果我们要克隆Administrator对象，只克隆他自身以及他包含的所有对象的引用地址。而深克隆，就是非浅克隆。克隆除自身以外所有的对象，包括自身所包含的所有对象实例。至于深克隆的层次，由具体的需求决定，也有“N层克隆”一说。但是，所有的基本(p...
Java对象序列化存储与读取技术详解
- 对象克隆：序列化是深度复制对象的一种方法。 - 快速恢复：将对象序列化后存储起来，需要时再反序列化读取。 ### Java序列化的关键点 #### 序列化接口 为了使一个类的对象可被序列化，该类必须实现Serializable...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值