当前页面: 在线文档首页 > JavaTM 2 Platform Standard Edition 6.0 API 规范中文版

类 java.io.IOException 的使用 (Java Platform SE 6) - JavaTM 2 Platform Standard Edition 6.0 API 规范中文版

---

概述  软件包  类   使用  树  已过时  索引  帮助		JavaTM Platform Standard Ed. 6
上一个   下一个	框架    无框架

---

类 java.io.IOException
的使用

使用 IOException 的软件包
java.applet	提供创建 applet 所必需的类和 applet 用来与其 applet 上下文通信的类。
java.awt	包含用于创建用户界面和绘制图形图像的所有类。
java.awt.color	提供用于颜色空间的类。
java.awt.datatransfer	提供在应用程序之间和在应用程序内部传输数据的接口和类。
java.awt.dnd	Drag 和 Drop 是一种直接操作动作，在许多图形用户界面系统中都会遇到它，它提供了一种机制，能够在两个与 GUI 中显示元素逻辑相关的实体之间传输信息。
java.awt.print	为通用的打印 API 提供类和接口。
java.beans	包含与开发 beans 有关的类，即基于 JavaBeansTM 架构的组件。
java.beans.beancontext	提供与 bean 上下文有关的类和接口。
java.io	通过数据流、序列化和文件系统提供系统输入和输出。
java.lang	提供利用 Java 编程语言进行程序设计的基础类。
java.lang.management	提供管理接口，用于监视和管理 Java 虚拟机以及 Java 虚拟机在其上运行的操作系统。
java.net	为实现网络应用程序提供类。
java.nio	定义作为数据容器的缓冲区，并提供其他 NIO 包的概述。
java.nio.channels	定义了各种通道，这些通道表示到能够执行 I/O 操作的实体（如文件和套接字）的连接；定义了用于多路复用的、非阻塞 I/O 操作的选择器。
java.nio.channels.spi	用于 java.nio.channels 包的服务提供者类。
java.nio.charset	定义用来在字节和 Unicode 字符之间转换的 charset、解码器和编码器。
java.rmi	提供 RMI 包。
java.rmi.activation	为 RMI 对象激活提供支持。
java.rmi.server	提供支持服务器端 RMI 的类和接口。
java.security	为安全框架提供类和接口。
java.security.cert	提供用于解析和管理证书、证书撤消列表 (CRL) 和证书路径的类和接口。
java.util	包含 collection 框架、遗留的 collection 类、事件模型、日期和时间设施、国际化和各种实用工具类（字符串标记生成器、随机数生成器和位数组）。
java.util.jar	提供读写 JAR (Java ARchive) 文件格式的类，该格式基于具有可选清单文件的标准 ZIP 文件格式。
java.util.logging	提供 JavaTM 2 平台核心日志工具的类和接口。
java.util.prefs	此包允许应用程序存储并获取用户和系统首选项和配置数据。
java.util.zip	提供用于读写标准 ZIP 和 GZIP 文件格式的类。
javax.activation
javax.activity	包含解组期间通过 ORB 机制抛出的与 Activity 服务有关的异常。
javax.annotation.processing	用来声明注释处理器并允许注释处理器与注释处理工具环境通信的工具。
javax.crypto	为加密操作提供类和接口。
javax.imageio	Java Image I/O API 的主要包。
javax.imageio.metadata	用于处理读写元数据的 Java Image I/O API 的包。
javax.imageio.spi	包含用于 reader、writer、transcoder 和流的插件接口以及一个运行时注册表的 Java Image I/O API 包。
javax.imageio.stream	Java Image I/O API 的一个包，用来处理从文件和流中产生的低级别 I/O。
javax.management	提供 Java Management Extensions 的核心类。
javax.management.loading	提供实现高级动态加载的类。
javax.management.remote	对 JMX MBean 服务器进行远程访问使用的接口。
javax.management.remote.rmi	RMI 连接器是供 JMX Remote API 使用的一种连接器，后者使用 RMI 将客户端请求传输到远程 MBean 服务器。
javax.naming.ldap	提供对 LDAPv3 扩展操作和控件的支持。
javax.net	提供用于网络应用程序的类。
javax.net.ssl	提供用于安全套接字包的类。
javax.print	为 JavaTM Print Service API 提供了主要类和接口。
javax.rmi.CORBA	包含用于 RMI-IIOP 的可移植性 API。
javax.rmi.ssl	通过安全套接字层 (SSL) 或传输层安全 (TLS) 协议提供 RMIClientSocketFactory 和 RMIServerSocketFactory 的实现。
javax.security.auth.callback	此包提供与应用程序进行交互所必需的类，以便检索信息（例如，包括用户名和密码的验证数据）或显示信息（例如，错误和警告消息）。
javax.security.sasl	包含用于支持 SASL 的类和接口。
javax.sound.midi	提供用于 MIDI（音乐乐器数字接口）数据的 I/O、序列化和合成的接口和类。
javax.sound.midi.spi	在提供新的 MIDI 设备、MIDI 文件 reader 和 writer、或音库 reader 时提供服务提供者要实现的接口。
javax.sound.sampled	提供用于捕获、处理和回放取样的音频数据的接口和类。
javax.sound.sampled.spi	在提供新音频设备、声音文件 reader 和 writer，或音频格式转换器时，提供将为其创建子类的服务提供者的抽象类。
javax.sql.rowset	JDBC RowSet 实现的标准接口和基类。
javax.swing	提供一组“轻量级”（全部是 Java 语言）组件，尽量让这些组件在所有平台上的工作方式都相同。
javax.swing.filechooser	包含 JFileChooser 组件使用的类和接口。
javax.swing.plaf.synth	Synth 是一个可更换皮肤 (skinnable) 的外观，在其中可委托所有绘制。
javax.swing.text	提供类 HTMLEditorKit 和创建 HTML 文本编辑器的支持类。
javax.swing.text.html	提供类 HTMLEditorKit 和创建 HTML 文本编辑器的支持类。
javax.swing.text.html.parser	提供默认的 HTML 解析器以及支持类。
javax.swing.text.rtf	提供一个类 (RTFEditorKit)，用于创建富文本格式（Rich-Text-Format）的文本编辑器。
javax.tools	为能够从程序（例如，编译器）中调用的工具提供接口。
javax.transaction	包含解组期间通过 ORB 机制抛出的三个异常。
javax.xml.bind	为包含解组、编组和验证功能的客户端应用程序提供运行时绑定框架。
javax.xml.parsers	提供允许处理 XML 文档的类。
javax.xml.soap	提供用于创建和构建 SOAP 消息的 API。
javax.xml.validation	此包提供了用于 XML 文档验证的 API。
org.omg.CORBA.portable	提供可移植性层，即可以使一个供应商生成的代码运行在另一个供应商 ORB 上的 ORB API 集合。
org.xml.sax	此包提供了核心 SAX API。
org.xml.sax.ext	此包包含适合的 SAX 驱动程序不一定支持的 SAX2 设施的接口。
org.xml.sax.helpers	此包包含“帮助器”类，其中包括对引导基于 SAX 的应用程序的支持。

 

java.applet 中 IOException 的使用

 

抛出 IOException 的 java.applet 中的方法
void	AppletContext.setStream(String key, InputStream stream)           在此 applet 上下文中用指定的键关联指定的流。

 

java.awt 中 IOException 的使用

 

抛出 IOException 的 java.awt 中的方法
void	Desktop.browse(URI uri)           启动默认浏览器来显示 URI。
static Font	Font.createFont(int fontFormat, File fontFile)           返回一个使用指定字体类型和指定字体文件的新 Font。
static Font	Font.createFont(int fontFormat, InputStream fontStream)           返回一个使用指定字体类型和输入数据的新 Font。
void	Desktop.edit(File file)           启动关联编辑器应用程序并打开用于编辑的文件。
void	Desktop.mail()           启动用户默认邮件客户端的邮件组合窗口。
void	Desktop.mail(URI mailtoURI)           启动用户默认邮件客户端的邮件组合窗口，填充由 mailto: URI 指定的消息字段。
void	Desktop.open(File file)           启动关联应用程序来打开文件。
void	Desktop.print(File file)           使用关联应用程序的打印命令，用本机桌面打印设施来打印文件。
protected static void	AWTEventMulticaster.save(ObjectOutputStream s, String k, EventListener l)
protected  void	AWTEventMulticaster.saveInternal(ObjectOutputStream s, String k)
void	SplashScreen.setImageURL(URL imageURL)           更改闪现屏幕图像。

 

java.awt.color 中 IOException 的使用

 

抛出 IOException 的 java.awt.color 中的方法
static ICC_Profile	ICC_Profile.getInstance(InputStream s)           构造一个与 InputStream 中的数据相对应的 ICC_Profile。
static ICC_Profile	ICC_Profile.getInstance(String fileName)           构造一个与文件中的数据相对应的 ICC_Profile。
void	ICC_Profile.write(OutputStream s)           将 ICC_Profile 写入一个 OutputStream。
void	ICC_Profile.write(String fileName)           将此 ICC_Profile 写入一个文件。

 

java.awt.datatransfer 中 IOException 的使用

 

抛出 IOException 的 java.awt.datatransfer 中的方法
Object	Clipboard.getData(DataFlavor flavor)           返回一个对象，表示此剪贴板中指定 DataFlavor 类型的当前内容。
Reader	DataFlavor.getReaderForText(Transferable transferable)           获取文本 flavor 的 Reader，如果需要，则为期望的 charset（编码的）解码。
Object	StringSelection.getTransferData(DataFlavor flavor)           如果可能，则使用请求的 DataFlavor 返回 Transferable 的数据。
Object	Transferable.getTransferData(DataFlavor flavor)           返回一个对象，该对象表示将要被传输的数据。
void	DataFlavor.readExternal(ObjectInput is)           根据 Serialized 状态还原此 DataFlavor。
void	DataFlavor.writeExternal(ObjectOutput os)           序列化此 DataFlavor。

 

java.awt.dnd 中 IOException 的使用

 

抛出 IOException 的 java.awt.dnd 中的方法
Object	DropTargetContext.TransferableProxy.getTransferData(DataFlavor df)           返回一个对象，该对象表示数据是由封装的 transferable 为所请求的数据 flavor 提供的。

 

java.awt.print 中 IOException 的使用

 

返回 IOException 的 java.awt.print 中的方法
IOException	PrinterIOException.getIOException()           返回终止打印作业的 IOException。

 

参数类型为 IOException 的 java.awt.print 中的构造方法
PrinterIOException(IOException exception)           构造具有指定 IOException 字符串表示形式的新 PrinterIOException。

 

java.beans 中 IOException 的使用

 

抛出 IOException 的 java.beans 中的方法
static Object	Beans.instantiate(ClassLoader cls, String beanName)            实例化 JavaBean。
static Object	Beans.instantiate(ClassLoader cls, String beanName, BeanContext beanContext)            实例化 JavaBean。
static Object	Beans.instantiate(ClassLoader cls, String beanName, BeanContext beanContext, AppletInitializer initializer)           实例化 bean。

 

java.beans.beancontext 中 IOException 的使用

 

抛出 IOException 的 java.beans.beancontext 中的方法
protected  void	BeanContextServicesSupport.bcsPreDeserializationHook(ObjectInputStream ois)           在反序列化子级之前，从 BeanContextSupport readObject 中调用。
protected  void	BeanContextSupport.bcsPreDeserializationHook(ObjectInputStream ois)           在调用 defaultReadObject() 之后，但在反序列化任意子级之前，由 readObject 调用。
protected  void	BeanContextServicesSupport.bcsPreSerializationHook(ObjectOutputStream oos)           在序列化子级之前，从 BeanContextSupport writeObject 中调用。
protected  void	BeanContextSupport.bcsPreSerializationHook(ObjectOutputStream oos)           在调用 defaultWriteObject() 之后，但在序列化当前可序列化子级之前，由 writeObject 调用。
protected  void	BeanContextSupport.deserialize(ObjectInputStream ois, Collection coll)           readObject 使用此方法来反序列化一个 collection。
Object	BeanContext.instantiateChild(String beanName)           实例化指定为此 BeanContext 的一个子级的 javaBean。
Object	BeanContextSupport.instantiateChild(String beanName)            instantiateChild 方法是 BeanContext 中的便捷钩子 (hook)，用来简化将嵌套的 Bean 实例化为 BeanContext 这项任务。
void	BeanContextSupport.readChildren(ObjectInputStream ois)           在将此类的实例用作 BeanContext 协议（及其子协议）实现的代理时，在反序列化期间存在一个“先有鸡还是先有蛋”的问题。
protected  void	BeanContextSupport.serialize(ObjectOutputStream oos, Collection coll)           writeObject 使用此方法来序列化一个 Collection。
void	BeanContextSupport.writeChildren(ObjectOutputStream oos)           用于序列化此 BeanContext 的所有子级。

 

java.io 中 IOException 的使用

 

java.io 中 IOException 的子类
class	CharConversionException           用于字符转换异常的基类。
class	EOFException           当输入过程中意外到达文件或流的末尾时，抛出此异常。
class	FileNotFoundException           当试图打开指定路径名表示的文件失败时，抛出此异常。
class	InterruptedIOException           I/O 操作已中断信号，抛出此异常。
class	InvalidClassException           当 Serialization 运行时检测到某个类具有以下问题之一时，抛出此异常。
class	InvalidObjectException           指示一个或多个反序列化对象未通过验证测试。
class	NotActiveException           当序列化和反序列化不活动时，抛出此异常。
class	NotSerializableException           当实例需要具有序列化接口时，抛出此异常。
class	ObjectStreamException           特定于 Object Stream 类的所有异常的超类。
class	OptionalDataException           指示对象读取操作失败的异常，原因是无法读取流中的基本数据或已序列化对象的数据末尾。
class	StreamCorruptedException           当从对象流中读取的控制信息与内部一致性检查相冲突时，抛出此异常。
class	SyncFailedException           当 sync 操作失败时，抛出此异常。
class	UnsupportedEncodingException           不支持字符编码。
class	UTFDataFormatException           在数据输入流中或由实现该数据输入接口的任何类中以 UTF-8 修改版格式读取错误字符串时，抛出此异常。
class	WriteAbortedException           在写入操作过程中抛出 ObjectStreamException 之一的信号。

 

抛出 IOException 的 java.io 中的方法
protected  void	ObjectOutputStream.annotateClass(Class<?> cl)           子类可以实现此方法，从而允许在流中存储类数据。
protected  void	ObjectOutputStream.annotateProxyClass(Class<?> cl)           子类可以实现此方法，从而在流中存储定制数据和动态代理类的描述符。
Writer	Writer.append(char c)           将指定字符添加到此 writer。
Writer	Writer.append(CharSequence csq)           将指定字符序列添加到此 writer。
Writer	Writer.append(CharSequence csq, int start, int end)           将指定字符序列的子序列添加到此 writer.Appendable。
int	LineNumberInputStream.available()           已过时。 无阻塞情况下返回可以从此输入流中读取的字节数。
int	PipedInputStream.available()           返回可以不受阻塞地从此输入流中读取的字节数。
int	SequenceInputStream.available()           返回不受阻塞地从当前底层输入流读取（或跳过）的字节数的估计值，方法是通过下一次调用当前底层输入流的方法。
int	PushbackInputStream.available()           返回可以不受下一次调用此输入流的方法阻塞地从此输入流读取（或跳过）的估计字节数。
int	ObjectInputStream.available()           返回可以不受阻塞地读取的字节数。
int	ObjectInput.available()           返回可以无阻塞地读取的字节数。
int	BufferedInputStream.available()           返回可以从此输入流读取（或跳过）、且不受此输入流接下来的方法调用阻塞的估计字节数。
int	FilterInputStream.available()           返回下一次对此输入流调用的方法可以不受阻塞地从此输入流读取（或跳过）的估计剩余字节数。
int	FileInputStream.available()           返回下一次对此输入流调用的方法可以不受阻塞地从此输入流读取（或跳过）的估计剩余字节数。
int	InputStream.available()           返回此输入流下一个方法调用可以不受阻塞地从此输入流读取（或跳过）的估计字节数。
void	FilterWriter.close()
void	PipedInputStream.close()           关闭此管道输入流并释放与该流相关的所有系统资源。
void	PipedOutputStream.close()           关闭此管道输出流并释放与此流有关的所有系统资源。
void	PipedReader.close()           关闭此传送流并释放与该流相关的所有系统资源。
void	PipedWriter.close()           关闭此管道输出流并释放与此流相关的所有系统资源。
void	PushbackReader.close()           关闭该流并释放与之关联的所有系统资源。
void	SequenceInputStream.close()           关闭此输入流并释放与此流关联的所有系统资源。
void	PushbackInputStream.close()           关闭此输入流并释放与该流关联的所有系统资源。
void	StringWriter.close()           关闭 StringWriter 无效。
void	FilterReader.close()
void	RandomAccessFile.close()           关闭此随机访问文件流并释放与该流关联的所有系统资源。
void	ByteArrayOutputStream.close()           关闭 ByteArrayOutputStream 无效。
void	ByteArrayInputStream.close()           关闭 ByteArrayInputStream 无效。
void	ObjectInputStream.close()           关闭输入流。
void	ObjectInput.close()           关闭输入流。
void	ObjectOutputStream.close()           关闭流。
void	ObjectOutput.close()           关闭该流。
void	InputStreamReader.close()
void	BufferedReader.close()
abstract  void	Reader.close()           关闭该流并释放与之关联的所有资源。
void	BufferedWriter.close()
void	OutputStreamWriter.close()
abstract  void	Writer.close()           关闭此流，但要先刷新它。
void	FilterOutputStream.close()           关闭此输出流并释放与此流有关的所有系统资源。
void	BufferedInputStream.close()           关闭此输入流并释放与该流关联的所有系统资源。
void	FilterInputStream.close()           关闭此输入流并释放与此流关联的所有系统资源。
void	FileOutputStream.close()           关闭此文件输出流并释放与此流有关的所有系统资源。
void	OutputStream.close()           关闭此输出流并释放与此流有关的所有系统资源。
void	FileInputStream.close()           关闭此文件输入流并释放与此流有关的所有系统资源。
void	InputStream.close()           关闭此输入流并释放与该流关联的所有系统资源。
void	Closeable.close()           关闭此流并释放与此流关联的所有系统资源。
void	PipedOutputStream.connect(PipedInputStream snk)           将此管道输出流连接到接收者。
void	PipedInputStream.connect(PipedOutputStream src)           使此管道输入流连接到管道输出流 src。
void	PipedWriter.connect(PipedReader snk)           将此传送 writer 连接到接收方。
void	PipedReader.connect(PipedWriter src)           使此传送 reader 连接到传送 writer src。
boolean	File.createNewFile()           当且仅当不存在具有此抽象路径名指定名称的文件时，不可分地创建一个新的空文件。
static File	File.createTempFile(String prefix, String suffix)           在默认临时文件目录中创建一个空文件，使用给定前缀和后缀生成其名称。
static File	File.createTempFile(String prefix, String suffix, File directory)            在指定目录中创建一个新的空文件，使用给定的前缀和后缀字符串生成其名称。
abstract  boolean	ObjectInputStream.GetField.defaulted(String name)           如果指定的字段是默认字段并且在此流中不存在任何值，则返回 true。
void	ObjectInputStream.defaultReadObject()           从此流读取当前类的非静态和非瞬态字段。
void	ObjectOutputStream.defaultWriteObject()           将当前类的非静态和非瞬态字段写入此流。
protected  void	ObjectOutputStream.drain()           排空 ObjectOutputStream 中的所有已缓冲数据。
protected  void	FileOutputStream.finalize()           清理到文件的连接，并确保在不再引用此文件输出流时调用此流的 close 方法。
protected  void	FileInputStream.finalize()           确保在不再引用文件输入流时调用其 close 方法。
void	FilterWriter.flush()           刷新该流的缓冲。
void	PipedOutputStream.flush()           刷新此输出流并强制写出所有缓冲的输出字节。
void	PipedWriter.flush()           刷新此输出流并强制写出所有缓冲的输出字符。
void	DataOutputStream.flush()           清空此数据输出流。
void	ObjectOutputStream.flush()           刷新该流的缓冲。
void	ObjectOutput.flush()           刷新该流的缓冲。
void	BufferedWriter.flush()           刷新该流的缓冲。
void	OutputStreamWriter.flush()           刷新该流的缓冲。
abstract  void	Writer.flush()           刷新该流的缓冲。
void	BufferedOutputStream.flush()           刷新此缓冲的输出流。
void	FilterOutputStream.flush()           刷新此输出流，并强制将所有已缓冲的输出字节写入该流中。
void	OutputStream.flush()           刷新此输出流并强制写出所有缓冲的输出字节。
void	Flushable.flush()           通过将所有已缓冲输出写入底层流来刷新此流。
abstract  boolean	ObjectInputStream.GetField.get(String name, boolean val)           从持久字段获取指定的 boolean 字段值。
abstract  byte	ObjectInputStream.GetField.get(String name, byte val)           从持久字段获取指定字节字段的值。
abstract  char	ObjectInputStream.GetField.get(String name, char val)           从持久字段获取指定 char 字段的值。
abstract  double	ObjectInputStream.GetField.get(String name, double val)           从持久字段获取指定 double 字段的值。
abstract  float	ObjectInputStream.GetField.get(String name, float val)           从持久字段获取指定 float 字段的值。
abstract  int	ObjectInputStream.GetField.get(String name, int val)           从持久字段获取指定的 int 字段值。
abstract  long	ObjectInputStream.GetField.get(String name, long val)           从持久字段获取指定 long 字段的值。
abstract  Object	ObjectInputStream.GetField.get(String name, Object val)           从持久字段获取指定 Object 字段的值。
abstract  short	ObjectInputStream.GetField.get(String name, short val)           从持久字段获取指定的 short 字段值。
File	File.getCanonicalFile()           返回此抽象路径名的规范形式。
String	File.getCanonicalPath()           返回此抽象路径名的规范路径名字符串。
FileDescriptor	RandomAccessFile.getFD()           返回与此流关联的不透明文件描述符对象。
FileDescriptor	FileOutputStream.getFD()           返回与此流有关的文件描述符。
FileDescriptor	FileInputStream.getFD()           返回表示到文件系统中实际文件的连接的 FileDescriptor 对象，该文件系统正被此 FileInputStream 使用。
long	RandomAccessFile.getFilePointer()           返回此文件中的当前偏移量。
long	RandomAccessFile.length()           返回此文件的长度。
void	CharArrayReader.mark(int readAheadLimit)           标记流中的当前位置。
void	LineNumberReader.mark(int readAheadLimit)           标记该流中的当前位置。
void	PushbackReader.mark(int readAheadLimit)           标记流中的当前位置。
void	FilterReader.mark(int readAheadLimit)           在流中的当前位置上作标记。
void	StringReader.mark(int readAheadLimit)           标记流中的当前位置。
void	BufferedReader.mark(int readAheadLimit)           标记流中的当前位置。
void	Reader.mark(int readAheadLimit)           标记流中的当前位置。
void	BufferedWriter.newLine()           写入一个行分隔符。
int	StreamTokenizer.nextToken()           从此标记生成器的输入流中解析下一个标记。
ObjectOutputStream.PutField	ObjectOutputStream.putFields()           获取用于缓冲写入流中的持久存储字段的对象。
int	CharArrayReader.read()           读取单个字符。
int	LineNumberInputStream.read()           已过时。 从此输入流读取下一个数据字节。
int	LineNumberReader.read()           读取单个字符。
int	PipedInputStream.read()           读取此管道输入流中的下一个数据字节。
int	PipedReader.read()           读取此传送流中的下一个数据字符。
int	PushbackReader.read()           读取单个字符。
int	SequenceInputStream.read()           从此输入流中读取下一个数据字节。
int	PushbackInputStream.read()           从此输入流中读取下一个数据字节。
int	FilterReader.read()           读取单个字符。
int	StringReader.read()           读取单个字符。
int	RandomAccessFile.read()           从此文件中读取一个数据字节。
int	ObjectInputStream.read()           读取数据字节。
int	ObjectInput.read()           读取数据字节。
int	InputStreamReader.read()           读取单个字符。
int	BufferedReader.read()           读取单个字符。
int	Reader.read()           读取单个字符。
int	BufferedInputStream.read()           参见 InputStream 的 read 方法的常规协定。
int	FilterInputStream.read()           从此输入流中读取下一个数据字节。
int	FileInputStream.read()           从此输入流中读取一个数据字节。
abstract  int	InputStream.read()           从输入流中读取数据的下一个字节。
int	RandomAccessFile.read(byte[] b)           将最多 b.length 个数据字节从此文件读入 byte 数组。
int	ObjectInput.read(byte[] b)           读入 byte 数组。
int	DataInputStream.read(byte[] b)           从包含的输入流中读取一定数量的字节，并将它们存储到缓冲区数组 b 中。
int	FilterInputStream.read(byte[] b)           从此输入流中将 byte.length 个字节的数据读入一个 byte 数组中。
int	FileInputStream.read(byte[] b)           从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。
int	InputStream.read(byte[] b)           从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。
int	LineNumberInputStream.read(byte[] b, int off, int len)           已过时。 将最多 len 个数据字节从此输入流读入 byte 数组。
int	PipedInputStream.read(byte[] b, int off, int len)           将最多 len 个数据字节从此管道输入流读入 byte 数组。
int	SequenceInputStream.read(byte[] b, int off, int len)           将最多 len 个数据字节从此输入流读入 byte 数组。
int	PushbackInputStream.read(byte[] b, int off, int len)           从此输入流将最多 len 个数据字节读入 byte 数组。
int	RandomAccessFile.read(byte[] b, int off, int len)           将最多 len 个数据字节从此文件读入 byte 数组。
int	ObjectInputStream.read(byte[] buf, int off, int len)           读入 byte 数组。
int	ObjectInput.read(byte[] b, int off, int len)           读入 byte 数组。
int	DataInputStream.read(byte[] b, int off, int len)           从包含的输入流中将最多 len 个字节读入一个 byte 数组中。
int	BufferedInputStream.read(byte[] b, int off, int len)           从此字节输入流中给定偏移量处开始将各字节读取到指定的 byte 数组中。
int	FilterInputStream.read(byte[] b, int off, int len)           从此输入流中将 len 个字节的数据读入一个 byte 数组中。
int	FileInputStream.read(byte[] b, int off, int len)           从此输入流中将最多 len 个字节的数据读入一个 byte 数组中。
int	InputStream.read(byte[] b, int off, int len)           将输入流中最多 len 个数据字节读入 byte 数组。
int	Reader.read(char[] cbuf)           将字符读入数组。
int	CharArrayReader.read(char[] b, int off, int len)           将字符读入数组的某一部分。
int	LineNumberReader.read(char[] cbuf, int off, int len)           将字符读入数组中的某一部分。
int	PipedReader.read(char[] cbuf, int off, int len)           将此传送流中最多 len 个数据字符读入字符数组。
int	PushbackReader.read(char[] cbuf, int off, int len)           将字符读入数组的某一部分。
int	FilterReader.read(char[] cbuf, int off, int len)           将字符读入数组的某一部分。
int	StringReader.read(char[] cbuf, int off, int len)           将字符读入数组的某一部分。
int	InputStreamReader.read(char[] cbuf, int offset, int length)           将字符读入数组中的某一部分。
int	BufferedReader.read(char[] cbuf, int off, int len)           将字符读入数组的某一部分。
abstract  int	Reader.read(char[] cbuf, int off, int len)           将字符读入数组的某一部分。
int	Reader.read(CharBuffer target)           试图将字符读入指定的字符缓冲区。
boolean	RandomAccessFile.readBoolean()           从此文件读取一个 boolean。
boolean	ObjectInputStream.readBoolean()           读取一个 boolean 值。
boolean	DataInputStream.readBoolean()           参见 DataInput 的 readBoolean 方法的常规协定。
boolean	DataInput.readBoolean()           读取一个输入字节，如果该字节不是零，则返回 true，如果是零，则返回 false。
byte	RandomAccessFile.readByte()           从此文件读取一个有符号的八位值。
byte	ObjectInputStream.readByte()           读取一个 8 位的字节。
byte	DataInputStream.readByte()           参见 DataInput 的 readByte 方法的常规协定。
byte	DataInput.readByte()           读取并返回一个输入字节。
char	RandomAccessFile.readChar()           从此文件读取一个字符。
char	ObjectInputStream.readChar()           读取一个 16 位的 char 值。
char	DataInputStream.readChar()           参见 DataInput 的 readChar 方法的常规协定。
char	DataInput.readChar()           读取两个输入字节并返回一个 char 值。
protected  ObjectStreamClass	ObjectInputStream.readClassDescriptor()           从序列化流读取类描述符。
double	RandomAccessFile.readDouble()           从此文件读取一个 double。
double	ObjectInputStream.readDouble()           读取一个 64 位的 double 值。
double	DataInputStream.readDouble()           参见 DataInput 的 readDouble 方法的常规协定。
double	DataInput.readDouble()           读取八个输入字节并返回一个 double 值。
void	Externalizable.readExternal(ObjectInput in)           对象实现 readExternal 方法来恢复其内容，它通过调用 DataInput 的方法来恢复其基础类型，调用 readObject 来恢复对象、字符串和数组。
ObjectInputStream.GetField	ObjectInputStream.readFields()           按名称从流中读取持久字段并使其可用。
float	RandomAccessFile.readFloat()           从此文件读取一个 float。
float	ObjectInputStream.readFloat()           读取一个 32 位的 float 值。
float	DataInputStream.readFloat()           参见 DataInput 的 readFloat 方法的常规协定。
float	DataInput.readFloat()           读取四个输入字节并返回一个 float 值。
void	RandomAccessFile.readFully(byte[] b)           将 b.length 个字节从此文件读入 byte 数组，并从当前文件指针开始。
void	ObjectInputStream.readFully(byte[] buf)           读取字节，同时阻塞直至读取所有字节。
void	DataInputStream.readFully(byte[] b)           参见 DataInput 的 readFully 方法的常规协定。
void	DataInput.readFully(byte[] b)           从输入流中读取一些字节，并将它们存储在缓冲区数组 b 中。
void	RandomAccessFile.readFully(byte[] b, int off, int len)           将正好 len 个字节从此文件读入 byte 数组，并从当前文件指针开始。
void	ObjectInputStream.readFully(byte[] buf, int off, int len)           读取字节，同时阻塞直至读取所有字节。
void	DataInputStream.readFully(byte[] b, int off, int len)           参见 DataInput 的 readFully 方法的常规协定。
void	DataInput.readFully(byte[] b, int off, int len)           从输入流中读取 len 个字节。
int	RandomAccessFile.readInt()           从此文件读取一个有符号的 32 位整数。