概述
JAVA
序列化可以将内存中的类存储到物理磁盘,实现离线存储。也可以序列化到内存中,实现对象拷贝,这种拷贝方式我们称之为深拷贝。
对于 Java
生成的对象,一般有 2
种常见的方式
new
出一个对象- 使用
序列化
拷贝出一个对象
对于生成多个重复的对象来说,我们推荐使用序列化的方式,速度更快!
要点
- 首先需要实现
Serializable
接口 - 调用
ObjectOutputStream 类
、ObjectInputStream 类
序列化到内存
对于类中的对象,如果重写 clone
方法,形如:
public Object clone() {
Object o = null;
try {
o = (Object)super.clone();
} catch (Exception ex) {
ex.printStackTrace();
}
return o;
}
将实现内存浅拷贝,相当于只拷贝堆栈中的对象,所有堆栈中的对象都指向堆中同一个内存地址。从 C
语言的角度思考,假如数据源为数组,浅拷贝相当于生成多份数组指针同时指向源数组。使用每个数组指针都可以修改源数组内容。
而深拷贝的意思是,每一个堆栈指向堆中的内存区域在拷贝后都重新生成一份,相互之间不受影响。
举例:新建文件 Rectangle.java
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.ArrayList;
@SuppressWarnings("serial")
public class Rectangle implements Cloneable, Serializable {
private ArrayList<String> al = new ArrayList<String>();
public Rectangle clone() {
Rectangle s = null;
ByteArrayOutputStream baos = null;
ObjectOutputStream oos = null;
ByteArrayInputStream bais = null;
ObjectInputStream ois = null;
try {
baos = new ByteArrayOutputStream();
oos = new ObjectOutputStream(baos);
oos.writeObject(this);
bais = new ByteArrayInputStream(baos.toByteArray());
ois = new ObjectInputStream(bais);
s = (Rectangle)ois.readObject();
} catch (Exception ex) {
ex.printStackTrace();
} finally {
try {
oos.close();
baos.close();
ois.close();
bais.close();
} catch (Exception ex) {
ex.printStackTrace();
}
}
return s;
}
public void add(String value) {
al.add(value);
}
public void show() {
for (String s : al) {
System.out.println(s);
}
}
}
测试
新建文件 Master.java
public class Master {
public static void main(String[] args) {
Rectangle r = new Rectangle();
r.add("矩形");
Rectangle[] child = new Rectangle[3];
for (int i=0; i<child.length; ++i) {
System.out.println("---------------------");
child[i] = (Rectangle)r.clone();
child[i].add(String.valueOf(i));
child[i].show();
}
System.out.println("---------------------");
r.show();
}
}
结果
---------------------
矩形
0
---------------------
矩形
1
---------------------
矩形
2
---------------------
矩形
循环3次,每次在子对象中存储一个数字。但是父对象不受影响,实现深拷贝!
序列化到磁盘
和序列化到内存相似,区别是将在磁盘中生成一个文件,新建文件:Circle.java
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.ArrayList;
@SuppressWarnings("serial")
public class Circle implements Cloneable, Serializable {
private ArrayList<String> al = new ArrayList<String>();
public Circle clone() {
Circle c = null;
FileOutputStream fos = null;
ObjectOutputStream oos = null;
FileInputStream fis = null;
ObjectInputStream ois = null;
try {
String fileName = "./file.bin";
fos = new FileOutputStream(fileName);
oos = new ObjectOutputStream(fos);
oos.writeObject(this);
fis = new FileInputStream(fileName);
ois = new ObjectInputStream(fis);
c = (Circle)ois.readObject();
} catch (Exception ex) {
ex.printStackTrace();
} finally {
try {
fos.close();
oos.close();
fis.close();
ois.close();
} catch (Exception ex) {
ex.printStackTrace();
}
}
return c;
}
public void add(String value) {
al.add(value);
}
public void show() {
for (String s : al) {
System.out.println(s);
}
}
}
测试
新建文件:Master.java
/*
* 原型模式
*/
public class Master {
public static void main(String[] args) {
Circle c = new Circle();
c.add("圆形");
Circle[] child = new Circle[3];
for (int i=0; i<child.length; ++i) {
System.out.println("---------------------");
child[i] = (Circle)c.clone();
child[i].add(String.valueOf(i));
child[i].show();
}
System.out.println("---------------------");
c.show();
}
}
结果
---------------------
圆形
0
---------------------
圆形
1
---------------------
圆形
2
---------------------
圆形