java_IO流之ObjectInputStream与ObjectOutputStream的使用

ObjectOutputStream是用于操作对象的IO流，如果需要将某个对象以文件的形式保存起来，将对象持久存储。而ObjectInputStream与之相反。

使用ObjectInputStream与ObjectOutputStream要注意以下几个要点：

1、存储的对象类必须是可序列化，即要实现Serializable接口。

class Person implements Serializable ...

2、对象序列化是只针对堆中的数据，所以静态的代码是不会被序列化的。

private static String lover;    lover是不会被序列化的。

3、如果非静态的成员变量不想被序列化，可以添加修饰transient

private transient String name;   name也不会被序列化。

4、对象是通过什么判断自己就是哪个类的实例？

对象序列化，会根据自己成员量的的相关特性算出一个序列化id，通过判断id是否相同。这个id我们也可以自己指定。

如private static final long serialVersionUID = 1L;

下面介绍ObjectInputStream与ObjectOutputStream的相关用法：

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class ObjectInputStreamTest {

	/**将对象以文件的形式保存起来，需要用到关于类操作的IO流，被操作的类必须使可序列化的
	 * 类可序列化，要实现Serializable,像这种是接口但没方法的，为标记类
	 * @param args
	 */
	public static void main(String[] args) {
		writeObj();
		readObj();
	}
	//对象从文本中读入
	private static void readObj() {
		//创建对象输入流
		ObjectInputStream ois = null;
		try {
			ois = new ObjectInputStream(new FileInputStream("D:\\obj.txt"));
			//读取对象
			Person p = (Person) ois.readObject();
			System.out.println(p);
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} finally {
			try {
				if (ois != null)
					ois.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	//将对象写入至文本
	private static void writeObj() {
		//创建对象输出对象
		ObjectOutputStream oos = null;
		try {
			oos = new ObjectOutputStream(new FileOutputStream("D:\\obj.txt"));
			Person p = new Person("wangzhihong", 23);
			//写出对象
			oos.writeObject(p);
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				if (oos != null)
					oos.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

}



class Person implements Serializable {
	private static final long serialVersionUID = 1L;
	/**
	 *给类定义一个序列化标识。方便序列化 
	 *静态的代码将不会被序列化，序列化只针对堆里的数据。
	 *当不把某个非静态的成员变量序列化，只需要加上修饰  transient
	 */
	private String name;
	//private transient String name;
	private int age;
	
	public Person() {
	}

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

	public String toString() {
		return name + ":" + age;
	}
}