ObjectOutputStream (Java Platform SE 8 )

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

All Implemented Interfaces:

Closeable， DataOutput， Flushable， ObjectOutput， ObjectStreamConstants， AutoCloseable
```
public class ObjectOutputStream
extends OutputStream
implements ObjectOutput, ObjectStreamConstants
```
一个对象写入原始数据类型和java对象图的一个输出流。对象可以读取（重组）用ObjectInputStream。通过使用流的文件，可以实现对对象的持久存储。如果流是一个网络套接字流，对象可以被重新在另一个主机上或在另一个进程中。
只有对象支持java.io.serializable接口可以写入流。每个序列化对象的类是编码包括的类的名称和签名的对象的字段和数组的值，和任何其他对象引用的对象从最初的封闭。

该方法是使用writeObject写一个对象流。任何物体，包括字符串和数组，用writeObject。可以将多个对象或原语写入流中。对象必须具有相同的类型对应的对象输入流中读出，以相同的顺序为他们写的。

原始数据类型也可以用适当的方法利用数据流。字符串也可以用writeutf方法。

对象的默认序列化机制写入对象的类、类签名和所有非瞬态和非静态字段的值。对其他对象的引用（除了在瞬态或静态字段），导致这些对象也被写入。多个引用到一个单一的对象进行编码使用参考共享机制，使图形的对象可以恢复到相同的形状，当原来的书面。

例如，可以读写的例子，在ObjectInputStream的一个目标：
```
FileOutputStream FOS =新FileOutputStream（“t.tmp”）；ObjectOutputStream OOS =新对象（FOS）；（12345）writeint缺货；OOS writeObject（“今天”）；OOS writeObject（新（））；缺货。（）；
```
类，需要特殊处理的序列化和反序列化过程中必须用特殊方法在实施这些具体的签名：
```
private void readObject（java.io.objectinputstream流）抛出IOException，时抛出；private void writeObject（java.io.objectoutputstream流）抛出IOExceptionprivate void readobjectnodata()把objectstreamexception；
```
writeObject方法负责写作对象的状态为其特定的类，相应的readObject方法可以恢复。该方法不需要担心自己属于对象的超类或子类的状态。国家通过写个人领域使用writeObject方法或使用的方法对原始数据类型支持的数据对象的保存。

序列化不写任何对象，没有实现java.io.serializable接口等。那是不可序列化对象的子类可以被序列化。在这种情况下，不可序列化的类必须有一个无参数构造函数允许字段被初始化。在这种情况下，它的子类来保存和恢复的非序列化类的国家责任。它经常是这样的情况下，该类的字段是可访问的（公共，包或保护），或有得到和设置方法，可以用来恢复状态。

一个对象序列化可以实现writeObject和readObject方法，把notserializableexception阻止。例外将被对象和中止序列化过程。

实现Externalizable接口允许对象的假设和对象的序列化格式的内容完全控制。Externalizable接口的方法，readexternal writeExternal和，被称为保存和恢复对象的状态。由类实现时他们可以编写和使用所有的objectoutput和objectinput方法读自己的状态。它是对象的责任来处理出现的任何版本。

枚举常量是不同于普通的序列化序列化或外部对象。一个枚举常量的序列化形式由其名称；的恒值不能被发送。序列化一个枚举常量，ObjectOutputStream写的字符串常量的名称的方法返回。像其他序列化或外部对象，枚举常量可以作为反向引用的出现，随后在序列化流目标。通过枚举常量不能定制序列化的过程；任何特定类的writeObject和writereplace方法枚举类型定义被忽略在序列化期间。同样，任何serialpersistentfields serialVersionUID字段声明或忽视了所有枚举类型有一个固定的serialVersionUID 0L。

原始数据，不包括序列化字段和外部的数据，写入块数据记录的对象。一个块数据记录是由一个头和数据。块数据头由一个标记和字节数按照标题。连续的原始数据写入被合并成一个块数据记录。用于块数据记录的阻塞因子将是1024个字节。每个块数据记录将被填充到1024个字节，或被写入时，有一个块数据模式终止。调用对象的方法和writefields writeObject，defaultwriteobject最初终止任何现有的数据块记录。
从以下版本开始：

JDK1.1

另请参见：

DataOutput， ObjectInputStream， Serializable， Externalizable， Object Serialization Specification, Section 2, Object Output Classes

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`ObjectOutputStream.PutField` 提供编程访问持久性字段写入objectoutput。

Field Summary
- Fields inherited from interface java.io.ObjectStreamConstants
  baseWireHandle, PROTOCOL_VERSION_1, PROTOCOL_VERSION_2, SC_BLOCK_DATA, SC_ENUM, SC_EXTERNALIZABLE, SC_SERIALIZABLE, SC_WRITE_METHOD, STREAM_MAGIC, STREAM_VERSION, SUBCLASS_IMPLEMENTATION_PERMISSION, SUBSTITUTION_PERMISSION, TC_ARRAY, TC_BASE, TC_BLOCKDATA, TC_BLOCKDATALONG, TC_CLASS, TC_CLASSDESC, TC_ENDBLOCKDATA, TC_ENUM, TC_EXCEPTION, TC_LONGSTRING, TC_MAX, TC_NULL, TC_OBJECT, TC_PROXYCLASSDESC, TC_REFERENCE, TC_RESET, TC_STRING

构造方法摘要

构造方法
Modifier	Constructor and Description
`protected`	`ObjectOutputStream()` 提供完全重新实现的子类对象不需要分配的私有数据只是用于实现对象的方式。
	`ObjectOutputStream(OutputStream out)` 创建一个对象写入到指定的输出流。

方法摘要

所有方法接口方法具体的方法
Modifier and Type	Method and Description
`protected void`	`annotateClass(类<?> cl)` 子类可以实现这种方法，以允许将类数据存储在流中。
`protected void`	`annotateProxyClass(类<?> cl)` 子类可以实现这种方法来存储流中的自定义数据以及动态代理类的描述符。
`void`	`close()` 关闭流。
`void`	`defaultWriteObject()` 将当前类的非静态和非瞬态字段写入该流。
`protected void`	`drain()` 在ObjectOutputStream的任何缓冲的数据流失。
`protected boolean`	`enableReplaceObject(boolean enable)` 使流能够替换流中的对象。
`void`	`flush()` 冲流。
`ObjectOutputStream.PutField`	`putFields()` 检索用于将要写入流的缓冲持久字段的对象。
`protected Object`	`replaceObject(Object obj)` 这种方法将允许受信任的子类对象来代替一个物体对另一个序列化期间。
`void`	`reset()` 重置将忽略已写入流的任何对象的状态。
`void`	`useProtocolVersion(int version)` 在写入流时指定要使用的流协议版本。
`void`	`write(byte[] buf)` 写入一个字节数组。
`void`	`write(byte[] buf, int off, int len)` 写入字节数组的字节数。
`void`	`write(int val)` 写一个字节。
`void`	`writeBoolean(boolean val)` 写一个布尔值。
`void`	`writeByte(int val)` 写入一个8位字节。
`void`	`writeBytes(String str)` 写入字符串作为一个字节序列。
`void`	`writeChar(int val)` 写入一个16位字符。
`void`	`writeChars(String str)` 写一个字符串作为字符序列。
`protected void`	`writeClassDescriptor(ObjectStreamClass desc)` 写入指定的类描述的对象。
`void`	`writeDouble(double val)` 写一个64位双。
`void`	`writeFields()` 将缓冲区写到流中。
`void`	`writeFloat(float val)` 写一个32位浮点。
`void`	`writeInt(int val)` 将32位int。
`void`	`writeLong(long val)` 写一个64位长的。
`void`	`writeObject(Object obj)` 写入指定的对象的对象。
`protected void`	`writeObjectOverride(Object obj)` 用子类重写默认的writeObject方法。
`void`	`writeShort(int val)` 写一个16位的短。
`protected void`	`writeStreamHeader()` 的writestreamheader方法提供子类可以附加或在自己的头的流。
`void`	`writeUnshared(Object obj)` 写一个“独享”的对象的对象。
`void`	`writeUTF(String str)` 原始数据写在 modified UTF-8格式字符串。

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - ObjectOutputStream
```
public ObjectOutputStream(OutputStream out)
                   throws IOException
```
    创建一个对象写入到指定的输出流。此构造函数将序列化流头基础流；用户可能希望冲流立即确保构造函数接收objectinputstreams不会阻止阅读标题时。
    如果安装了安全管理器，该构造函数将检查“enablesubclassimplementation”时，直接或间接地通过调用子类覆盖objectoutputstream.putfields objectoutputstream.writeunshared方法或构造函数serializablepermission。
    
    参数
    
    out输出流写入
    
    异常
    
    IOException -如果在写流头发生I/O错误
    
    如果不受信任的子类重写 SecurityException非法安全敏感的方法
    
    如果是 null out NullPointerException
    
    从以下版本开始：
    
    一点四
    
    另请参见：
    
    ObjectOutputStream()， putFields()， ObjectInputStream.ObjectInputStream(InputStream)
  - ObjectOutputStream
```
protected ObjectOutputStream()
                      throws IOException,
                             SecurityException
```
    提供完全重新实现的子类对象不需要分配的私有数据只是用于实现对象的方式。
    如果存在安全管理器安装，这种方法首先调用一个SerializablePermission("enableSubclassImplementation")权限以确保可以使子类化安全管理的checkPermission方法。
    
    异常
    
    SecurityException -如果存在一个安全管理及其 checkPermission否认使子类化方法。
    
    IOException -如果在创建此流发生I/O错误
    
    另请参见：
    
    SecurityManager.checkPermission(java.security.Permission)， SerializablePermission
- 方法详细信息
  - useProtocolVersion
```
public void useProtocolVersion(int version)
                        throws IOException
```
    在写入流时指定要使用的流协议版本。
    此例程提供了一个钩子，使当前版本的序列化以一种向后兼容的格式写在流格式的前一个版本中。
    
    我们将尽一切努力避免引入额外的向后兼容；然而，有时没有其他选择。
    
    参数
    
    version从java.io.objectstreamconstants使用版本。
    
    异常
    
    IllegalStateException -如果任何对象被序列化为后。
    
    IllegalArgumentException如果无效的版本是通过。
    
    IOException如果I/O错误发生
    
    从以下版本开始：
    
    一点二
    
    另请参见：
    
    ObjectStreamConstants.PROTOCOL_VERSION_1， ObjectStreamConstants.PROTOCOL_VERSION_2
  - writeObject
```
public final void writeObject(Object obj)
                       throws IOException
```
    写入指定的对象的对象。该对象的类，类的签名，和价值观的非瞬态和非类及其所有类型的静态字段都写。一类可以重写默认的序列化使用writeObject和readObject方法。对象引用的对象是以可使对象的完全等价的图形可以通过ObjectInputStream重建。
    抛出异常与OutputStream类问题和不可序列化。所有的异常都是到OutputStream是致命的，这是一个不确定的状态离开，并由调用方忽略或恢复流的状态。
    
    Specified by:
    
    writeObject 接口 ObjectOutput
    
    参数
    
    obj -要写入的对象
    
    异常
    
    InvalidClassException -什么是一个用于序列化类错。
    
    NotSerializableException一些对象被序列化并没有落实java.io.serializable接口。
    
    IOException任何例外的OutputStream扔。
  - writeObjectOverride
```
protected void writeObjectOverride(Object obj)
                            throws IOException
```
    用子类重写默认的writeObject方法。这种方法被称为通过构建以保护对象输入流对象输入流无参数构造函数受信任的子类。该子类预计将提供一个重写方法与修改器“最终”。
    
    参数
    
    obj对象被写入基础流
    
    异常
    
    IOException -如果有I/O错误写入基础流
    
    从以下版本开始：
    
    一点二
    
    另请参见：
    
    ObjectOutputStream()， writeObject(Object)
  - writeUnshared
```
public void writeUnshared(Object obj)
                   throws IOException
```
    写一个“独享”的对象的对象。此方法与writeObject，除了它总是写入给定的对象作为一种新的，独特的流对象（而不是一个反向引用指向先前序列化实例）。具体来说：
    - 一个对象通过书面writeunshared总是连载中相同的方式作为一个新出现的对象（未到流写出来的对象），无论对象是否已经写过的。
    - 如果writeObject是用来写字的，以前一直用writeunshared对象，以前的writeunshared手术治疗好像是写一个单独的对象。换句话说，对象不会产生反向引用的对象用电话writeunshared数据。
    写作对象通过writeunshared本身并不能保证对对象的唯一引用时，它是反序列化，它允许一个对象在一个流中定义多次，所以多次调用readunshared由接收器不冲突。请注意，上述规则仅适用于用writeunshared基层对象，而不是任何传递引用的子对象的对象图中的可序列化。
    对象的子类重写此方法只能在安全领域中具有“enablesubclassimplementation”serializablepermission构造；任何试图实例化子类无此权限会导致引发SecurityException。
    参数
    
    obj对象写入流
    
    异常
    
    NotSerializableException -如果图形中的对象进行序列化不实现Serializable接口
    
    InvalidClassException -如果存在问题和对象的类序列化
    
    IOException -如果在序列化期间发生I/O错误
    
    从以下版本开始：
    
    一点四
  - defaultWriteObject
```
public void defaultWriteObject()
                        throws IOException
```
    将当前类的非静态和非瞬态字段写入该流。这只能被类的writeObject方法序列化。如果这是所谓的否则把notactiveexception。
    
    异常
    
    IOException如果I/O错误发生而写作的基本 OutputStream
  - putFields
```
public ObjectOutputStream.PutField putFields()
                                      throws IOException
```
    检索用于将要写入流的缓冲持久字段的对象。该字段将被写入到流时，writefields方法称为。
    
    结果
    
    这是可序列化的域类putfield实例
    
    异常
    
    IOException如果I/O错误发生
    
    从以下版本开始：
    
    一点二
  - writeFields
```
public void writeFields()
                 throws IOException
```
    将缓冲区写到流中。
    
    异常
    
    IOException如果I/O错误发生在写入基础流
    
    “当一个类 NotActiveException writeObject方法不被称为对象的状态写。
    
    从以下版本开始：
    
    一点二
  - reset
```
public void reset()
           throws IOException
```
    重置将忽略已写入流的任何对象的状态。状态复位可作为一种新的对象相同。流中的当前点标记为重置，所以相应的对象输入流将在同一点重置。以前写入流的对象将不会被称为已经存在于流中的对象。他们将再次被写入流。
    
    异常
    
    如果reset() IOException调用，序列化一个对象。
  - annotateClass
```
protected void annotateClass(类<?> cl)
                      throws IOException
```
    子类可以实现这种方法，以允许将类数据存储在流中。默认情况下，这种方法不做任何事。在ObjectInputStream，相应的方法是resolveclass。这种方法被准确地称为一次为流中的每一个独特的类。该类的名称和签名将已被写入流中。这种方法可以使该对象使用免费保存任何类的表示，它认为合适的（例如，字节的类文件）。在相应的子类对象输入流resolveclass方法必须阅读和使用任何数据或对象所写的annotateclass。
    
    参数
    
    cl -类注释自定义数据
    
    异常
    
    IOException任何例外的OutputStream扔。
  - annotateProxyClass
```
protected void annotateProxyClass(类<?> cl)
                           throws IOException
```
    子类可以实现这种方法来存储流中的自定义数据以及动态代理类的描述符。
    这种方法在流中的每一个唯一的代理类描述符被调用一次。在ObjectOutputStream此方法的默认实现不执行任何操作。
    
    在ObjectInputStream对应的方法是resolveProxyClass。对于一个给定的ObjectOutputStream重写此方法的子类，在子类ObjectInputStream相应的resolveProxyClass方法必须读取任何数据或对象所写的annotateProxyClass。
    
    参数
    
    cl -代理类注释自定义数据
    
    异常
    
    IOException任何例外的基本 OutputStream扔
    
    从以下版本开始：
    
    一点三
    
    另请参见：
    
    ObjectInputStream.resolveProxyClass(String[])
  - replaceObject
```
protected Object replaceObject(Object obj)
                        throws IOException
```
    这种方法将允许受信任的子类对象来代替一个物体对另一个序列化期间。替换对象是残疾人直到enablereplaceobject叫做。的enablereplaceobject方法检查流请求做置换是可以信任的。每个对象写入序列化流中第一次出现是通过替换对象。随后对该对象的引用被返回的对象取代原来的调用替换对象。确保对象的私有状态不是无意暴露，只有受信任的数据流可以使用替换对象。
    的objectoutputstream.writeobject方法以对象类型的参数（而不是类型序列化）允许的情况下，非序列化的对象是可序列化的取代。
    
    当一个类对象必须确保替代或互补代换必须在反序列化期间或取代的对象是兼容的各个领域，将参考存储。类型不是字段或数组元素的类型的子类的对象通过引发异常中止序列化，而对象是不被存储的。
    
    此方法仅在第一次遇到每个对象时调用一次。所有后续对该对象的引用将被重定向到新的对象。此方法应返回被替换的对象或原始对象。
    
    零可以作为可替代的对象返回，但可能因为他们可以期待一个对象而不是空导致包含引用的原始对象类NullReferenceException。
    
    参数
    
    obj要替换的对象
    
    结果
    
    替换指定的一个的替代对象
    
    异常
    
    IOException任何例外的OutputStream扔。
  - enableReplaceObject
```
protected boolean enableReplaceObject(boolean enable)
                               throws SecurityException
```
    使流能够替换流中的对象。当启用时，替换对象的方法称为每个对象被序列化。
    如果enable是真实的，并有一个安全管理安装，这种方法首先调用一个SerializablePermission("enableSubstitution")权限以确保可以使流在流做置换对象的安全经理的checkPermission方法。
    
    参数
    
    enable -布尔参数使替换对象
    
    结果
    
    调用此方法之前的前一个设置
    
    异常
    
    SecurityException -如果存在一个安全管理及其 checkPermission方法拒绝使流在流做替代物。
    
    另请参见：
    
    SecurityManager.checkPermission(java.security.Permission)， SerializablePermission
  - writeStreamHeader
```
protected void writeStreamHeader()
                          throws IOException
```
    的writestreamheader方法提供子类可以附加或在自己的头的流。它将神奇的数字和版本写入流中。
    
    异常
    
    IOException如果I/O错误发生在写入基础流
  - writeClassDescriptor
```
protected void writeClassDescriptor(ObjectStreamClass desc)
                             throws IOException
```
    写入指定的类描述的对象。类的描述符用于标识写入流的对象的类。子类可以重写此方法以自定义对象的类描述符写入序列化流方式。在ObjectInputStream的相应的方法， readClassDescriptor，应该重写重组类描述符从自定义流表示。默认情况下，该方法根据对象序列化规范中定义的格式写类描述符。
    注意，这种方法只会如果不使用旧的对象序列化流格式（通过调用对象的useProtocolVersion法）。如果序列化流是使用旧格式（PROTOCOL_VERSION_1），类描述符将被写在一个方法不能被重写或定制。
    
    参数
    
    desc类描述符写入该流
    
    异常
    
    IOException如果发生I/O错误。
    
    从以下版本开始：
    
    一点三
    
    另请参见：
    
    ObjectInputStream.readClassDescriptor()， useProtocolVersion(int)， ObjectStreamConstants.PROTOCOL_VERSION_1
  - write
```
public void write(int val)
           throws IOException
```
    写一个字节。这种方法将阻止，直到字节实际上是书面的。
    
    Specified by:
    
    write 接口 DataOutput
    
    Specified by:
    
    write 接口 ObjectOutput
    
    Specified by:
    
    write 方法重写，继承类 OutputStream
    
    参数
    
    val的字节被写入到流
    
    异常
    
    IOException如果发生I/O错误。
  - write
```
public void write(byte[] buf)
           throws IOException
```
    写入一个字节数组。这种方法将阻塞，直到实际写入字节数为止。
    
    Specified by:
    
    write 接口 DataOutput
    
    Specified by:
    
    write 接口 ObjectOutput
    
    重写：
    
    write 方法重写，继承类 OutputStream
    
    参数
    
    buf -要写入的数据
    
    异常
    
    IOException如果发生I/O错误。
    
    另请参见：
    
    OutputStream.write(byte[], int, int)
  - write
```
public void write(byte[] buf,
                  int off,
                  int len)
           throws IOException
```
    写入字节数组的字节数。
    
    Specified by:
    
    write 接口 DataOutput
    
    Specified by:
    
    write 接口 ObjectOutput
    
    重写：
    
    write 方法重写，继承类 OutputStream
    
    参数
    
    buf -要写入的数据
    
    off的起始偏移量的数据
    
    len -字节写数
    
    异常
    
    IOException如果发生I/O错误。
  - flush
```
public void flush()
           throws IOException
```
    冲流。这将写任何缓冲的输出字节，并刷新到底层流。
    
    Specified by:
    
    flush 接口 Flushable
    
    Specified by:
    
    flush 接口 ObjectOutput
    
    重写：
    
    flush 方法重写，继承类 OutputStream
    
    异常
    
    IOException如果发生I/O错误。
  - drain
```
protected void drain()
              throws IOException
```
    在ObjectOutputStream的任何缓冲的数据流失。类似于冲洗，但不传播到底层流的冲洗。
    
    异常
    
    IOException如果I/O错误发生在写入基础流
  - close
```
public void close()
           throws IOException
```
    关闭流。必须调用此方法以释放与流关联的任何资源。
    
    Specified by:
    
    close 接口 Closeable
    
    Specified by:
    
    close 接口 ObjectOutput
    
    Specified by:
    
    close 接口 AutoCloseable
    
    重写：
    
    close 方法重写，继承类 OutputStream
    
    异常
    
    IOException如果发生I/O错误。
  - writeBoolean
```
public void writeBoolean(boolean val)
                  throws IOException
```
    写一个布尔值。
    
    Specified by:
    
    writeBoolean 接口 DataOutput
    
    参数
    
    val -布尔写的
    
    异常
    
    IOException如果I/O错误发生在写入基础流
  - writeByte
```
public void writeByte(int val)
               throws IOException
```
    写入一个8位字节。
    
    Specified by:
    
    writeByte 接口 DataOutput
    
    参数
    
    val -要写入的字节值
    
    异常
    
    IOException如果I/O错误发生在写入基础流
  - writeShort
```
public void writeShort(int val)
                throws IOException
```
    写一个16位的短。
    
    Specified by:
    
    writeShort 接口 DataOutput
    
    参数
    
    val -写短的价值
    
    异常
    
    IOException如果I/O错误发生在写入基础流
  - writeChar
```
public void writeChar(int val)
               throws IOException
```
    写入一个16位字符。
    
    Specified by:
    
    writeChar 接口 DataOutput
    
    参数
    
    val -要写入的字符值
    
    异常
    
    IOException如果I/O错误发生在写入基础流
  - writeInt
```
public void writeInt(int val)
              throws IOException
```
    将32位int。
    
    Specified by:
    
    writeInt 接口 DataOutput
    
    参数
    
    val -要写入的整数
    
    异常
    
    IOException如果I/O错误发生在写入基础流
  - writeLong
```
public void writeLong(long val)
               throws IOException
```
    写一个64位长的。
    
    Specified by:
    
    writeLong 接口 DataOutput
    
    参数
    
    val -要写长值
    
    异常
    
    IOException如果I/O错误发生在写入基础流
  - writeFloat
```
public void writeFloat(float val)
                throws IOException
```
    写一个32位浮点。
    
    Specified by:
    
    writeFloat 接口 DataOutput
    
    参数
    
    val -被写入浮点值
    
    异常
    
    IOException如果I/O错误发生在写入基础流
  - writeDouble
```
public void writeDouble(double val)
                 throws IOException
```
    写一个64位双。
    
    Specified by:
    
    writeDouble 接口 DataOutput
    
    参数
    
    val -要写入的双重价值
    
    异常
    
    IOException如果I/O错误发生在写入基础流
  - writeBytes
```
public void writeBytes(String str)
                throws IOException
```
    写入字符串作为一个字节序列。
    
    Specified by:
    
    writeBytes 接口 DataOutput
    
    参数
    
    str -字节被写入字符串
    
    异常
    
    IOException如果I/O错误发生在写入基础流
  - writeChars
```
public void writeChars(String str)
                throws IOException
```
    写一个字符串作为字符序列。
    
    Specified by:
    
    writeChars 接口 DataOutput
    
    参数
    
    str -焦要写入的字符串
    
    异常
    
    IOException如果I/O错误发生在写入基础流
  - writeUTF
```
public void writeUTF(String str)
              throws IOException
```
    原始数据写在 modified UTF-8格式字符串。请注意，将字符串写入流作为原始数据或作为对象，有一个显着的区别。一个字符串实例用writeObject写入流作为一个字符串开始。本writeobject()调用写入字符串引用到流。
    
    Specified by:
    
    writeUTF 接口 DataOutput
    
    参数
    
    str -要写入的字符串
    
    异常
    
    IOException如果I/O错误发生在写入基础流

Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2014, Oracle and/or its affiliates. All rights reserved.

Class ObjectOutputStream

Nested Class Summary

Field Summary

Fields inherited from interface java.io.ObjectStreamConstants

构造方法摘要

方法摘要

Methods inherited from class java.lang.Object

Constructor Detail

ObjectOutputStream

ObjectOutputStream

方法详细信息

useProtocolVersion

writeObject

writeObjectOverride

writeUnshared

defaultWriteObject

putFields

writeFields

reset

annotateClass

annotateProxyClass

replaceObject

enableReplaceObject

writeStreamHeader

writeClassDescriptor

write

write

write

flush

drain

close

writeBoolean

writeByte

writeShort

writeChar

writeInt

writeLong

writeFloat

writeDouble

writeBytes

writeChars

writeUTF