compact1, compact2, compact3

java.io

Class ObjectInputStream

java.lang.Object

java.io.InputStream

java.io.ObjectInputStream

All Implemented Interfaces:

Closeable， DataInput， ObjectInput， ObjectStreamConstants， AutoCloseable

public class ObjectInputStream
extends InputStream
implements ObjectInput, ObjectStreamConstants

ObjectInputStream将原始数据和对象以前写的使用对象。

对象和对象输入流可以提供持久存储应用程序的图形对象时使用一个和FileInputStream分别。对象输入流是用来恢复以前那些对象序列化。其他用途包括主机使用Socket流或编组和解组的参数和参数的远程通信系统之间传递对象。

确保在创建对象输入流从流匹配类的java虚拟机当前图中所有对象的类型。按要求加载类，使用标准机制。

只有对象支持java.io.serializable或java.io.externalizable接口可以读取流。

方法readObject是用来读取从流对象。java的安全铸造应该用来获得想要的类型。在java中，字符串和数组是对象和处理对象序列化期间。当阅读时，他们需要被转换到预期的类型。

原始数据类型可以从流中读到使用适当的方法对数据输入。

对象的默认序列化机制将每个字段的内容和类型的值时写的。字段声明为短暂的或静态的反序列化过程中忽视。对其他对象的引用会导致这些对象在必要时从流中读取。对象的图形恢复正确使用参考共享机制。新的对象总是分配当反序列化，使现有的对象被覆盖。

读取一个对象类似于运行一个新对象的构造函数。内存分配给该对象，并初始化为零（空）。无参数构造函数的非序列化的类调用，然后对序列化的类字段恢复从流从序列化类接近整理java.lang.Object对象的最具体的类。

例如从流在ObjectOutputStream的例子：
读写

FileInputStream FIS =新的输入（“t.tmp”）；ObjectInPutStream OIS =新对象输入流（FIS）；int i = readint() OIS；字符串（String）今天= readobject() OIS；日期=（日期）readobject() OIS；OIS。（）；

类控制它们是如何被实施的java.io.serializable或java.io.externalizable接口。

实现Serializable接口允许对象序列化保存和恢复对象的整个状态，它允许类进化的时间流写入的时间是一念之间。它会自动遍历对象间的引用，保存和恢复整个图。

序列化的类，需要特殊处理的序列化和反序列化过程中应实现以下的方法：

private void writeObject（java.io.objectoutputstream流）抛出IOException；private void readObject（java.io.objectinputstream流）抛出IOException，时抛出；private void readobjectnodata()把objectstreamexception；

readObject方法负责阅读和使用相应的writeObject方法流写入的数据恢复其特定的类的对象的状态。该方法不需要担心自己属于其超类或子类的状态。状态是读数据从对象输入流对个人领域和分配对象的相应字段恢复。阅读原始数据类型支持的数据输入。

任何试图读取对象数据超过相应的writeObject方法编写自定义的数据边界将导致optionaldataexception被与真正的EOF字段值。非对象读取超过所分配的数据最终将反映在他们表示流的结尾相同的方式结束：该数据读取将返回1字节读取或读取到的字节数，而原始的阅读会把eofexceptions。如果没有相应的writeObject方法，则默认的序列化的数据标志着结束分配的数据结束。

原始对象读取电话发出的readexternal方法内的行为方式相同，如果流已经位于相应的writeExternal方法写入的数据读取结束，对象将optionaldataexceptions EOF设置为true，该读取将返回1，而原始的阅读会把eofexceptions。请注意，此行为不坚持用老ObjectStreamConstants.PROTOCOL_VERSION_1协议流，其中通过writeExternal方法写入的数据到底是不是清楚，因此无法检测。

的readobjectnodata方法负责初始化对象的状态的特定类型的事件，序列化流不列出给定类的父类被反序列化的对象。这可能的情况下，接受方使用不同版本的反序列化实例的类比发送方和接收器的版本出现，延伸是不是由发送者的版本扩展的类。这也可能如果序列化流已被篡改的发生；因此，readobjectnodata用于初始化反序列化对象尽管“敌意”或不完整的源与流。

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

当反序列化对象将被对象输入流和中止阅读过程中的任何异常。

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

枚举常量是不同于普通反序列化序列化或外部对象。一个枚举常量的序列化形式由其名称；的恒值不能被发送。反序列化一个枚举常量，对象输入流从流中读取常数名称；反序列化的常数，然后通过与枚举常量的基本类型和接收常数的名称作为参数调用静态方法Enum.valueOf(Class, String)获得。像其他序列化或外部对象，枚举常量可以作为反向引用的出现，随后在序列化流目标。通过枚举常数反序列化无法自定义过程：任何特定类的readObject，readobjectnodata，和枚举类型定义的实例方法被忽略在反序列化期间。同样，任何serialpersistentfields serialVersionUID字段声明或忽视了所有枚举类型有一个固定的serialVersionUID 0L。

从以下版本开始：

JDK1.1

另请参见：

DataInput， ObjectOutputStream， Serializable， Object Serialization Specification, Section 3, Object Input Classes

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	ObjectInputStream.GetField 提供对从输入流读取的持久字段的访问。

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	ObjectInputStream() 为子类，完全重新实现了ObjectInPutStream没有分配私有数据只是用于实现对象输入流的方式。
	ObjectInputStream(InputStream in) 创建一个对象输入流读取从指定的输入流。

方法摘要

Modifier and Type	Method and Description
int	available() 返回可以不阻塞读取的字节数。
void	close() 关闭输入流。
void	defaultReadObject() 从该流中读取当前类的非静态和非瞬态字段。
protected boolean	enableResolveObject(boolean enable) 使流能够允许从流中读取的对象被替换。
int	read() 读取一个字节的数据。
int	read(byte[] buf, int off, int len) 读入一个字节数组。
boolean	readBoolean() 在布尔值中读取。
byte	readByte() 读取一个8位字节。
char	readChar() 读取一个16位字符。
protected ObjectStreamClass	readClassDescriptor() 从序列化流中读取类描述符。
double	readDouble() 读一个64位的双。
ObjectInputStream.GetField	readFields() 从流中读取持久字段，并使它们可用名称命名。
float	readFloat() 读取一个32位浮点。
void	readFully(byte[] buf) 读取字节，阻塞，直到所有的字节都读。
void	readFully(byte[] buf, int off, int len) 读取字节，阻塞，直到所有的字节都读。
int	readInt() 读取一个32位int。
String	readLine() 过时的。 此方法没有正确地将字节转换为字符。详见和替代输入流。
long	readLong() 读一个64位长的。
Object	readObject() 从对象输入流对象。
protected Object	readObjectOverride() 这种方法被称为对象，通过构建保护对象使用无参数构造函数受信任的子类。
short	readShort() 读一个16位的短。
protected void	readStreamHeader() 的readstreamheader方法是提供让子类来读取和验证自己的流头。
Object	readUnshared() 读取对象输入流“独享”的对象。
int	readUnsignedByte() 读取一个无符号的8位字节。
int	readUnsignedShort() 读取一个无符号的16位短。
String	readUTF() 读 modified UTF-8格式字符串。
void	registerValidation(ObjectInputValidation obj, int prio) 在返回图形之前注册一个要验证的对象。
protected 类<?>	resolveClass(ObjectStreamClass desc) 加载指定的流类描述的本地类等价。
protected Object	resolveObject(Object obj) 这种方法将允许受信任的子类对象输入流用另一个来代替在反序列化期间。
protected 类<?>	resolveProxyClass(String[] interfaces) 返回实现代理类描述符中命名的接口的代理类；子类可以实现此方法从流中读取自定义数据以及动态代理类的描述符，从而允许它们使用接口和代理类的替代加载机制。
int	skipBytes(int len) 跳过的字节。

Methods inherited from class java.io.InputStream

mark, markSupported, read, reset, skip

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface java.io.ObjectInput

read, skip

Constructor Detail

ObjectInputStream

public ObjectInputStream(InputStream in)
                  throws IOException

创建一个对象输入流读取从指定的输入流。从流读取序列化流头并验证。此构造函数将阻塞直到相应的对象写了冲头。

如果安装了安全管理器，该构造函数将检查“enablesubclassimplementation”时，直接或间接地通过调用子类覆盖objectinputstream.readfields objectinputstream.readunshared方法或构造函数serializablepermission。

参数

in输入流读取

异常

StreamCorruptedException如果流头是不正确的

如果在阅读 IOException流头发生I/O错误

如果不受信任的子类重写 SecurityException非法安全敏感的方法

如果是 null in NullPointerException

另请参见：

ObjectInputStream()， readFields()， ObjectOutputStream.ObjectOutputStream(OutputStream)

ObjectInputStream

protected ObjectInputStream()
                     throws IOException,
                            SecurityException

为子类，完全重新实现了ObjectInPutStream没有分配私有数据只是用于实现对象输入流的方式。

如果存在安全管理器安装，这种方法首先调用与SerializablePermission("enableSubclassImplementation")权限安全管理的checkPermission方法保证可以使子类化。

异常

SecurityException -如果存在一个安全管理及其 checkPermission否认使子类化方法。

IOException -如果在创建此流发生I/O错误

另请参见：

SecurityManager.checkPermission(java.security.Permission)， SerializablePermission

方法详细信息

readObject

public final Object readObject()
                        throws IOException,
                               ClassNotFoundException

从对象输入流对象。该对象的类，类的签名，和价值观的非瞬态和非类及其所有类型的静态字段读取。默认的序列化一个类可以重写使用writeObject和readObject方法。对象，此对象引用的传递，阅读对象的完全等价的图形重建的readObject。

当所有的字段和它引用的对象完全恢复时，根对象完全恢复了。在这一点上验证回调对象依次执行基于注册的优先权。回调函数是注册的对象（在readObject方法）为他们单独恢复。

异常抛出的问题和用InputStream类不应该被反序列化。所有的异常都是致命的InputStream和离开它在一个不确定的状态；它是由调用者忽略或恢复流的状态。

Specified by:

readObject 接口 ObjectInput

结果

从流中读取的对象

异常

ClassNotFoundException -序列化对象的类不能被发现。

InvalidClassException -什么是一个用于序列化类错。

StreamCorruptedException -流中的控制信息不一致。

OptionalDataException原始数据而不是对象的流。

IOException -任何常见的输入/输出相关异常。

readObjectOverride

protected Object readObjectOverride()
                             throws IOException,
                                    ClassNotFoundException

这种方法被称为对象，通过构建保护对象使用无参数构造函数受信任的子类。该子类预计将提供一个重写方法与修改器“最终”。

结果

从流中读取的对象。

异常

ClassNotFoundException -序列化对象的类定义，不能被发现。

OptionalDataException原始数据而不是对象的流。

IOException如果I/O而从底层流读取时发生错误

从以下版本开始：

一点二

另请参见：

ObjectInputStream()， readObject()

readUnshared

public Object readUnshared()
                    throws IOException,
                           ClassNotFoundException

读取对象输入流“独享”的对象。此方法与readObject，除了防止随后调用readObject和readunshared返回附加引用反序列化实例通过电话了。具体来说：

• 如果readunshared称为反序列化后的参考（其中已写以前的流对象流表示），一个objectstreamexception将抛出。
• 如果readunshared成功返回，然后反序列化后引用的流处理反序列化的readunshared任何后续的企图将导致objectstreamexception被。

反序列化对象通过readunshared无效的流处理返回的对象关联。请注意，这本身并不能保证参考返回readunshared独特；反序列化的对象可以定义一个实例方法，返回一个对象，可见到另一方，或readunshared可能返回一个类对象或枚举的其他流或通过外部手段不断得到。如果反序列化的对象定义一个实例方法和该方法返回一个数组的调用，然后readunshared返回浅克隆那阵；这保证返回的数组对象是独特的，不可从一个调用readObject或readunshared在对象输入流一次，即使底层的数据流被操纵。

对象输入流的子类重写此方法只能在安全领域中具有“enablesubclassimplementation”serializablepermission构造；任何试图实例化子类无此权限会导致引发SecurityException。

结果

反序列化对象的引用

异常

ClassNotFoundException -如果一个类对象反序列化无法找到

StreamCorruptedException -如果在流控制信息不一致

ObjectStreamException如果对象反序列化已经出现在流

OptionalDataException如果原始数据是下一个流

IOException -如果在反序列化期间发生I/O错误

从以下版本开始：

一点四

defaultReadObject

public void defaultReadObject()
                       throws IOException,
                              ClassNotFoundException

从该流中读取当前类的非静态和非瞬态字段。这只能被类的readObject方法反序列化。如果这是所谓的否则把notactiveexception。

异常

ClassNotFoundException如果序列化对象的类不能被发现。

IOException如果I/O错误发生。

NotActiveException如果流不阅读对象。

readFields

public ObjectInputStream.GetField readFields()
                                      throws IOException,
                                             ClassNotFoundException

从流中读取持久字段，并使它们可用名称命名。

结果

代表被反序列化的对象持久性领域的 GetField对象

异常

ClassNotFoundException如果序列化对象的类不能被发现。

IOException如果I/O错误发生。

NotActiveException如果流不阅读对象。

从以下版本开始：

一点二

registerValidation

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

在返回图形之前注册一个要验证的对象。而类似resolveobject这些验证后，整个图形已经重组为。通常，一个readObject方法将登记对象的流，当所有的物体都恢复了最后一组验证可执行。

参数

obj -对象接收验证回调。

prio控制回调的顺序；零是一个很好的默认。使用更高的数字被称为早，为以后的回调数较低。在一个优先级，回调是在没有特定的顺序处理。

异常

NotActiveException -流不是当前阅读的对象是登记一个回调无效。

InvalidObjectException -验证对象是无效的。

resolveClass

protected 类<?> resolveClass(ObjectStreamClass desc)
                         throws IOException,
                                ClassNotFoundException

加载指定的流类描述的本地类等价。子类可以实现这种方法，让类从一个备用源中获取。

在ObjectOutputStream对应的方法是annotateClass。此方法将只为流中的每一个唯一类调用一次。该方法可以实现子类使用不同的加载机制，但必须返回一个类对象。一旦返回，如果类没有数组类，它是相对于serialVersionUID的序列化类的serialVersionUID，如果有一个错配，反序列化失败和InvalidClassException抛出。

在ObjectInputStream此方法的默认实现调用的返回结果

类。forName（描述getname()、虚假、装载机）

哪里 loader决定如下：如果有一个在当前线程的堆栈的声明类的自定义类装载器定义的方法（而不是生成实现反射调用），然后 loader是类装载器对应到最近的这种方法目前执行框架；否则， loader是 null。如果这个调用的结果在 ClassNotFoundException和过去的 ObjectStreamClass实例的名称是一个原始的类型或无效的java语言的关键字，然后 类对象表示简单类型或无效将返回（例如，与一名 "int" ObjectStreamClass将解决 Integer.TYPE）。否则，该 ClassNotFoundException就会抛给方法的调用者。

参数

desc - ObjectStreamClass类实例

结果

desc 类对象对应一个

异常

IOException -任何常见的输入/输出异常。

ClassNotFoundException如果序列化对象的类不能被发现。

resolveProxyClass

protected 类<?> resolveProxyClass(String[] interfaces)
                              throws IOException,
                                     ClassNotFoundException

返回实现代理类描述符中命名的接口的代理类；子类可以实现此方法从流中读取自定义数据以及动态代理类的描述符，从而允许它们使用接口和代理类的替代加载机制。

这种方法在流中的每一个唯一的代理类描述符被调用一次。

在ObjectOutputStream对应的方法是annotateProxyClass。对于一个给定的ObjectInputStream重写此方法的子类，在子类ObjectOutputStream相应的annotateProxyClass方法必须写任何数据或对象的读取方法。

在ObjectInputStream此方法的默认实现返回的，在interfaces参数命名的接口调用Proxy.getProxyClass 类对象列表的结果。每个接口的名称i 类对象是通过调用的返回值

类。（我，假，forName装载机）

哪里 loader是第一个非 null类装载器的执行堆栈，或 null如果没有非 null类装载器是在栈上（由 resolveClass方法使用相同的类装载器的选择）。除非解决接口是非公开的，同样的价值 loader也传递给 Proxy.getProxyClass类装载器；如果非公开的接口的存在，它们的类加载器通过相反（如果遇到多个非公开接口的类装载器是一个 IllegalAccessError抛出）。如果 Proxy.getProxyClass抛出一个 IllegalArgumentException， resolveProxyClass将 ClassNotFoundException含有 IllegalArgumentException。

参数

interfaces -接口名称进行反序列化代理类中的描述符列表

结果

指定接口的代理类

异常

IOException任何例外的基本 InputStream扔

ClassNotFoundException如果代理类或任何指定的接口不能被发现

从以下版本开始：

一点三

另请参见：

ObjectOutputStream.annotateProxyClass(Class)

resolveObject

protected Object resolveObject(Object obj)
                        throws IOException

这种方法将允许受信任的子类对象输入流用另一个来代替在反序列化期间。替换对象是残疾人直到enableresolveobject叫做。的enableresolveobject方法检查流请求解决对象是可以信任的。凡引用序列化对象传递给resolveobject。为了确保对象的私有状态不是无意暴露只有受信任的数据流可能使用resolveobject。

这种方法是在对象已读但之前返回从readObject叫。默认resolveobject方法只返回相同的对象。

当一个子类替换对象时，它必须确保被替换的对象与所存储的引用的每个字段都是兼容的。类型不是字段或数组元素的类型的子类的对象通过引发异常中止序列化，而对象是不被存储的。

此方法仅在第一次遇到每个对象时调用一次。所有后续对该对象的引用将被重定向到新的对象。

参数

obj对象被取代

结果

取代的对象

异常

IOException -任何常见的输入/输出异常。

enableResolveObject

protected boolean enableResolveObject(boolean enable)
                               throws SecurityException

使流能够允许从流中读取的对象被替换。当启用时，该resolveobject方法称为每个对象被反序列化。

如果使可能是真实的，并有一个安全管理安装，这种方法首先调用与SerializablePermission("enableSubstitution")权限安全管理的checkPermission方法保证可以使流允许对象从流中读取被取代。

参数

enable真正使每个对象反序列化的 resolveObject使用

结果

调用此方法之前的前一个设置

异常

SecurityException -如果存在一个安全管理及其 checkPermission方法拒绝使流允许对象从流中读取被取代。

另请参见：

SecurityManager.checkPermission(java.security.Permission)， SerializablePermission

readStreamHeader

protected void readStreamHeader()
                         throws IOException,
                                StreamCorruptedException

的readstreamheader方法是提供让子类来读取和验证自己的流头。它读取和验证魔法数和版本号。

异常

IOException -如果有I/O而从底层 InputStream读数误差

StreamCorruptedException -如果在流控制信息不一致

readClassDescriptor

protected ObjectStreamClass readClassDescriptor()
                                         throws IOException,
                                                ClassNotFoundException

从序列化流中读取类描述符。这种方法被称为当ObjectInPutStream预计类描述符作为下一个项目中的序列化流。子类可以重写此方法以对象输入流类的描述，已经写在非标准格式的读取（通过对象的子类的方法重写 writeClassDescriptor）。默认情况下，该方法根据对象序列化规范中定义的格式读取类描述符。

结果

类描述符读取

异常

IOException如果发生I/O错误。

ClassNotFoundException如果序列化对象的类中使用的描述符表示的类不能找到

从以下版本开始：

一点三

另请参见：

ObjectOutputStream.writeClassDescriptor(java.io.ObjectStreamClass)

read

public int read()
         throws IOException

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

Specified by:

read 接口 ObjectInput

Specified by:

read 方法重写，继承类 InputStream

结果

字节读，或-如果流结束的话- 1。

异常

IOException如果发生I/O错误。

read

public int read(byte[] buf,
                int off,
                int len)
         throws IOException

读入一个字节数组。这种方法将阻塞，直到有一些输入可用。考虑使用java.io.datainputstream.readfully读准确长度的字节。

Specified by:

read 接口 ObjectInput

重写：

read 方法重写，继承类 InputStream

参数

buf -缓冲区中读取数据

off的起始偏移量的数据

len -的最大字节数读

结果

读取的实际字节数，当流结束时- 1返回。

异常

IOException如果发生I/O错误。

另请参见：

DataInputStream.readFully(byte[],int,int)

available

public int available()
              throws IOException

返回可以不阻塞读取的字节数。

Specified by:

available 接口 ObjectInput

重写：

available 方法重写，继承类 InputStream

结果

可用字节数。

异常

IOException -如果有I/O而从底层 InputStream读数误差

close

public void close()
           throws IOException

关闭输入流。必须调用以释放与流关联的任何资源。

Specified by:

close 接口 Closeable

Specified by:

close 接口 ObjectInput

Specified by:

close 接口 AutoCloseable

重写：

close 方法重写，继承类 InputStream

异常

IOException如果发生I/O错误。

readBoolean

public boolean readBoolean()
                    throws IOException

在布尔值中读取。

Specified by:

readBoolean 接口 DataInput

结果

布尔读取。

异常

EOFException如果文件结束了。

IOException -如果发生其他I/O错误。

readByte

public byte readByte()
              throws IOException

读取一个8位字节。

Specified by:

readByte 接口 DataInput

结果

8位字节读。

异常

EOFException如果文件结束了。

IOException -如果发生其他I/O错误。

readUnsignedByte

public int readUnsignedByte()
                     throws IOException

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

Specified by:

readUnsignedByte 接口 DataInput

结果

8位字节读。

异常

EOFException如果文件结束了。

IOException -如果发生其他I/O错误。

readChar

public char readChar()
              throws IOException

读取一个16位字符。

Specified by:

readChar 接口 DataInput

结果

16位字符。

异常

EOFException如果文件结束了。

IOException -如果发生其他I/O错误。

readShort

public short readShort()
                throws IOException

读一个16位的短。

Specified by:

readShort 接口 DataInput

结果

16位短读。

异常

EOFException如果文件结束了。

IOException -如果发生其他I/O错误。

readUnsignedShort

public int readUnsignedShort()
                      throws IOException

读取一个无符号的16位短。

Specified by:

readUnsignedShort 接口 DataInput

结果

16位短读。

异常

EOFException如果文件结束了。

IOException -如果发生其他I/O错误。

readInt

public int readInt()
            throws IOException

读取一个32位int。

Specified by:

readInt 接口 DataInput

结果

32位整数读。

异常

EOFException如果文件结束了。

IOException -如果发生其他I/O错误。

readLong

public long readLong()
              throws IOException

读一个64位长的。

Specified by:

readLong 接口 DataInput

结果

读64位长。

异常

EOFException如果文件结束了。

IOException -如果发生其他I/O错误。

readFloat

public float readFloat()
                throws IOException

读取一个32位浮点。

Specified by:

readFloat 接口 DataInput

结果

32位浮点读。

异常

EOFException如果文件结束了。

IOException -如果发生其他I/O错误。

readDouble

public double readDouble()
                  throws IOException

读一个64位的双。

Specified by:

readDouble 接口 DataInput

结果

64位双读。

异常

EOFException如果文件结束了。

IOException -如果发生其他I/O错误。

readFully

public void readFully(byte[] buf)
               throws IOException

读取字节，阻塞，直到所有的字节都读。

Specified by:

readFully 接口 DataInput

参数

buf -缓冲区中读取数据

异常

EOFException如果文件结束了。

IOException -如果发生其他I/O错误。

readFully

public void readFully(byte[] buf,
                      int off,
                      int len)
               throws IOException

读取字节，阻塞，直到所有的字节都读。

Specified by:

readFully 接口 DataInput

参数

buf -缓冲区中读取数据

off的起始偏移量的数据

len -的最大字节数读

异常

EOFException如果文件结束了。

IOException -如果发生其他I/O错误。

skipBytes

public int skipBytes(int len)
              throws IOException

跳过的字节。

Specified by:

skipBytes 接口 DataInput

参数

len -字节数被跳过

结果

跳过的实际字节数。

异常

IOException如果发生I/O错误。

readLine

@Deprecated
public String readLine()
                            throws IOException

过时的。 此方法没有正确地将字节转换为字符。详见和替代输入流。

读取一行，已由一个n，R终止，\r\n或EOF。

Specified by:

readLine 接口 DataInput

结果

线的字符串拷贝。

异常

IOException -如果有I/O而从底层 InputStream读数误差

readUTF

public String readUTF()
               throws IOException

读 modified UTF-8格式字符串。

Specified by:

readUTF 接口 DataInput

结果

字符串。

异常

IOException -如果有I/O而从底层 InputStream读数误差

UTFDataFormatException如果读取的字节数不代表一个有效的UTF-8字符串编码的改进