类 java.io.ObjectOutputStream

java.lang.Object
   |
   +----java.io.OutputStream
           |
           +----java.io.ObjectOutputStream

public class ObjectOutputStream

extends OutputStream

implements ObjectOutput, ObjectStreamConstants

类 ObjectOutputStream 将 Java 对象中的基本数据类型和图元写入到一个 OutputStream 对象中。可使用 ObjectInputStream 读取这些对象。另外使用此流对应的文件能存储这些对象。如果该流是一个网络通讯流，则在另一台主机或另一个处理机上可重建这些对象。

只有支持 java.io.Serializable 接口的对象才能被写入该流。对每个可序列化的对象进行编码，包括相应类的名称和标记，对象的属性和数组值，以及初始化对象时引用的任何其它对象等。

使用 writeObject 将一个对象写入该流。任一对象，包括串和数组，均采用 writeObject 方法被写入。也能将多个对象或基类型对象写入此流。反过来，必须以这些对象被写入的相同类型和相同顺序，从相应的 ObjectInputstream 流中读回这些对象。

基类型也可使用 DataOutput 中的正确方法写入此流。串对象也可使用 writeUTF 方法写入。

一个对象的缺省序列化机制将写入对象的类，类标记和所有的非暂时的和非静态的属性值。其它对象(除暂时的或静态的属性)的引用也将促使以上这些对象被写入。 使用共享机制，对单一对象的多次引用进行编码，以至对象的图元能被存储为与它原来写入时有相同的形状。

例如写入一个对象，此对象能从 ObjectInputStream 中读出：

	FileOutputStream ostream = new FileOutputStream("t.tmp");
	ObjectOutputStream p = new ObjectOutputStream(ostream);
	p.writeInt(12345);
	p.writeObject("Today");
	p.writeObject(new Date());
	p.flush();
	ostream.close();
 

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

writeObject 方法负责写特定类的对象的状态，以使相应的 readObject 方法能存储它。此方法不必关心写入对象的父类或子类的状态。使用 writeObject 方法或基本类型支持的 DataOutput 方法将每个域的状态保存到 ObjectOutputStream 中。

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

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

来自：

JDK1.1

参见：

DataOutput, ObjectInputStream, Serializable, Externalizable

构造子索引

ObjectOutputStream(OutputStream)

创建一个 ObjectOutputStream 对象，写入指定的 OutputStream。

方法索引

annotateClass(Class)

继承类可以实现此方法，将类数据存储到该流。

close()

关闭流。

defaultWriteObject()

将当前类的非静态的和非暂时的属性写入此流。

drain()

排除 ObjectOutputStream 中的所有缓冲数据。

enableReplaceObject(boolean)

使该流能替换它中的对象。

flush()

刷新流。

replaceObject(Object)

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

reset()

复位操作不考虑已写入该流的任一对象的状态。

write(byte[])

写一个字节数组。

write(byte[], int, int)

写一个子字节数组。

write(int)

写一个字节。

writeBoolean(boolean)

写一个 Boolean 对象。

writeByte(int)

写一个 8 位的字节。

writeBytes(String)

写入一个串，作为一个字节序列。

writeChar(int)

写一个 16 位字符。

writeChars(String)

写一个字符串，作为一个字符序列。

writeDouble(double)

写入一个 64 位的双精度浮点数。

writeFloat(float)

写入一个 32 位的浮点数。

writeInt(int)

写入一个 32 位的整数。

writeLong(long)

写入一个 64 位的长整型。

writeObject(Object)

将指定对象写入 ObjectOutputStream。

writeShort(int)

写一个 16 位的短整型数。

writeStreamHeader()

提供 writeStreamHeader 方法，可以使继承类向此流从前或从后追加它们自己的头信息。

writeUTF(String)

以 UTF 格式写入一个串。

构造子

 public ObjectOutputStream(OutputStream out) throws IOException

创建一个 ObjectOutputStream 对象，写入指定的 OutputStream。 将流头部写入该流。调用者可能想立即调用刷新操作，以致相应的 ObjectInputStream 能立即读此头部。

抛出： IOException

如果基本的 OutputStream 抛出任一异常。

方法

 public final void writeObject(Object obj) throws IOException

将指定对象写入 ObjectOutputStream。 将该对象对应的类、类标记和此类的所有的非暂时的和非静态的属性值，以及它的子类型的所有这些信息写入流。 使用 writeObject 和 readObject 方法可以覆盖一个类的缺省序列化操作。 暂时输出当前对象引用的对象，以至 ObjectInputStream 能重新创建对象的一个完全等值的图象。

使用 OutputStream 时，当出现不应序列化的类时抛出异常信息。 对于 OutputStream 来说，所有的异常都是至命的，它将因此处于不定状态，直到调用者忽略或恢复该流状态。

抛出： InvalidClassException

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

抛出： NotSerializableException

被序列化的一些对象没有实现 java.io.Serializable 接口。

抛出： IOException

如果基本的 OutputStream 抛出任一异常。

 public final void defaultWriteObject() throws IOException

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

 public void reset() throws IOException

复位操作将放弃已写入该流的任一对象的状态。 复位后的状态同一个新的 ObjectOutputStream 对象的状态相同。将该流中的当前点标记为复位时状态，以至相应的 ObjectInputStream 方法将能在同样点被复位。以前输出到该流中的对象将不当作已在此流中。它们将再被输出到此流中。

 protected void annotateClass(Class cl) throws IOException

继承类可以实现此方法，将类数据存储到该流。 缺省时这个方法不做任何事。 ObjectInputStream 中的相应方法是 resolveClass。仅对流中的每个唯一的类调用这个方法。 类名和标记也被输出到该流中。这个方法可以自由使用 ObjectOutputStream，保存与类相关的任一恰当表示(例如类文件的字节)。 ObjectInputStream 的相应子类中 resolveClass 方法必须读取和使用任一数据或 annotateClass 输出的对象。仅对普通类调用 annotateClass。数组不是普通类。

抛出： IOException

如果基本的 OutputStream 抛出任一异常。

 protected Object replaceObject(Object obj) throws IOException

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

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

当每个对象首次出现时调用这个方法。所有对该对象的后继引用将重新定位到此新对象。这个方法应该返回将被替换的对象或原始对象。

返回的将被替换的对象可一为 Null，但是在包含对原始对象的引用的类中可能导致 NullReferenceException 异常，因为它们期望是一个对象而不是 Null。

抛出： IOException

如果基本的 OutputStream 抛出任一异常。

 protected final boolean enableReplaceObject(boolean enable) throws SecurityException

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

当允许置换时，为序列化的每个对象调用 replaceObject 方法。

抛出： SecurityException

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

 protected void writeStreamHeader() throws IOException

提供 writeStreamHeader 方法，可以使继承类向此流从前或从后追加它们自己的头信息。 它将密码和版本号写入此流。

 public void write(int data) throws IOException

写一个字节。该方法将阻塞直到这个字节被写入。

参数：

b - 字节

抛出： IOException

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

覆盖：

类 OutputStream 中的 write

 public void write(byte b[]) throws IOException

写一个字节数组。该方法将阻塞直到这些字节被实际写入。

参数：

b - 被写的数据

抛出： IOException

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

覆盖：

类 OutputStream 中的 write

 public void flush() throws IOException

刷新流。 这将写入任一缓冲输出的字节，并刷新基本流。

抛出： IOException

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

覆盖：

类 OutputStream 中的 flush

 protected void drain() throws IOException

排除 ObjectOutputStream 中的所有缓冲数据。 与刷新类似，但是不影响基本流。

 public void close() throws IOException

关闭流。 这个方法必须被调用，以释放与此流相关的任何资源。

抛出： IOException

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

覆盖：

类 OutputStream 中的 close

 public void writeBoolean(boolean data) throws IOException

写一个 Boolean 对象。

参数：

data - 待写的布尔值

 public void write(byte b[],
                   int off,
                 int len) throws IOException

写一个子字节数组。

参数：

b - 被写的数据

off - 数据中的初始偏移量

len - 被写的字节数

抛出： IOException

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

覆盖：

类 OutputStream 中的 write

 public void writeByte(int data) throws IOException

写一个 8 位的字节。

参数：

data - 写入的字节值

 public void writeShort(int data) throws IOException

写一个 16 位的短整型数。

参数：

data - 写入的短整型值

 public void writeChar(int data) throws IOException

写一个 16 位字符。

参数：

data - 写入的字节值

 public void writeInt(int data) throws IOException

写入一个 32 位的整数。

参数：

data - 写入的整型值

 public void writeLong(long data) throws IOException

写入一个 64 位的长整型。

参数：

data - 写入的长整型值

 public void writeFloat(float data) throws IOException

写入一个 32 位的浮点数。

参数：

data - 写入的浮点值

 public void writeDouble(double data) throws IOException

写入一个 64 位的双精度浮点数。

参数：

data - 写入的双精度浮点值

 public void writeBytes(String data) throws IOException

写入一个串，作为一个字节序列。

参数：

s - 写入的字节串。

 public void writeChars(String data) throws IOException

写一个字符串，作为一个字符序列。

参数：

s - 写入的字符串。

 public void writeUTF(String data) throws IOException

以 UTF 格式写入一个串。

参数：

str - UTF 格式的串