序列化与反序列化一个对象

对象序列化：把一个对象变为 二进制数据流 的一种方法。

一个类要想被序列化，就行必须实现java.io.Serializable接口。实现了这个接口之后，就表示这个类具有被序列化的能力。先让我们实现一个具有序列化能力的类吧：

class Person implements Serializable {
	public Person() {
	}
 
	public Person(String name, int age) {
		this.name = name;
		this.age = age;
	}
 
	@Override
	public String toString() {
		return "姓名：" + name + "  年龄：" + age;
	}
 
	private String name;
	private int age;
}

然后进行序列化与反序列化

public class ObjectOutputStreamDemo {
	public static void main(String[] args) throws IOException, ClassNotFoundException {
		File file = new File("C:/Users/liuyan/Desktop/test/one.txt");
		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(
				file));
		oos.writeObject(new Person("rollen", 20)); //直接写入 序列化的一个对象 
		oos.close();
		
		ObjectInputStream input = new ObjectInputStream(new FileInputStream(
				file));
		Object obj = input.readObject(); //直接读取 反序列化的一个对象
		input.close();
		System.out.println(obj);
	}
}

上面代码打印如下：

 姓名：rollen  年龄：20

 

注意：被Serializable接口声明的类的(对象的属性)都将被序列化，但是如果想自定义序列化的内容的时候，就需要实现Externalizable接口。

当一个类要使用Externalizable这个接口的时候，这个类中必须要有一个无参的构造函数，如果没有的话，在构造的时候会产生异常，这是因为在反序列话的时候会默认调用无参的构造函数。例子如下：

class Person implements Externalizable {
	public Person() {
		//带一个无参的构造
	}
 
	public Person(String name, int age) {
		this.name = name;
		this.age = age;
	}
 
	@Override
	public String toString() {
		return "姓名：" + name + "  年龄：" + age;
	}
 
	// 复写这个方法，根据需要 保存对象的属性或者具体内容，在序列化的时候使用
	@Override
	public void writeExternal(ObjectOutput out) throws IOException {
		out.writeObject(this.name);
		//out.writeInt(age); //我们尝试在序列化的时候不让age被序列化,那么一定要让age也不能被反序列化，不然会报错
	}
 
	// 复写这个方法，根据需要读取内容 反序列话的时候需要
	@Override
	public void readExternal(ObjectInput in) throws IOException,
			ClassNotFoundException {
		this.name = (String) in.readObject();
		//this.age = in.readInt(); //设置age不能被反序列化
	}
 
	private String name;
	private int age;
}

public class ObjectOutputStreamDemo {
	public static void main(String[] args) throws Exception {
		ser(); // 序列化
		dser(); // 反序列话
	}
 
	public static void ser() throws Exception {
		File file = new File("C:/Users/liuyan/Desktop/test/one.txt");
		ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(
				file));
		out.writeObject(new Person("rollen", 20));
		out.close();
	}
 
	public static void dser() throws Exception {
		File file = new File("C:/Users/liuyan/Desktop/test/one.txt");
		ObjectInputStream input = new ObjectInputStream(new FileInputStream(
				file));
		Object obj = input.readObject();
		input.close();
		System.out.println(obj); //会调用对象的toString()方法
	}
}

上面代码打印如下：可以看到，年龄age没有被序列化。

姓名：rollen  年龄：0

 

注意：Serializable接口实现的操作其实是一个对象中的全部属性进行序列化，当然也可以使用我们上面使用的Externalizable接口以实现部分属性的序列化，但是这样的操作比较麻烦。

• 当我们使用Serializable接口实现序列化操作的时候，如果一个对象的某一个属性不想被序列化保存下来，那么我们可以使用transient关键字进行说明。

使用transient关键字进行 序列化 和 反序列化 操作

class Person1 implements Serializable {
	public Person1() {

	}

	public Person1(String name, int age) {
		this.name = name;
		this.age = age;
	}

	@Override
	public String toString() {
		return "姓名：" + name + "  年龄：" + age;
	}

	// 注意这里
	private transient String name; //使用了transient，表明name不能被序列化
	private int age;
}

public class ObjectOutputStreamDemo {
	public static void main(String[] args) throws Exception {
		ser(); // 序列化
		dser(); // 反序列话
	}

	public static void ser() throws Exception {
		File file = new File("C:/Users/liuyan/Desktop/test/one.txt");
		ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(file));
		out.writeObject(new Person1("rollen", 20));
		out.close();
	}

	public static void dser() throws Exception {
		File file = new File("C:/Users/liuyan/Desktop/test/one.txt");
		ObjectInputStream input = new ObjectInputStream(new FileInputStream(file));
		Object obj = input.readObject();
		input.close();
		System.out.println(obj);
	}
}

上面打印如下：可以看到姓名name没有被序列化

姓名：null  年龄：20

 

序列化一组对象

对象输出时只提供了一个对象的输出操作（writeObject(Object obj)），并没有提供多个对象的输出。

所以如果现在要同时 序列化多个对象，就可以使用对象数组进行操作，因为数组属于引用数据类型，所以可以直接使用Object类型进行接收。例子如下：

class Person implements Serializable {
	public Person() {

	}

	public Person(String name, int age) {
		this.name = name;
		this.age = age;
	}

	@Override
	public String toString() {
		return "姓名：" + name + "  年龄：" + age;
	}

	// 注意这里
	private String name;
	private int age;
}

public class ObjectOutputStreamDemo {
	public static void main(String[] args) throws Exception {
		Person per[] = { new Person("张三", 30), new Person("李四", 31), new Person("王五", 32) };
		// 序列化 对象数组（其实是把对象数组看成一个对象用于序列化与反序列化）
		ser(per);
		//反序列化 对象数组（其实是把对象数组看成一个对象用于序列化与反序列化）
		Object o[] = dser();
		// 读取被序列化的对象数组
		for (int i = 0; i < o.length; i++) {
			Person p = (Person) o[i];
			System.out.println(p);
		}
	}

	public static void ser(Object obj[]) throws Exception {
		File f = new File("C:/Users/liuyan/Desktop/test/one.txt");
		ObjectOutputStream oos = null;
		OutputStream out = new FileOutputStream(f);
		// 文件输出流
		oos = new ObjectOutputStream(out);
		// 为对象输出流实例化
		oos.writeObject(obj);
		// 保存对象数组到文件
		oos.close();
		// 关闭输出
	}

	public static Object[] dser() throws Exception {
		File f = new File("C:/Users/liuyan/Desktop/test/one.txt");
		ObjectInputStream ois = null;
		InputStream input = new FileInputStream(f);
		// 文件输入流
		ois = new ObjectInputStream(input);
		// 为对象输出流实例化
		Object obj[] = (Object[]) ois.readObject();
		// 读取对象数组
		ois.close();
		// 关闭输出
		return obj; 
	}
}

上面代码打印如下：

姓名：张三  年龄：30
姓名：李四  年龄：31
姓名：王五  年龄：32