【序列化流】

序列化流

概述

Java 提供了一种对象序列化的机制。用一个字节序列可以表示一个对象，该字节序列包含该对象的数据、对象的类型和对象中存储的属性等信息。字节序列写入到文件之后，相当于文件中持久保存了一个对象的信息。

反之，该字节序列还可以从文件中读取回来，重构对象，对它进行反序列化。对象的数据、对象的类型和对象中存储的数据信息，都可以用来在内存中创建对象。看图理解序列化：

ObjectOutputStream类

java.io.ObjectOutputStream 类，将Java对象的原始数据类型写出到文件,实现对象的持久存储。

构造方法

• public ObjectOutputStream(OutputStream out)： 创建一个指定OutputStream的ObjectOutputStream。

构造举例，代码如下：

FileOutputStream fileOut = new FileOutputStream("employee.txt");
ObjectOutputStream out = new ObjectOutputStream(fileOut);

序列化操作

1. 一个对象要想序列化，必须满足两个条件:

• 该类必须实现java.io.Serializable 接口，Serializable 是一个标记接口，不实现此接口的类将不会使任何状态序列化或反序列化，会抛出NotSerializableException 。
• 该类的所有属性必须是可序列化的。如果有一个属性不需要可序列化的，则该属性必须注明是瞬态的，使用transient 关键字修饰。

 static关键字:静态关键字
        静态优先于非静态加载到内存中(静态优先于对象进入到内存中)
        被static修饰的成员变量不能被序列化的,序列化的都是对象
        private static int age;
        oos.writeObject(new Person("小美女",18));
        Object o = ois.readObject();
        Person{name='小美女', age=0}

    transient关键字:瞬态关键字
        被transient修饰成员变量,不能被序列化
        private transient int age;
        oos.writeObject(new Person("小美女",18));
        Object o = ois.readObject();
        Person{name='小美女', age=0}

public class Employee implements java.io.Serializable {
    public String name;
    public String address;
    public transient int age; // transient瞬态修饰成员,不会被序列化
    public void addressCheck() {
      	System.out.println("Address  check : " + name + " -- " + address);
    }
}

对象特有方法

• public final void writeObject (Object obj) : 将指定的对象写出。

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

/*
 * 	java.io.ObjectOutputStream extends OutputStream
 * 	ObjectOutputStream：对象的序列化流
 * 	作用:把对象以流的方式写入到文件中保存
 * 
 * 	构造方法：ObjectOutputStream(OutputStream out) 创建写入指定 OutputStream 的 ObjectOutputStream
 * 
 * 	特有的成员方法：
 * 		 void writeObject(Object obj) 将指定的对象写入 ObjectOutputStream。 
 * 
 * 	步骤：
 * 		1.创建ObjectOutputStream对象,构造方法中传递字符输出流
 * 		2.使用ObjectOutputStream对象中的方法writeObject,把对象写入文件
 * 		3.释放资源	
 */
public class ObjectOutputStreamDemo {
	public static void main(String[] args) throws IOException {
		//1.创建ObjectOutputStream对象,构造方法中传递字符输出流
		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("d:\\1.txt"));
		//2.使用ObjectOutputStream对象中的方法writeObject,把对象写入文件
		oos.writeObject(new Person("张三",20));
		//3.释放资源
		oos.close();
	}
}

ObjectInputStream类

ObjectInputStream反序列化流，将之前使用ObjectOutputStream序列化的原始数据恢复为对象。

构造方法

• public ObjectInputStream(InputStream in)： 创建一个指定InputStream的ObjectInputStream。

反序列化操作

如果能找到一个对象的class文件，我们可以进行反序列化操作，调用ObjectInputStream读取对象的方法：

• public final Object readObject () : 读取一个对象。

/*
 * 	java.io.ObjectInputStream extends InputStream
 * 	ObjectInputStream:对象的反序列化流
 * 	作用：把保存的对象,以流的方式读取出来使用
 * 
 * 	构造方法：
 * 	ObjectInputStream(InputStream in) 创建从指定 InputStream 读取的 ObjectInputStream。
 * 
 * 	特有的成员方法：
 * 	 Object readObject() 从 ObjectInputStream 读取对象。 
*
 * 	 readObject方法声明抛出了ClassNotFoundException(class文件找不到异常)
 * 		当不存在对象的class文件时抛出此异常
 * 	反序列化的前提：
 * 	1.类必须实现Serializable
 * 	2.必须存在对应的class文件
 * 	步骤：
 * 		1.创建ObjectInputStream对象,构造方法中传递字节输入流
 * 		2.使用ObjectInputStream对象的方法readObject读取保存对象的文件
 * 		3.释放资源
 * 		4.打印对象
 */
public class ObjectInputStreamDemo {
	public static void main(String[] args) throws IOException, ClassNotFoundException {
		//1.创建ObjectInputStream对象,构造方法中传递字节输入流
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("d:\\1.txt"));
		//2.使用ObjectInputStream对象的方法readObject读取保存对象的文件
		Object o = ois.readObject();
		//3.释放资源
		ois.close();
		//打印对象
		Person p = (Person)o;
		System.out.println(p);
		
	}
}

对于JVM可以反序列化对象，它必须是能够找到class文件的类。如果找不到该类的class文件，则抛出一个 ClassNotFoundException 异常。

反序列化注意事项

另外，当JVM反序列化对象时，能找到class文件，但是class文件在序列化对象之后发生了修改，那么反序列化操作也会失败，抛出一个InvalidClassException异常。**发生这个异常的原因如下：

• 该类的序列版本号与从流中读取的类描述符的版本号不匹配
• 该类包含未知数据类型
• 该类没有可访问的无参数构造方法

Serializable 接口给需要序列化的类，提供了一个序列版本号。serialVersionUID 该版本号的目的在于验证序列化的对象和对应类是否版本匹配。

public class Employee implements java.io.Serializable {
     // 加入序列版本号
     private static final long serialVersionUID = 1L;
     public String name;
     public String address;
     // 添加新的属性 ,重新编译, 可以反序列化,该属性赋为默认值.
     public int eid; 

     public void addressCheck() {
         System.out.println("Address  check : " + name + " -- " + address);
     }
}

序列号冲突异常的原理和解决方案

练习：序列化集合

1. 将存有多个自定义对象的集合序列化操作，保存到list.txt文件中。
2. 反序列化list.txt ，并遍历集合，打印对象信息。

案例实现

/*
 * 	步骤：
 * 	1.创建存储Person对象的集合ArrayList
 * 	2.向集合中添加Person对象集合
 * 	3.创建ObjectOutputStream对象,构造方法中传递字节输出流
 * 	4.使用ObjectOutputStream对象的方法writeObject,将集合序列化
 * 	5.创建ObjectInputStream对象,构造方法传递字节输入流
 * 	6.使用ObjectInputStream对象的方法readObject,将集合反序列化
 * 	7.把Object类型的集合转换为ArrayList类型
 * 	8.遍历集合
 * 	9.释放资源
 */
public class Test {
	public static void main(String[] args) throws IOException, ClassNotFoundException {
		// 1.创建存储Person对象的集合ArrayList
		ArrayList<Person> list = new ArrayList<Person>();
		// 2.向集合中添加Person对象集合
		list.add(new Person("张三", 29));
		list.add(new Person("李四", 40));
		list.add(new Person("王五", 20));
		// 3.创建ObjectOutputStream对象,构造方法中传递字节输出流
		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("d:\\list.txt"));
		// 4.使用ObjectOutputStream对象的方法writeObject,将集合序列化
		oos.writeObject(list);
		// 5.创建ObjectInputStream对象,构造方法传递字节输入流
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("d:\\list.txt"));
		// 6.使用ObjectInputStream对象的方法readObject,将集合反序列化

		Object o = ois.readObject();
		// 7.把Object类型的集合转换为ArrayList类型
		ArrayList<Person> list1 = (ArrayList<Person>) o;
		// 8.遍历集合
		for (Person p : list1) {
			System.out.println(p);
		}
		// 9.释放资源
		ois.close();
		oos.close();

	}
}