类 java.io.ObjectInputStream

java.lang.Object
   |
   +----java.io.InputStream
           |
           +----java.io.ObjectInputStream

public class ObjectInputStream

extends InputStream

implements ObjectInput, ObjectStreamConstants

ObjectInputStream 类恢复以前使用 ObjectOutputStream 类序列化后的基本类型数据和对象。 ObjectOutputStream 和 ObjectInputStream 分别利用 FileOutputStream 和 FileInputStream 能支持应用程序实现对象图象的稳定存储。 ObjectInputStream 可用于恢复以前序列化过的对象。另外其它一些情况也使用此类，诸如使用一个 Socket 在主机间传递对象时，或在远程通讯系统中为实现参数和参变量的通讯而进行对象传递时。

ObjectInputStream 保证从流中创建的图象中的所有对象的类型与 Java 虚拟机中出现的类匹配。使用标准机制按需装载相应类。

只有支持 java.io.Serializable 或 java.io.Externalizable 接口的对象才能从流中读取。使用 readObject 方法从该流中读取一个对象。 Java 的安全造型应该用于获取期望类型。在 Java 中, 串和数组都是对象且可当作是序列化过程中的对象。读取时，它们需要转换为所需类型。

另外基类型也可使用 DataInput 中的正确方法从该流中读取。

对象的缺省逆序列化机制将每个域的内容恢复为它被写入时的值和类型。逆序列化过程中忽略申明为暂时的或静态的域。对其它对象的引用促使那些对象必须从流中读取。使用引用共享机制正确地恢复对象的图象。逆序列化时总是分配新对象，防止重写已存在的对象。

读取一个对象同运行一个新对象的构造子类似。为该对象分配的内存初始化为空(NULL)。为非序列化类调用无参构造子，然后将序列化类的域从该流中恢复，恢复从最接近 java.lang.object 的序列化对象开始，到指定对象结束。

例如读取在示例中写入 ObjectOutputStream 中的流：

	FileInputStream istream = new FileInputStream("t.tmp");
	ObjectInputStream p = new ObjectInputStream(istream);
	int i = p.readInt();
	String today = (String)p.readObject();
	Date date = (Date)p.readObject();
	istream.close();
 

实现序列化接口可以使对象能保存和恢复它的完整状态，可以使类在写入流和从流中读取的期间内进行改进。它自动地遍历对象间的引用，保存和恢复完整图象。在序列化和逆序列化处理过程中需要特定句柄的可序列化类，必须实现如下这两个方法：

 private void writeObject(java.io.ObjectOutputStream stream)
     throws IOException;
 private void readObject(java.io.ObjectInputStream stream)
     throws IOException, ClassNotFoundException; 
 

利用 writeObjectmethod 方法将一个特殊类的对象的状态写入某流后，相应的 readObject 方法将负责读取和恢复这些数据。此方法不必关心状态是属于它的父类还是子类。 从 ObjectInputStream 读取数据恢复单个域的状态，并将之赋给该对象的恰当域。使用 DataInput 方法读取基本数据类型。

序列化操作对没有实现 java.io.Serializable 接口的对象，不读取或分配它的域值。非序列化对象的子类可以是序列化的。在这种情况下，非序列化类必须有一个无参构造子，使它的域能使用此构造子完成初始化。 在此情况下，子类负责保存和恢复非序列化类的状态。通常情况父类的域是可存储的(公有的、包或保护的)，或存在用于恢复它的状态的可使用的获取或设置方法。

ObjectInputStream 能获取逆序列化一个对象期间出现的任一异常，一旦出现异常，则放弃读过程。

实现外部接口可以使对象完全控制此对象序列化形式的内容和格式。调用外部接口的方法：writeExternal 和 readExternal 保存和恢复对象状态。当一个类实现了这些方法时，它们就能使用 ObjectOutput 和 ObjectInput 方法的所有方法写入或读取它们自己的状态。对象负责管理它出现的相应版本。

来自：

JDK1.1

参见：

DataInput, ObjectOutputStream, Serializable

构造子索引

ObjectInputStream(InputStream)

读取指定的 InputStream，创建一个 ObjectInputStream。

方法索引

available()

返回从当前输入流中可无阻塞读取的字节数。

close()

关闭输入流。

defaultReadObject()

从当前流中读取当前类的非静态和非暂时的属性。

enableResolveObject(boolean)

使该流允许对象从置换流中读取数据。

read()

读取数据的一个字节。

read(byte[], int, int)

读入一个字节数组。

readBoolean()

读取一个布尔值。

readByte()

读一个 8 位的字节。

readChar()

读一个 16 位字符。

readDouble()

读取一个 64 位的双精度浮点数。

readFloat()

读取一个 32 位的浮点数。

readFully(byte[])

读取字节，阻塞直到所有字节被读入。

readFully(byte[], int, int)

读取字节，阻塞直到所有字节被读入。

readInt()

读取一个 32 位的整数。

readLine()

读入一个行，行以 \n, \r, \r\n 或 EOF 结束。

readLong()

读入一个 64 位的长整型。

readObject()

从 ObjectInputStream 中读入一个对象。

readShort()

读一个 16 位的短整型数。

readStreamHeader()

提供 readStreamHeader 方法，允许子类读取和验证它们自己的流头部。

readUnsignedByte()

读一个 8 位的字节。

readUnsignedShort()

读一个 16 位的短整型数。

readUTF()

读取一个 UTF 格式的串。

registerValidation(ObjectInputValidation, int)

在返回该图象前注册一个确认对象。

resolveClass(ObjectStreamClass)

继承类可以实现此方法，允许从一个替换资源中返回类。

resolveObject(Object)

此方法允许 ObjectInputStream 的可靠的继承类，在逆序列化期间将一个对象替换成另一个。

skipBytes(int)

跳过字节，阻塞直到所有字节被跳过。

构造子

 public ObjectInputStream(InputStream in) throws IOException, StreamCorruptedException

读取指定的 InputStream，创建一个 ObjectInputStream。 流头部包含从该流中读取和校验的密码和版本号。这个方法将阻塞，直到相应的 ObjectOutputStream 已写入和刷新了流头部。

抛出：StreamCorruptedException

版本号或密码不正确。

抛出： IOException

基本流中出现一个异常。

方法

 public final Object readObject() throws OptionalDataException, ClassNotFoundException, IOException

从 ObjectInputStream 中读入一个对象。 读取该对象对应的类、类标记和此类的所有的非暂时和非静态的属性值，以及它的子类型的所有这些相应信息。使用 writeObject 和 readObject 方法可以覆盖一个类的缺省逆序列化。暂时读取当前对象引用的对象，以至可以用 readObject 方法重新创建对象的一个完全等值的图象。

当根对象的所有域和它引用的对象均被完全恢复时，则此对象也被完全恢复。此时跟据这些对象注册的优先权，依次调用它们的验证回调。当对象分别被注册时，他们注册这些回调(在 readObject 中专有的方法)。使用 InputStream 时，当出现不应逆序列化的类时抛出异常信息。对于 InputStream 来说，所有的异常都是至命的，它将因此处于不定状态，直到调用者忽略或恢复该流状态。

抛出： ClassNotFoundException

如果找不到一个序列化对象对应的类。

抛出： InvalidClassException

用于序列化的类出现某些错误。

抛出：StreamCorruptedException

流中的控制信息不一致。

抛出：OptionalDataException

流中发现了基本类型数据而不是对象。

抛出： IOException

出现任一通常的 Input/Output 异常。

 public final void defaultReadObject() throws IOException, ClassNotFoundException, NotActiveException

从当前流中读取当前类的非静态和非暂时的属性。 这个方法仅在被逆序列化的类的 readObject 方法中调用。否则将抛出 NotActiveException 异常信息。

抛出： ClassNotFoundException

若不能找到一个序列化对象的类。

抛出： IOException

如果发生一个 I/O 错误。

抛出： NotActiveException

如果该流当前不在读对象。

 public synchronized void registerValidation(ObjectInputValidation obj,
                                             int prio) throws NotActiveException, InvalidObjectException

在返回该图象前注册一个确认对象。 与 resolveObject 方法类似，在重新构造了整个图象之后调用这些验证方法。典型地，一个 readObject 方法将用此流注册该对象，以至当恢复了所有的对象时，能执行一个最终的验证集。

参数：

obj - 将接收验证回调的对象。

prio - 控制回调的顺序；零是一个好的缺省值。数值越高越早调用，数值越低越晚调用。使用优先权，以不特定的顺序处理回调。

抛出： NotActiveException

该流当前不在读对象，所以注册一个回调是非法的。

抛出： InvalidObjectException

验证对象为 null。

 protected Class resolveClass(ObjectStreamClass v) throws IOException, ClassNotFoundException

继承类可以实现此方法，允许从一个替换资源中返回类。 ObjectOutputStream 中相应的方法是 annotateClass。仅对流中的每个唯一的类调用这个方法。子类能实现这个方法，使用一个替换的装载机制但是必须返回一个类对象。一旦返回，该类的 serialVersionUID 被比作此序列化类的 serialVersionUID。如果存在不匹配，则逆序列化失败且产生一个异常。

缺省时类名由相对于调用 readObject 的类解析。

抛出： ClassNotFoundException

如果找不到一个序列化对象类。

 protected Object resolveObject(Object obj) throws IOException

此方法允许 ObjectInputStream 的可靠的继承类，在逆序列化期间将一个对象替换成另一个。 置换对象无效直到调用 enableResolveObject 方法。 enableResolveObject 方法检查流的可靠置换请求。 将可序列化对象的每次引用传递到 resolveObject。 为确保对象的私有状态期望暴露，仅可靠流可以使用 resolveObject。

这个方法在一个对象已被读取之后从 readObject 方法返回之前被调用。缺省的 resolveObject 方法仅返回新对象。

当一个子类将置换对象时，它必须确保替换对象与将被保存的引用的每个域兼容。对象类型不是域或数组元素类型的子类的对象产生一个异常信息时丢弃该序列化操作，且此对象没有被恢复。

当每个对象首次出现时调用这个方法。 所有对该对象的后继引用将重新定位到此新对象。

抛出： IOException

出现任一通常的 Input/Output 异常。

 protected final boolean enableResolveObject(boolean enable) throws SecurityException

使该流允许对象从置换流中读取数据。 如果此流是一个可靠类，则它被允许能置换。 可靠类是那些 classLoader 等于 null 的类。

当能置换时，对每个将被逆序列化的对象调用 resolveObject 方法。

抛出： SecurityException

当前流对象的类装载子非空。

 protected void readStreamHeader() throws IOException, StreamCorruptedException

提供 readStreamHeader 方法，允许子类读取和验证它们自己的流头。 它读取且验证密码和版本号。

 public int read() throws IOException

读取数据的一个字节。 如果没有可用的输入流，那么此方法将阻塞。

返回值：

读取的字节；如果已读到流尾则为 -1。

抛出： IOException

如果发生了一个 I/O 错误

覆盖：

类 InputStream 中的 read

 public int read(byte data[],
               int offset,
                 int length) throws IOException

读入一个字节数组。 这个方法将阻塞直到有可用的输入数据。

参数：

b - 数据读入的缓冲区

off - 数据的初始偏移量

len - 可读入字节的最大数

返回值：

读取的实际字节数，若已读到流尾则返回 -1 。

抛出： IOException

如果发生了一个 I/O 错误

覆盖：

类 InputStream 中的 read

 public int available() throws IOException

返回从当前输入流中可无阻塞读取的字节数。

返回值：

可读取的字节数。

覆盖：

类 InputStream 中的 available

 public void close() throws IOException

关闭输入流。 必须调用此方法以释放与此流相关的任何资源。

抛出： IOException

如果发生了一个 I/O 错误

覆盖：

类 InputStream 中的 close

 public boolean readBoolean() throws IOException

读取一个布尔值。

返回值：

读取的布尔值。

抛出： EOFException

如果已到文件尾。

抛出： IOException

如果发生了其它 I/O 错误

 public byte readByte() throws IOException

读一个 8 位的字节。

返回值：

读取的 8 位字节。

抛出： EOFException

如果已到文件尾。

抛出： IOException

如果发生了其它 I/O 错误

 public int readUnsignedByte() throws IOException

读一个无符号的 8 位的字节。

返回值：

读取的 8 位字节。

抛出： EOFException

如果已到文件尾。

抛出： IOException

如果发生了其它 I/O 错误

 public short readShort() throws IOException

读一个 16 位的短整型数。

返回值：

读取的 16 位短整型。

抛出： EOFException

如果已到文件尾。

抛出： IOException

如果发生了其它 I/O 错误

 public int readUnsignedShort() throws IOException

读一个无符号的 16 位的短整型数。

返回值：

读取的 16 位短整型。

抛出： EOFException

如果已到文件尾。

抛出： IOException

如果发生了其它 I/O 错误

 public char readChar() throws IOException

读一个 16 位字符。

返回值：

读取的 16 位字符。

抛出： EOFException

如果已到文件尾。

抛出： IOException

如果发生了其它 I/O 错误

 public int readInt() throws IOException

读取一个 32 位的整数。

返回值：

读取的 32 位整数。

抛出： EOFException

如果已到文件尾。

抛出： IOException

如果发生了其它 I/O 错误

 public long readLong() throws IOException

读入一个 64 位的长整型。

返回值：

读取的 64 位的长整型。

抛出： EOFException

如果已到文件尾。

抛出： IOException

如果发生了其它 I/O 错误

 public float readFloat() throws IOException

读取一个 32 位的浮点数。

返回值：

读取的 32 位浮点数。

抛出： EOFException

如果已到文件尾。

抛出： IOException

如果发生了其它 I/O 错误

 public double readDouble() throws IOException

读取一个 64 位的双精度浮点数。

返回值：

读取的 64 位的双精度浮点数。

抛出： EOFException

如果已到文件尾。

抛出： IOException

如果发生了其它 I/O 错误

 public void readFully(byte data[]) throws IOException

读取字节，阻塞直到所有字节被读入。

参数：

b - 数据读入的缓冲区

抛出： EOFException

如果已到文件尾。

抛出： IOException

如果发生了其它 I/O 错误

 public void readFully(byte data[],
               int offset,
                       int size) throws IOException

读取字节，阻塞直到所有字节被读入。

参数：

b - 数据读入的缓冲区

off - 数据的初始偏移量

len - 读取的最大字节数。

抛出： EOFException

如果已到文件尾。

抛出： IOException

如果发生了其它 I/O 错误

 public int skipBytes(int len) throws IOException

跳过字节，阻塞直到所有字节被跳过。

参数：

n - 跳过的字节数

返回值：

实际跳过的字节数。

抛出： EOFException

如果已到文件尾。

抛出： IOException

如果发生了其它 I/O 错误

 public String readLine() throws IOException

读入一个行，行以 \n, \r, \r\n 或 EOF 结束。

返回值：

此串的复制串。

 public String readUTF() throws IOException

读取一个 UTF 格式的串。

返回值：

字符串。