类 java.io.IOException 的使用 (Java Platform SE 6)

概述

软件包

类

使用

树

已过时

索引

帮助

Java^TM 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 有关的类，即基于 JavaBeans^TM 架构的组件。
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	提供 Java^TM 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	为 Java^TM 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 位整数。
`int`	`ObjectInputStream.readInt()` 读取一个 32 位的 int 值。
`int`	`DataInputStream.readInt()` 参见 `DataInput` 的 `readInt` 方法的常规协定。
`int`	`DataInput.readInt()` 读取四个输入字节并返回一个 `int` 值。
`String`	`LineNumberReader.readLine()` 读取文本行。
`String`	`RandomAccessFile.readLine()` 从此文件读取文本的下一行。
`String`	`ObjectInputStream.readLine()` 已过时。此方法不能正确地将字节转换为字符。请参见 DataInputStream 以获取详细信息和替代方法。
`String`	`DataInputStream.readLine()` 已过时。该方法无法将字节正确转换为字符。从 JDK 1.1 开始，读取文本行的首选方法是使用 `BufferedReader.readLine()` 方法。使用 `DataInputStream` 类读取文本行的程序可以改为使用 `BufferedReader` 类，只要将以下形式的代码： DataInputStream d = new DataInputStream(in); 替换为： BufferedReader d = new BufferedReader(new InputStreamReader(in));
`String`	`DataInput.readLine()` 从输入流中读取下一文本行。
`String`	`BufferedReader.readLine()` 读取一个文本行。
`long`	`RandomAccessFile.readLong()` 从此文件读取一个有符号的 64 位整数。
`long`	`ObjectInputStream.readLong()` 读取一个 64 位的 long 值。
`long`	`DataInputStream.readLong()` 参见 `DataInput` 的 `readLong` 方法的常规协定。
`long`	`DataInput.readLong()` 读取八个输入字节并返回一个 `long` 值。
`Object`	`ObjectInputStream.readObject()` 从 ObjectInputStream 读取对象。
`Object`	`ObjectInput.readObject()` 读取并返回对象。
`protected Object`	`ObjectInputStream.readObjectOverride()` 此方法由 ObjectOutputStream 的受信任子类调用，这些子类使用受保护的无参数构造方法构造 ObjectOutputStream。
`short`	`RandomAccessFile.readShort()` 从此文件读取一个有符号的 16 位数。
`short`	`ObjectInputStream.readShort()` 读取一个 16 位的 short 值。
`short`	`DataInputStream.readShort()` 参见 `DataInput` 的 `readShort` 方法的常规协定。
`short`	`DataInput.readShort()` 读取两个输入字节并返回一个 `short` 值。
`protected void`	`ObjectInputStream.readStreamHeader()` 提供的 readStreamHeader 方法允许子类读取并验证它们自己的流头部。
`Object`	`ObjectInputStream.readUnshared()` 从 ObjectInputStream 读取“非共享”对象。
`int`	`RandomAccessFile.readUnsignedByte()` 从此文件读取一个无符号的八位数。
`int`	`ObjectInputStream.readUnsignedByte()` 读取一个无符号的 8 位字节。
`int`	`DataInputStream.readUnsignedByte()` 参见 `DataInput` 的 `readUnsignedByte` 方法的常规协定。
`int`	`DataInput.readUnsignedByte()` 读取一个输入字节，将它左侧补零 (zero-extend) 转变为 `int` 类型，并返回结果，所以结果的范围是 `0` 到 `255`。
`int`	`RandomAccessFile.readUnsignedShort()` 从此文件读取一个无符号的 16 位数。
`int`	`ObjectInputStream.readUnsignedShort()` 读取一个无符号的 16 位 short 值。
`int`	`DataInputStream.readUnsignedShort()` 参见 `DataInput` 的 `readUnsignedShort` 方法的常规协定。
`int`	`DataInput.readUnsignedShort()` 读取两个输入字节，并返回 `0` 到 `65535` 范围内的一个 `int` 值。
`String`	`RandomAccessFile.readUTF()` 从此文件读取一个字符串。
`String`	`ObjectInputStream.readUTF()` 读取 UTF-8 修改版格式的 String。
`String`	`DataInputStream.readUTF()` 参见 `DataInput` 的 `readUTF` 方法的常规协定。
`String`	`DataInput.readUTF()` 读入一个已使用 UTF-8 修改版格式编码的字符串。
`static String`	`DataInputStream.readUTF(DataInput in)` 从流 `in` 中读取用 UTF-8 修改版格式编码的 Unicode 字符格式的字符串；然后以 `String` 形式返回此字符串。
`boolean`	`CharArrayReader.ready()` 判断此流是否已准备好被读取。
`boolean`	`PipedReader.ready()` 告知是否准备读取此流。
`boolean`	`PushbackReader.ready()` 判断是否准备读取此流。
`boolean`	`FilterReader.ready()` 判断此流是否已经准备好用于读取。
`boolean`	`StringReader.ready()` 判断此流是否已经准备好用于读取。
`boolean`	`InputStreamReader.ready()` 判断此流是否已经准备好用于读取。
`boolean`	`BufferedReader.ready()` 判断此流是否已准备好被读取。
`boolean`	`Reader.ready()` 判断是否准备读取此流。
`protected void`	`PipedInputStream.receive(int b)` 接收数据字节。
`protected Object`	`ObjectOutputStream.replaceObject(Object obj)` 在序列化期间，此方法允许 ObjectOutputStream 的受信任子类使用一个对象替代另一个对象。
`void`	`CharArrayReader.reset()` 将该流重置为最新的标记，如果从未标记过，则将其重置到开头。
`void`	`LineNumberInputStream.reset()` 已过时。将此流重新定位到对此输入流最后调用 `mark` 方法时的位置。
`void`	`LineNumberReader.reset()` 将该流重新设置为最新的标记。
`void`	`PushbackReader.reset()` 重置该流。
`void`	`PushbackInputStream.reset()` 将此流重新定位到最后一次对此输入流调用 `mark` 方法时的位置。
`void`	`FilterReader.reset()` 重置该流。
`void`	`StringReader.reset()` 将该流重置为最新的标记，如果从未标记过，则将其重置到该字符串的开头。
`void`	`ObjectOutputStream.reset()` 重置将丢弃已写入流中的所有对象的状态。
`void`	`BufferedReader.reset()` 将流重置到最新的标记。
`void`	`Reader.reset()` 重置该流。
`void`	`BufferedInputStream.reset()` 参见 `InputStream` 的 `reset` 方法的常规协定。
`void`	`FilterInputStream.reset()` 将此流重新定位到对此输入流最后调用 `mark` 方法时的位置。
`void`	`InputStream.reset()` 将此流重新定位到最后一次对此输入流调用 `mark` 方法时的位置。
`protected Class<?>`	`ObjectInputStream.resolveClass(ObjectStreamClass desc)` 加载指定流类描述的本地等价类。
`protected Object`	`ObjectInputStream.resolveObject(Object obj)` 在反序列化期间，此方法允许 ObjectInputStream 的受信任子类使用一个对象替代另一个。
`protected Class<?>`	`ObjectInputStream.resolveProxyClass(String[] interfaces)` 返回一个代理类，该类实现在代理类描述符中命名的接口；子类可以实现此方法，以便从流及动态代理类的描述符中读取自定义数据，允许它们使用接口和代理类的替换加载机制。
`void`	`RandomAccessFile.seek(long pos)` 设置到此文件开头测量到的文件指针偏移量，在该位置发生下一个读取或写入操作。
`void`	`RandomAccessFile.setLength(long newLength)` 设置此文件的长度。
`long`	`CharArrayReader.skip(long n)` 跳过字符。
`long`	`LineNumberInputStream.skip(long n)` 已过时。跳过和放弃此输入流中的 `n` 个数据字节。
`long`	`LineNumberReader.skip(long n)` 跳过字符。
`long`	`PushbackReader.skip(long n)` 跳过字符。
`long`	`PushbackInputStream.skip(long n)` 从此输入流中跳过并丢弃 `n` 个数据字节。
`long`	`FilterReader.skip(long n)` 跳过某些字符。
`long`	`StringReader.skip(long ns)` 跳过流中指定数量的字符。
`long`	`ObjectInput.skip(long n)` 跳过输入的 n 个字节。
`long`	`BufferedReader.skip(long n)` 跳过字符。
`long`	`Reader.skip(long n)` 跳过字符。
`long`	`BufferedInputStream.skip(long n)` 参见 `InputStream` 的 `skip` 方法的常规协定。
`long`	`FilterInputStream.skip(long n)` 跳过和丢弃此输入流中数据的 `n` 个字节。
`long`	`FileInputStream.skip(long n)` 从输入流中跳过并丢弃 `n` 个字节的数据。
`long`	`InputStream.skip(long n)` 跳过和丢弃此输入流中数据的 `n` 个字节。
`int`	`RandomAccessFile.skipBytes(int n)` 尝试跳过输入的 `n` 个字节以丢弃跳过的字节。
`int`	`ObjectInputStream.skipBytes(int len)` 跳过字节。
`int`	`DataInputStream.skipBytes(int n)` 参见 `DataInput` 的 `skipBytes` 方法的常规协定。
`int`	`DataInput.skipBytes(int n)` 试图在输入流中跳过数据的 `n` 个字节，并丢弃跳过的字节。
`void`	`PushbackInputStream.unread(byte[] b)` 推回一个 byte 数组：将其复制到推回缓冲区之前。
`void`	`PushbackInputStream.unread(byte[] b, int off, int len)` 推回 byte 数组的某一部分：将其复制到推回缓冲区之前。
`void`	`PushbackReader.unread(char[] cbuf)` 推回一个字符数组，方法是将其复制到推回缓冲区前面。
`void`	`PushbackReader.unread(char[] cbuf, int off, int len)` 推回字符数组的某一部分，方法是将其复制到推回缓冲区的前面。
`void`	`PushbackReader.unread(int c)` 推回单个字符：将其复制到推回缓冲区的前面。
`void`	`PushbackInputStream.unread(int b)` 推回一个字节：将其复制到推回缓冲区之前。
`void`	`ObjectOutputStream.useProtocolVersion(int version)` 指定要在写入流时使用的流协议版本。
`void`	`RandomAccessFile.write(byte[] b)` 将 `b.length` 个字节从指定 byte 数组写入到此文件，并从当前文件指针开始。
`void`	`ObjectOutputStream.write(byte[] buf)` 写入一个 byte 数组。
`void`	`ObjectOutput.write(byte[] b)` 写入 byte 数组。
`void`	`DataOutput.write(byte[] b)` 将数组 `b` 中的所有字节写入输出流。
`void`	`FilterOutputStream.write(byte[] b)` 将 `b.length` 个字节写入此输出流。
`void`	`FileOutputStream.write(byte[] b)` 将 `b.length` 个字节从指定 byte 数组写入此文件输出流中。
`void`	`OutputStream.write(byte[] b)` 将 `b.length` 个字节从指定的 byte 数组写入此输出流。
`void`	`PipedOutputStream.write(byte[] b, int off, int len)` 将 `len` 字节从初始偏移量为 `off` 的指定 byte 数组写入该管道输出流。
`void`	`DataOutputStream.write(byte[] b, int off, int len)` 将指定 byte 数组中从偏移量 `off` 开始的 `len` 个字节写入基础输出流。
`void`	`RandomAccessFile.write(byte[] b, int off, int len)` 将 `len` 个字节从指定 byte 数组写入到此文件，并从偏移量 `off` 处开始。
`void`	`ObjectOutputStream.write(byte[] buf, int off, int len)` 写入字节的子数组。
`void`	`ObjectOutput.write(byte[] b, int off, int len)` 写入字节的子数组。
`void`	`DataOutput.write(byte[] b, int off, int len)` 将数组 `b` 中的 `len` 个字节按顺序写入输出流。
`void`	`BufferedOutputStream.write(byte[] b, int off, int len)` 将指定 byte 数组中从偏移量 `off` 开始的 `len` 个字节写入此缓冲的输出流。
`void`	`FilterOutputStream.write(byte[] b, int off, int len)` 将指定 `byte` 数组中从偏移量 `off` 开始的 `len` 个字节写入此输出流。
`void`	`FileOutputStream.write(byte[] b, int off, int len)` 将指定 byte 数组中从偏移量 `off` 开始的 `len` 个字节写入此文件输出流。
`void`	`OutputStream.write(byte[] b, int off, int len)` 将指定 byte 数组中从偏移量 `off` 开始的 `len` 个字节写入此输出流。
`void`	`Writer.write(char[] cbuf)` 写入字符数组。
`void`	`FilterWriter.write(char[] cbuf, int off, int len)` 将字符写入数组的某一部分。
`void`	`PipedWriter.write(char[] cbuf, int off, int len)` 将 `len` 字符从指定初始偏移量为 `off` 的字符数组写入到此管道输出流。
`void`	`BufferedWriter.write(char[] cbuf, int off, int len)` 写入字符数组的某一部分。
`void`	`OutputStreamWriter.write(char[] cbuf, int off, int len)` 写入字符数组的某一部分。
`abstract void`	`Writer.write(char[] cbuf, int off, int len)` 写入字符数组的某一部分。
`void`	`FilterWriter.write(int c)` 写入单个字符。
`void`	`PipedOutputStream.write(int b)` 将指定 `byte` 写入传送的输出流。
`void`	`PipedWriter.write(int c)` 将指定的 `char` 写入管道输出流。
`void`	`DataOutputStream.write(int b)` 将指定字节（参数 `b` 的八个低位）写入基础输出流。
`void`	`RandomAccessFile.write(int b)` 向此文件写入指定的字节。
`void`	`ObjectOutputStream.write(int val)` 写入一个字节。
`void`	`ObjectOutput.write(int b)` 写入字节。
`void`	`DataOutput.write(int b)` 将参数 `b` 的八个低位写入输出流。
`void`	`BufferedWriter.write(int c)` 写入单个字符。
`void`	`OutputStreamWriter.write(int c)` 写入单个字符。
`void`	`Writer.write(int c)` 写入单个字符。
`void`	`BufferedOutputStream.write(int b)` 将指定的字节写入此缓冲的输出流。
`void`	`FilterOutputStream.write(int b)` 将指定 `byte` 写入此输出流。
`void`	`FileOutputStream.write(int b)` 将指定字节写入此文件输出流。
`abstract void`	`OutputStream.write(int b)` 将指定的字节写入此输出流。
`abstract void`	`ObjectOutputStream.PutField.write(ObjectOutput out)` 已过时。此方法不能以正确格式写入 `PutField` 对象中包含的值，并且可能导致序列化流的损坏。写入 `PutField` 数据的正确方法是调用 `ObjectOutputStream.writeFields()` 方法。
`void`	`Writer.write(String str)` 写入字符串。
`void`	`FilterWriter.write(String str, int off, int len)` 写入一部分字符串。
`void`	`BufferedWriter.write(String s, int off, int len)` 写入字符串的某一部分。
`void`	`OutputStreamWriter.write(String str, int off, int len)` 写入字符串的某一部分。
`void`	`Writer.write(String str, int off, int len)` 写入字符串的某一部分。
`void`	`DataOutputStream.writeBoolean(boolean v)` 将一个 `boolean` 值以 1-byte 值形式写入基础输出流。
`void`	`RandomAccessFile.writeBoolean(boolean v)` 按单字节值将 `boolean` 写入该文件。
`void`	`ObjectOutputStream.writeBoolean(boolean val)` 写入一个 boolean 值。
`void`	`DataOutput.writeBoolean(boolean v)` 将一个 `boolean` 值写入输出流。
`void`	`DataOutputStream.writeByte(int v)` 将一个 `byte` 值以 1-byte 值形式写出到基础输出流中。
`void`	`RandomAccessFile.writeByte(int v)` 按单字节值将 `byte` 写入该文件。
`void`	`ObjectOutputStream.writeByte(int val)` 写入一个 8 位字节。
`void`	`DataOutput.writeByte(int v)` 将参数 `v` 的八个低位写入输出流。
`void`	`DataOutputStream.writeBytes(String s)` 将字符串按字节顺序写出到基础输出流中。
`void`	`RandomAccessFile.writeBytes(String s)` 按字节序列将该字符串写入该文件。
`void`	`ObjectOutputStream.writeBytes(String str)` 以字节序列形式写入一个 String。
`void`	`DataOutput.writeBytes(String s)` 将一个字符串写入输出流。
`void`	`DataOutputStream.writeChar(int v)` 将一个 `char` 值以 2-byte 值形式写入基础输出流中，先写入高字节。
`void`	`RandomAccessFile.writeChar(int v)` 按双字节值将 `char` 写入该文件，先写高字节。
`void`	`ObjectOutputStream.writeChar(int val)` 写入一个 16 位的 char 值。
`void`	`DataOutput.writeChar(int v)` 将一个 `char` 值写入输出流，该值由两个字节组成。
`void`	`DataOutputStream.writeChars(String s)` 将字符串按字符顺序写入基础输出流。
`void`	`RandomAccessFile.writeChars(String s)` 按字符序列将一个字符串写入该文件。
`void`	`ObjectOutputStream.writeChars(String str)` 以 char 序列形式写入一个 String。
`void`	`DataOutput.writeChars(String s)` 将字符串 `s` 中的所有字符按顺序写入输出流，每个字符用两个字节表示。
`protected void`	`ObjectOutputStream.writeClassDescriptor(ObjectStreamClass desc)` 将指定的类描述符写入 ObjectOutputStream。
`void`	`DataOutputStream.writeDouble(double v)` 使用 `Double` 类中的 `doubleToLongBits` 方法将 double 参数转换为一个 `long` 值，然后将该 `long` 值以 8-byte 值形式写入基础输出流中，先写入高字节。
`void`	`RandomAccessFile.writeDouble(double v)` 使用 `Double` 类中的 `doubleToLongBits` 方法将双精度参数转换为一个 `long`，然后按八字节数量将该 `long` 值写入该文件，先定高字节。
`void`	`ObjectOutputStream.writeDouble(double val)` 写入一个 64 位的 double 值。
`void`	`DataOutput.writeDouble(double v)` 将一个 `double` 值写入输出流，该值由八个字节组成。
`void`	`Externalizable.writeExternal(ObjectOutput out)` 该对象可实现 writeExternal 方法来保存其内容，它可以通过调用 DataOutput 的方法来保存其基本值，或调用 ObjectOutput 的 writeObject 方法来保存对象、字符串和数组。
`void`	`ObjectOutputStream.writeFields()` 将已缓冲的字段写入流中。
`void`	`DataOutputStream.writeFloat(float v)` 使用 `Float` 类中的 `floatToIntBits` 方法将 float 参数转换为一个 `int` 值，然后将该 `int` 值以 4-byte 值形式写入基础输出流中，先写入高字节。
`void`	`RandomAccessFile.writeFloat(float v)` 使用 `Float` 类中的 `floatToIntBits` 方法将浮点参数转换为一个 `int`，然后按四字节数量将该 `int` 值写入该文件，先写高字节。
`void`	`ObjectOutputStream.writeFloat(float val)` 写入一个 32 位的 float 值。
`void`	`DataOutput.writeFloat(float v)` 将一个 `float` 值写入输出流，该值由四个字节组成。
`void`	`DataOutputStream.writeInt(int v)` 将一个 `int` 值以 4-byte 值形式写入基础输出流中，先写入高字节。
`void`	`RandomAccessFile.writeInt(int v)` 按四个字节将 `int` 写入该文件，先写高字节。
`void`	`ObjectOutputStream.writeInt(int val)` 写入一个 32 位的 int 值。
`void`	`DataOutput.writeInt(int v)` 将一个 `int` 值写入输出流，该值由四个字节组成。
`void`	`DataOutputStream.writeLong(long v)` 将一个 `long` 值以 8-byte 值形式写入基础输出流中，先写入高字节。
`void`	`RandomAccessFile.writeLong(long v)` 按八个字节将 `long` 写入该文件，先写高字节。
`void`	`ObjectOutputStream.writeLong(long val)` 写入一个 64 位的 long 值。
`void`	`DataOutput.writeLong(long v)` 将一个 `long` 值写入输出流，该值由八个字节组成。
`void`	`ObjectOutputStream.writeObject(Object obj)` 将指定的对象写入 ObjectOutputStream。
`void`	`ObjectOutput.writeObject(Object obj)` 将对象写入底层存储或流。
`protected void`	`ObjectOutputStream.writeObjectOverride(Object obj)` 子类用于重写默认 writeObject 方法的方法。
`void`	`DataOutputStream.writeShort(int v)` 将一个 `short` 值以 2-byte 值形式写入基础输出流中，先写入高字节。
`void`	`RandomAccessFile.writeShort(int v)` 按两个字节将 `short` 写入该文件，先写高字节。
`void`	`ObjectOutputStream.writeShort(int val)` 写入一个 16 位的 short 值。
`void`	`DataOutput.writeShort(int v)` 将两个字节写入输出流，用它们表示参数值。
`protected void`	`ObjectOutputStream.writeStreamHeader()` 提供 writeStreamHeader 方法，这样子类可以将其自身的头部添加或预加到流中。
`void`	`ByteArrayOutputStream.writeTo(OutputStream out)` 将此 byte 数组输出流的全部内容写入到指定的输出流参数中，这与使用 `out.write(buf, 0, count)` 调用该输出流的 write 方法效果一样。
`void`	`CharArrayWriter.writeTo(Writer out)` 将缓冲区的内容写入另一个字符流。
`void`	`ObjectOutputStream.writeUnshared(Object obj)` 将“未共享”对象写入 ObjectOutputStream。
`void`	`DataOutputStream.writeUTF(String str)` 以与机器无关方式使用 UTF-8 修改版编码将一个字符串写入基础输出流。
`void`	`RandomAccessFile.writeUTF(String str)` 使用 modified UTF-8 编码以与机器无关的方式将一个字符串写入该文件。
`void`	`ObjectOutputStream.writeUTF(String str)` 以 UTF-8 修改版格式写入此 String 的基本数据。
`void`	`DataOutput.writeUTF(String s)` 将表示长度信息的两个字节写入输出流，后跟字符串 `s` 中每个字符的 UTF-8 修改版表示形式。

抛出 IOException 的 java.io 中的构造方法
`FileWriter(File file)` 根据给定的 File 对象构造一个 FileWriter 对象。
`FileWriter(File file, boolean append)` 根据给定的 File 对象构造一个 FileWriter 对象。
`FileWriter(String fileName)` 根据给定的文件名构造一个 FileWriter 对象。
`FileWriter(String fileName, boolean append)` 根据给定的文件名以及指示是否附加写入数据的 boolean 值来构造 FileWriter 对象。
`ObjectInputStream()` 为完全重新实现 ObjectInputStream 的子类提供一种方式，让它不必分配仅由 ObjectInputStream 的实现使用的私有数据。
`ObjectInputStream(InputStream in)` 创建从指定 InputStream 读取的 ObjectInputStream。
`ObjectOutputStream()` 为完全重新实现 ObjectOutputStream 的子类提供一种方法，让它不必分配仅由 ObjectOutputStream 的实现使用的私有数据。
`ObjectOutputStream(OutputStream out)` 创建写入指定 OutputStream 的 ObjectOutputStream。
`PipedInputStream(PipedOutputStream src)` 创建 `PipedInputStream`，使其连接到管道输出流 `src`。
`PipedInputStream(PipedOutputStream src, int pipeSize)` 创建一个 `PipedInputStream`，使其连接到管道输出流 `src`，并对管道缓冲区使用指定的管道大小。
`PipedOutputStream(PipedInputStream snk)` 创建连接到指定管道输入流的管道输出流。
`PipedReader(PipedWriter src)` 创建连接到传送 writer `src` 的 `PipedReader`。
`PipedReader(PipedWriter src, int pipeSize)` 创建一个 `PipedReader`，使其连接到管道 writer `src`，并对管道缓冲区使用指定的管道大小。
`PipedWriter(PipedReader snk)` 创建传送 writer，使其连接到指定的传送 reader。

java.lang 中 IOException 的使用

抛出 IOException 的 java.lang 中的方法
`Appendable`	`Appendable.append(char c)` 向此 `Appendable` 添加指定字符。
`Appendable`	`Appendable.append(CharSequence csq)` 向此 `Appendable` 添加指定的字符序列。
`Appendable`	`Appendable.append(CharSequence csq, int start, int end)` 向此 `Appendable` 添加指定字符序列的子序列。
`Process`	`Runtime.exec(String command)` 在单独的进程中执行指定的字符串命令。
`Process`	`Runtime.exec(String[] cmdarray)` 在单独的进程中执行指定命令和变量。
`Process`	`Runtime.exec(String[] cmdarray, String[] envp)` 在指定环境的独立进程中执行指定命令和变量。
`Process`	`Runtime.exec(String[] cmdarray, String[] envp, File dir)` 在指定环境和工作目录的独立进程中执行指定的命令和变量。
`Process`	`Runtime.exec(String command, String[] envp)` 在指定环境的单独进程中执行指定的字符串命令。
`Process`	`Runtime.exec(String command, String[] envp, File dir)` 在有指定环境和工作目录的独立进程中执行指定的字符串命令。
`protected Enumeration<URL>`	`ClassLoader.findResources(String name)` 返回表示所有具有给定名称的资源的 `URL` 对象的枚举。
`Enumeration<URL>`	`ClassLoader.getResources(String name)` 查找所有给定名称的资源。
`static Enumeration<URL>`	`ClassLoader.getSystemResources(String name)` 从用来加载类的搜索路径中查找所有具有指定名称的资源。
`static Channel`	`System.inheritedChannel()` 返回从创建此 Java 虚拟机的实体中继承的信道。
`int`	`Readable.read(CharBuffer cb)` 试图将字符读入指定的字符缓冲区。
`Process`	`ProcessBuilder.start()` 使用此进程生成器的属性启动一个新进程。

java.lang.management 中 IOException 的使用

抛出 IOException 的 java.lang.management 中的方法

static



<T> T

ManagementFactory.newPlatformMXBeanProxy(MBeanServerConnection connection,
String mxbeanName,
Class<T> mxbeanInterface)

返回用于给定 MXBean 名称的平台 MXBean 接口的代理，以便通过给定 MBeanServerConnection 转发其方法调用。

java.net 中 IOException 的使用

java.net 中 IOException 的子类
`class`	`BindException` 试图将套接字绑定到本地地址和端口时发生错误的情况下，抛出此异常。
`class`	`HttpRetryException` 抛出此异常指示 HTTP 请求需要重试，但由于启用了流模式而无法自动重试。
`class`	`MalformedURLException` 抛出这一异常指示出现了错误的 URL。
`class`	`NoRouteToHostException` 试图将套接字连接到远程地址和端口时发生错误的情况下，抛出此异常。
`class`	`PortUnreachableException` 在连接的数据报上已接收到 ICMP Port Unreachable 消息时，抛出该异常。
`class`	`ProtocolException` 抛出此异常指示在底层协议中存在错误，如 TCP 错误。
`class`	`SocketException` 抛出此异常指示在底层协议中存在错误，如 TCP 错误。
`class`	`SocketTimeoutException` 如果在读取或接受套接字时发生超时，则抛出此异常。
`class`	`UnknownHostException` 指示主机 IP 地址无法确定而抛出的异常。
`class`	`UnknownServiceException` 抛出这一异常指示出现了未知服务异常。

参数类型为 IOException 的 java.net 中的方法
`abstract void`	`ProxySelector.connectFailed(URI uri, SocketAddress sa, IOException ioe)` 调用此方法来指示无法建立到代理/socks 服务器的连接。

抛出 IOException 的 java.net 中的方法
`Socket`	`ServerSocket.accept()` 侦听并接受到此套接字的连接。
`protected abstract void`	`SocketImpl.accept(SocketImpl s)` 接受连接。
`protected abstract int`	`SocketImpl.available()` 返回可以不受阻塞地从此套接字中读取的字节数。
`protected abstract void`	`SocketImpl.bind(InetAddress host, int port)` 将此套接字绑定到指定的本地 IP 地址和端口号。
`void`	`ServerSocket.bind(SocketAddress endpoint)` 将 `ServerSocket` 绑定到特定地址（IP 地址和端口号）。
`void`	`Socket.bind(SocketAddress bindpoint)` 将套接字绑定到本地地址。
`void`	`ServerSocket.bind(SocketAddress endpoint, int backlog)` 将 `ServerSocket` 绑定到特定地址（IP 地址和端口号）。
`void`	`ServerSocket.close()` 关闭此套接字。
`protected abstract void`	`SocketImpl.close()` 关闭此套接字。
`void`	`Socket.close()` 关闭此套接字。
`abstract void`	`URLConnection.connect()` 打开到此 URL 引用的资源的通信链接（如果尚未建立这样的连接）。
`protected abstract void`	`SocketImpl.connect(InetAddress address, int port)` 将此套接字连接到指定主机上的指定端口号。
`void`	`Socket.connect(SocketAddress endpoint)` 将此套接字连接到服务器。
`protected abstract void`	`SocketImpl.connect(SocketAddress address, int timeout)` 将此套接字连接到指定主机上的指定端口号。
`void`	`Socket.connect(SocketAddress endpoint, int timeout)` 将此套接字连接到服务器，并指定一个超时值。
`protected abstract void`	`SocketImpl.connect(String host, int port)` 将此套接字连接到指定主机上的指定端口。
`protected abstract void`	`SocketImpl.create(boolean stream)` 创建一个流或数据报套接字。
`Enumeration<URL>`	`URLClassLoader.findResources(String name)` 返回表示 URL 搜索路径中具有指定名称的所有资源的 URL 枚举。
`abstract Map<String,List<String>>`	`CookieHandler.get(URI uri, Map<String,List<String>> requestHeaders)` 从请求头中指定 uri 的 cookie 缓存中获取所有可用的 cookie。
`Map<String,List<String>>`	`CookieManager.get(URI uri, Map<String,List<String>> requestHeaders)`
`abstract CacheResponse`	`ResponseCache.get(URI uri, String rqstMethod, Map<String,List<String>> rqstHeaders)` 根据请求的 uri、请求方法和请求头获取缓存的响应。
`Attributes`	`JarURLConnection.getAttributes()` 如果此连接的 URL 指向 JAR 文件条目，则返回其 Attribute 对象；否则返回 null。
`abstract OutputStream`	`CacheRequest.getBody()` 返回可以将响应正文写入其中的 OutputStream。
`abstract InputStream`	`CacheResponse.getBody()` 以 InputStream 的形式返回响应正文。
`Certificate[]`	`JarURLConnection.getCertificates()` 如果此连接的 URL 指向 JAR 文件条目，则返回其 Certificate 对象；否则返回 null。
`Object`	`URLConnection.getContent()` 获取此 URL 连接的内容。
`Object`	`URL.getContent()` 获取此 URL 的内容。
`Object`	`URLConnection.getContent(Class[] classes)` 获取此 URL 连接的内容。
`Object`	`URL.getContent(Class[] classes)` 获取此 URL 的内容。
`abstract Object`	`ContentHandler.getContent(URLConnection urlc)` 如果给出位于对象表示形式开头的 URL 连接流，则此方法读取该流并根据其创建对象。
`Object`	`ContentHandler.getContent(URLConnection urlc, Class[] classes)` 如果给出位于对象表示形式开头的 URL 连接流，则此方法读取该流并创建与给定类型之一匹配的对象。
`abstract Map<String,List<String>>`	`CacheResponse.getHeaders()` 以 Map 的形式返回响应头。
`protected abstract InputStream`	`SocketImpl.getInputStream()` 返回此套接字的输入流。
`InputStream`	`Socket.getInputStream()` 返回此套接字的输入流。
`InputStream`	`URLConnection.getInputStream()` 返回从此打开的连接读取的输入流。
`JarEntry`	`JarURLConnection.getJarEntry()` 返回此连接的 JAR 条目对象（如果有）。
`abstract JarFile`	`JarURLConnection.getJarFile()` 返回此连接的 JAR 文件。
`Attributes`	`JarURLConnection.getMainAttributes()` 返回此连接的 JAR 文件的主要 Attribute。
`Manifest`	`JarURLConnection.getManifest()` 返回此连接的 Manifest；如果没有，则返回 null。
`protected abstract OutputStream`	`SocketImpl.getOutputStream()` 返回此套接字的输出流。
`OutputStream`	`Socket.getOutputStream()` 返回此套接字的输出流。
`OutputStream`	`URLConnection.getOutputStream()` 返回写入到此连接的输出流。
`Permission`	`HttpURLConnection.getPermission()`
`Permission`	`URLConnection.getPermission()` 返回一个权限对象，其代表建立此对象表示的连接所需的权限。
`int`	`HttpURLConnection.getResponseCode()` 从 HTTP 响应消息获取状态码。
`String`	`HttpURLConnection.getResponseMessage()` 获取与来自服务器的响应代码一起返回的 HTTP 响应消息（如果有）。
`int`	`ServerSocket.getSoTimeout()` 获取 SO_TIMEOUT 的设置。
`protected abstract int`	`DatagramSocketImpl.getTimeToLive()` 获取 TTL （生存时间）选项。
`int`	`MulticastSocket.getTimeToLive()` 获取在套接字上发出的多播数据包的默认生存时间。
`protected abstract byte`	`DatagramSocketImpl.getTTL()` 已过时。使用 getTimeToLive 代替。
`byte`	`MulticastSocket.getTTL()` 已过时。使用 getTimeToLive 方法来代替，该方法返回 int（而不是 byte）。
`static String`	`URLConnection.guessContentTypeFromStream(InputStream is)` 根据输入流的开始字符尝试确定输入流的类型。
`protected void`	`ServerSocket.implAccept(Socket s)` ServerSocket 的子类使用此方法重写 accept() 以返回它们自己的套接字子类。
`boolean`	`InetAddress.isReachable(int timeout)` 测试是否可以达到该地址。
`boolean`	`InetAddress.isReachable(NetworkInterface netif, int ttl, int timeout)` 测试是否可以达到该地址。
`protected abstract void`	`DatagramSocketImpl.join(InetAddress inetaddr)` 加入多播组。
`void`	`MulticastSocket.joinGroup(InetAddress mcastaddr)` 加入多播组。
`protected abstract void`	`DatagramSocketImpl.joinGroup(SocketAddress mcastaddr, NetworkInterface netIf)` 加入多播组。
`void`	`MulticastSocket.joinGroup(SocketAddress mcastaddr, NetworkInterface netIf)` 加入指定接口上的指定多播组。
`protected abstract void`	`DatagramSocketImpl.leave(InetAddress inetaddr)` 退出多播组。
`void`	`MulticastSocket.leaveGroup(InetAddress mcastaddr)` 离开多播组。
`protected abstract void`	`DatagramSocketImpl.leaveGroup(SocketAddress mcastaddr, NetworkInterface netIf)` 退出多播组。
`void`	`MulticastSocket.leaveGroup(SocketAddress mcastaddr, NetworkInterface netIf)` 离开指定本地接口上的多播组。
`protected abstract void`	`SocketImpl.listen(int backlog)` 将传入连接指示（连接请求）的最大队列长度设置为 `count` 参数。
`URLConnection`	`URL.openConnection()` 返回一个 `URLConnection` 对象，它表示到 `URL` 所引用的远程对象的连接。
`URLConnection`	`URL.openConnection(Proxy proxy)` 与 openConnection() 类似，所不同是连接通过指定的代理建立；不支持代理方式的协议处理程序将忽略该代理参数并建立正常的连接。
`protected abstract URLConnection`	`URLStreamHandler.openConnection(URL u)` 打开一个到 `URL` 参数引用的对象的连接。
`protected URLConnection`	`URLStreamHandler.openConnection(URL u, Proxy p)` 与 openConnection(URL) 相同，不同点在于：通过指定的代理进行连接；不支持代理方式的协议处理程序将忽略该代理参数并进行正常的连接。
`InputStream`	`URL.openStream()` 打开到此 `URL` 的连接并返回一个用于从该连接读入的 `InputStream`。
`protected abstract int`	`DatagramSocketImpl.peek(InetAddress i)` 查看包来自哪里。
`protected abstract int`	`DatagramSocketImpl.peekData(DatagramPacket p)` 查看包来自哪里。
`abstract void`	`CookieHandler.put(URI uri, Map<String,List<String>> responseHeaders)` 将响应头中出现的所有可用 cookie（例如名为 Set-Cookie2 的响应头字段）设置到 cookie 缓存中。
`void`	`CookieManager.put(URI uri, Map<String,List<String>> responseHeaders)`
`abstract CacheRequest`	`ResponseCache.put(URI uri, URLConnection conn)` 协议处理程序在获得资源后调用此方法，ResponseCache 必须决定是否在其缓存中存储资源。
`protected abstract void`	`DatagramSocketImpl.receive(DatagramPacket p)` 接收数据报包。
`void`	`DatagramSocket.receive(DatagramPacket p)` 从此套接字接收数据报包。
`protected abstract void`	`DatagramSocketImpl.send(DatagramPacket p)` 发送数据报包。
`void`	`DatagramSocket.send(DatagramPacket p)` 从此套接字发送数据报包。
`void`	`MulticastSocket.send(DatagramPacket p, byte ttl)` 已过时。使用以下代码或其等效代码：...... int ttl = mcastSocket.getTimeToLive(); mcastSocket.setTimeToLive(newttl); mcastSocket.send(p); mcastSocket.setTimeToLive(ttl); ......
`protected abstract void`	`SocketImpl.sendUrgentData(int data)` 在套接字上发送一个紧急数据字节。
`void`	`Socket.sendUrgentData(int data)` 在套接字上发送一个紧急数据字节。
`static void`	`DatagramSocket.setDatagramSocketImplFactory(DatagramSocketImplFactory fac)` 为应用程序设置数据报套接字实现工厂。
`static void`	`ServerSocket.setSocketFactory(SocketImplFactory fac)` 为应用程序设置服务器套接字实现工厂。
`static void`	`Socket.setSocketImplFactory(SocketImplFactory fac)` 为应用程序设置客户端套接字实现工厂。
`protected abstract void`	`DatagramSocketImpl.setTimeToLive(int ttl)` 设置 TTL （生存时间）选项。
`void`	`MulticastSocket.setTimeToLive(int ttl)` 设置在此 `MulticastSocket` 上发出的多播数据包的默认生存时间，以便控制多播的范围。
`protected abstract void`	`DatagramSocketImpl.setTTL(byte ttl)` 已过时。使用 setTimeToLive 代替。
`void`	`MulticastSocket.setTTL(byte ttl)` 已过时。使用 setTimeToLive 方法来代替，该方法使用 int（而不用 byte）作为 ttl 的类型。
`protected void`	`SocketImpl.shutdownInput()` 将此套接字的输入流置于“流的末尾”。
`void`	`Socket.shutdownInput()` 此套接字的输入流置于“流的末尾”。
`protected void`	`SocketImpl.shutdownOutput()` 禁用此套接字的输出流。
`void`	`Socket.shutdownOutput()` 禁用此套接字的输出流。

抛出 IOException 的 java.net 中的构造方法
`MulticastSocket()` 创建多播套接字。
`MulticastSocket(int port)` 创建多播套接字并将其绑定到特定端口。
`MulticastSocket(SocketAddress bindaddr)` 创建绑定到指定套接字地址的 MulticastSocket。
`ServerSocket()` 创建非绑定服务器套接字。
`ServerSocket(int port)` 创建绑定到特定端口的服务器套接字。
`ServerSocket(int port, int backlog)` 利用指定的 backlog 创建服务器套接字并将其绑定到指定的本地端口号。
`ServerSocket(int port, int backlog, InetAddress bindAddr)` 使用指定的端口、侦听 backlog 和要绑定到的本地 IP 地址创建服务器。
`Socket(InetAddress address, int port)` 创建一个流套接字并将其连接到指定 IP 地址的指定端口号。
`Socket(InetAddress host, int port, boolean stream)` 已过时。 Use DatagramSocket instead for UDP transport.
`Socket(InetAddress address, int port, InetAddress localAddr, int localPort)` 创建一个套接字并将其连接到指定远程地址上的指定远程端口。
`Socket(String host, int port)` 创建一个流套接字并将其连接到指定主机上的指定端口号。
`Socket(String host, int port, boolean stream)` 已过时。使用 DatagramSocket 取代 UDP 传输。
`Socket(String host, int port, InetAddress localAddr, int localPort)` 创建一个套接字并将其连接到指定远程主机上的指定远程端口。

java.nio 中 IOException 的使用

抛出 IOException 的 java.nio 中的方法
`int`	`CharBuffer.read(CharBuffer target)` 试图将字符读入指定的字符缓冲区。

java.nio.channels 中 IOException 的使用

java.nio.channels 中 IOException 的子类
`class`	`AsynchronousCloseException` 当在某个信道的 I/O 操作中处于阻塞状态的某个线程被另一个线程关闭了该信道或部分信道时，该信道所接收的经过检查的异常。
`class`	`ClosedByInterruptException` 当在某个信道的 I/O 操作中处于阻塞状态的某个线程被另一个线程中断时，该线程将收到此经过检查的异常。
`class`	`ClosedChannelException` 当试图对已关闭的、或者至少对某个 I/O 操作已关闭的信道上调用或完成该操作时，抛出此经过检查的异常。
`class`	`FileLockInterruptionException` 当某个线程正在等待获取文件锁定时被另一个线程中断，则由该线程接收此经过检查的异常。

抛出 IOException 的 java.nio.channels 中的方法
`abstract SocketChannel`	`ServerSocketChannel.accept()` 接受到此通道套接字的连接。
`abstract void`	`Selector.close()` 关闭此选择器。
`void`	`InterruptibleChannel.close()` 关闭此通道。
`void`	`Channel.close()` 关闭此通道。
`abstract SelectableChannel`	`SelectableChannel.configureBlocking(boolean block)` 调整此通道的阻塞模式。
`abstract DatagramChannel`	`DatagramChannel.connect(SocketAddress remote)` 连接此通道的套接字。
`abstract boolean`	`SocketChannel.connect(SocketAddress remote)` 连接此通道的套接字。
`abstract DatagramChannel`	`DatagramChannel.disconnect()` 断开此通道套接字的连接。
`abstract boolean`	`SocketChannel.finishConnect()` 完成套接字通道的连接过程。
`abstract void`	`FileChannel.force(boolean metaData)` 强制将所有对此通道的文件更新写入包含该文件的存储设备中。
`FileLock`	`FileChannel.lock()` 获取对此通道的文件的独占锁定。
`abstract FileLock`	`FileChannel.lock(long position, long size, boolean shared)` 获取此通道的文件给定区域上的锁定。
`abstract MappedByteBuffer`	`FileChannel.map(FileChannel.MapMode mode, long position, long size)` 将此通道的文件区域直接映射到内存中。
`static DatagramChannel`	`DatagramChannel.open()` 打开数据报通道。
`static Pipe`	`Pipe.open()` 打开一个管道。
`static Selector`	`Selector.open()` 打开一个选择器。
`static ServerSocketChannel`	`ServerSocketChannel.open()` 打开服务器套接字通道。
`static SocketChannel`	`SocketChannel.open()` 打开套接字通道。
`static SocketChannel`	`SocketChannel.open(SocketAddress remote)` 打开套接字通道并将其连接到远程地址。
`abstract long`	`FileChannel.position()` 返回此通道的文件位置。
`abstract FileChannel`	`FileChannel.position(long newPosition)` 设置此通道的文件位置。
`abstract int`	`DatagramChannel.read(ByteBuffer dst)` 从此通道读取数据报。
`abstract int`	`SocketChannel.read(ByteBuffer dst)`
`abstract int`	`FileChannel.read(ByteBuffer dst)` 将字节序列从此通道读入给定的缓冲区。
`int`	`ReadableByteChannel.read(ByteBuffer dst)` 将字节序列从此通道中读入给定的缓冲区。
`long`	`DatagramChannel.read(ByteBuffer[] dsts)` 从此通道读取数据报。
`long`	`SocketChannel.read(ByteBuffer[] dsts)`
`long`	`FileChannel.read(ByteBuffer[] dsts)` 将字节序列从此通道读入给定的缓冲区。
`long`	`ScatteringByteChannel.read(ByteBuffer[] dsts)` 将字节序列从此通道读入给定的缓冲区。
`abstract long`	`DatagramChannel.read(ByteBuffer[] dsts, int offset, int length)` 从此通道读取数据报。
`abstract long`	`SocketChannel.read(ByteBuffer[] dsts, int offset, int length)`
`abstract long`	`FileChannel.read(ByteBuffer[] dsts, int offset, int length)` 将字节序列从此通道读入给定缓冲区的子序列中。
`long`	`ScatteringByteChannel.read(ByteBuffer[] dsts, int offset, int length)` 将字节序列从此通道读入给定缓冲区的子序列中。
`abstract int`	`FileChannel.read(ByteBuffer dst, long position)` 从给定的文件位置开始，从此通道读取字节序列,并写入给定的缓冲区。
`abstract SocketAddress`	`DatagramChannel.receive(ByteBuffer dst)` 通过此通道接收数据报。
`abstract void`	`FileLock.release()` 释放此锁定。
`abstract int`	`Selector.select()` 选择一组键，其相应的通道已为 I/O 操作准备就绪。
`abstract int`	`Selector.select(long timeout)` 选择一组键，其相应的通道已为 I/O 操作准备就绪。
`abstract int`	`Selector.selectNow()` 选择一组键，其相应的通道已为 I/O 操作准备就绪。
`abstract int`	`DatagramChannel.send(ByteBuffer src, SocketAddress target)` 通过此通道发送数据报。
`abstract long`	`FileChannel.size()` 返回此通道的文件的当前大小。
`abstract long`	`FileChannel.transferFrom(ReadableByteChannel src, long position, long count)` 将字节从给定的可读取字节通道传输到此通道的文件中。
`abstract long`	`FileChannel.transferTo(long position, long count, WritableByteChannel target)` 将字节从此通道的文件传输到给定的可写入字节通道。
`abstract FileChannel`	`FileChannel.truncate(long size)` 将此通道的文件截取为给定大小。
`FileLock`	`FileChannel.tryLock()` 试图获取对此通道的文件的独占锁定。
`abstract FileLock`	`FileChannel.tryLock(long position, long size, boolean shared)` 试图获取对此通道的文件给定区域的锁定。
`abstract int`	`DatagramChannel.write(ByteBuffer src)` 将数据报写入此通道。
`abstract int`	`SocketChannel.write(ByteBuffer src)`
`abstract int`	`FileChannel.write(ByteBuffer src)` 将字节序列从给定的缓冲区写入此通道。
`int`	`WritableByteChannel.write(ByteBuffer src)` 将字节序列从给定的缓冲区中写入此通道。
`long`	`DatagramChannel.write(ByteBuffer[] srcs)` 将数据报写入此通道。
`long`	`SocketChannel.write(ByteBuffer[] srcs)`
`long`	`FileChannel.write(ByteBuffer[] srcs)` 将字节序列从给定的缓冲区写入此通道。
`long`	`GatheringByteChannel.write(ByteBuffer[] srcs)` 将字节序列从给定的缓冲区写入此通道。
`abstract long`	`DatagramChannel.write(ByteBuffer[] srcs, int offset, int length)` 将数据报写入此通道。
`abstract long`	`SocketChannel.write(ByteBuffer[] srcs, int offset, int length)`
`abstract long`	`FileChannel.write(ByteBuffer[] srcs, int offset, int length)` 将字节序列从给定缓冲区的子序列写入此通道。
`long`	`GatheringByteChannel.write(ByteBuffer[] srcs, int offset, int length)` 将字节序列从给定缓冲区的子序列写入此通道。
`abstract int`	`FileChannel.write(ByteBuffer src, long position)` 从给定的文件位置开始，将字节序列从给定缓冲区写入此通道。

java.nio.channels.spi 中 IOException 的使用

抛出 IOException 的 java.nio.channels.spi 中的方法
`void`	`AbstractSelector.close()` 关闭此选择器。
`void`	`AbstractInterruptibleChannel.close()` 关闭此通道。
`SelectableChannel`	`AbstractSelectableChannel.configureBlocking(boolean block)` 调整此通道的阻塞模式。
`protected void`	`AbstractSelectableChannel.implCloseChannel()` 关闭此通道。
`protected abstract void`	`AbstractInterruptibleChannel.implCloseChannel()` 关闭此通道。
`protected abstract void`	`AbstractSelectableChannel.implCloseSelectableChannel()` 关闭此可选择通道。
`protected abstract void`	`AbstractSelector.implCloseSelector()` 关闭此选择器。
`protected abstract void`	`AbstractSelectableChannel.implConfigureBlocking(boolean block)` 调整此通道的阻塞模式。
`Channel`	`SelectorProvider.inheritedChannel()` 返回从创建此 Java 虚拟机的实体中继承的通道。
`abstract DatagramChannel`	`SelectorProvider.openDatagramChannel()` 打开数据报通道。
`abstract Pipe`	`SelectorProvider.openPipe()` 打开一个管道。
`abstract AbstractSelector`	`SelectorProvider.openSelector()` 打开一个选择器。
`abstract ServerSocketChannel`	`SelectorProvider.openServerSocketChannel()` 打开服务器套接字通道。
`abstract SocketChannel`	`SelectorProvider.openSocketChannel()` 打开套接字通道。

java.nio.charset 中 IOException 的使用

java.nio.charset 中 IOException 的子类
`class`	`CharacterCodingException` 出现字符编码或解码错误时，抛出此经过检查的异常。
`class`	`MalformedInputException` 当输入字节序列对于给定 charset 来说是不合法的，或者输入字符序列不是合法的 16 位 Unicode 序列时，抛出此经过检查的异常。
`class`	`UnmappableCharacterException` 当输入字符（或字节）序列有效，但不能被映射为输出字节（或字符）序列时，抛出此经过检查的异常。

java.rmi 中 IOException 的使用

java.rmi 中 IOException 的子类
`class`	`AccessException` `AccessException` 由 `java.rmi.Naming` 类（特别是 `bind`、`rebind` 和 `unbind`）的某些方法和 `java.rmi.activation.ActivationSystem` 接口的方法抛出，以指示调用方不允许执行该方法调用所请求的操作。
`class`	`ConnectException` 如果拒绝远程主机对连接的远程方法调用，则抛出 `ConnectException`。
`class`	`ConnectIOException` 如果在连接到远程主机以便进行远程方法调用时发生 `IOException`，则抛出 `ConnectIOException`。
`class`	`MarshalException` 如果在编组远程调用标题、参数或远程方法调用的返回值时发生 `java.io.IOException`，则抛出 `MarshalException`。
`class`	`NoSuchObjectException` 如果试图调用远程虚拟机上已不存在的对象上的方法，则抛出 `NoSuchObjectException`。
`class`	`RemoteException` `RemoteException` 是许多与通信相关的异常的通用超类，这些异常可能会在执行远程方法调用期间发生。
`class`	`ServerError` 当在服务器上处理远程方法调用时（既可以是解编参数、执行远程方法本身时，也可以是编组返回值时），如果抛出 `Error`，则作为远程方法调用的结果，将抛出 `ServerError`。
`class`	`ServerException` 在服务器上处理远程方法调用（既可以在解编参数时，也可以是在执行远程方法本身时）时，如果抛出 `RemoteException`，则作为远程方法调用的结果，也会抛出 `ServerException`。
`class`	`ServerRuntimeException` 已过时。无替换版本
`class`	`StubNotFoundException` 如果在导入某个远程对象时无法找到该对象的有效 stub 类，则抛出 `StubNotFoundException`。
`class`	`UnexpectedException` 如果远程方法调用的客户机因为该调用而收到一个未经检查的异常（该异常不属于远程接口方法的 `throws` 语句中声明的经检查的异常类型），则抛出 `UnexpectedException`。
`class`	`UnmarshalException` 在解组参数时或者如果发生以下任何情况导致远程方法调用，则抛出 `UnmarshalException`：如果在解组调用标题时发生异常如果返回值的协议无效如果解组参数（在服务器端）或返回值（在客户机端）时发生 `java.io.IOException`。

抛出 IOException 的 java.rmi 中的方法
`T`	`MarshalledObject.get()` 返回所包含的 marshalledobject 的新副本。

抛出 IOException 的 java.rmi 中的构造方法
`MarshalledObject(T obj)` 创建一个新的 `MarshalledObject`，它包含所提供对象的当前状态的序列化表示形式。

java.rmi.activation 中 IOException 的使用

java.rmi.activation 中 IOException 的子类
`class`	`ActivateFailedException` 在一个对可激活对象的远程调用过程中，当激活失败时，此异常由 RMI 运行时抛出。

java.rmi.server 中 IOException 的使用

java.rmi.server 中 IOException 的子类
`class`	`ExportException` `ExportException` 是在尝试导出远程对象失败时抛出的 `RemoteException`。
`class`	`SkeletonMismatchException` 已过时。无替代版本。在 Java 2 平台 1.2 版及更高版本中，远程方法调用不再需要 Skeleton。
`class`	`SkeletonNotFoundException` 已过时。无替代版本在 Java 2 平台 1.2 版及更高版本中，远程方法调用不再需要 Skeleton。
`class`	`SocketSecurityException` 已废弃的 `ExportException` 的子类。

抛出 IOException 的 java.rmi.server 中的方法
`ServerSocket`	`RMIServerSocketFactory.createServerSocket(int port)` 在指定端口上（端口 0 指示匿名端口）创建服务器套接字。
`abstract ServerSocket`	`RMISocketFactory.createServerSocket(int port)` 在指定端口上（端口 0 指示匿名端口）创建服务器套接字。
`Socket`	`RMIClientSocketFactory.createSocket(String host, int port)` 创建连接到指定主机和端口的客户机套接字。
`abstract Socket`	`RMISocketFactory.createSocket(String host, int port)` 创建连接到指定主机和端口的客户机套接字。
`void`	`RemoteCall.done()` 已过时。无替代版本
`ObjectInput`	`RemoteCall.getInputStream()` 已过时。无替代版本
`ObjectOutput`	`RemoteCall.getOutputStream()` 已过时。无替代版本
`ObjectOutput`	`RemoteCall.getResultStream(boolean success)` 已过时。无替代版本
`static UID`	`UID.read(DataInput in)` 通过从 `DataInput` 实例解组二进制表示形式构造并返回一个新的 `UID`。
`static ObjID`	`ObjID.read(ObjectInput in)` 通过从 `ObjectInput` 实例解组二进制表示形式来构造和返回一个新的 `ObjID` 实例。
`void`	`RemoteCall.releaseInputStream()` 已过时。无替代版本
`void`	`RemoteCall.releaseOutputStream()` 已过时。无替代版本
`static void`	`RMISocketFactory.setSocketFactory(RMISocketFactory fac)` 设置 RMI 从中获取套接字的全局套接字工厂（如果远程对象与指定客户机和/或服务器套接字工厂无关）。
`void`	`UID.write(DataOutput out)` 将此 `UID` 的二进制表示形式编组为一个 `DataOutput` 实例。
`void`	`ObjID.write(ObjectOutput out)` 将此 `ObjID` 的二进制表示形式编组为一个 `ObjectOutput` 实例。

java.security 中 IOException 的使用

抛出 IOException 的 java.security 中的方法
`void`	`Certificate.decode(InputStream stream)` 已过时。从输入流解码证书。
`void`	`Certificate.encode(OutputStream stream)` 已过时。以 `decode` 方法可以解码的格式将证书编码到输出流。
`protected abstract byte[]`	`AlgorithmParametersSpi.engineGetEncoded()` 返回基本编码格式的参数。
`protected abstract byte[]`	`AlgorithmParametersSpi.engineGetEncoded(String format)` 返回以指定格式编码的参数。
`protected abstract void`	`AlgorithmParametersSpi.engineInit(byte[] params)` 根据参数的基本解码格式导入指定的参数并对其解码。
`protected abstract void`	`AlgorithmParametersSpi.engineInit(byte[] params, String format)` 根据指定的解码格式从 `params` 导入参数并对其解码。
`abstract void`	`KeyStoreSpi.engineLoad(InputStream stream, char[] password)` 从给定的输入流中加载此 KeyStore。
`void`	`KeyStoreSpi.engineLoad(KeyStore.LoadStoreParameter param)` 使用给定的 `KeyStore.LoadStoreParameter` 加载该 keystore。
`void`	`KeyStoreSpi.engineStore(KeyStore.LoadStoreParameter param)` 使用给定的 `KeyStore.LoadStoreParmeter` 存储此 keystore。
`abstract void`	`KeyStoreSpi.engineStore(OutputStream stream, char[] password)` 将此 keystore 存储到给定输出流中，并用给定的密码保护其完整性。
`byte[]`	`AlgorithmParameters.getEncoded()` 返回基本编码格式的参数。
`byte[]`	`AlgorithmParameters.getEncoded(String format)` 返回以指定方案编码的参数。
`Object`	`SignedObject.getObject()` 获取已封装的对象。
`void`	`AlgorithmParameters.init(byte[] params)` 根据参数的基本解码格式导入指定的参数并对其解码。
`void`	`AlgorithmParameters.init(byte[] params, String format)` 根据指定的解码方案从 `params` 导入参数并对其解码。
`void`	`Provider.load(InputStream inStream)` 从输入流中读取属性列表（键和元素对）。
`void`	`KeyStore.load(InputStream stream, char[] password)` 从给定输入流中加载此 KeyStore。
`void`	`KeyStore.load(KeyStore.LoadStoreParameter param)` 使用给定 `LoadStoreParameter` 加载此 keystore。
`int`	`DigestInputStream.read()` 读取字节并更新消息摘要（如果开启了摘要功能）。
`int`	`DigestInputStream.read(byte[] b, int off, int len)` 读入 byte 数组并更新消息摘要（如果开启了摘要功能）。
`void`	`KeyStore.store(KeyStore.LoadStoreParameter param)` 使用给定 `LoadStoreParameter` 存储此 keystore。
`void`	`KeyStore.store(OutputStream stream, char[] password)` 将此 keystore 存储到给定输出流，并用给定密码保护其完整性。
`void`	`DigestOutputStream.write(byte[] b, int off, int len)` 使用指定的子数组更新消息摘要（如果开启了摘要功能），并将子数组写入输出流（不管是否开启了摘要功能）。
`void`	`DigestOutputStream.write(int b)` 使用指定的字节更新消息摘要（如果开启了摘要功能），并将字节写入输出流（不管是否开启了摘要功能）。

抛出 IOException 的 java.security 中的构造方法
`SignedObject(Serializable object, PrivateKey signingKey, Signature signingEngine)` 通过任何可序列化对象构造 SignedObject。

java.security.cert 中 IOException 的使用

抛出 IOException 的 java.security.cert 中的方法
`void`	`X509CRLSelector.addIssuerName(byte[] name)` 向 issuerNames 标准中添加名称。
`void`	`X509CRLSelector.addIssuerName(String name)` 已过时，使用 X509CRLSelector.addIssuer(X500Principal) 或 X509CRLSelector.addIssuerName(byte[]) 替代。
`void`	`X509CertSelector.addPathToName(int type, byte[] name)` 向 pathToNames 标准中添加一个名称。
`void`	`X509CertSelector.addPathToName(int type, String name)` 向 pathToNames 标准中添加一个名称。
`void`	`X509CertSelector.addSubjectAlternativeName(int type, byte[] name)` 向 subjectAlternativeNames 标准中添加一个名称。
`void`	`X509CertSelector.addSubjectAlternativeName(int type, String name)` 向 subjectAlternativeNames 标准中添加一个名称。
`byte[]`	`X509CertSelector.getIssuerAsBytes()` 返回以 byte 数组表示的 issuer 标准。
`byte[]`	`X509CertSelector.getSubjectAsBytes()` 以 byte 数组的形式返回 subject 标准。
`void`	`X509CertSelector.setExtendedKeyUsage(Set<String> keyPurposeSet)` 设置 extendedKeyUsage 标准。
`void`	`X509CertSelector.setIssuer(byte[] issuerDN)` 设置 issuer 标准。
`void`	`X509CertSelector.setIssuer(String issuerDN)` 已过时，使用 X509CertSelector.setIssuer(X500Principal) 或 X509CertSelector.setIssuer(byte[]) 替代。
`void`	`X509CRLSelector.setIssuerNames(Collection<?> names)` 注意：请使用 X509CRLSelector.setIssuers(Collection) 方法，或者使用此方法时仅指定 byte 数组形式的标识名。
`void`	`X509CertSelector.setNameConstraints(byte[] bytes)` 设置 NameConstraints 标准。
`void`	`X509CertSelector.setPathToNames(Collection<List<?>> names)` 设置 pathToNames 标准。
`void`	`X509CertSelector.setPolicy(Set<String> certPolicySet)` 设置策略限制。
`void`	`X509CertSelector.setSubject(byte[] subjectDN)` 设置 subject 标准。
`void`	`X509CertSelector.setSubject(String subjectDN)` 已过时，使用 X509CertSelector.setSubject(X500Principal) 或 X509CertSelector.setSubject(byte[]) 替代。
`void`	`X509CertSelector.setSubjectAlternativeNames(Collection<List<?>> names)` 设置 subjectAlternativeNames 标准。
`void`	`X509CertSelector.setSubjectPublicKey(byte[] key)` 设置 subjectPublicKey 标准。
`void`	`X509CertSelector.setSubjectPublicKeyAlgID(String oid)` 设置 subjectPublicKeyAlgID 标准。

抛出 IOException 的 java.security.cert 中的构造方法
`PolicyQualifierInfo(byte[] encoded)` 根据已编码的字节创建一个 `PolicyQualifierInfo` 实例。

java.util 中 IOException 的使用

java.util 中 IOException 的子类
`class`	`InvalidPropertiesFormatException` 当按照 `Properties` 规范，输入内容不符合属性集的正确 XML 文档类型，从而无法完成操作时，抛出此异常。

返回 IOException 的 java.util 中的方法
`IOException`	`Formatter.ioException()` 返回由此 formatter 的 `Appendable` 方法上次抛出的 `IOException` 异常。
`IOException`	`Scanner.ioException()` 返回此 `Scanner` 的底层 `Readable` 最后抛出的 `IOException`。

抛出 IOException 的 java.util 中的方法
`void`	`Properties.load(InputStream inStream)` 从输入流中读取属性列表（键和元素对）。
`void`	`Properties.load(Reader reader)` 按简单的面向行的格式从输入字符流中读取属性列表（键和元素对）。
`void`	`Properties.loadFromXML(InputStream in)` 将指定输入流中由 XML 文档所表示的所有属性加载到此属性表中。
`ResourceBundle`	`ResourceBundle.Control.newBundle(String baseName, Locale locale, String format, ClassLoader loader, boolean reload)` 针对给定格式和语言环境的给定包名称，实例化一个资源包，如有必要，可使用给定的类加载器。
`void`	`Properties.store(OutputStream out, String comments)` 以适合使用 `load(InputStream)` 方法加载到 `Properties` 表中的格式，将此 `Properties` 表中的属性列表（键和元素对）写入输出流。
`void`	`Properties.store(Writer writer, String comments)` 以适合使用 `load(Reader)` 方法的格式，将此 `Properties` 表中的属性列表（键和元素对）写入输出字符。
`void`	`Properties.storeToXML(OutputStream os, String comment)` 发出一个表示此表中包含的所有属性的 XML 文档。
`void`	`Properties.storeToXML(OutputStream os, String comment, String encoding)` 使用指定的编码发出一个表示此表中包含的所有属性的 XML 文档。

抛出 IOException 的 java.util 中的构造方法
`PropertyResourceBundle(InputStream stream)` 根据 `InputStream` 创建属性资源包。
`PropertyResourceBundle(Reader reader)` 根据 `Reader` 创建属性资源包。

java.util.jar 中 IOException 的使用

java.util.jar 中 IOException 的子类
`class`	`JarException` 读取或写入 JAR 文件时，如果发生某种错误，则抛出此异常。

抛出 IOException 的 java.util.jar 中的方法
`Attributes`	`JarEntry.getAttributes()` 返回此条目的 `Manifest` `Attributes`；如果没有，则返回 `null`。
`InputStream`	`JarFile.getInputStream(ZipEntry ze)` 返回用于读取指定 zip 文件条目内容的输入流。
`Manifest`	`JarFile.getManifest()` 返回 jar 文件清单；如果没有，则返回 `null`。
`ZipEntry`	`JarInputStream.getNextEntry()` 读取下一个 ZIP 文件条目，并将流定位于此条目数据的开始处。
`JarEntry`	`JarInputStream.getNextJarEntry()` 读取下一个 JAR 文件条目，并将流定位于此条目数据的开始处。
`void`	`Pack200.Packer.pack(JarFile in, OutputStream out)` 接收 JarFile 并将其转换为 Pack200 存档。
`void`	`Pack200.Packer.pack(JarInputStream in, OutputStream out)` 接收 JarInputStream 并将其转换成 Pack200 存档。
`void`	`JarOutputStream.putNextEntry(ZipEntry ze)` 开始写入新的 JAR 文件条目，并将流定位到条目数据的开始处。
`int`	`JarInputStream.read(byte[] b, int off, int len)` 从当前 JAR 文件条目读入字节数组。
`void`	`Manifest.read(InputStream is)` 从指定的 InputStream 读取 Manifest。
`void`	`Pack200.Unpacker.unpack(File in, JarOutputStream out)` 读取 Pack200 存档，并将已编码的 JAR 写入 JarOutputStream。
`void`	`Pack200.Unpacker.unpack(InputStream in, JarOutputStream out)` 读取 Pack200 存档，并将已编码的 JAR 写入 JarOutputStream。
`void`	`Manifest.write(OutputStream out)` 将 Manifest 写入指定的 OutputStream。

抛出 IOException 的 java.util.jar 中的构造方法
`JarFile(File file)` 创建一个要从指定的 `File` 对象读取的新的 `JarFile`。
`JarFile(File file, boolean verify)` 创建一个要从指定的 `File` 对象读取的新的 `JarFile`。
`JarFile(File file, boolean verify, int mode)` 创建一个要从指定的 `File` 对象中以指定模式读取的新的 `JarFile`。
`JarFile(String name)` 创建一个要从指定的文件 `name` 读取的新的 `JarFile`。
`JarFile(String name, boolean verify)` 创建一个要从指定的文件 `name` 读取的新的 `JarFile`。
`JarInputStream(InputStream in)` 创建新的 `JarInputStream` 并读取可选的清单。
`JarInputStream(InputStream in, boolean verify)` 创建新的 `JarInputStream` 并读取可选的清单。
`JarOutputStream(OutputStream out)` 创建不带清单的新的 `JarOutputStream`。
`JarOutputStream(OutputStream out, Manifest man)` 使用指定的 `Manifest` 创建新的 `JarOutputStream`。
`Manifest(InputStream is)` 从指定的输入流构造新的 Manifest。

java.util.logging 中 IOException 的使用

抛出 IOException 的 java.util.logging 中的方法
`void`	`LogManager.readConfiguration()` 重新初始化日志属性并重新读取日志配置。
`void`	`LogManager.readConfiguration(InputStream ins)` 从给定流重新初始化并重新读取日志配置，该配置为 java.util.Properties 格式。

抛出 IOException 的 java.util.logging 中的构造方法
`FileHandler()` 构造一个默认的 `FileHandler`。
`FileHandler(String pattern)` 初始化要写入给定文件名的 `FileHandler` 。
`FileHandler(String pattern, boolean append)` 初始化要写入给定文件名的 `FileHandler`（使用可选的 append）。
`FileHandler(String pattern, int limit, int count)` 初始化要写入文件集的 `FileHandler`。
`FileHandler(String pattern, int limit, int count, boolean append)` 初始化要写入文件集的 `FileHandler`（使用可选的 append）。
`SocketHandler()` 仅使用 `LogManager` 属性（或其默认值）创建 `SocketHandler`。
`SocketHandler(String host, int port)` 构造一个带有指定主机和端口的 `SocketHandler`。

java.util.prefs 中 IOException 的使用

抛出 IOException 的 java.util.prefs 中的方法
`void`	`AbstractPreferences.exportNode(OutputStream os)` 根据 `Preferences.exportNode(OutputStream)` 中的规范实现 `exportNode` 方法。
`abstract void`	`Preferences.exportNode(OutputStream os)` 在指定输出流上发出表示此节点（不是其子节点）中包含的所有首选项的 XML 文档。
`void`	`AbstractPreferences.exportSubtree(OutputStream os)` 根据 `Preferences.exportSubtree(OutputStream)` 中的规范实现 `exportSubtree` 方法。
`abstract void`	`Preferences.exportSubtree(OutputStream os)` 发出表示此节点及其所有子节点中包含的全部首选项的 XML 文档。
`static void`	`Preferences.importPreferences(InputStream is)` 导入指定输入流中由 XML 文档表示的所有首选项。

java.util.zip 中 IOException 的使用

java.util.zip 中 IOException 的子类
`class`	`ZipException` 如果某种 ZIP 异常发生，则抛出此错误。

抛出 IOException 的 java.util.zip 中的方法
`int`	`DeflaterInputStream.available()` 在到达 EOF 后返回 0；否则始终返回 1。
`int`	`ZipInputStream.available()` 在 EOF 到达当前条目数据后，返回 0；否则，始终返回 1。
`int`	`InflaterInputStream.available()` 在到达 EOF 后返回 0；否则始终返回 1。
`void`	`DeflaterInputStream.close()` 关闭此输入流和它的底层输入流，丢弃挂起的未压缩数据。
`void`	`InflaterOutputStream.close()` 将剩余未压缩数据写入输出流并关闭底层输出流。
`void`	`ZipOutputStream.close()` 关闭 ZIP 输出流和正在过滤的流。
`void`	`DeflaterOutputStream.close()` 将剩余压缩数据写入输出流并关闭底层流。
`void`	`GZIPInputStream.close()` 关闭此输入流并释放与该流关联的所有系统资源。
`void`	`ZipInputStream.close()` 关闭此输入流并释放与此流关联的所有系统资源。
`void`	`InflaterInputStream.close()` 关闭此输入流并释放与该流关联的所有系统资源。
`void`	`ZipFile.close()` 关闭 ZIP 文件。
`void`	`ZipOutputStream.closeEntry()` 关闭当前 ZIP 条目并定位流以写入下一个条目。
`void`	`ZipInputStream.closeEntry()` 关闭当前 ZIP 条目并定位流以读取下一个条目。
`protected void`	`DeflaterOutputStream.deflate()` 将下一个压缩数据块写入输出流。
`protected void`	`InflaterInputStream.fill()` 使用更多要解压缩的数据填充输入缓冲区。
`protected void`	`ZipFile.finalize()` 确保不再引用此 ZIP 文件时调用它的 `close` 方法。
`void`	`GZIPOutputStream.finish()` 完成将压缩数据写入输出流的操作，无需关闭底层流。
`void`	`InflaterOutputStream.finish()` 完成将未压缩数据写入输出流的操作，无需关闭底层流。
`void`	`ZipOutputStream.finish()` 完成写入 ZIP 输出流的内容，无需关闭底层流。
`void`	`DeflaterOutputStream.finish()` 完成将压缩数据写入输出流的操作，无需关闭底层流。
`void`	`InflaterOutputStream.flush()` 刷新此输出流，并强制写出挂起的所有缓冲输出字节。
`InputStream`	`ZipFile.getInputStream(ZipEntry entry)` 返回输入流以读取指定 ZIP 文件条目的内容。
`ZipEntry`	`ZipInputStream.getNextEntry()` 读取下一个 ZIP 文件条目并将流定位到该条目数据的开始处。
`void`	`ZipOutputStream.putNextEntry(ZipEntry e)` 开始写入新的 ZIP 文件条目并将流定位到条目数据的开始处。
`int`	`CheckedInputStream.read()` 读取字节。
`int`	`DeflaterInputStream.read()` 从输入流读取一个压缩数据的单个字节。
`int`	`InflaterInputStream.read()` 读取未压缩数据的字节。
`int`	`CheckedInputStream.read(byte[] buf, int off, int len)` 读入字节数组。
`int`	`DeflaterInputStream.read(byte[] b, int off, int len)` 将压缩数据读入 byte 数组。
`int`	`GZIPInputStream.read(byte[] buf, int off, int len)` 将未压缩数据读入字节数组。
`int`	`ZipInputStream.read(byte[] b, int off, int len)` 从当前 ZIP 条目读入字节数组。
`int`	`InflaterInputStream.read(byte[] b, int off, int len)` 将未压缩数据读入字节数组。
`void`	`DeflaterInputStream.reset()` 不支持此操作。
`void`	`InflaterInputStream.reset()` 将此流重新定位到对此输入流最后调用 `mark` 方法时的位置。
`long`	`CheckedInputStream.skip(long n)` 跳过指定的输入字节数。
`long`	`DeflaterInputStream.skip(long n)` 从输入流中跳过并丢弃数据。
`long`	`ZipInputStream.skip(long n)` 跳过当前 ZIP 条目中指定的字节数。
`long`	`InflaterInputStream.skip(long n)` 跳过指定的未压缩数据的字节数。
`void`	`CheckedOutputStream.write(byte[] b, int off, int len)` 写入字节数组。
`void`	`GZIPOutputStream.write(byte[] buf, int off, int len)` 将字节数组写入压缩输出流。
`void`	`InflaterOutputStream.write(byte[] b, int off, int len)` 将 byte 数组写入未压缩输出流。
`void`	`ZipOutputStream.write(byte[] b, int off, int len)` 将字节数组写入当前 ZIP 条目数据。
`void`	`DeflaterOutputStream.write(byte[] b, int off, int len)` 将字节数组写入压缩的输出流。
`void`	`CheckedOutputStream.write(int b)` 写入字节。
`void`	`InflaterOutputStream.write(int b)` 将字节写入未压缩输出流。
`void`	`DeflaterOutputStream.write(int b)` 将字节写入压缩的输出流。

抛出 IOException 的 java.util.zip 中的构造方法
`GZIPInputStream(InputStream in)` 使用默认缓冲区大小创建新的输入流。
`GZIPInputStream(InputStream in, int size)` 使用指定缓冲区大小创建新的输入流。
`GZIPOutputStream(OutputStream out)` 使用默认缓冲区大小创建新的输出流。
`GZIPOutputStream(OutputStream out, int size)` 使用指定缓冲区大小创建新的输出流。
`ZipFile(File file)` 打开供阅读的 ZIP 文件，由指定的 File 对象给出。
`ZipFile(File file, int mode)` 打开新的 `ZipFile` 以使用指定模式从指定 `File` 对象读取。
`ZipFile(String name)` 打开 ZIP 文件进行阅读。

javax.activation 中 IOException 的使用

javax.activation 中 IOException 的子类
`class`	`UnsupportedDataTypeException` 当请求操作不支持请求的数据类型时，抛出此异常。

抛出 IOException 的 javax.activation 中的方法
`Object`	`CommandInfo.getCommandObject(DataHandler dh, ClassLoader loader)` 返回已实例化的 JavaBean 组件。
`Object`	`DataHandler.getContent()` 以其首选 Object 的形式返回数据。
`Object`	`DataContentHandler.getContent(DataSource ds)` 返回一个对象，该对象表示其首选形式的数据。
`InputStream`	`DataHandler.getInputStream()` 获取此对象的 InputSteam。
`InputStream`	`DataSource.getInputStream()` 此方法返回一个表示数据的 `InputStream`；如果无法提供，则抛出适当的异常。
`InputStream`	`FileDataSource.getInputStream()` 此方法将返回一个表示数据的 InputStream；如果不能返回，则抛出 IOException。
`InputStream`	`URLDataSource.getInputStream()` URL 的 getInputStream 方法。
`OutputStream`	`DataHandler.getOutputStream()` 获取此 DataHandler 的 OutputStream，以允许重写底层数据。
`OutputStream`	`DataSource.getOutputStream()` 此方法返回一个可以写入数据的 `OutputStream`，如果无法返回，则抛出适当的异常。
`OutputStream`	`FileDataSource.getOutputStream()` 此方法将返回一个表示数据的 OutputStream；如果不能返回，则抛出 IOException。
`OutputStream`	`URLDataSource.getOutputStream()` URL 的 getOutputStream 方法。
`Object`	`DataHandler.getTransferData(DataFlavor flavor)` 返回一个对象，该对象表示要传输的数据。
`Object`	`DataContentHandler.getTransferData(DataFlavor df, DataSource ds)` 返回一个对象，该对象表示将要传输的数据。
`void`	`MimeType.readExternal(ObjectInput in)` 对象可实现 readExternal 方法来恢复其内容：对于基本类型，调用 DataInput 的方法；对于对象、字符串和数组，调用 readObject。
`void`	`CommandObject.setCommandContext(String verb, DataHandler dh)` 用请求处理的动词和描述将要操作的数据的 DataHandler 来初始化 Command。
`void`	`MimeType.writeExternal(ObjectOutput out)` 对象可实现 writeExternal 方法来保存其内容：对于其基本值，调用 DataOutput 的方法；对于对象、字符串和数组，调用 ObjectOutput 的 writeObject 方法。
`void`	`DataContentHandler.writeTo(Object obj, String mimeType, OutputStream os)` 将对象转换为指定 MIME 类型的字节流，并将其写入输出流。
`void`	`DataHandler.writeTo(OutputStream os)` 将数据写入 `OutputStream`。

抛出 IOException 的 javax.activation 中的构造方法
`MailcapCommandMap(String fileName)` 允许调用者指定 mailcap 文件路径的构造方法。
`MimetypesFileTypeMap(String mimeTypeFileName)` 用从指定文件中添加的编程条目构造 MimetypesFileTypeMap。

javax.activity 中 IOException 的使用

javax.activity 中 IOException 的子类
`class`	`ActivityCompletedException` 任何访问 Activity 上下文的方法都可能抛出此异常，它指示不能继续在 Activity 内部执行操作。
`class`	`ActivityRequiredException` 如果方法没有接收到它所要求的 Activity 上下文，则容器将抛出此异常。
`class`	`InvalidActivityException` 任何访问 Activity 上下文的方法都可能抛出此异常，它指示尝试调用或与尝试调用相关的 Activity 上下文与 Activity 的当前状态不兼容。

javax.annotation.processing 中 IOException 的使用

javax.annotation.processing 中 IOException 的子类
`class`	`FilerException` 指示一个检测到试图打开某一文件的 `Filer`，该文件违反 `Filer` 提供的保证。

抛出 IOException 的 javax.annotation.processing 中的方法
`JavaFileObject`	`Filer.createClassFile(CharSequence name, Element... originatingElements)` 创建一个新的类文件，并返回一个对象以允许写入它。
`FileObject`	`Filer.createResource(JavaFileManager.Location location, CharSequence pkg, CharSequence relativeName, Element... originatingElements)` 创建一个用于写入操作的新辅助资源文件，并为它返回一个文件对象。
`JavaFileObject`	`Filer.createSourceFile(CharSequence name, Element... originatingElements)` 创建一个新的源文件，并返回一个对象以允许写入它。
`FileObject`	`Filer.getResource(JavaFileManager.Location location, CharSequence pkg, CharSequence relativeName)` 返回一个用于读取现有资源的对象。

javax.crypto 中 IOException 的使用

抛出 IOException 的 javax.crypto 中的方法
`int`	`CipherInputStream.available()` 返回不发生阻塞地从此输入流读取的字节数。
`void`	`CipherInputStream.close()` 关闭该输入流并释放任何与该流关联的系统资源。
`void`	`CipherOutputStream.close()` 关闭此输出流并释放任何与此流关联的系统资源。
`void`	`CipherOutputStream.flush()` 强制写出已由封装的密码对象处理的任何缓存输出字节来刷新此输出流。
`byte[]`	`EncryptedPrivateKeyInfo.getEncoded()` 返回此对象的 ASN.1 编码。
`Object`	`SealedObject.getObject(Cipher c)` 获取原始（封装的）对象。
`Object`	`SealedObject.getObject(Key key)` 获取原始（封装的）对象。
`Object`	`SealedObject.getObject(Key key, String provider)` 获取原始（封装的）对象。
`int`	`CipherInputStream.read()` 从该输入流读取下一数据字节。
`int`	`CipherInputStream.read(byte[] b)` 从该输入流将 `b.length` 个数据字节读入到字节数组中。
`int`	`CipherInputStream.read(byte[] b, int off, int len)` 从该输入流将 `len` 个字节数据读入到字节数组中。
`long`	`CipherInputStream.skip(long n)` 跳过不发生阻塞地从该输入流读取的字节中的 `n` 个字节的输入。
`void`	`CipherOutputStream.write(byte[] b)` 从指定的字节数组中将 `b.length` 个字节写入此输出流。
`void`	`CipherOutputStream.write(byte[] b, int off, int len)` 将指定的字节数组中从 `off` 偏移量开始的 `len` 个字节写入此输出流。
`void`	`CipherOutputStream.write(int b)` 将指定的字节写入此输出流。

抛出 IOException 的 javax.crypto 中的构造方法
`EncryptedPrivateKeyInfo(byte[] encoded)` 根据其 ASN.1 编码构造（即解析）`EncryptedPrivateKeyInfo`。
`SealedObject(Serializable object, Cipher c)` 从任何 Serializable 对象构造一个 SealedObject。

javax.imageio 中 IOException 的使用

javax.imageio 中 IOException 的子类
`class`	`IIOException` 该异常类用于发出关于读取和写入操作的运行时故障的信号。

抛出 IOException 的 javax.imageio 中的方法
`boolean`	`ImageWriter.canInsertEmpty(int imageIndex)` 如果 writer 支持在给定索引处插入新的空图像，则返回 `true`。
`boolean`	`ImageWriter.canInsertImage(int imageIndex)` 如果 writer 支持在给定索引处插入新图像，则返回 `true`。
`boolean`	`ImageWriter.canRemoveImage(int imageIndex)` 如果 writer 支持在给定索引处移除现有图像，则返回 `true`。
`boolean`	`ImageWriter.canReplaceImageMetadata(int imageIndex)` 如果有可能使用索引 `imageIndex` 替换与现有图像有关的图像元数据，则返回 `true`。
`boolean`	`ImageWriter.canReplacePixels(int imageIndex)` 如果 writer 允许使用 `replacePixels` 方法替换给定图像的索引，则返回 `true`。
`boolean`	`ImageWriter.canReplaceStreamMetadata()` 如果有可能替换已存在于输出中的流元数据，则返回 `true`。
`boolean`	`ImageWriter.canWriteEmpty()` 如果 writer 支持写入由单个图像组成的完整图像流，则返回 `true`，这些对象带有要输出的不确定像素值、有关元数据和缩略图。
`static ImageInputStream`	`ImageIO.createImageInputStream(Object input)` 返回一个 `ImageInputStream`，它将从给定 `Object` 中获取输入。
`static ImageOutputStream`	`ImageIO.createImageOutputStream(Object output)` 返回一个 `ImageOutputStream`，它将其输出发送到给定 `Object`。
`void`	`ImageWriter.endInsertEmpty()` 完成对新图像的插入，该操作是从以前调用 `prepareInsertEmpty` 开始的。
`void`	`ImageWriter.endReplacePixels()` 终止调用 `replacePixels` 的序列。
`void`	`ImageWriter.endWriteEmpty()` 完成对新图像的写入，该操作是从优先调用 `prepareWriteEmpty` 开始的。
`void`	`ImageWriter.endWriteSequence()` 完成以 `prepareWriteSequence` 开头的一系列图像的写入。
`float`	`ImageReader.getAspectRatio(int imageIndex)` 以 `float` 的形式返回给定图像的高宽比（即宽度除以高度）。
`String`	`ImageReader.getFormatName()` 返回一个标识输入源格式的 `String`。
`abstract int`	`ImageReader.getHeight(int imageIndex)` 返回输入源中的给定图像的高度，以像素为单位。
`abstract IIOMetadata`	`ImageReader.getImageMetadata(int imageIndex)` 返回包含与给定图像关联的元数据的 `IIOMetadata` 对象，如果 reader 不支持读取元数据、被设置为忽略元数据，或者没有元数据可用，则返回 `null`。
`IIOMetadata`	`ImageReader.getImageMetadata(int imageIndex, String formatName, Set<String> nodeNames)` 返回表示与给定图像关联的元数据的 `IIOMetadata` 对象，如果 reader 不支持读取元数据或者没有元数据可用，则返回 `null`。
`abstract Iterator<ImageTypeSpecifier>`	`ImageReader.getImageTypes(int imageIndex)` 以 `ImageTypeSpecifier` 形式返回包含可能的图像类型的 `Iterator`，给定图像可能被解码成这些类型。
`abstract int`	`ImageReader.getNumImages(boolean allowSearch)` 返回当前输入源中可用的图像数，不包括缩略图。
`int`	`ImageReader.getNumThumbnails(int imageIndex)` 返回与给定图像关联的缩略图预览图像的数量。
`ImageTypeSpecifier`	`ImageReader.getRawImageType(int imageIndex)` 返回一个 `ImageTypeSpecifier`，指示最能代表图像“原始”内部格式的 `SampleModel` 和 `ColorModel`。
`abstract IIOMetadata`	`ImageReader.getStreamMetadata()` 返回一个 `IIOMetadata` 对象，它表示作为一个整体与输入源关联的元数据（即不与任何特定图像关联）；如果 reader 不支持读取元数据、被设置为忽略元数据，或者没有元数据可用，则返回 `null`。
`IIOMetadata`	`ImageReader.getStreamMetadata(String formatName, Set<String> nodeNames)` 返回一个 `IIOMetadata` 对象，它表示作为一个整体与输入源关联的元数据（即不与任何特定图像关联）。
`int`	`ImageReader.getThumbnailHeight(int imageIndex, int thumbnailIndex)` 返回通过索引 `thumbnailIndex` 指定的缩略图预览图像的高度，其与通过索引 `ImageIndex` 指定的图像关联。
`int`	`ImageReader.getThumbnailWidth(int imageIndex, int thumbnailIndex)` 返回通过索引 `thumbnailIndex` 指定的缩略图预览图像的宽度，其与通过索引 `ImageIndex` 指定的图像关联。
`int`	`ImageReader.getTileGridXOffset(int imageIndex)` 返回给定图像中 tile (0, 0) 的左上角的 X 坐标。
`int`	`ImageReader.getTileGridYOffset(int imageIndex)` 返回给定图像中 tile (0, 0) 的左上角的 Y 坐标。
`int`	`ImageReader.getTileHeight(int imageIndex)` 返回给定图像中 tile 的高度。
`int`	`ImageReader.getTileWidth(int imageIndex)` 返回给定图像中 tile 的宽度。
`abstract int`	`ImageReader.getWidth(int imageIndex)` 返回输入源中的给定图像的宽度，以像素为单位。
`boolean`	`ImageReader.hasThumbnails(int imageIndex)` 如果给定图像具有与之关联的缩略图预览图像，则返回 `true`。
`boolean`	`ImageReader.isImageTiled(int imageIndex)` 如果图像被组织成 tile（即等大小的非重叠矩形），则返回 `true`。
`boolean`	`ImageReader.isRandomAccessEasy(int imageIndex)` 如果给定图像的存储格式不会给像素的随机访问带来内在妨碍，则返回 `true`。
`void`	`ImageWriter.prepareInsertEmpty(int imageIndex, ImageTypeSpecifier imageType, int width, int height, IIOMetadata imageMetadata, List<? extends BufferedImage> thumbnails, ImageWriteParam param)` 从将带有不确定像素值的新图像插入现有图像流中开始。
`void`	`ImageWriter.prepareReplacePixels(int imageIndex, Rectangle region)` 准备好 writer，处理一系列对 `replacePixels` 方法的调用。
`void`	`ImageWriter.prepareWriteEmpty(IIOMetadata streamMetadata, ImageTypeSpecifier imageType, int width, int height, IIOMetadata imageMetadata, List<? extends BufferedImage> thumbnails, ImageWriteParam param)` 从写入完整图像流开始，该图像流由带有要输出的不确定像素值、有关元数据和缩略图的单个图像组成。
`void`	`ImageWriter.prepareWriteSequence(IIOMetadata streamMetadata)` 使用提供的流元数据对象准备一个流，以接受一系列的后续 `writeToSequence` 调用。
`static BufferedImage`	`ImageIO.read(File input)` 返回一个 `BufferedImage`，作为使用 `ImageReader`（它是从当前已注册 ImageReader 中自动选择的）解码所提供 `File` 的结果。
`static BufferedImage`	`ImageIO.read(ImageInputStream stream)` 返回一个 `BufferedImage`，作为使用 `ImageReader`（它是从当前已注册 ImageReader 中自动选择的）解码所提供 `ImageInputStream` 的结果。
`static BufferedImage`	`ImageIO.read(InputStream input)` 返回一个 `BufferedImage`，作为使用 `ImageReader`（它是从当前已注册 ImageReader 中自动选择的）解码所提供 `InputStream` 的结果。
`BufferedImage`	`ImageReader.read(int imageIndex)` 使用默认 `ImageReadParam` 读取通过索引 `imageIndex` 指定的图像，并将其作为一个完整的 `BufferedImage` 返回。
`abstract BufferedImage`	`ImageReader.read(int imageIndex, ImageReadParam param)` 使用所提供的 `ImageReadParam` 读取通过索引 `imageIndex` 指定的对象，并将它作为一个完整的 `BufferedImage` 返回。
`static BufferedImage`	`ImageIO.read(URL input)` 返回一个 `BufferedImage`，作为使用 `ImageReader`（它是从当前已注册 ImageReader 中自动选择的）解码所提供 `URL` 的结果。
`IIOImage`	`ImageReader.readAll(int imageIndex, ImageReadParam param)` 使用所提供的 `ImageReadParam` 读取通过索引 `imageIndex` 指定的图像，并返回包含图像、缩略图和相关图像元数据的 `IIOImage`。
`Iterator<IIOImage>`	`ImageReader.readAll(Iterator<? extends ImageReadParam> params)` 以 `IIOImage` 对象形式返回包含输入源中所有图像、缩略图和元数据的 `Iterator`，从 `getMinIndex` 给定的索引开始。
`RenderedImage`	`ImageReader.readAsRenderedImage(int imageIndex, ImageReadParam param)` 返回一个 `RenderedImage` 对象，该对象包含通过索引 `imageIndex` 指定的图像的内容。
`Raster`	`ImageReader.readRaster(int imageIndex, ImageReadParam param)` 返回包含图像流中原始像素数据的新 `Raster` 对象，不应用任何颜色转换。
`BufferedImage`	`ImageReader.readThumbnail(int imageIndex, int thumbnailIndex)` 以 `BufferedImage` 形式返回通过索引 `thumbnailIndex` 指定的缩略图预览图像，其与通过索引 `ImageIndex` 指定的图像关联。
`BufferedImage`	`ImageReader.readTile(int imageIndex, int tileX, int tileY)` 读取由 `tileX` 和 `tileY` 参数指示的 tile，并以 `BufferedImage` 形式返回。
`Raster`	`ImageReader.readTileRaster(int imageIndex, int tileX, int tileY)` 返回包含 tile 中的原始像素数据的新 `Raster` 对象，不应用任何颜色转换。
`void`	`ImageWriter.removeImage(int imageIndex)` 从流中移除图像。
`void`	`ImageWriter.replaceImageMetadata(int imageIndex, IIOMetadata imageMetadata)` 替换与现有图像有关的图像元数据。
`void`	`ImageWriter.replacePixels(Raster raster, ImageWriteParam param)` 用给定 `Raster` 部分替换已出现在输出中的图像部分。
`void`	`ImageWriter.replacePixels(RenderedImage image, ImageWriteParam param)` 用给定图像部分替换已出现在输出中的图像部分。
`void`	`ImageWriter.replaceStreamMetadata(IIOMetadata streamMetadata)` 使用新信息替换输出中的流元数据。
`void`	`ImageWriter.write(IIOImage image)` 将包含带有默认元数据和缩略图的单个图像的完整图像流添加到输出中。
`abstract void`	`ImageWriter.write(IIOMetadata streamMetadata, IIOImage image, ImageWriteParam param)` 添加一个完整的图像流，该图像流包含一幅图像、相关的流、图像元数据和要输出的缩略图。
`void`	`ImageWriter.write(RenderedImage image)` 将由带有默认元数据和缩略图的单个图像组成的完整图像流添加到输出中。
`static boolean`	`ImageIO.write(RenderedImage im, String formatName, File output)` 使用支持给定格式的任意 `ImageWriter` 将一个图像写入 `File`。
`static boolean`	`ImageIO.write(RenderedImage im, String formatName, ImageOutputStream output)` 使用支持给定格式的任意 `ImageWriter` 将一个图像写入 `ImageOutputStream`。
`static boolean`	`ImageIO.write(RenderedImage im, String formatName, OutputStream output)` 使用支持给定格式的任意 `ImageWriter` 将一个图像写入 `OutputStream`。
`void`	`ImageWriter.writeInsert(int imageIndex, IIOImage image, ImageWriteParam param)` 将新的图像插入现有图像流。
`void`	`ImageWriter.writeToSequence(IIOImage image, ImageWriteParam param)` 将单幅图像、可能相关的元数据和缩略图添加到输出中。

javax.imageio.metadata 中 IOException 的使用

javax.imageio.metadata 中 IOException 的子类
`class`	`IIOInvalidTreeException` 当 `IIOMetadata` 对象尝试解析 `IIOMetadataNode` 的树失败时，将抛出 `IIOInvalidTreeException`。

javax.imageio.spi 中 IOException 的使用

抛出 IOException 的 javax.imageio.spi 中的方法
`abstract boolean`	`ImageReaderSpi.canDecodeInput(Object source)` 如果给定的源对象看起来是此 reader 支持的格式，则返回 `true`。
`ImageInputStream`	`ImageInputStreamSpi.createInputStreamInstance(Object input)` 返回与此服务提供者关联的 `ImageInputStream` 实现的实例。
`abstract ImageInputStream`	`ImageInputStreamSpi.createInputStreamInstance(Object input, boolean useCache, File cacheDir)` 返回与此服务提供者关联的 `ImageInputStream` 实现的实例。
`ImageOutputStream`	`ImageOutputStreamSpi.createOutputStreamInstance(Object output)` 返回与此服务提供者关联的 `ImageOutputStream` 实现的实例。
`abstract ImageOutputStream`	`ImageOutputStreamSpi.createOutputStreamInstance(Object output, boolean useCache, File cacheDir)` 返回与此服务提供者关联的 `ImageOutputStream` 实现的实例。
`ImageReader`	`ImageReaderSpi.createReaderInstance()` 返回与此服务提供者关联的 `ImageReader` 实现的实例。
`abstract ImageReader`	`ImageReaderSpi.createReaderInstance(Object extension)` 返回与此服务提供者关联的 `ImageReader` 实现的实例。
`ImageWriter`	`ImageWriterSpi.createWriterInstance()` 返回与此服务提供者关联的 `ImageWriter` 实现的实例。
`abstract ImageWriter`	`ImageWriterSpi.createWriterInstance(Object extension)` 返回与此服务提供者关联的 `ImageWriter` 实现的实例。

javax.imageio.stream 中 IOException 的使用

抛出 IOException 的 javax.imageio.stream 中的方法
`protected void`	`ImageInputStreamImpl.checkClosed()` 如果已经关闭流，则抛出 `IOException`。
`void`	`FileCacheImageInputStream.close()` 关闭此 `FileCacheImageInputStream`，关闭并移除缓存文件。
`void`	`FileCacheImageOutputStream.close()` 关闭此 `FileCacheImageOututStream`。
`void`	`FileImageInputStream.close()`
`void`	`FileImageOutputStream.close()`
`void`	`ImageInputStream.close()` 关闭流。
`void`	`ImageInputStreamImpl.close()`
`void`	`MemoryCacheImageInputStream.close()` 关闭此 `MemoryCacheImageInputStream`，释放缓存。
`void`	`MemoryCacheImageOutputStream.close()` 关闭此 `MemoryCacheImageOutputStream`。
`void`	`ImageInputStream.flush()` 丢弃当前流位置之前的流初始部分。
`void`	`ImageInputStreamImpl.flush()`
`void`	`FileCacheImageOutputStream.flushBefore(long pos)`
`void`	`ImageInputStream.flushBefore(long pos)` 丢弃所指示位置之前的流初始部分。
`void`	`ImageInputStreamImpl.flushBefore(long pos)`
`void`	`ImageOutputStream.flushBefore(long pos)` 刷新给定位置之前所有数据的缓冲并转到底层目标（如 `OutputStream` 或 `File`）。
`void`	`MemoryCacheImageInputStream.flushBefore(long pos)`
`void`	`MemoryCacheImageOutputStream.flushBefore(long pos)`
`protected void`	`ImageOutputStreamImpl.flushBits()` 如果位偏移量为非零，则将当前字节中的剩余位强制归 0，并将流位置前移一个字节。
`int`	`ImageInputStream.getBitOffset()` 以整数的形式返回当前位偏移量，该整数在 0 到 7 之间（包含两者）。
`int`	`ImageInputStreamImpl.getBitOffset()`
`long`	`ImageInputStream.getStreamPosition()` 返回流的当前字节位置。
`long`	`ImageInputStreamImpl.getStreamPosition()`
`long`	`ImageInputStream.length()` 返回流的总长度（如果已知）。
`int`	`FileCacheImageInputStream.read()`
`int`	`FileCacheImageOutputStream.read()`
`int`	`FileImageInputStream.read()`
`int`	`FileImageOutputStream.read()`
`int`	`ImageInputStream.read()` 从流中读取单个字节，并以整数（0 到 255 之间）形式返回该字节。
`abstract int`	`ImageInputStreamImpl.read()` 从流中读取单个字节，并以 `int`（0 到 255 之间）形式返回该字节。
`int`	`MemoryCacheImageInputStream.read()`
`int`	`MemoryCacheImageOutputStream.read()`
`int`	`ImageInputStream.read(byte[] b)` 从流中读取至多 `b.length` 个字节，并将其存储到 `b` 中（从索引 0 开始）。
`int`	`ImageInputStreamImpl.read(byte[] b)` 调用 `read(b, 0, b.length)` 的便捷方法。
`int`	`FileCacheImageInputStream.read(byte[] b, int off, int len)`
`int`	`FileCacheImageOutputStream.read(byte[] b, int off, int len)`
`int`	`FileImageInputStream.read(byte[] b, int off, int len)`
`int`	`FileImageOutputStream.read(byte[] b, int off, int len)`
`int`	`ImageInputStream.read(byte[] b, int off, int len)` 从流中读取至多 `len` 个字节，并将其存储到 `b` 中（从索引 `off` 开始）。
`abstract int`	`ImageInputStreamImpl.read(byte[] b, int off, int len)` 从流中读取至多 `len` 个字节，并将其存储到 `b` 中（从 `off` 索引处开始）。
`int`	`MemoryCacheImageInputStream.read(byte[] b, int off, int len)`
`int`	`MemoryCacheImageOutputStream.read(byte[] b, int off, int len)`
`int`	`ImageInputStream.readBit()` 从流中读取单个字节，并以 `int`（`0` 或 `1`）的形式返回该字节。
`int`	`ImageInputStreamImpl.readBit()`
`long`	`ImageInputStream.readBits(int numBits)` 从流中读取位串 (bitstring) 并以 `long` 的形式返回，使第一个读取的位成为输出的最高有效位。
`long`	`ImageInputStreamImpl.readBits(int numBits)`
`boolean`	`ImageInputStream.readBoolean()` 从流中读取一个字节，如果其不为 0，则返回 `boolean` 值 `true`；如果为 0，则返回 `false`。
`boolean`	`ImageInputStreamImpl.readBoolean()`
`byte`	`ImageInputStream.readByte()` 从流中读取一个字节，并以 `byte` 值的形式返回该字节。
`byte`	`ImageInputStreamImpl.readByte()`
`void`	`ImageInputStream.readBytes(IIOByteBuffer buf, int len)` 从流中读取至多 `len` 个字节，并修改提供的 `IIOByteBuffer` 以指示可以找到数据的 byte 数组、偏移量和长度。
`void`	`ImageInputStreamImpl.readBytes(IIOByteBuffer buf, int len)`
`char`	`ImageInputStream.readChar()` 与 `readUnsignedShort` 等效，唯一的不同在于它的结果使用 `char` 数据类型返回。
`char`	`ImageInputStreamImpl.readChar()`
`double`	`ImageInputStream.readDouble()` 从流中读取 8 个字节，根据当前字节顺序将其连接（概念上），然后以 `double` 值的形式返回结果。
`double`	`ImageInputStreamImpl.readDouble()`
`float`	`ImageInputStream.readFloat()` 从流中读取 4 个字节，根据当前字节顺序将其连接（概念上），然后以 `float` 值的形式返回结果。
`float`	`ImageInputStreamImpl.readFloat()`
`void`	`ImageInputStream.readFully(byte[] b)` 从流中读取 `b.length` 个字节，并将其存储到 `b` 中（从索引 `0` 开始）。
`void`	`ImageInputStreamImpl.readFully(byte[] b)`
`void`	`ImageInputStream.readFully(byte[] b, int off, int len)` 从流中读取 `len` 个字节，并将其存储到 `b` 中（从索引 `off` 开始）。
`void`	`ImageInputStreamImpl.readFully(byte[] b, int off, int len)`
`void`	`ImageInputStream.readFully(char[] c, int off, int len)` 根据当前字节顺序从流中读取 `len` 个 char（无符号 16 位整数），并将其存储到 `c` 中（从索引 `off` 开始）。
`void`	`ImageInputStreamImpl.readFully(char[] c, int off, int len)`
`void`	`ImageInputStream.readFully(double[] d, int off, int len)` 根据当前字节顺序从流中读取 `len` 个 double（64 位 IEEE 双精度浮点值），并将其存储到 `d` 中（从索引 `off` 开始）。
`void`	`ImageInputStreamImpl.readFully(double[] d, int off, int len)`
`void`	`ImageInputStream.readFully(float[] f, int off, int len)` 根据当前字节顺序从流中读取 `len` 个 float（32 位 IEEE 单精度浮点值），并将其存储到 `f` 中（从索引 `off` 开始）。
`void`	`ImageInputStreamImpl.readFully(float[] f, int off, int len)`
`void`	`ImageInputStream.readFully(int[] i, int off, int len)` 根据当前字节顺序从流中读取 `len` 个 int（有符号 32 位整数），并将其存储到 `i` 中（从索引 `off` 开始）。
`void`	`ImageInputStreamImpl.readFully(int[] i, int off, int len)`
`void`	`ImageInputStream.readFully(long[] l, int off, int len)` 根据当前字节顺序从流中读取 `len` 个 long（有符号 64 位整数），并将其存储到 `l` 中（从索引 `off` 开始）。
`void`	`ImageInputStreamImpl.readFully(long[] l, int off, int len)`
`void`	`ImageInputStream.readFully(short[] s, int off, int len)` 根据当前字节顺序从流中读取 `len` 个 short（有符号 16 位整数），并将其存储到 `s` 中（从索引 `off` 开始）。
`void`	`ImageInputStreamImpl.readFully(short[] s, int off, int len)`
`int`	`ImageInputStream.readInt()` 从流中读取 4 个字节，根据当前字节顺序将其连接（概念上），然后以 `int` 值的形式返回结果。
`int`	`ImageInputStreamImpl.readInt()`
`String`	`ImageInputStream.readLine()` 从输入流中读取文本的下一行。
`String`	`ImageInputStreamImpl.readLine()`
`long`	`ImageInputStream.readLong()` 从流中读取 8 个字节，根据当前字节顺序将其连接（概念上），然后以 `long` 值的形式返回结果。
`long`	`ImageInputStreamImpl.readLong()`
`short`	`ImageInputStream.readShort()` 从流中读取两个字节，根据当前字节顺序将其连接（概念上），然后以 `short` 值的形式返回结果。
`short`	`ImageInputStreamImpl.readShort()`
`int`	`ImageInputStream.readUnsignedByte()` 从流中读取一个字节，将其转换为 int（概念上），使用 `0xff` 屏蔽以便去掉所有符号扩展位，然后以 `byte` 值的形式返回。
`int`	`ImageInputStreamImpl.readUnsignedByte()`
`long`	`ImageInputStream.readUnsignedInt()` 从流中读取 4 个字节，根据当前字节顺序将其连接（概念上），将得到的值转换为 long，使用 `0xffffffffL` 屏蔽以便去掉所有符号扩展位，然后以无符号 `long` 值的形式返回结果。
`long`	`ImageInputStreamImpl.readUnsignedInt()`
`int`	`ImageInputStream.readUnsignedShort()` 从流中读取两个字节，根据当前字节顺序将其连接（概念上），将得到的值转换为 `int`，使用 `0xffff` 屏蔽以便去掉所有符号扩展位，然后以无符号 `int` 值的形式返回结果。
`int`	`ImageInputStreamImpl.readUnsignedShort()`
`String`	`ImageInputStream.readUTF()` 读入一个已使用 UTF-8 修改版格式编码的字符串。
`String`	`ImageInputStreamImpl.readUTF()`
`void`	`ImageInputStream.reset()` 返回在最近一次非匹配地调用 `mark` 时指向上一个位置（包括位偏移量）的流指针。
`void`	`ImageInputStreamImpl.reset()` 根据标记的堆栈重置当前流字节和位位置。
`void`	`FileCacheImageOutputStream.seek(long pos)` 设置当前流位置并将位偏移量重置为 0。
`void`	`FileImageInputStream.seek(long pos)`
`void`	`FileImageOutputStream.seek(long pos)` 设置当前流位置并将位偏移量重置为 0。
`void`	`ImageInputStream.seek(long pos)` 将当前流位置设置为所需的位置。
`void`	`ImageInputStreamImpl.seek(long pos)`
`void`	`ImageInputStream.setBitOffset(int bitOffset)` 将位偏移量设置为 0 到 7 之间（包含两者）的整数。
`void`	`ImageInputStreamImpl.setBitOffset(int bitOffset)`
`int`	`ImageInputStream.skipBytes(int n)` 将流位置向前移动给定的字节数。
`int`	`ImageInputStreamImpl.skipBytes(int n)` 通过调用 `seek(getStreamPosition() + n)` 推进当前流位置。
`long`	`ImageInputStream.skipBytes(long n)` 将流位置向前移动给定的字节数。
`long`	`ImageInputStreamImpl.skipBytes(long n)` 通过调用 `seek(getStreamPosition() + n)` 推进当前流位置。
`void`	`ImageOutputStream.write(byte[] b)` 将字节序列写入到流中的当前位置。
`void`	`ImageOutputStreamImpl.write(byte[] b)`
`void`	`FileCacheImageOutputStream.write(byte[] b, int off, int len)`
`void`	`FileImageOutputStream.write(byte[] b, int off, int len)`
`void`	`ImageOutputStream.write(byte[] b, int off, int len)` 将字节序列写入到流中的当前位置。
`abstract void`	`ImageOutputStreamImpl.write(byte[] b, int off, int len)`
`void`	`MemoryCacheImageOutputStream.write(byte[] b, int off, int len)`
`void`	`FileCacheImageOutputStream.write(int b)`
`void`	`FileImageOutputStream.write(int b)`
`void`	`ImageOutputStream.write(int b)` 将单个字节写入到流中的当前位置。
`abstract void`	`ImageOutputStreamImpl.write(int b)`
`void`	`MemoryCacheImageOutputStream.write(int b)`
`void`	`ImageOutputStream.writeBit(int bit)` 将单个位（由参数的最低有效位给定）写入到流的当前字节位置中的当前位偏移量。
`void`	`ImageOutputStreamImpl.writeBit(int bit)`
`void`	`ImageOutputStream.writeBits(long bits, int numBits)` 将一个位序列（由 `bits` 参数的 `numBits` 个最低有效位按从左到右的顺序给定）写入到流的当前字节位置中的当前位偏移量。
`void`	`ImageOutputStreamImpl.writeBits(long bits, int numBits)`
`void`	`ImageOutputStream.writeBoolean(boolean v)` 将一个 `boolean` 值写入到流中。
`void`	`ImageOutputStreamImpl.writeBoolean(boolean v)`
`void`	`ImageOutputStream.writeByte(int v)` 将 `v` 的 8 个低位写入到流中。
`void`	`ImageOutputStreamImpl.writeByte(int v)`
`void`	`ImageOutputStream.writeBytes(String s)` 将一个字符串写入输出流。
`void`	`ImageOutputStreamImpl.writeBytes(String s)`
`void`	`ImageOutputStream.writeChar(int v)` 此方法与 `writeShort` 同义。
`void`	`ImageOutputStreamImpl.writeChar(int v)`
`void`	`ImageOutputStream.writeChars(char[] c, int off, int len)` 将 char 序列写入到流中的当前位置。
`void`	`ImageOutputStreamImpl.writeChars(char[] c, int off, int len)`
`void`	`ImageOutputStream.writeChars(String s)` 将一个字符串写入输出流。
`void`	`ImageOutputStreamImpl.writeChars(String s)`
`void`	`ImageOutputStream.writeDouble(double v)` 将一个 `double` 值写入输出流，该值由四个字节组成。
`void`	`ImageOutputStreamImpl.writeDouble(double v)`
`void`	`ImageOutputStream.writeDoubles(double[] d, int off, int len)` 将 double 序列写入到流中的当前位置。
`void`	`ImageOutputStreamImpl.writeDoubles(double[] d, int off, int len)`
`void`	`ImageOutputStream.writeFloat(float v)` 将一个 `float` 值（由四个字节组成）写入输出流。
`void`	`ImageOutputStreamImpl.writeFloat(float v)`
`void`	`ImageOutputStream.writeFloats(float[] f, int off, int len)` 将 float 序列写入到流中的当前位置。
`void`	`ImageOutputStreamImpl.writeFloats(float[] f, int off, int len)`
`void`	`ImageOutputStream.writeInt(int v)` 将 `v` 的 32 个位写入到流中。
`void`	`ImageOutputStreamImpl.writeInt(int v)`
`void`	`ImageOutputStream.writeInts(int[] i, int off, int len)` 将 int 序列写入到流中的当前位置。
`void`	`ImageOutputStreamImpl.writeInts(int[] i, int off, int len)`
`void`	`ImageOutputStream.writeLong(long v)` 将 `v` 的 64 个位写入到流中。
`void`	`ImageOutputStreamImpl.writeLong(long v)`
`void`	`ImageOutputStream.writeLongs(long[] l, int off, int len)` 将 long 序列写入到流中的当前位置。
`void`	`ImageOutputStreamImpl.writeLongs(long[] l, int off, int len)`
`void`	`ImageOutputStream.writeShort(int v)` 将 `v` 的 16 个低位写入到流中。
`void`	`ImageOutputStreamImpl.writeShort(int v)`
`void`	`ImageOutputStream.writeShorts(short[] s, int off, int len)` 将 short 序列写入到流中的当前位置。
`void`	`ImageOutputStreamImpl.writeShorts(short[] s, int off, int len)`
`void`	`ImageOutputStream.writeUTF(String s)` 将表示长度信息的两个字节按网络字节顺序写入输出流，后跟字符串 `s` 中每个字符的 UTF-8 修改版表示形式。
`void`	`ImageOutputStreamImpl.writeUTF(String s)`

抛出 IOException 的 javax.imageio.stream 中的构造方法
`FileCacheImageInputStream(InputStream stream, File cacheDir)` 构造一个将从给定 `InputStream` 进行读取的 `FileCacheImageInputStream`。
`FileCacheImageOutputStream(OutputStream stream, File cacheDir)` 构造一个将向给定 `outputStream` 进行写入的 `FileCacheImageOutputStream`。
`FileImageInputStream(File f)` 构造一个将从给定 `File` 进行读取的 `FileImageInputStream`。
`FileImageOutputStream(File f)` 构造一个将向给定 `File` 进行写入的 `FileImageOutputStream`。

javax.management 中 IOException 的使用

抛出 IOException 的 javax.management 中的方法
`void`	`MBeanServerConnection.addNotificationListener(ObjectName name, NotificationListener listener, NotificationFilter filter, Object handback)` 向已注册的 MBean 添加一个侦听器。
`void`	`MBeanServerConnection.addNotificationListener(ObjectName name, ObjectName listener, NotificationFilter filter, Object handback)` 向已注册的 MBean 添加一个侦听器。
`ObjectInstance`	`MBeanServerConnection.createMBean(String className, ObjectName name)` 在 MBean 服务器中实例化并注册一个 MBean。
`ObjectInstance`	`MBeanServerConnection.createMBean(String className, ObjectName name, Object[] params, String[] signature)` 在 MBean 服务器中实例化并注册一个 MBean。
`ObjectInstance`	`MBeanServerConnection.createMBean(String className, ObjectName name, ObjectName loaderName)` 在 MBean 服务器中实例化并注册一个 MBean。
`ObjectInstance`	`MBeanServerConnection.createMBean(String className, ObjectName name, ObjectName loaderName, Object[] params, String[] signature)` 在 MBean 服务器中实例化并注册一个 MBean。
`Object`	`MBeanServerConnection.getAttribute(ObjectName name, String attribute)` 获得指定 MBean 的特定属性值。
`AttributeList`	`MBeanServerConnection.getAttributes(ObjectName name, String[] attributes)` 获得指定 MBean 的多个属性值。
`String`	`MBeanServerConnection.getDefaultDomain()` 返回对 MBean 命名时使用的默认域。
`String[]`	`MBeanServerConnection.getDomains()` 返回其中所有 MBean 当前已注册的域的列表。
`Integer`	`MBeanServerConnection.getMBeanCount()` 返回 MBean 服务器中已注册的 MBean 数目。
`MBeanInfo`	`MBeanServerConnection.getMBeanInfo(ObjectName name)` 此方法发现了 MBean 为管理而公开的属性和操作。
`ObjectInstance`	`MBeanServerConnection.getObjectInstance(ObjectName name)` 获得向 MBean 服务器注册的给定 MBean 的 `ObjectInstance`。
`Object`	`MBeanServerConnection.invoke(ObjectName name, String operationName, Object[] params, String[] signature)` 在 MBean 上调用某个操作。
`boolean`	`MBeanServerConnection.isInstanceOf(ObjectName name, String className)` 如果指定的 MBean 是指定类的一个实例，则返回 true；否则返回 false。
`boolean`	`MBeanServerConnection.isRegistered(ObjectName name)` 检查某个 MBean（通过其对象名标识）是否已向 MBean 服务器注册。
`Set<ObjectInstance>`	`MBeanServerConnection.queryMBeans(ObjectName name, QueryExp query)` 获得该 MBean 服务器所控制的 MBean。
`Set<ObjectName>`	`MBeanServerConnection.queryNames(ObjectName name, QueryExp query)` 获得该 MBean 服务器所控制的 MBean 的名称。
`void`	`MBeanServerConnection.removeNotificationListener(ObjectName name, NotificationListener listener)` 从已注册的 MBean 中移除一个侦听器。
`void`	`MBeanServerConnection.removeNotificationListener(ObjectName name, NotificationListener listener, NotificationFilter filter, Object handback)` 从已注册的 MBean 中移除一个侦听器。
`void`	`MBeanServerConnection.removeNotificationListener(ObjectName name, ObjectName listener)` 从已注册的 MBean 中移除一个侦听器。
`void`	`MBeanServerConnection.removeNotificationListener(ObjectName name, ObjectName listener, NotificationFilter filter, Object handback)` 从已注册的 MBean 中移除一个侦听器。
`void`	`MBeanServerConnection.setAttribute(ObjectName name, Attribute attribute)` 设置指定 MBean 的特定属性值。
`AttributeList`	`MBeanServerConnection.setAttributes(ObjectName name, AttributeList attributes)` 设置指定 MBean 的多个属性值。
`void`	`MBeanServerConnection.unregisterMBean(ObjectName name)` 从 MBean 服务器中注销一个 MBean。

javax.management.loading 中 IOException 的使用

抛出 IOException 的 javax.management.loading 中的方法
`Enumeration<URL>`	`MLetMBean.getResources(String name)` 查找所有具有给定名称的资源。
`void`	`MLet.readExternal(ObjectInput in)` 从给定的 `ObjectInput` 恢复此 MLet 的内容。
`void`	`MLet.writeExternal(ObjectOutput out)` 将此 MLet 的内容保存到给定的 `ObjectOutput`。

javax.management.remote 中 IOException 的使用

javax.management.remote 中 IOException 的子类
`class`	`JMXProviderException` 当提供者存在所需的协议但由于某种原因不能使用时由 `JMXConnectorFactory` 和 `JMXConnectorServerFactory` 抛出的异常。
`class`	`JMXServerErrorException` 在处理远程 MBean 服务器中的调用的过程中抛出了 `Error` 时，远程 `MBeanServer` 方法调用导致抛出的异常。

抛出 IOException 的 javax.management.remote 中的方法
`void`	`JMXConnector.close()` 关闭客户端到其服务器的连接。
`void`	`JMXConnector.connect()` 建立到连接器服务器的连接。
`static JMXConnector`	`JMXConnectorFactory.connect(JMXServiceURL serviceURL)` 创建到位于给定地址的连接器服务器的连接。
`static JMXConnector`	`JMXConnectorFactory.connect(JMXServiceURL serviceURL, Map<String,?> environment)` 创建到位于给定地址的连接器服务器的连接。
`void`	`JMXConnector.connect(Map<String,?> env)` 建立到连接器服务器的连接。
`String`	`JMXConnector.getConnectionId()` 获得来自连接器服务器的连接 ID。
`MBeanServerConnection`	`JMXConnector.getMBeanServerConnection()` 返回一个代表远程 MBean 服务器的 `MBeanServerConnection` 对象。
`MBeanServerConnection`	`JMXConnector.getMBeanServerConnection(Subject delegationSubject)` 返回 `MBeanServerConnection` 对象，它表示在其上执行代表提供的委托主题操作的远程 MBean 服务器。
`static JMXConnector`	`JMXConnectorFactory.newJMXConnector(JMXServiceURL serviceURL, Map<String,?> environment)` 为位于给定地址的连接器服务器创建一个连接器客户端。
`JMXConnector`	`JMXConnectorProvider.newJMXConnector(JMXServiceURL serviceURL, Map<String,?> environment)` 创建一个新的可随时连接到位于给定地址的连接器服务器的连接器客户端。
`static JMXConnectorServer`	`JMXConnectorServerFactory.newJMXConnectorServer(JMXServiceURL serviceURL, Map<String,?> environment, MBeanServer mbeanServer)` 创建位于给定地址的连接器服务器。
`JMXConnectorServer`	`JMXConnectorServerProvider.newJMXConnectorServer(JMXServiceURL serviceURL, Map<String,?> environment, MBeanServer mbeanServer)` 创建位于给定地址的新连接器服务器。
`void`	`JMXConnectorServerMBean.start()` 激活连接器服务器，即开始侦听客户端连接。
`void`	`JMXConnectorServerMBean.stop()` 取消激活连接器服务器，即停止对客户端连接的侦听。
`JMXConnector`	`JMXConnectorServer.toJMXConnector(Map<String,?> env)` 返回此连接器服务器的客户端 stub。
`JMXConnector`	`JMXConnectorServerMBean.toJMXConnector(Map<String,?> env)` 返回此连接器服务器的客户端 stub。

javax.management.remote.rmi 中 IOException 的使用

抛出 IOException 的 javax.management.remote.rmi 中的方法
`void`	`RMIConnection.addNotificationListener(ObjectName name, ObjectName listener, MarshalledObject filter, MarshalledObject handback, Subject delegationSubject)` 处理 `MBeanServerConnection.addNotificationListener(ObjectName, ObjectName, NotificationFilter, Object)` 方法。
`void`	`RMIConnectionImpl.addNotificationListener(ObjectName name, ObjectName listener, MarshalledObject filter, MarshalledObject handback, Subject delegationSubject)`
`void`	`RMIConnectionImpl_Stub.addNotificationListener(ObjectName $param_ObjectName_1, ObjectName $param_ObjectName_2, MarshalledObject $param_MarshalledObject_3, MarshalledObject $param_MarshalledObject_4, Subject $param_Subject_5)`
`Integer[]`	`RMIConnection.addNotificationListeners(ObjectName[] names, MarshalledObject[] filters, Subject[] delegationSubjects)` 处理 `MBeanServerConnection.addNotificationListener(ObjectName, NotificationListener, NotificationFilter, Object)` 方法。
`Integer[]`	`RMIConnectionImpl.addNotificationListeners(ObjectName[] names, MarshalledObject[] filters, Subject[] delegationSubjects)`
`Integer[]`	`RMIConnectionImpl_Stub.addNotificationListeners(ObjectName[] $param_arrayOf_ObjectName_1, MarshalledObject[] $param_arrayOf_MarshalledObject_2, Subject[] $param_arrayOf_Subject_3)`
`protected void`	`RMIServerImpl.clientClosed(RMIConnection client)` 关闭由 `makeClient` 创建的客户端连接时调用的方法。
`void`	`RMIConnection.close()` 关闭此连接。
`void`	`RMIConnectionImpl.close()`
`void`	`RMIConnectionImpl_Stub.close()`
`void`	`RMIConnector.close()`
`void`	`RMIServerImpl.close()` 关闭此连接服务器。
`protected void`	`RMIIIOPServerImpl.closeClient(RMIConnection client)`
`protected void`	`RMIJRMPServerImpl.closeClient(RMIConnection client)`
`protected abstract void`	`RMIServerImpl.closeClient(RMIConnection client)` 关闭由 `makeClient` 建立的客户端连接。
`protected void`	`RMIIIOPServerImpl.closeServer()` 由 `RMIServerImpl.close()` 调用以通过取消导出此对象关闭连接器服务器。
`protected void`	`RMIJRMPServerImpl.closeServer()` 由 `RMIServerImpl.close()` 调用以通过取消导出此对象关闭连接器服务器。
`protected abstract void`	`RMIServerImpl.closeServer()` 由 `RMIServerImpl.close()` 调用以关闭连接器服务器。
`void`	`RMIConnector.connect()`
`void`	`RMIConnector.connect(Map<String,?> environment)`
`ObjectInstance`	`RMIConnection.createMBean(String className, ObjectName name, MarshalledObject params, String[] signature, Subject delegationSubject)` 处理 `MBeanServerConnection.createMBean(String, ObjectName, Object[], String[])` 方法。
`ObjectInstance`	`RMIConnectionImpl.createMBean(String className, ObjectName name, MarshalledObject params, String[] signature, Subject delegationSubject)`
`ObjectInstance`	`RMIConnectionImpl_Stub.createMBean(String $param_String_1, ObjectName $param_ObjectName_2, MarshalledObject $param_MarshalledObject_3, String[] $param_arrayOf_String_4, Subject $param_Subject_5)`
`ObjectInstance`	`RMIConnection.createMBean(String className, ObjectName name, ObjectName loaderName, MarshalledObject params, String[] signature, Subject delegationSubject)` 处理 `MBeanServerConnection.createMBean(String, ObjectName, ObjectName, Object[], String[])` 方法。
`ObjectInstance`	`RMIConnectionImpl.createMBean(String className, ObjectName name, ObjectName loaderName, MarshalledObject params, String[] signature, Subject delegationSubject)`
`ObjectInstance`	`RMIConnectionImpl_Stub.createMBean(String $param_String_1, ObjectName $param_ObjectName_2, ObjectName $param_ObjectName_3, MarshalledObject $param_MarshalledObject_4, String[] $param_arrayOf_String_5, Subject $param_Subject_6)`
`ObjectInstance`	`RMIConnection.createMBean(String className, ObjectName name, ObjectName loaderName, Subject delegationSubject)` 处理 `MBeanServerConnection.createMBean(String, ObjectName, ObjectName)` 方法。
`ObjectInstance`	`RMIConnectionImpl.createMBean(String className, ObjectName name, ObjectName loaderName, Subject delegationSubject)`
`ObjectInstance`	`RMIConnectionImpl_Stub.createMBean(String $param_String_1, ObjectName $param_ObjectName_2, ObjectName $param_ObjectName_3, Subject $param_Subject_4)`
`ObjectInstance`	`RMIConnection.createMBean(String className, ObjectName name, Subject delegationSubject)` 处理 `MBeanServerConnection.createMBean(String, ObjectName)` 方法。
`ObjectInstance`	`RMIConnectionImpl.createMBean(String className, ObjectName name, Subject delegationSubject)`
`ObjectInstance`	`RMIConnectionImpl_Stub.createMBean(String $param_String_1, ObjectName $param_ObjectName_2, Subject $param_Subject_3)`
`protected void`	`RMIIIOPServerImpl.export()`
`protected void`	`RMIJRMPServerImpl.export()`
`protected abstract void`	`RMIServerImpl.export()` 导出此 RMI 对象。
`NotificationResult`	`RMIConnection.fetchNotifications(long clientSequenceNumber, int maxNotifications, long timeout)` 检索来自连接器服务器的通知。
`NotificationResult`	`RMIConnectionImpl.fetchNotifications(long clientSequenceNumber, int maxNotifications, long timeout)`
`NotificationResult`	`RMIConnectionImpl_Stub.fetchNotifications(long $param_long_1, int $param_int_2, long $param_long_3)`
`Object`	`RMIConnection.getAttribute(ObjectName name, String attribute, Subject delegationSubject)` 处理 `MBeanServerConnection.getAttribute(ObjectName, String)` 方法。
`Object`	`RMIConnectionImpl.getAttribute(ObjectName name, String attribute, Subject delegationSubject)`
`Object`	`RMIConnectionImpl_Stub.getAttribute(ObjectName $param_ObjectName_1, String $param_String_2, Subject $param_Subject_3)`
`AttributeList`	`RMIConnection.getAttributes(ObjectName name, String[] attributes, Subject delegationSubject)` 处理 `MBeanServerConnection.getAttributes(ObjectName, String[])` 方法。
`AttributeList`	`RMIConnectionImpl.getAttributes(ObjectName name, String[] attributes, Subject delegationSubject)`
`AttributeList`	`RMIConnectionImpl_Stub.getAttributes(ObjectName $param_ObjectName_1, String[] $param_arrayOf_String_2, Subject $param_Subject_3)`
`String`	`RMIConnection.getConnectionId()` 返回连接 ID。
`String`	`RMIConnectionImpl.getConnectionId()`
`String`	`RMIConnectionImpl_Stub.getConnectionId()`
`String`	`RMIConnector.getConnectionId()`
`String`	`RMIConnection.getDefaultDomain(Subject delegationSubject)` 处理 `MBeanServerConnection.getDefaultDomain()` 方法。
`String`	`RMIConnectionImpl.getDefaultDomain(Subject delegationSubject)`
`String`	`RMIConnectionImpl_Stub.getDefaultDomain(Subject $param_Subject_1)`
`String[]`	`RMIConnection.getDomains(Subject delegationSubject)` 处理 `MBeanServerConnection.getDomains()` 方法。
`String[]`	`RMIConnectionImpl.getDomains(Subject delegationSubject)`
`String[]`	`RMIConnectionImpl_Stub.getDomains(Subject $param_Subject_1)`
`Integer`	`RMIConnection.getMBeanCount(Subject delegationSubject)` 处理 `MBeanServerConnection.getMBeanCount()` 方法。
`Integer`	`RMIConnectionImpl.getMBeanCount(Subject delegationSubject)`
`Integer`	`RMIConnectionImpl_Stub.getMBeanCount(Subject $param_Subject_1)`
`MBeanInfo`	`RMIConnection.getMBeanInfo(ObjectName name, Subject delegationSubject)` 处理 `MBeanServerConnection.getMBeanInfo(ObjectName)` 方法。
`MBeanInfo`	`RMIConnectionImpl.getMBeanInfo(ObjectName name, Subject delegationSubject)`
`MBeanInfo`	`RMIConnectionImpl_Stub.getMBeanInfo(ObjectName $param_ObjectName_1, Subject $param_Subject_2)`
`MBeanServerConnection`	`RMIConnector.getMBeanServerConnection()`
`MBeanServerConnection`	`RMIConnector.getMBeanServerConnection(Subject delegationSubject)`
`ObjectInstance`	`RMIConnection.getObjectInstance(ObjectName name, Subject delegationSubject)` 处理 `MBeanServerConnection.getObjectInstance(ObjectName)` 方法。
`ObjectInstance`	`RMIConnectionImpl.getObjectInstance(ObjectName name, Subject delegationSubject)`
`ObjectInstance`	`RMIConnectionImpl_Stub.getObjectInstance(ObjectName $param_ObjectName_1, Subject $param_Subject_2)`
`Object`	`RMIConnection.invoke(ObjectName name, String operationName, MarshalledObject params, String[] signature, Subject delegationSubject)` 处理 `MBeanServerConnection.invoke(ObjectName, String, Object[], String[])` 方法。
`Object`	`RMIConnectionImpl.invoke(ObjectName name, String operationName, MarshalledObject params, String[] signature, Subject delegationSubject)`
`Object`	`RMIConnectionImpl_Stub.invoke(ObjectName $param_ObjectName_1, String $param_String_2, MarshalledObject $param_MarshalledObject_3, String[] $param_arrayOf_String_4, Subject $param_Subject_5)`
`boolean`	`RMIConnection.isInstanceOf(ObjectName name, String className, Subject delegationSubject)` 处理 `MBeanServerConnection.isInstanceOf(ObjectName, String)` 方法。
`boolean`	`RMIConnectionImpl.isInstanceOf(ObjectName name, String className, Subject delegationSubject)`
`boolean`	`RMIConnectionImpl_Stub.isInstanceOf(ObjectName $param_ObjectName_1, String $param_String_2, Subject $param_Subject_3)`
`boolean`	`RMIConnection.isRegistered(ObjectName name, Subject delegationSubject)` 处理 `MBeanServerConnection.isRegistered(ObjectName)` 方法。
`boolean`	`RMIConnectionImpl.isRegistered(ObjectName name, Subject delegationSubject)`
`boolean`	`RMIConnectionImpl_Stub.isRegistered(ObjectName $param_ObjectName_1, Subject $param_Subject_2)`
`protected RMIConnection`	`RMIIIOPServerImpl.makeClient(String connectionId, Subject subject)` 创建一个如同从 IIOP 导出的 RMI 对象的新客户端连接。
`protected RMIConnection`	`RMIJRMPServerImpl.makeClient(String connectionId, Subject subject)` 创建一个如同从 JRMP 导出的 RMI 对象的新的客户端连接。
`protected abstract RMIConnection`	`RMIServerImpl.makeClient(String connectionId, Subject subject)` 创建一个新的客户端连接。
`RMIConnection`	`RMIServer.newClient(Object credentials)` 建立一个使用该 RMI 连接器的新连接。
`RMIConnection`	`RMIServerImpl.newClient(Object credentials)` 创建一个新的客户端连接。
`RMIConnection`	`RMIServerImpl_Stub.newClient(Object $param_Object_1)`
`Set<ObjectInstance>`	`RMIConnection.queryMBeans(ObjectName name, MarshalledObject query, Subject delegationSubject)` 处理 `MBeanServerConnection.queryMBeans(ObjectName, QueryExp)` 方法。
`Set<ObjectInstance>`	`RMIConnectionImpl.queryMBeans(ObjectName name, MarshalledObject query, Subject delegationSubject)`
`Set`	`RMIConnectionImpl_Stub.queryMBeans(ObjectName $param_ObjectName_1, MarshalledObject $param_MarshalledObject_2, Subject $param_Subject_3)`
`Set<ObjectName>`	`RMIConnection.queryNames(ObjectName name, MarshalledObject query, Subject delegationSubject)` 处理 `MBeanServerConnection.queryNames(ObjectName, QueryExp)` 方法。
`Set<ObjectName>`	`RMIConnectionImpl.queryNames(ObjectName name, MarshalledObject query, Subject delegationSubject)`
`Set`	`RMIConnectionImpl_Stub.queryNames(ObjectName $param_ObjectName_1, MarshalledObject $param_MarshalledObject_2, Subject $param_Subject_3)`
`void`	`RMIConnection.removeNotificationListener(ObjectName name, ObjectName listener, MarshalledObject filter, MarshalledObject handback, Subject delegationSubject)` 处理 `MBeanServerConnection.removeNotificationListener(ObjectName, ObjectName, NotificationFilter, Object)` 方法。
`void`	`RMIConnectionImpl.removeNotificationListener(ObjectName name, ObjectName listener, MarshalledObject filter, MarshalledObject handback, Subject delegationSubject)`
`void`	`RMIConnectionImpl_Stub.removeNotificationListener(ObjectName $param_ObjectName_1, ObjectName $param_ObjectName_2, MarshalledObject $param_MarshalledObject_3, MarshalledObject $param_MarshalledObject_4, Subject $param_Subject_5)`
`void`	`RMIConnection.removeNotificationListener(ObjectName name, ObjectName listener, Subject delegationSubject)` 处理 `MBeanServerConnection.removeNotificationListener(ObjectName, ObjectName)` 方法。
`void`	`RMIConnectionImpl.removeNotificationListener(ObjectName name, ObjectName listener, Subject delegationSubject)`
`void`	`RMIConnectionImpl_Stub.removeNotificationListener(ObjectName $param_ObjectName_1, ObjectName $param_ObjectName_2, Subject $param_Subject_3)`
`void`	`RMIConnection.removeNotificationListeners(ObjectName name, Integer[] listenerIDs, Subject delegationSubject)` 处理 `removeNotificationListener(ObjectName, NotificationListener)` 和 `removeNotificationListener(ObjectName, NotificationListener, NotificationFilter, Object)` 方法。
`void`	`RMIConnectionImpl.removeNotificationListeners(ObjectName name, Integer[] listenerIDs, Subject delegationSubject)`
`void`	`RMIConnectionImpl_Stub.removeNotificationListeners(ObjectName $param_ObjectName_1, Integer[] $param_arrayOf_Integer_2, Subject $param_Subject_3)`
`void`	`RMIConnection.setAttribute(ObjectName name, MarshalledObject attribute, Subject delegationSubject)` 处理 `MBeanServerConnection.setAttribute(ObjectName, Attribute)` 方法。
`void`	`RMIConnectionImpl.setAttribute(ObjectName name, MarshalledObject attribute, Subject delegationSubject)`
`void`	`RMIConnectionImpl_Stub.setAttribute(ObjectName $param_ObjectName_1, MarshalledObject $param_MarshalledObject_2, Subject $param_Subject_3)`
`AttributeList`	`RMIConnection.setAttributes(ObjectName name, MarshalledObject attributes, Subject delegationSubject)` 处理 `MBeanServerConnection.setAttributes(ObjectName, AttributeList)` 方法。
`AttributeList`	`RMIConnectionImpl.setAttributes(ObjectName name, MarshalledObject attributes, Subject delegationSubject)`
`AttributeList`	`RMIConnectionImpl_Stub.setAttributes(ObjectName $param_ObjectName_1, MarshalledObject $param_MarshalledObject_2, Subject $param_Subject_3)`
`void`	`RMIConnectorServer.start()` 激活连接器服务器，即启动对客户端连接的侦听。
`void`	`RMIConnectorServer.stop()` 取消激活连接器服务器，即停止对客户端连接的侦听。
`JMXConnector`	`RMIConnectorServer.toJMXConnector(Map<String,?> env)` 返回此连接器服务器的客户端 stub。
`Remote`	`RMIIIOPServerImpl.toStub()` 返回一个 IIOP stub。
`Remote`	`RMIJRMPServerImpl.toStub()` 返回此 `RMIServer` 对象的可序列化的 stub。
`abstract Remote`	`RMIServerImpl.toStub()` 返回此服务器对象的可远程化的 stub。
`void`	`RMIConnection.unregisterMBean(ObjectName name, Subject delegationSubject)` 处理 `MBeanServerConnection.unregisterMBean(ObjectName)` 方法。
`void`	`RMIConnectionImpl.unregisterMBean(ObjectName name, Subject delegationSubject)`
`void`	`RMIConnectionImpl_Stub.unregisterMBean(ObjectName $param_ObjectName_1, Subject $param_Subject_2)`

抛出 IOException 的 javax.management.remote.rmi 中的构造方法
`RMIConnectorServer(JMXServiceURL url, Map<String,?> environment)` 建立 `RMIConnectorServer`。
`RMIConnectorServer(JMXServiceURL url, Map<String,?> environment, MBeanServer mbeanServer)` 为给定的 MBean 服务器建立一个 `RMIConnectorServer`。
`RMIConnectorServer(JMXServiceURL url, Map<String,?> environment, RMIServerImpl rmiServerImpl, MBeanServer mbeanServer)` 为给定的 MBean 服务器建立一个 `RMIConnectorServer`。
`RMIIIOPServerImpl(Map<String,?> env)` 创建新的 `RMIServerImpl`。
`RMIJRMPServerImpl(int port, RMIClientSocketFactory csf, RMIServerSocketFactory ssf, Map<String,?> env)` 创建一个新的 `RMIServer` 对象，它将使用给定的套接字工厂从给定端口导出。

javax.naming.ldap 中 IOException 的使用

抛出 IOException 的 javax.naming.ldap 中的方法
`abstract void`	`StartTlsResponse.close()` 妥善地关闭 TLS 连接并转换回底层连接。
`abstract SSLSession`	`StartTlsResponse.negotiate()` 使用默认的 SSL 套接字工厂协商 TLS 会话。
`abstract SSLSession`	`StartTlsResponse.negotiate(SSLSocketFactory factory)` 使用 SSL 套接字工厂协商 TLS 会话。

抛出 IOException 的 javax.naming.ldap 中的构造方法
`PagedResultsControl(int pageSize, boolean criticality)` 构造一个控件来设置要在每页结果中返回的项数。
`PagedResultsControl(int pageSize, byte[] cookie, boolean criticality)` 构造一个控件来设置要在每页结果中返回的项数。
`PagedResultsResponseControl(String id, boolean criticality, byte[] value)` 构造分页结果响应控件。
`SortControl(SortKey[] sortBy, boolean criticality)` 构造一个控件来对排序键列表进行排序。
`SortControl(String[] sortBy, boolean criticality)` 构造一个控件来按升序对属性列表进行排序。
`SortControl(String sortBy, boolean criticality)` 构造一个控件来按升序对单个属性进行排序。
`SortResponseControl(String id, boolean criticality, byte[] value)` 构造一个控件来指示排序请求的结果。

javax.net 中 IOException 的使用

抛出 IOException 的 javax.net 中的方法
`ServerSocket`	`ServerSocketFactory.createServerSocket()` 返回未绑定的服务器套接字。
`abstract ServerSocket`	`ServerSocketFactory.createServerSocket(int port)` 返回绑定到指定端口的服务器套接字。
`abstract ServerSocket`	`ServerSocketFactory.createServerSocket(int port, int backlog)` 返回绑定到指定端口的服务器套接字，并且使用指定的连接 backlog。
`abstract ServerSocket`	`ServerSocketFactory.createServerSocket(int port, int backlog, InetAddress ifAddress)` 返回绑定到指定端口的服务器套接字，该套接字带有指定的侦听 backlog 和本地 IP。
`Socket`	`SocketFactory.createSocket()` 创建一个未连接的套接字。
`abstract Socket`	`SocketFactory.createSocket(InetAddress host, int port)` 创建一个套接字并把它连接到指定地址上的指定端口号。
`abstract Socket`	`SocketFactory.createSocket(InetAddress address, int port, InetAddress localAddress, int localPort)` 创建一个套接字并把它连接到指定远程端口上的指定远程地址。
`abstract Socket`	`SocketFactory.createSocket(String host, int port)` 创建一个套接字并把它连接到指定远程主机上的指定远程端口。
`abstract Socket`	`SocketFactory.createSocket(String host, int port, InetAddress localHost, int localPort)` 创建一个套接字并把它连接到指定远程主机上的指定远程端口。

javax.net.ssl 中 IOException 的使用

javax.net.ssl 中 IOException 的子类
`class`	`SSLException` 指示由 SSL 子系统检测到的某类错误。
`class`	`SSLHandshakeException` 指示客户端和服务器不能就所需安全级别进行协商。
`class`	`SSLKeyException` 报告错误的 SSL 密钥。
`class`	`SSLPeerUnverifiedException` 指示还没有验证同位体的身份。
`class`	`SSLProtocolException` 报告在 SSL 协议的操作中的错误。

抛出 IOException 的 javax.net.ssl 中的方法
`abstract Socket`	`SSLSocketFactory.createSocket(Socket s, String host, int port, boolean autoClose)` 返回在连接到指定主机的给定端口的现有套接字上分层的套接字。
`abstract void`	`SSLSocket.startHandshake()` 在此连接上开始 SSL 握手。

抛出 IOException 的 javax.net.ssl 中的构造方法
`SSLServerSocket()` 仅供子类使用。
`SSLServerSocket(int port)` 仅供子类使用。
`SSLServerSocket(int port, int backlog)` 仅供子类使用。
`SSLServerSocket(int port, int backlog, InetAddress address)` 仅供子类使用。
`SSLSocket(InetAddress address, int port)` 仅供子类使用。
`SSLSocket(InetAddress address, int port, InetAddress clientAddress, int clientPort)` 仅供子类使用。
`SSLSocket(String host, int port)` 仅供子类使用。
`SSLSocket(String host, int port, InetAddress clientAddress, int clientPort)` 仅供子类使用。

javax.print 中 IOException 的使用

抛出 IOException 的 javax.print 中的方法
`Doc`	`MultiDoc.getDoc()` 获取当前的 doc 对象。
`Object`	`Doc.getPrintData()` 获得打印数据表示形式对象，该对象包含此 doc 对象的部分打印数据，其格式对应于受支持的 DocFlavor。
`Object`	`SimpleDoc.getPrintData()`
`Reader`	`Doc.getReaderForText()` 获得一个从此 doc 中提取字符打印数据的 reader。
`Reader`	`SimpleDoc.getReaderForText()` 获得一个从此 doc 中提取字符打印数据的 reader。
`InputStream`	`Doc.getStreamForBytes()` 获得一个从此 doc 中提取 byte 打印数据的输入流。
`InputStream`	`SimpleDoc.getStreamForBytes()` 获得一个从此 doc 中提取 byte 打印数据的输入流。
`MultiDoc`	`MultiDoc.next()` 转到包含 doc 对象序列中下一个 doc 对象的 multidoc 对象。

javax.rmi.CORBA 中 IOException 的使用

抛出 IOException 的 javax.rmi.CORBA 中的方法
`void`	`StubDelegate.readObject(Stub self, ObjectInputStream s)` `Stub.readObject(java.io.ObjectInputStream)` 的委托调用。
`void`	`StubDelegate.writeObject(Stub self, ObjectOutputStream s)` `Stub.writeObject(java.io.ObjectOutputStream)` 的委托调用。

javax.rmi.ssl 中 IOException 的使用

抛出 IOException 的 javax.rmi.ssl 中的方法
`ServerSocket`	`SslRMIServerSocketFactory.createServerSocket(int port)` 创建一个服务器套接字，该套接字接受根据此工厂的 SSL 套接字配置参数配置的 SSL 连接。
`Socket`	`SslRMIClientSocketFactory.createSocket(String host, int port)` 创建一个 SSL 套接字。

javax.security.auth.callback 中 IOException 的使用

抛出 IOException 的 javax.security.auth.callback 中的方法
`void`	`CallbackHandler.handle(Callback[] callbacks)` 获取或显示在提供的 Callback 中请求的信息。

javax.security.sasl 中 IOException 的使用

javax.security.sasl 中 IOException 的子类
`class`	`AuthenticationException` 此异常由 SASL 机制实现抛出，指示由于和验证有关的原因（如无效的标识、口令或密钥），SASL 交换已失败。
`class`	`SaslException` 此类表示在使用 SASL 时所发生的错误。

javax.sound.midi 中 IOException 的使用

抛出 IOException 的 javax.sound.midi 中的方法
`static MidiFileFormat`	`MidiSystem.getMidiFileFormat(File file)` 获得指定 `File` 的 MIDI 文件格式。
`static MidiFileFormat`	`MidiSystem.getMidiFileFormat(InputStream stream)` 获得指定的输入流中数据的 MIDI 文件格式。
`static MidiFileFormat`	`MidiSystem.getMidiFileFormat(URL url)` 获得指定 URL 中数据的 MIDI 文件格式。
`static Sequence`	`MidiSystem.getSequence(File file)` 从指定的 `File` 获得 MIDI 序列。
`static Sequence`	`MidiSystem.getSequence(InputStream stream)` 从指定的输入流获得 MIDI 序列。
`static Sequence`	`MidiSystem.getSequence(URL url)` 从指定的 URL 获得 MIDI 序列。
`static Soundbank`	`MidiSystem.getSoundbank(File file)` 通过从指定的 `File` 读取来构造一个 `Soundbank`。
`static Soundbank`	`MidiSystem.getSoundbank(InputStream stream)` 通过从指定的流读取来构造一个 MIDI 音库。
`static Soundbank`	`MidiSystem.getSoundbank(URL url)` 通过从指定的 URL 处读取来构造一个 `Soundbank`。
`void`	`Sequencer.setSequence(InputStream stream)` 设置 sequencer 所操作的当前 sequence。
`static int`	`MidiSystem.write(Sequence in, int type, File out)` 将表示所指示 MIDI 文件类型的文件的字节流写入提供的外部文件。
`static int`	`MidiSystem.write(Sequence in, int fileType, OutputStream out)` 将表示所指示 MIDI 文件类型的文件的字节流写入提供的输出流。

javax.sound.midi.spi 中 IOException 的使用

抛出 IOException 的 javax.sound.midi.spi 中的方法
`abstract MidiFileFormat`	`MidiFileReader.getMidiFileFormat(File file)` 获得提供的 `File` 的 MIDI 文件格式。
`abstract MidiFileFormat`	`MidiFileReader.getMidiFileFormat(InputStream stream)` 获得所提供的输入流的 MIDI 文件格式。
`abstract MidiFileFormat`	`MidiFileReader.getMidiFileFormat(URL url)` 获得提供的 URL 的 MIDI 文件格式。
`abstract Sequence`	`MidiFileReader.getSequence(File file)` 从提供的 `File` 获得 MIDI 序列。
`abstract Sequence`	`MidiFileReader.getSequence(InputStream stream)` 从提供的输入流获得 MIDI 序列。
`abstract Sequence`	`MidiFileReader.getSequence(URL url)` 从提供的 URL 获得 MIDI 序列。
`abstract Soundbank`	`SoundbankReader.getSoundbank(File file)` 从提供的 `File` 获得音库对象。
`abstract Soundbank`	`SoundbankReader.getSoundbank(InputStream stream)` 从提供的 `InputStream` 获得音库对象。
`abstract Soundbank`	`SoundbankReader.getSoundbank(URL url)` 从提供的 URL 获得音库对象。
`abstract int`	`MidiFileWriter.write(Sequence in, int fileType, File out)` 写入表示指示为所提供外部文件的文件类型的 MIDI 文件的字节流。
`abstract int`	`MidiFileWriter.write(Sequence in, int fileType, OutputStream out)` 写入表示指示为所提供输出流的文件类型的 MIDI 文件的字节流。

javax.sound.sampled 中 IOException 的使用

抛出 IOException 的 javax.sound.sampled 中的方法
`int`	`AudioInputStream.available()` 返回可不受阻塞地从此音频输入流中读取（或跳过）的最大字节数。
`void`	`AudioInputStream.close()` 关闭此音频输入流并释放与该流关联的所有系统资源。
`static AudioFileFormat`	`AudioSystem.getAudioFileFormat(File file)` 获得指定 `File` 的音频文件格式。
`static AudioFileFormat`	`AudioSystem.getAudioFileFormat(InputStream stream)` 获得提供的音频输入流的音频文件格式。
`static AudioFileFormat`	`AudioSystem.getAudioFileFormat(URL url)` 获得指定 URL 的音频文件格式。
`static AudioInputStream`	`AudioSystem.getAudioInputStream(File file)` 从提供的 `File` 获得音频输入流。
`static AudioInputStream`	`AudioSystem.getAudioInputStream(InputStream stream)` 从提供的输入流获得音频输入流。
`static AudioInputStream`	`AudioSystem.getAudioInputStream(URL url)` 从提供的 URL 获得音频输入流。
`void`	`Clip.open(AudioInputStream stream)` 使用出现在所提供的音频输入流中的格式和音频数据打开剪辑。
`int`	`AudioInputStream.read()` 从音频输入流读取数据下一个字节。
`int`	`AudioInputStream.read(byte[] b)` 从音频输入流读取一定数量的字节，并将其存储在缓冲区数组 `b` 中。
`int`	`AudioInputStream.read(byte[] b, int off, int len)` 从音频流读取指定的最大数量的数据字节，并将其放入给定的字节数组中。
`void`	`AudioInputStream.reset()` 将此音频输入流重新定位到上一次调用其 `mark` 方法时的位置。
`long`	`AudioInputStream.skip(long n)` 跳过并丢弃此音频输入流中指定数量的字节。
`static int`	`AudioSystem.write(AudioInputStream stream, AudioFileFormat.Type fileType, File out)` 将表示指定文件类型的音频文件的字节流写入所提供的外部文件。
`static int`	`AudioSystem.write(AudioInputStream stream, AudioFileFormat.Type fileType, OutputStream out)` 将表示指定文件类型的音频文件的字节流写入所提供的输出流。

javax.sound.sampled.spi 中 IOException 的使用

抛出 IOException 的 javax.sound.sampled.spi 中的方法
`abstract AudioFileFormat`	`AudioFileReader.getAudioFileFormat(File file)` 获得所提供 `File` 的音频文件格式。
`abstract AudioFileFormat`	`AudioFileReader.getAudioFileFormat(InputStream stream)` 获得所提供输入流的音频文件格式。
`abstract AudioFileFormat`	`AudioFileReader.getAudioFileFormat(URL url)` 获得所提供 URL 的音频文件格式。
`abstract AudioInputStream`	`AudioFileReader.getAudioInputStream(File file)` 从所提供的 `File` 获得音频输入流。
`abstract AudioInputStream`	`AudioFileReader.getAudioInputStream(InputStream stream)` 从所提供的输入流中获得音频输入流。
`abstract AudioInputStream`	`AudioFileReader.getAudioInputStream(URL url)` 从所提供的 URL 获得音频输入流。
`abstract int`	`AudioFileWriter.write(AudioInputStream stream, AudioFileFormat.Type fileType, File out)` 将表示所指示文件格式的音频文件的字节流写入所提供的外部文件。
`abstract int`	`AudioFileWriter.write(AudioInputStream stream, AudioFileFormat.Type fileType, OutputStream out)` 将表示所指示文件类型的音频文件的字节流写入所提供的输出流。

javax.sql.rowset 中 IOException 的使用

抛出 IOException 的 javax.sql.rowset 中的方法
`void`	`WebRowSet.readXml(InputStream iStream)` 读取基于流的 XML 输入，以填充此 `WebRowSet` 对象。
`void`	`WebRowSet.writeXml(OutputStream oStream)` 以 XML 格式将此 `WebRowSet` 对象的数据、属性和元数据写入给定的 `OutputStream` 对象。
`void`	`WebRowSet.writeXml(ResultSet rs, OutputStream oStream)` 使用给定 `ResultSet` 对象的内容填充此 `WebRowSet` 对象，并以 XML 格式将其数据、属性和元数据写入给定的 `OutputStream` 对象。

javax.swing 中 IOException 的使用

抛出 IOException 的 javax.swing 中的方法
`void`	`ProgressMonitorInputStream.close()` 重写 `FilterInputStream.close`，以便关闭进度监视器以及流。
`protected InputStream`	`JEditorPane.getStream(URL page)` 获取给定 URL 的流，该 URL 是将要由 `setPage` 方法加载的。
`int`	`ProgressMonitorInputStream.read()` 重写 `FilterInputStream.read`，以便在读取之后更新进度监视器。
`int`	`ProgressMonitorInputStream.read(byte[] b)` 重写 `FilterInputStream.read`，以读取之后更新进度监视器。
`int`	`ProgressMonitorInputStream.read(byte[] b, int off, int len)` 重写 `FilterInputStream.read`，以便在读取之后更新进度监视器。
`void`	`JEditorPane.read(InputStream in, Object desc)` 此方法根据流进行初始化。
`void`	`ProgressMonitorInputStream.reset()` 重写 `FilterInputStream.reset`，以重置进度监视器以及流。
`void`	`JEditorPane.setPage(String url)` 设置当前要显示的 URL。
`void`	`JEditorPane.setPage(URL page)` 设置当前要显示的 URL。
`long`	`ProgressMonitorInputStream.skip(long n)` 重写 `FilterInputStream.skip`，以便在跳过之后更新进度监视器。

抛出 IOException 的 javax.swing 中的构造方法
`JEditorPane(String url)` 根据包含 URL 规范的字符串创建一个 `JEditorPane`。
`JEditorPane(URL initialPage)` 根据用作输入的指定 URL 创建一个 `JEditorPane`。

javax.swing.filechooser 中 IOException 的使用

抛出 IOException 的 javax.swing.filechooser 中的方法
`abstract File`	`FileSystemView.createNewFolder(File containingDir)` 创建具有默认文件夹名称的新文件夹。

javax.swing.plaf.synth 中 IOException 的使用

抛出 IOException 的 javax.swing.plaf.synth 中的方法
`void`	`SynthLookAndFeel.load(URL url)` 加载此 `SynthLookAndFeel` 将使用的 `SynthStyle` 集合。

javax.swing.text 中 IOException 的使用

javax.swing.text 中 IOException 的子类
`class`	`ChangedCharSetException` 顾名思义，ChangedCharSetException 是字符集改变时抛出的异常。

抛出 IOException 的 javax.swing.text 中的方法
`protected void`	`AbstractWriter.indent()` 执行缩进。
`protected void`	`AbstractWriter.output(char[] content, int start, int length)` 写出内容过程的最后一步。
`void`	`DefaultEditorKit.read(InputStream in, Document doc, int pos)` 插入取自给定流的内容，其格式需要适合此类型的内容处理程序。
`abstract void`	`EditorKit.read(InputStream in, Document doc, int pos)` 插入来自给定流的内容，其格式需要适合此类型的内容处理程序。
`void`	`DefaultEditorKit.read(Reader in, Document doc, int pos)` 插入取自给定流的内容，它将被视为纯文本。
`abstract void`	`EditorKit.read(Reader in, Document doc, int pos)` 插入来自给定流的内容，其格式需要适合此类型的内容处理程序。
`void`	`JTextComponent.read(Reader in, Object desc)` 根据流进行初始化。
`void`	`StyleContext.readAttributes(ObjectInputStream in, MutableAttributeSet a)` 读入属性的特定于上下文的处理。
`static void`	`StyleContext.readAttributeSet(ObjectInputStream in, MutableAttributeSet a)` 从以前通过 `writeAttributeSet` 写出的给定对象输入流中读取一个属性集。
`protected void`	`AbstractWriter.text(Element elem)` 写出文本。
`protected abstract void`	`AbstractWriter.write()` 需要由子类实现此抽象方法。
`protected void`	`AbstractWriter.write(char ch)` 写出字符。
`protected void`	`AbstractWriter.write(char[] chars, int startIndex, int length)` 所有 write 方法都调用到此方法。
`void`	`DefaultEditorKit.write(OutputStream out, Document doc, int pos, int len)` 将文档中的内容以适合此类型内容处理程序的格式写入给定的流。
`abstract void`	`EditorKit.write(OutputStream out, Document doc, int pos, int len)` 将文档中的内容以适合此类型内容处理程序的格式写入给定的流。
`protected void`	`AbstractWriter.write(String content)` 写出字符串。
`void`	`JTextComponent.write(Writer out)` 将模型的内容存储到给定的流中。
`void`	`DefaultEditorKit.write(Writer out, Document doc, int pos, int len)` 将取自文档的内容以纯文本格式写入给定流。
`abstract void`	`EditorKit.write(Writer out, Document doc, int pos, int len)` 将文档中的内容以适合此类型内容处理程序的格式写入给定的流。
`protected void`	`AbstractWriter.writeAttributes(AttributeSet attr)` 以 " =" 对的形式写出属性集。
`void`	`StyleContext.writeAttributes(ObjectOutputStream out, AttributeSet a)` 写出属性的特定于上下文的处理。
`static void`	`StyleContext.writeAttributeSet(ObjectOutputStream out, AttributeSet a)` 将属性集写入到给定的对象流以便序列化。
`protected void`	`AbstractWriter.writeLineSeparator()` 写入行分隔符。

javax.swing.text.html 中 IOException 的使用

抛出 IOException 的 javax.swing.text.html 中的方法
`protected void`	`HTMLWriter.closeOutUnwantedEmbeddedTags(AttributeSet attr)` 搜索属性集和存储在标记向量中的每个标记。
`protected void`	`HTMLWriter.comment(Element elem)` 写出注释。
`protected void`	`HTMLWriter.emptyTag(Element elem)` 写出所有空元素（没有对应结束标记的所有标记）。
`protected void`	`MinimalHTMLWriter.endFontTag()` 此方法已不再使用，而用写出 <span> 来替换。
`protected void`	`HTMLWriter.endTag(Element elem)` 写出元素的结束标记。
`void`	`HTMLDocument.insertAfterEnd(Element elem, String htmlText)` 将指定为字符串的 HTML 插入给定元素的起始处之后。
`void`	`HTMLDocument.insertAfterStart(Element elem, String htmlText)` 将指定为字符串的 HTML 插入元素的起始处。
`void`	`HTMLDocument.insertBeforeEnd(Element elem, String htmlText)` 将指定为字符串的 HTML 插入元素的结尾处。
`void`	`HTMLDocument.insertBeforeStart(Element elem, String htmlText)` 将指定为字符串的 HTML 插入给定元素的起始处之前。
`void`	`HTMLEditorKit.insertHTML(HTMLDocument doc, int offset, String html, int popDepth, int pushDepth, HTML.Tag insertTag)` 将 HTML 插入现有文档。
`void`	`StyleSheet.loadRules(Reader in, URL ref)` 加载 CSS1 语法中指定的规则集合。
`protected void`	`HTMLWriter.output(char[] chars, int start, int length)` 重写此方法来映射任何字符实体，例如 < 映射到 <。
`abstract void`	`HTMLEditorKit.Parser.parse(Reader r, HTMLEditorKit.ParserCallback cb, boolean ignoreCharSet)` 解析给定的流并通过解析的结果驱动给定的回调。
`void`	`HTMLEditorKit.read(Reader in, Document doc, int pos)` 插入来自给定流的内容。
`protected void`	`HTMLWriter.selectContent(AttributeSet attr)` 写出 SELECT 表单元素的内容。
`void`	`HTMLDocument.setInnerHTML(Element elem, String htmlText)` 用指定为 HTML 字符串的内容替换给定元素的子元素。
`void`	`HTMLDocument.setOuterHTML(Element elem, String htmlText)` 用指定为 HTML 字符串的内容替换父元素中的给定元素。
`protected void`	`MinimalHTMLWriter.startFontTag(String style)` 此方法已不再使用，而用写出 <span> 来替换。
`protected void`	`HTMLWriter.startTag(Element elem)` 写出元素的开始标记。
`protected void`	`HTMLWriter.text(Element elem)` 写出文本。
`protected void`	`MinimalHTMLWriter.text(Element elem)` 写出文本。
`protected void`	`HTMLWriter.textAreaContent(AttributeSet attr)` 写出 TEXTAREA 表单元素中所包含的文本。
`void`	`HTMLWriter.write()` 对 Element 树进行迭代并控制所有标记及其属性的写出。
`void`	`MinimalHTMLWriter.write()` 从 StyledDocument 生成 HTML 输出。
`void`	`HTMLEditorKit.write(Writer out, Document doc, int pos, int len)` 以适合此类内容处理程序的格式，将文档中的内容写入给定流。
`protected void`	`HTMLWriter.writeAttributes(AttributeSet attr)` 写出属性集。
`protected void`	`MinimalHTMLWriter.writeAttributes(AttributeSet attr)` 写出以下类型的所有属性：StyleConstants.ParagraphConstants、StyleConstants.CharacterConstants、StyleConstants.FontConstants、StyleConstants.ColorConstants。
`protected void`	`MinimalHTMLWriter.writeBody()` 对文档中的元素进行迭代，并基于元素是分支元素还是叶元素来处理它们。
`protected void`	`MinimalHTMLWriter.writeComponent(Element elem)` 负责处理 Component Elements；有意不实现它。
`protected void`	`MinimalHTMLWriter.writeContent(Element elem, boolean needsIndenting)` 以与 HTML 兼容的方式写出属性集。
`protected void`	`HTMLWriter.writeEmbeddedTags(AttributeSet attr)` 搜索 AttributeSet 中的嵌入式标记并写出它们。
`protected void`	`MinimalHTMLWriter.writeEndParagraph()` 发出 <p> 标记的结束标记。
`protected void`	`MinimalHTMLWriter.writeEndTag(String endTag)` 写出适当缩进的结束标记。
`protected void`	`MinimalHTMLWriter.writeHeader()` 写出 <head> 和 <style> 标记，然后调用 writeStyles()，以写出所有命名的样式，这些样式作为 <style> 标记的内容。
`protected void`	`MinimalHTMLWriter.writeHTMLTags(AttributeSet attr)` 基于文本的属性设置生成文本的 bold <b>、italic <i> 和 <u> 标记。
`protected void`	`MinimalHTMLWriter.writeImage(Element elem)` 负责处理 Icon Elements；有意不实现它。
`protected void`	`MinimalHTMLWriter.writeLeaf(Element elem)` 负责写出其他非文本叶元素。
`protected void`	`HTMLWriter.writeLineSeparator()` 写出行分隔符。
`protected void`	`MinimalHTMLWriter.writeNonHTMLAttributes(AttributeSet attr)` 以与 HTML 兼容的方式写出其余的字符级属性（bold、italic 和 underline 之外的属性）。
`protected void`	`HTMLWriter.writeOption(Option option)` 写出 Option 表单元素的内容。
`protected void`	`MinimalHTMLWriter.writeStartParagraph(Element elem)` 发出段落的开始标记。
`protected void`	`MinimalHTMLWriter.writeStartTag(String tag)` 写出适当缩进的开始标记。
`protected void`	`MinimalHTMLWriter.writeStyles()` 写出所有命名的样式，这些样式作为 <style> 标记的内容。

javax.swing.text.html.parser 中 IOException 的使用

抛出 IOException 的 javax.swing.text.html.parser 中的方法
`static DTD`	`DTD.getDTD(String name)` 返回具有指定 `name` 的 DTD。
`void`	`Parser.parse(Reader in)` 在给定 DTD 的情况下，解析 HTML 流。
`void`	`DocumentParser.parse(Reader in, HTMLEditorKit.ParserCallback callback, boolean ignoreCharSet)`
`void`	`ParserDelegator.parse(Reader r, HTMLEditorKit.ParserCallback cb, boolean ignoreCharSet)`
`String`	`Parser.parseDTDMarkup()` 解析 Document Type Declaration 标记声明。
`protected boolean`	`Parser.parseMarkupDeclarations(StringBuffer strBuff)` 解析标记声明。
`void`	`DTD.read(DataInputStream in)` 根据存档格式重新创建一个 DTD。

javax.swing.text.rtf 中 IOException 的使用

抛出 IOException 的 javax.swing.text.rtf 中的方法
`void`	`RTFEditorKit.read(InputStream in, Document doc, int pos)` 插入来自给定流的内容，该内容的格式需要适合于此类内容处理程序。
`void`	`RTFEditorKit.read(Reader in, Document doc, int pos)` 插入来自给定流的内容，该内容将被视为纯文本。
`void`	`RTFEditorKit.write(OutputStream out, Document doc, int pos, int len)` 以适合此类内容处理程序的格式，将文档中的内容写入给定流。
`void`	`RTFEditorKit.write(Writer out, Document doc, int pos, int len)` 将文档中的内容作为纯文本写入给定的流。

javax.tools 中 IOException 的使用

抛出 IOException 的 javax.tools 中的方法
`void`	`ForwardingJavaFileManager.close()`
`void`	`JavaFileManager.close()` 释放此文件管理器直接或间接打开的所有资源。
`void`	`ForwardingJavaFileManager.flush()`
`void`	`JavaFileManager.flush()` 刷新此文件管理器直接或间接为输出打开的所有资源。
`CharSequence`	`FileObject.getCharContent(boolean ignoreEncodingErrors)` 返回此文件对象的字符内容（如果有）。
`CharSequence`	`ForwardingFileObject.getCharContent(boolean ignoreEncodingErrors)`
`CharSequence`	`SimpleJavaFileObject.getCharContent(boolean ignoreEncodingErrors)` 此实现总是抛出 UnsupportedOperationException。
`FileObject`	`ForwardingJavaFileManager.getFileForInput(JavaFileManager.Location location, String packageName, String relativeName)`
`FileObject`	`JavaFileManager.getFileForInput(JavaFileManager.Location location, String packageName, String relativeName)` 获取输入的文件对象，它表示给定位置处指定包中的指定相对名称。
`FileObject`	`ForwardingJavaFileManager.getFileForOutput(JavaFileManager.Location location, String packageName, String relativeName, FileObject sibling)`
`FileObject`	`JavaFileManager.getFileForOutput(JavaFileManager.Location location, String packageName, String relativeName, FileObject sibling)` 获取输出的文件对象，它表示给定位置处指定包中的指定相对名称。
`JavaFileObject`	`ForwardingJavaFileManager.getJavaFileForInput(JavaFileManager.Location location, String className, JavaFileObject.Kind kind)`
`JavaFileObject`	`JavaFileManager.getJavaFileForInput(JavaFileManager.Location location, String className, JavaFileObject.Kind kind)` 获取输入的文件对象，它表示给定位置处指定类型的指定类。
`JavaFileObject`	`ForwardingJavaFileManager.getJavaFileForOutput(JavaFileManager.Location location, String className, JavaFileObject.Kind kind, FileObject sibling)`
`JavaFileObject`	`JavaFileManager.getJavaFileForOutput(JavaFileManager.Location location, String className, JavaFileObject.Kind kind, FileObject sibling)` 获取输出的文件对象，它表示给定位置处指定类型的指定类。
`Iterable<JavaFileObject>`	`ForwardingJavaFileManager.list(JavaFileManager.Location location, String packageName, Set<JavaFileObject.Kind> kinds, boolean recurse)`
`Iterable<JavaFileObject>`	`JavaFileManager.list(JavaFileManager.Location location, String packageName, Set<JavaFileObject.Kind> kinds, boolean recurse)` 列出给定位置处符合给定标准的所有文件对象。
`InputStream`	`FileObject.openInputStream()` 获取此文件对象的 InputStream。
`InputStream`	`ForwardingFileObject.openInputStream()`
`InputStream`	`SimpleJavaFileObject.openInputStream()` 此实现总是抛出 UnsupportedOperationException。
`OutputStream`	`FileObject.openOutputStream()` 获取此文件对象的 OutputStream。
`OutputStream`	`ForwardingFileObject.openOutputStream()`
`OutputStream`	`SimpleJavaFileObject.openOutputStream()` 此实现总是抛出 UnsupportedOperationException。
`Reader`	`FileObject.openReader(boolean ignoreEncodingErrors)` 获取此对象的 reader。
`Reader`	`ForwardingFileObject.openReader(boolean ignoreEncodingErrors)`
`Reader`	`SimpleJavaFileObject.openReader(boolean ignoreEncodingErrors)` 在 Reader 中包装 SimpleJavaFileObject.getCharContent(boolean) 的结果。
`Writer`	`FileObject.openWriter()` 获取此文件对象的 Writer。
`Writer`	`ForwardingFileObject.openWriter()`
`Writer`	`SimpleJavaFileObject.openWriter()` 在 Writer 中包装 openOutputStream 的结果。
`void`	`StandardJavaFileManager.setLocation(JavaFileManager.Location location, Iterable<? extends File> path)` 将给定路径与给定位置关联。

javax.transaction 中 IOException 的使用

javax.transaction 中 IOException 的子类
`class`	`InvalidTransactionException` 此异常指示该请求带来了无效的事务上下文。
`class`	`TransactionRequiredException` 此异常指示某个请求带来了 null 事务上下文，但目标对象需要激活的事务。
`class`	`TransactionRolledbackException` 此异常指示与请求处理关联的事务已回滚，或已标记为回滚。

javax.xml.bind 中 IOException 的使用

抛出 IOException 的 javax.xml.bind 中的方法
`abstract Result`	`SchemaOutputResolver.createOutput(String namespaceUri, String suggestedFileName)` 确定写入模式文件（由给定名称空间 URI 指定）的位置，并以 `Result` 对象的形式返回它。
`void`	`JAXBContext.generateSchema(SchemaOutputResolver outputResolver)` 生成此上下文的模式文档。

javax.xml.parsers 中 IOException 的使用

抛出 IOException 的 javax.xml.parsers 中的方法
`Document`	`DocumentBuilder.parse(File f)` 将给定文件的内容解析为一个 XML 文档，并且返回一个新的 DOM `Document` 对象。
`void`	`SAXParser.parse(File f, DefaultHandler dh)` 使用指定的 `DefaultHandler` 将指定文件的内容解析为 XML。
`void`	`SAXParser.parse(File f, HandlerBase hb)` 使用指定的 `HandlerBase` 将指定文件的内容解析为 XML。
`abstract Document`	`DocumentBuilder.parse(InputSource is)` 将给定输入源的内容解析为一个 XML 文档，并且返回一个新的 DOM `Document` 对象。
`void`	`SAXParser.parse(InputSource is, DefaultHandler dh)` 使用指定的 `DefaultHandler` 将给定 `InputSource` 的内容解析为 XML。
`void`	`SAXParser.parse(InputSource is, HandlerBase hb)` 使用指定的 `HandlerBase` 将给定 `InputSource` 的内容解析为 XML。
`Document`	`DocumentBuilder.parse(InputStream is)` 将给定 `InputStream` 的内容解析为一个 XML 文档，并且返回一个新的 DOM `Document` 对象。
`void`	`SAXParser.parse(InputStream is, DefaultHandler dh)` 使用指定的 `DefaultHandler` 将给定的 `InputStream` 实例的内容解析为 XML。
`void`	`SAXParser.parse(InputStream is, DefaultHandler dh, String systemId)` 使用指定的 `DefaultHandler` 将给定的 `InputStream` 实例的内容解析为 XML。
`void`	`SAXParser.parse(InputStream is, HandlerBase hb)` 使用指定的 `HandlerBase` 将给定的 `InputStream` 实例的内容解析为 XML。
`void`	`SAXParser.parse(InputStream is, HandlerBase hb, String systemId)` 使用指定的 `HandlerBase` 将给定的 `InputStream` 实例的内容解析为 XML。
`Document`	`DocumentBuilder.parse(InputStream is, String systemId)` 将给定 `InputStream` 的内容解析为一个 XML 文档，并且返回一个新的 DOM `Document` 对象。
`Document`	`DocumentBuilder.parse(String uri)` 将给定 URI 的内容解析为一个 XML 文档，并且返回一个新的 DOM `Document` 对象。
`void`	`SAXParser.parse(String uri, DefaultHandler dh)` 使用指定的 `DefaultHandler` 将给定统一资源标识符 (URI) 描述的内容解析为 XML。
`void`	`SAXParser.parse(String uri, HandlerBase hb)` 使用指定的 `HandlerBase` 将给定统一资源标识符 (URI) 描述的内容解析为 XML。

javax.xml.soap 中 IOException 的使用

抛出 IOException 的 javax.xml.soap 中的方法
`abstract SOAPMessage`	`MessageFactory.createMessage(MimeHeaders headers, InputStream in)` 将给定 `InputStream` 对象的内容内部化到新的 `SOAPMessage` 对象，并返回该 `SOAPMessage` 对象。
`abstract void`	`SOAPMessage.writeTo(OutputStream out)` 将此 `SOAPMessage` 对象写入给定输出流。

javax.xml.validation 中 IOException 的使用

抛出 IOException 的 javax.xml.validation 中的方法
`void`	`Validator.validate(Source source)` 验证指定的输入。
`abstract void`	`Validator.validate(Source source, Result result)` 验证指定输入并将扩充的验证结果发送到指定输出。

org.omg.CORBA.portable 中 IOException 的使用

抛出 IOException 的 org.omg.CORBA.portable 中的方法
`int`	`InputStream.read()`
`void`	`OutputStream.write(int b)` 将一个 integer（数组长度）写入此流。

org.xml.sax 中 IOException 的使用

抛出 IOException 的 org.xml.sax 中的方法
`void`	`Parser.parse(InputSource source)` 已过时。解析 XML 文档。
`void`	`XMLReader.parse(InputSource input)` 解析 XML 文档。
`void`	`Parser.parse(String systemId)` 已过时。从系统标识符 (URI) 解析 XML 文档。
`void`	`XMLReader.parse(String systemId)` 从系统标识符 (URI) 解析 XML 文档。
`InputSource`	`EntityResolver.resolveEntity(String publicId, String systemId)` 允许应用程序解析外部实体。

org.xml.sax.ext 中 IOException 的使用

抛出 IOException 的 org.xml.sax.ext 中的方法
`InputSource`	`DefaultHandler2.getExternalSubset(String name, String baseURI)` 告知解析器如果在文档文本中没有声明任何外部子集，则不应使用任何外部子集。
`InputSource`	`EntityResolver2.getExternalSubset(String name, String baseURI)` 允许应用程序为不能显式定义外部子集的文档提供外部子集。
`InputSource`	`DefaultHandler2.resolveEntity(String publicId, String systemId)` 使用 null 实体名称和基 URI 调用 `EntityResolver2.resolveEntity()`。
`InputSource`	`DefaultHandler2.resolveEntity(String name, String publicId, String baseURI, String systemId)` 告知解析器根据 baseURI 解析 systemId，并从产生的绝对 URI 读取实体文本。
`InputSource`	`EntityResolver2.resolveEntity(String name, String publicId, String baseURI, String systemId)` 允许应用程序把对外部实体的引用映射到输入源，或告知解析器它应使用常规 URI 解析。

org.xml.sax.helpers 中 IOException 的使用

抛出 IOException 的 org.xml.sax.helpers 中的方法
`void`	`ParserAdapter.parse(InputSource input)` 解析 XML 文档。
`void`	`XMLFilterImpl.parse(InputSource input)` 解析一个文档。
`void`	`XMLReaderAdapter.parse(InputSource input)` 解析文档。
`void`	`ParserAdapter.parse(String systemId)` 解析 XML 文档。
`void`	`XMLFilterImpl.parse(String systemId)` 解析一个文档。
`void`	`XMLReaderAdapter.parse(String systemId)` 解析文档。
`InputSource`	`DefaultHandler.resolveEntity(String publicId, String systemId)` 解析外部实体。
`InputSource`	`XMLFilterImpl.resolveEntity(String publicId, String systemId)` 过滤一个外部实体解析。

概述

软件包

类

使用

树

已过时

索引

帮助

Java^TM Platform
Standard Ed. 6

上一个下一个

框架 无框架

提交错误或意见
有关更多的 API 参考资料和开发人员文档，请参阅 Java SE 开发人员文档。该文档包含更详细的、面向开发人员的描述，以及总体概述、术语定义、使用技巧和工作代码示例。

类 java.io.IOException的使用

类 java.io.IOException
的使用