当创建对象时,只要你需要,它就会一直存在,但当程序终止时,创建的对象也会不复存在。
假设我们想在程序不运行的情况下,也能保存对象的信息,这时可以通过 JAVA 的对象序列化将对象进行持久化保存(虽然可以通过写入文件或者数据库达到相同的效果,但任何实现方式都有适合它自己的场景,技多不压身)。
序列化的对象必须实现 Serializable 接口,它会转换成字节序列,并能够将这个字节序列完全恢复为原来的对象,这一过程可以通过网络运行,能弥补不同操作系统之间的差异,即在 windows 系统创建的对象进行序列化后,发送至 unix 机器进行反序列化还原出原本的对象。
要序列化一个对象,要创建 OutputStream 对象,然后调用 writeObject(Object obj) 即可将对象序列化;要反序列化,则需要通过创建 ObjectInputStream ,调用 readObject() ,会返回一个 Object 的引用,我们需要将其强制向下转型才能正常使用,需要注意的时,写入对象的顺序和读取的顺序需保持一致。
序列化不仅仅保存了对象自身的基本信息,还保存了每个引用,每个引用对象中的引用也同样被保存下来,依次类推,最终形成了整个“对象网”。
下面我们通过一个例子,来巩固序列化的基础知识点,创建一个 Worm 对象,它包含了一个 Data 类型的数组,还有一个指向下一个 Worm 对象的引用。
public class Data implements Serializable {
private int n;
public Data(int n) {
this.n = n;
}
@Override
public String toString() {
return Integer.toString(n);
}
}
public class Worm implements Serializable {
private static Random rand = new Random(47);
private Data[] d = {
new Data(rand.nextInt(10)),
new Data(rand.nextInt(10)),
new Data(rand.nextInt(10))
};
//下一个Worm的引用
private Worm next;
private char c;
/**
* @param i 构造Worm的长度
* @param c 存储的字符
*/
public Worm(int i, char c) {
System.out.println("Worm construction: " + i);
this.c = c;
//下一个构造的Worm长度-1,字符+1
if (--i > 0) {
next = new Worm(i, (char) (c + 1));
}
}
@Override
public String toString() {
StringBuilder result = new StringBuilder(":");
result.append(c);
result.append("(");
for (Data data : d) {
result.append(data);
}
result.append(")");
if (next != null) {
result.append(next);
}
return result.toString();
}
public static void main(String[] args) throws IOException, ClassNotFoundException {
Worm w = new Worm(6, 'a');
System.out.println("w =" + w);
//通过文件流写入
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("worm.out"));
out.writeObject("Worm storage \n");
out.writeObject(w);
out.close();
//通过文件流读取
ObjectInputStream in = new ObjectInputStream(new FileInputStream("worm.out"));
String s = (String) in.readObject();
Worm w2 = (Worm) in.readObject();
System.out.println(s + "w2 = " + w2);
//通过字节数组流写入
ByteArrayOutputStream bout = new ByteArrayOutputStream();
ObjectOutputStream out2 = new ObjectOutputStream(bout);
out2.writeObject("Worm storage \n");
out2.writeObject(w);
out2.flush();
//通过字节数组流读取
ObjectInputStream in2 = new ObjectInputStream(new ByteArrayInputStream(bout.toByteArray()));
s = (String) in2.readObject();
Worm w3 = (Worm) in2.readObject();
System.out.println(s + "w3 = " + w3);
}
}
Worm construction: 6
Worm construction: 5
Worm construction: 4
Worm construction: 3
Worm construction: 2
Worm construction: 1
w =:a(853):b(119):c(802):d(788):e(199):f(881)
Worm storage
w2 = :a(853):b(119):c(802):d(788):e(199):f(881)
Worm storage
w3 = :a(853):b(119):c(802):d(788):e(199):f(881)
通过上述例子,我们可以发现序列化不仅仅只保留了单个 Worm 本身,它所引用的对象网也同时被保存了下来。我们可以通过文件流(FileOutputStream、FileInputStream)和字节数组(ByteArrayOutputStream、ByteArrayInputStream)流来进行序列化和反序列化(进行反序列化时,要保证虚拟机能找到对应的.class文件)。
本次分享至此结束,希望本文对你有所帮助,若能点亮下方的点赞按钮,在下感激不尽,谢谢您的【精神支持】。
若有任何疑问,也欢迎与我交流,若存在不足之处,也欢迎各位指正!