类的用途
java.io.IOException

使用 IOException 的包

包	描述
com.sun.jarsigner	该包包含用于定义 jarsigner 工具使用的签名机制的接口和类。
com.sun.jdi	这是 Java 调试接口 (JDI) 的核心包，它定义了值、类型和目标 VirtualMachine 本身的镜像——以及引导工具。
com.sun.jdi.connect	这个包定义了使用 JDI 的虚拟机和目标虚拟机之间的连接。
com.sun.jdi.connect.spi	该包包含用于开发新的 TransportService 实现的接口和类。
com.sun.management	这个包包含 JDK 对 java.lang.management API 的标准实现的扩展，还定义了平台的一些其他组件的管理接口。
com.sun.net.httpserver	提供简单的高级 Http 服务 API，可用于构建嵌入式 HTTP 服务。
com.sun.net.httpserver.spi	提供一个可插入的服务提供者接口，它允许用其他实现替换 HTTP 服务实现。
com.sun.nio.sctp	用于流控制传输协议的 Java API。
com.sun.security.auth.callback	提供 CallbackHandler 的实现。
com.sun.source.util	为抽象语法树 (AST) 的操作提供实用程序。
com.sun.tools.attach	提供附加到 Java 虚拟机的 API。
com.sun.tools.attach.spi	只有定义新附加提供程序的开发人员才需要直接使用此包。
java.applet	提供创建 applet 所需的类以及 applet 用来与其 applet 上下文通信的类。
java.awt	包含用于创建用户界面以及绘制图形和图像的所有类。
java.awt.color	提供颜色空间的类。
java.awt.datatransfer	提供用于在应用程序之间和应用程序内传输数据的接口和类。
java.awt.dnd	拖放是一种在许多图形用户界面系统中发现的直接操作手势，它提供了一种机制，可以在逻辑上与 GUI 中的表示元素相关联的两个实体之间传输信息。
java.awt.print	为通用打印 API 提供类和接口。
java.beans	包含与开发 beans 相关的类——基于 JavaBeans 体系结构的组件。
java.beans.beancontext	提供与 bean 上下文相关的类和接口。
java.io	通过数据流、序列化和文件系统提供系统输入和输出。
java.lang	提供对 Java 编程语言的设计至关重要的类。
java.lang.management	提供Java运行时Java虚拟机和其他组件的监控和管理的管理接口。
java.lang.module	通过解析和服务绑定支持模块描述符和创建模块配置的类。
java.net	提供用于实现网络应用程序的类。
java.net.http	HTTP 客户端和 WebSocket API
java.nio	定义作为数据容器的缓冲区，并提供其他 NIO 包的概述。
java.nio.channels	定义通道，它表示与能够执行 I/O 操作的实体的连接，例如文件和套接字；定义选择器，用于多路复用、非阻塞 I/O 操作。
java.nio.channels.spi	java.nio.channels 包的服务提供商类。
java.nio.charset	定义字符集、解码器和编码器，用于字节和 Unicode 字符之间的转换。
java.nio.file	定义Java虚拟机访问文件、文件属性和文件系统的接口和类。
java.nio.file.attribute	提供对文件和文件系统属性的访问的接口和类。
java.nio.file.spi	java.nio.file 包的服务提供商类。
java.rmi	提供RMI包。
java.rmi.server	提供用于支持 RMI 服务端的类和接口。
java.security	为安全框架提供类和接口。
java.security.cert	提供用于解析和管理证书、证书撤销列表 (CRL) 和证书路径的类和接口。
java.util	包含集合框架、一些国际化支持类、服务加载器、属性、随机数生成、字符串解析和扫描类、base64 编码和解码、位数组和几个杂项实用程序类。
java.util.jar	提供用于读取和写入 JAR (Java ARchive) 文件格式的类，该文件格式基于标准 ZIP 文件格式，带有可选的清单文件。
java.util.logging	提供 Java 2 平台的核心日志记录工具的类和接口。
java.util.prefs	这个包允许应用程序存储和检索用户和系统首选项和配置数据。
java.util.zip	提供用于读取和写入标准 ZIP 和 GZIP 文件格式的类。
javax.annotation.processing	用于声明注解处理器和允许注解处理器与注释处理工具环境进行通信的工具。
javax.crypto	提供用于加密操作的类和接口。
javax.imageio	Java Image I/O API 的主要包。
javax.imageio.metadata	处理读取和写入元数据的 Java Image I/O API 包。
javax.imageio.spi	Java 图像 I/O API 的一个包，其中包含用于读取器、写入器、转码器和流的插件接口，以及一个运行时注册表。
javax.imageio.stream	处理来自文件和流的低级 I/O 的 Java 图像 I/O API 包。
javax.management	为 Java 管理扩展提供核心类。
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 打印服务 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 文件读取器和写入器或音库读取器时实现。
javax.sound.sampled	提供用于捕获、处理和播放采样音频数据的接口和类。
javax.sound.sampled.spi	在提供新的音频设备、声音文件读取器和写入器或音频格式转换器时，为服务提供者提供抽象类以进行子类化。
javax.sql.rowset	JDBC RowSet 实现的标准接口和基类。
javax.swing	提供一组“轻量级”（全 Java 语言）组件，尽可能在所有平台上以相同的方式工作。
javax.swing.filechooser	包含 JFileChooser 组件使用的类和接口。
javax.swing.plaf.synth	Synth 是一种可换肤的外观和感觉，其中所有绘画都是委托的。
javax.swing.text	提供处理可编辑和不可编辑文本组件的类和接口。
javax.swing.text.html	提供用于创建 HTML 文本编辑器的类 HTMLEditorKit 和支持类。
javax.swing.text.html.parser	提供默认的 HTML 解析器以及支持类。
javax.swing.text.rtf	提供用于创建 Rich-Text-Format 文本编辑器的类 (RTFEditorKit)。
javax.tools	为可以从程序中调用的工具提供接口，例如编译器。
javax.xml.parsers	提供用于使用 SAX（XML 简单 API）解析器或 DOM（文档对象模型）文档生成器处理 XML 文档的类。
javax.xml.validation	提供用于验证 XML 文档的 API。
jdk.jfr	这个包提供类来创建事件和控制飞行记录器。
jdk.jfr.consumer	此包包含用于使用 Flight Recorder 数据的类。
jdk.jshell.execution	为构建 JShell 执行引擎提供实现支持。
jdk.management.jfr	此包包含通过 Java 管理扩展 (JMX) 控制和监视 Flight Recorder 的类。
jdk.net	java.net 和 java.nio.channels 套接字类的平台特定套接字选项。
jdk.nio	定义 JDK 特定的 channel API。
org.xml.sax	为 XML (SAX) 的简单 API 提供接口。
org.xml.sax.ext	为符合标准的 SAX 驱动程序不一定支持的 SAX2 设施提供接口。
org.xml.sax.helpers	提供帮助程序类，包括对引导基于 SAX 的应用程序的支持。

IOException 在 com.sun.jarsigner 中的用法

在 com.sun.jarsigner 中抛出 IOException

修饰符和类型	方法	描述
abstract byte[]	ContentSigner.generateSignedData(ContentSignerParameters parameters, boolean omitContent, boolean applyTimestamp)	已弃用，将被删除：此 API 元素可能会在未来版本中删除。 生成 PKCS #7 签名数据消息。

IOException 在 com.sun.jdi 中的用法

在 com.sun.jdi 中抛出 IOException

修饰符和类型	方法	描述
VirtualMachine	VirtualMachineManager.createVirtualMachine(Connection connection)	创建一个新的虚拟机。
VirtualMachine	VirtualMachineManager.createVirtualMachine(Connection connection, Process process)	为目标 VM 创建虚拟机镜像。

IOException 在 com.sun.jdi.connect 中的用法

com.sun.jdi.connect 中 IOException 的子类

修饰符和类型	类	描述
class	TransportTimeoutException	附加到目标 VM 或等待接受来自目标 VM 的连接时超时可能会引发此异常。

在 com.sun.jdi.connect 中抛出 IOException

修饰符和类型	方法	描述
VirtualMachine	ListeningConnector.accept(Map<String,? extends Connector.Argument> arguments)	等待目标 VM 附加到此连接器。
VirtualMachine	AttachingConnector.attach(Map<String,? extends Connector.Argument> arguments)	附加到正在运行的应用程序并返回其 VM 的镜像。
VirtualMachine	LaunchingConnector.launch(Map<String,? extends Connector.Argument> arguments)	启动应用程序并连接到其 VM。
String	ListeningConnector.startListening(Map<String,? extends Connector.Argument> arguments)	监听由目标 VM 发起的一个或多个连接。
void	ListeningConnector.stopListening(Map<String,? extends Connector.Argument> arguments)	取消监听连接。

IOException 在 com.sun.jdi.connect.spi 中的用法

com.sun.jdi.connect.spi 中 IOException 的子类

修饰符和类型	类	描述
class	ClosedConnectionException	当 I/O 操作正在进行时，异步关闭 Connection 可能会引发此异常。

在 com.sun.jdi.connect.spi 中抛出 IOException

修饰符和类型	方法	描述
abstract Connection	TransportService.accept(TransportService.ListenKey listenKey, long acceptTimeout, long handshakeTimeout)	接受来自目标 VM 的连接。
abstract Connection	TransportService.attach(String address, long attachTimeout, long handshakeTimeout)	附加到指定地址。
abstract void	Connection.close()	关闭此连接。
abstract byte[]	Connection.readPacket()	从目标 VM 读取数据包。
abstract TransportService.ListenKey	TransportService.startListening()	监听传输服务选择的地址。
abstract TransportService.ListenKey	TransportService.startListening(String address)	监听入站连接的指定地址。
abstract void	TransportService.stopListening(TransportService.ListenKey listenKey)	停止监听入站连接。
abstract void	Connection.writePacket(byte[] pkt)	将数据包写入目标 VM。

IOException 在 com.sun.management 中的用法

在 com.sun.management 中抛出 IOException

修饰符和类型	方法	描述
void	HotSpotDiagnosticMXBean.dumpHeap(String outputFile, boolean live)	以与 hprof 堆转储相同的格式将堆转储到 outputFile 文件。
default void	HotSpotDiagnosticMXBean.dumpThreads(String outputFile, HotSpotDiagnosticMXBean.ThreadDumpFormatPREVIEW format)	预览。 以给定格式生成给定文件的线程转储。

IOException 在 com.sun.net.httpserver 中的用法

在 com.sun.net.httpserver 中抛出 IOException

修饰符和类型	方法	描述
abstract void	HttpServer.bind(InetSocketAddress addr, int backlog)	将当前未绑定的 HttpServer 绑定到给定的地址和端口号。
static HttpServer	HttpServer.create()	创建一个最初未绑定到任何本地地址/端口的HttpServer实例。
static HttpServer	HttpServer.create(InetSocketAddress addr, int backlog)	创建一个 HttpServer 实例，它将绑定到指定的 InetSocketAddress （IP 地址和端口号）。
static HttpServer	HttpServer.create(InetSocketAddress addr, int backlog, String path, HttpHandler handler, Filter... filters)	创建一个带有初始上下文的 HttpServer 实例。
static HttpsServer	HttpsServer.create()	创建一个最初未绑定到任何本地地址/端口的HttpsServer实例。
static HttpsServer	HttpsServer.create(InetSocketAddress addr, int backlog)	创建一个 HttpsServer 实例，它将绑定到指定的 InetSocketAddress （IP 地址和端口号）。
static HttpsServer	HttpsServer.create(InetSocketAddress addr, int backlog, String path, HttpHandler handler, Filter... filters)	创建一个带有初始上下文的 HttpsServer 实例。
void	Filter.Chain.doFilter(HttpExchange exchange)	调用链中的下一个过滤器，或者如果这是链中的最后一个过滤器，则调用用户交换处理程序。
abstract void	Filter.doFilter(HttpExchange exchange, Filter.Chain chain)	要求此过滤器对给定的交换进行预处理/后处理。
void	HttpHandler.handle(HttpExchange exchange)	处理给定的请求并生成适当的响应。
abstract void	HttpExchange.sendResponseHeaders(int rCode, long responseLength)	开始使用当前的响应标头集和此方法中指定的数字响应代码将响应发送回客户端。

IOException 在 com.sun.net.httpserver.spi 中的用法

在 com.sun.net.httpserver.spi 中抛出 IOException

修饰符和类型	方法	描述
abstract HttpServer	HttpServerProvider.createHttpServer(InetSocketAddress addr, int backlog)	从这个提供者创建一个 HttpServer
abstract HttpsServer	HttpServerProvider.createHttpsServer(InetSocketAddress addr, int backlog)	从这个提供者创建一个 HttpsServer

IOException 在 com.sun.nio.sctp 中的用法

在 com.sun.nio.sctp 中抛出 IOException

修饰符和类型	方法	描述
abstract SctpChannel	SctpServerChannel.accept()	接受此通道套接字上的关联。
abstract Association	SctpChannel.association()	返回此通道套接字上的关联。
abstract Set<Association>	SctpMultiChannel.associations()	返回此通道套接字上的打开关联。
abstract SctpChannel	SctpChannel.bind(SocketAddress local)	将通道的套接字绑定到本地地址。
final SctpMultiChannel	SctpMultiChannel.bind(SocketAddress local)	将通道的套接字绑定到本地地址并配置套接字以监听连接。
abstract SctpMultiChannel	SctpMultiChannel.bind(SocketAddress local, int backlog)	将通道的套接字绑定到本地地址并配置套接字以监听连接。
final SctpServerChannel	SctpServerChannel.bind(SocketAddress local)	将通道的套接字绑定到本地地址并配置套接字以监听关联。
abstract SctpServerChannel	SctpServerChannel.bind(SocketAddress local, int backlog)	将通道的套接字绑定到本地地址并配置套接字以监听关联。
abstract SctpChannel	SctpChannel.bindAddress(InetAddress address)	将给定地址添加到通道套接字的绑定地址。
abstract SctpMultiChannel	SctpMultiChannel.bindAddress(InetAddress address)	将给定地址添加到通道套接字的绑定地址。
abstract SctpServerChannel	SctpServerChannel.bindAddress(InetAddress address)	将给定地址添加到通道套接字的绑定地址。
abstract SctpChannel	SctpMultiChannel.branch(Association association)	分支出一个关联.
abstract boolean	SctpChannel.connect(SocketAddress remote)	连接此通道的套接字。
abstract boolean	SctpChannel.connect(SocketAddress remote, int maxOutStreams, int maxInStreams)	连接此通道的套接字。
abstract boolean	SctpChannel.finishConnect()	完成连接 SCTP 通道的过程。
abstract Set<SocketAddress>	SctpChannel.getAllLocalAddresses()	返回此通道的套接字绑定到的所有套接字地址。
abstract Set<SocketAddress>	SctpMultiChannel.getAllLocalAddresses()	返回此通道的套接字绑定到的所有套接字地址。
abstract Set<SocketAddress>	SctpServerChannel.getAllLocalAddresses()	返回此通道的套接字绑定到的所有套接字地址。
abstract <T> T	SctpChannel.getOption(SctpSocketOption<T> name)	返回套接字选项的值。
abstract <T> T	SctpMultiChannel.getOption(SctpSocketOption<T> name, Association association)	返回套接字选项的值。
abstract <T> T	SctpServerChannel.getOption(SctpSocketOption<T> name)	返回套接字选项的值。
abstract Set<SocketAddress>	SctpChannel.getRemoteAddresses()	返回此通道的套接字连接到的所有远程地址。
abstract Set<SocketAddress>	SctpMultiChannel.getRemoteAddresses(Association association)	返回此通道套接字上给定关联所连接到的所有远程地址。
static SctpChannel	SctpChannel.open()	打开 SCTP 通道。
static SctpChannel	SctpChannel.open(SocketAddress remote, int maxOutStreams, int maxInStreams)	打开 SCTP 通道并将其连接到远程地址。
static SctpMultiChannel	SctpMultiChannel.open()	打开 SCTP 多通道。
static SctpServerChannel	SctpServerChannel.open()	打开 SCTP 服务通道。
abstract <T> MessageInfo	SctpChannel.receive(ByteBuffer dst, T attachment, NotificationHandler<T> handler)	在给定缓冲区中接收消息和/或处理通知。
abstract <T> MessageInfo	SctpMultiChannel.receive(ByteBuffer buffer, T attachment, NotificationHandler<T> handler)	通过此通道接收消息和/或处理通知。
abstract int	SctpChannel.send(ByteBuffer src, MessageInfo messageInfo)	通过此通道发送消息。
abstract int	SctpMultiChannel.send(ByteBuffer buffer, MessageInfo messageInfo)	通过此通道发送消息。
abstract <T> SctpChannel	SctpChannel.setOption(SctpSocketOption<T> name, T value)	设置套接字选项的值。
abstract <T> SctpMultiChannel	SctpMultiChannel.setOption(SctpSocketOption<T> name, T value, Association association)	设置套接字选项的值。
abstract <T> SctpServerChannel	SctpServerChannel.setOption(SctpSocketOption<T> name, T value)	设置套接字选项的值。
abstract SctpChannel	SctpChannel.shutdown()	在不关闭通道的情况下关闭连接。
abstract SctpMultiChannel	SctpMultiChannel.shutdown(Association association)	在不关闭通道的情况下关闭关联。
abstract SctpChannel	SctpChannel.unbindAddress(InetAddress address)	从通道套接字的绑定地址中删除给定地址。
abstract SctpMultiChannel	SctpMultiChannel.unbindAddress(InetAddress address)	从通道套接字的绑定地址中删除给定地址。
abstract SctpServerChannel	SctpServerChannel.unbindAddress(InetAddress address)	从通道套接字的绑定地址中删除给定地址。

IOException 在 com.sun.security.auth.callback 中的用法

在 com.sun.security.auth.callback 中抛出 IOException

修饰符和类型	方法	描述
void	TextCallbackHandler.handle(Callback[] callbacks)	处理指定的回调集。

IOException 在 com.sun.source.util 中的用法

在 com.sun.source.util 中抛出 IOException

修饰符和类型	方法	描述
abstract Iterable<? extends Element>	JavacTask.analyze()	完成所有分析。
abstract Iterable<? extends JavaFileObject>	JavacTask.generate()	生成代码。
abstract DocCommentTree	DocTrees.getDocCommentTree(Element e, String relativePath)	返回给定文件的文档注释树，其路径是相对于给定元素指定的。
abstract Iterable<? extends CompilationUnitTree>	JavacTask.parse()	解析返回抽象语法树列表的指定文件。

IOException 在 com.sun.tools.attach 中的用法

com.sun.tools.attach 中 IOException 的子类

修饰符和类型	类	描述
class	AttachOperationFailedException	表示目标 VM 中的附加操作失败的异常类型。

在 com.sun.tools.attach 中抛出 IOException

修饰符和类型	方法	描述
static VirtualMachine	VirtualMachine.attach(VirtualMachineDescriptor vmd)	附加到 Java 虚拟机。
static VirtualMachine	VirtualMachine.attach(String id)	附加到 Java 虚拟机。
abstract void	VirtualMachine.detach()	与虚拟机分离。
abstract Properties	VirtualMachine.getAgentProperties()	返回当前代理属性在目标虚拟机中。
abstract Properties	VirtualMachine.getSystemProperties()	返回目标虚拟机中的当前系统属性。
void	VirtualMachine.loadAgent(String agent)	加载代理。
abstract void	VirtualMachine.loadAgent(String agent, String options)	加载代理。
void	VirtualMachine.loadAgentLibrary(String agentLibrary)	加载代理库。
abstract void	VirtualMachine.loadAgentLibrary(String agentLibrary, String options)	加载代理库。
void	VirtualMachine.loadAgentPath(String agentPath)	通过完整路径名加载本机代理库。
abstract void	VirtualMachine.loadAgentPath(String agentPath, String options)	通过完整路径名加载本机代理库。
abstract String	VirtualMachine.startLocalManagementAgent()	在目标虚拟机中启动本地 JMX 管理代理。
abstract void	VirtualMachine.startManagementAgent(Properties agentProperties)	在目标虚拟机中启动 JMX 管理代理。

IOException 在 com.sun.tools.attach.spi 中的用法

在 com.sun.tools.attach.spi 中抛出 IOException

修饰符和类型	方法	描述
VirtualMachine	AttachProvider.attachVirtualMachine(VirtualMachineDescriptor vmd)	附加到 Java 虚拟机。
abstract VirtualMachine	AttachProvider.attachVirtualMachine(String id)	附加到 Java 虚拟机。

IOException 在 java.applet 中的用法

在 java.applet 中抛出 IOException

修饰符和类型	方法	描述
void	AppletContext.setStream(String key, InputStream stream)	已弃用，将被删除：此 API 元素可能会在未来版本中删除。 将指定流与此 applet 上下文中的指定键相关联。

IOException 在 java.awt 中的用法

在 java.awt 中抛出 IOException

修饰符和类型	方法	描述
void	Desktop.browse(URI uri)	启动默认浏览器以显示 URI 。
static Font	Font.createFont(int fontFormat, File fontFile)	使用指定的字体类型和指定的字体文件返回一个新的 Font。
static Font	Font.createFont(int fontFormat, InputStream fontStream)	使用指定的字体类型和输入数据返回一个新的 Font。
static Font[]	Font.createFonts(File fontFile)	返回从指定文件解码的新数组 Font。
static Font[]	Font.createFonts(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)	更改初始屏幕图像。

IOException 在 java.awt.color 中的用法

在 java.awt.color 中抛出 IOException

修饰符和类型	方法	描述
static ICC_Profile	ICC_Profile.getInstance(InputStream s)	构造一个 ICC_Profile 对应于 InputStream 中的数据。
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 写入文件。

IOException 在 java.awt.datatransfer 中的用法

在 java.awt.datatransfer 中抛出 IOException

修饰符和类型	方法	描述
Object	Clipboard.getData(DataFlavor flavor)	返回表示指定 DataFlavor 中此剪贴板当前内容的对象。
Reader	DataFlavor.getReaderForText(Transferable transferable)	获取文本风格的阅读器，如有必要，解码为预期的字符集（编码）。
Object	StringSelection.getTransferData(DataFlavor flavor)	如果可能，在请求的 DataFlavor 中返回 Transferable 的数据。
Object	Transferable.getTransferData(DataFlavor flavor)	返回表示要传输的数据的对象。
void	DataFlavor.readExternal(ObjectInput is)	从序列化状态恢复此 DataFlavor。
void	DataFlavor.writeExternal(ObjectOutput os)	序列化这个 DataFlavor 。

IOException 在 java.awt.dnd 中的用法

在 java.awt.dnd 中抛出 IOException

修饰符和类型	方法	描述
Object	DropTargetContext.TransferableProxy.getTransferData(DataFlavor df)	返回一个对象，该对象表示由封装的可传输对象为请求的数据类型提供的数据。

IOException 在 java.awt.print 中的用法

java.awt.print 中返回 IOException 的方法

修饰符和类型	方法	描述
IOException	PrinterIOException.getIOException()	返回终止打印作业的 IOException。

java.awt.print 中的构造函数，参数类型为 IOException

修饰符	构造方法	描述
	PrinterIOException(IOException exception)	使用指定的 IOException 的字符串表示构造一个新的 PrinterIOException。

IOException 在 java.beans 中的用法

在 java.beans 中抛出 IOException

修饰符和类型	方法	描述
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)	已弃用，将被删除：此 API 元素可能会在未来版本中删除。 建议使用 Beans.instantiate(ClassLoader, String, BeanContext) ，因为 Applet API 已弃用。

IOException 在 java.beans.beancontext 中的用法

在 java.beans.beancontext 中抛出 IOException

修饰符和类型	方法	描述
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 final void	BeanContextSupport.deserialize(ObjectInputStream ois, Collection coll)	readObject 使用它来反序列化一个集合。
Object	BeanContext.instantiateChild(String beanName)	实例化名为 BeanContext 的子级的 javaBean。
Object	BeanContextSupport.instantiateChild(String beanName)	instantiateChild 方法是 BeanContext 中的一个便利挂钩，用于简化将嵌套的 Bean 实例化为 BeanContext 的任务。
final void	BeanContextSupport.readChildren(ObjectInputStream ois)	当此类的实例用作 BeanContext 协议（及其子协议）实现的委托时，在反序列化期间存在“先有鸡还是先有蛋”的问题
protected final void	BeanContextSupport.serialize(ObjectOutputStream oos, Collection<?> coll)	由 writeObject 用于序列化 Collection。
final void	BeanContextSupport.writeChildren(ObjectOutputStream oos)	用于序列化此 BeanContext 的所有子项。

IOException 在 java.io 中的用法

java.io 中 IOException 的子类

修饰符和类型	类	描述
class	CharConversionException	字符转换异常的基类。
class	EOFException	表示在输入期间意外到达文件末尾或流末尾的信号。
class	FileNotFoundException	表示尝试打开由指定路径名表示的文件失败的信号。
class	InterruptedIOException	I/O 操作已被中断的信号。
class	InvalidClassException	当序列化运行时检测到类存在以下问题之一时抛出。
class	InvalidObjectException	指示一个或多个反序列化对象未通过验证测试。
class	NotActiveException	当序列化或反序列化未处于活动状态时抛出。
class	NotSerializableException	当需要实例具有 Serializable 接口时抛出。
class	ObjectStreamException	特定于对象流类的所有异常的超类。
class	OptionalDataException	异常指示由于未读取的原始数据或属于流中序列化对象的数据结束而导致对象读取操作失败。
class	StreamCorruptedException	当从对象流中读取的控制信息违反内部一致性检查时抛出。
class	SyncFailedException	同步操作失败的信号。
class	UnsupportedEncodingException	不支持字符编码。
class	UTFDataFormatException	表示 修改后的 UTF-8 格式的格式错误的字符串已在数据输入流中或由任何实现数据输入接口的类读取。
class	WriteAbortedException	表示在写入操作期间抛出了 ObjectStreamExceptions 之一。

java.io 中返回 IOException 的方法

修饰符和类型	方法	描述
IOException	UncheckedIOException.getCause()	返回此异常的原因。

在 java.io 中抛出 IOException

修饰符和类型	方法	描述
protected void	ObjectOutputStream.annotateClass(Class<?> cl)	子类可以实现此方法以允许将类数据存储在流中。
protected void	ObjectOutputStream.annotateProxyClass(Class<?> cl)	子类可以实现此方法以将自定义数据与动态代理类的描述符一起存储在流中。
Writer	Writer.append(char c)	将指定的字符附加到此编写器。
Writer	Writer.append(CharSequence csq)	将指定的字符序列附加到此编写器。
Writer	Writer.append(CharSequence csq, int start, int end)	将指定字符序列的子序列附加到此 writer。
int	BufferedInputStream.available()	返回可以从此输入流中读取（或跳过）的字节数的估计值，而不会被下一次为此输入流的方法调用阻塞。
int	FileInputStream.available()	返回可以从此输入流中读取（或跳过）的剩余字节数的估计值，而不会被下一次为此输入流的方法调用阻塞。
int	FilterInputStream.available()	返回可以从此输入流中读取（或跳过）的字节数的估计值，而不会被此输入流的方法的下一个调用者阻塞。
int	InputStream.available()	返回可以从此输入流读取（或跳过）而不阻塞的字节数的估计值，它可能是 0，或者当检测到流结束时为 0。
int	LineNumberInputStream.available()	已弃用。 返回可以从该输入流中无阻塞地读取的字节数。
int	ObjectInput.available()	返回可以无阻塞读取的字节数。
int	ObjectInputStream.available()	返回可以无阻塞读取的字节数。
int	PipedInputStream.available()	返回可以从该输入流中无阻塞地读取的字节数。
int	PushbackInputStream.available()	返回可以从此输入流中读取（或跳过）的字节数的估计值，而不会被下一次为此输入流的方法调用阻塞。
int	SequenceInputStream.available()	返回可以从当前底层输入流中读取（或跳过）的字节数的估计值，而不会被当前底层输入流的下一次方法调用阻塞。
void	BufferedInputStream.close()	关闭此输入流并释放与该流关联的所有系统资源。
void	BufferedReader.close()
void	BufferedWriter.close()
void	ByteArrayInputStream.close()	关闭 ByteArrayInputStream 没有任何效果。
void	ByteArrayOutputStream.close()	关闭 ByteArrayOutputStream 没有任何效果。
void	Closeable.close()	关闭此流并释放与其关联的所有系统资源。
void	FileInputStream.close()	关闭此文件输入流并释放与该流关联的所有系统资源。
void	FileOutputStream.close()	关闭此文件输出流并释放与此流关联的所有系统资源。
void	FilterInputStream.close()	关闭此输入流并释放与该流关联的所有系统资源。
void	FilterOutputStream.close()	关闭此输出流并释放与该流关联的所有系统资源。
void	FilterReader.close()
void	FilterWriter.close()
void	InputStream.close()	关闭此输入流并释放与该流关联的所有系统资源。
void	InputStreamReader.close()
void	ObjectInput.close()	关闭输入流。
void	ObjectInputStream.close()	关闭此输入流并释放与该流关联的所有系统资源。
void	ObjectOutput.close()	关闭流。
void	ObjectOutputStream.close()	关闭流。
void	OutputStream.close()	关闭此输出流并释放与此流关联的任何系统资源。
void	OutputStreamWriter.close()
void	PipedInputStream.close()	关闭此输入流并释放与该流关联的所有系统资源。
void	PipedOutputStream.close()	关闭此管道输出流并释放与此流关联的任何系统资源。
void	PipedReader.close()	关闭此管道流并释放与该流关联的任何系统资源。
void	PipedWriter.close()	关闭此管道输出流并释放与此流关联的任何系统资源。
void	PushbackInputStream.close()	关闭此输入流并释放与该流关联的所有系统资源。
void	PushbackReader.close()	关闭流并释放与其关联的任何系统资源。
void	RandomAccessFile.close()	关闭此随机访问文件流并释放与该流关联的所有系统资源。
abstract void	Reader.close()	关闭流并释放与其关联的任何系统资源。
void	SequenceInputStream.close()	关闭此输入流并释放与该流关联的所有系统资源。
void	StringWriter.close()	关闭 StringWriter 没有任何效果。
abstract void	Writer.close()	关闭流，首先冲洗它。
void	PipedInputStream.connect(PipedOutputStream src)	导致此管道输入流连接到管道输出流 src 。
void	PipedOutputStream.connect(PipedInputStream snk)	将此管道输出流连接到接收器。
void	PipedReader.connect(PipedWriter src)	导致此管道读取器连接到管道写入器 src 。
void	PipedWriter.connect(PipedReader snk)	将此管道编写器连接到接收器。
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 中的所有缓冲数据。
void	BufferedOutputStream.flush()	刷新此缓冲输出流。
void	BufferedWriter.flush()	冲洗流。
void	DataOutputStream.flush()	刷新此数据输出流。
void	FilterOutputStream.flush()	刷新此输出流并强制将任何缓冲的输出字节写出到流中。
void	FilterWriter.flush()	冲洗流。
void	Flushable.flush()	通过将任何缓冲输出写入基础流来刷新此流。
void	ObjectOutput.flush()	冲洗流。
void	ObjectOutputStream.flush()	冲洗流。
void	OutputStream.flush()	刷新此输出流并强制写出任何缓冲的输出字节。
void	OutputStreamWriter.flush()	冲洗流。
void	PipedOutputStream.flush()	刷新此输出流并强制写出任何缓冲的输出字节。
void	PipedWriter.flush()	刷新此输出流并强制写出任何缓冲的输出字符。
abstract void	Writer.flush()	冲洗流。
abstract boolean	ObjectInputStream.GetField.get(String name, boolean val)	从持久字段中获取命名布尔字段的值。
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)	从持久字段中获取命名双精度字段的值。
abstract float	ObjectInputStream.GetField.get(String name, float val)	从持久字段中获取命名浮点字段的值。
abstract int	ObjectInputStream.GetField.get(String name, int val)	从持久字段中获取指定 int 字段的值。
abstract long	ObjectInputStream.GetField.get(String name, long val)	从持久字段中获取指定长字段的值。
abstract short	ObjectInputStream.GetField.get(String name, short val)	从持久字段中获取指定短字段的值。
abstract Object	ObjectInputStream.GetField.get(String name, Object val)	从持久字段中获取命名对象字段的值。
File	File.getCanonicalFile()	返回此抽象路径名的规范形式。
String	File.getCanonicalPath()	返回此抽象路径名的规范路径名字符串。
final FileDescriptor	FileInputStream.getFD()	返回 FileDescriptor 对象，该对象表示与此 FileInputStream 使用的文件系统中的实际文件的连接。
final FileDescriptor	FileOutputStream.getFD()	返回与此流关联的文件描述符。
final FileDescriptor	RandomAccessFile.getFD()	返回与此流关联的不透明文件描述符对象。
long	RandomAccessFile.getFilePointer()	返回此文件中的当前偏移量。
long	RandomAccessFile.length()	返回此文件的长度。
void	BufferedReader.mark(int readAheadLimit)	标记流中的当前位置。
void	CharArrayReader.mark(int readAheadLimit)	标记流中的当前位置。
void	FilterReader.mark(int readAheadLimit)	标记流中的当前位置。
void	LineNumberReader.mark(int readAheadLimit)	标记流中的当前位置。
void	PushbackReader.mark(int readAheadLimit)	标记流中的当前位置。
void	Reader.mark(int readAheadLimit)	标记流中的当前位置。
void	StringReader.mark(int readAheadLimit)	标记流中的当前位置。
void	BufferedWriter.newLine()	写入行分隔符。
int	StreamTokenizer.nextToken()	从此分词器的输入流中解析下一个分词。
ObjectOutputStream.PutField	ObjectOutputStream.putFields()	检索用于缓冲要写入流的持久字段的对象。
int	BufferedInputStream.read()	参见InputStream的read方法的总契约。
int	BufferedInputStream.read(byte[] b, int off, int len)	从此字节输入流中读取字节到指定的字节数组，从给定的偏移量开始。
int	BufferedReader.read()	读取单个字符。
int	BufferedReader.read(char[] cbuf, int off, int len)	将字符读入数组的一部分。
int	CharArrayReader.read()	读取单个字符。
int	CharArrayReader.read(char[] cbuf, int off, int len)	将字符读入数组的一部分。
final int	DataInputStream.read(byte[] b)	从包含的输入流中读取一定数量的字节并将它们存储到缓冲区数组 b 中。
final int	DataInputStream.read(byte[] b, int off, int len)	从包含的输入流中读取最多 len 字节的数据到字节数组中。
int	FileInputStream.read()	从此输入流中读取一个字节的数据。
int	FileInputStream.read(byte[] b)	从此输入流中读取最多 b.length 字节的数据到字节数组中。
int	FileInputStream.read(byte[] b, int off, int len)	从此输入流中读取最多 len 字节的数据到字节数组中。
int	FilterInputStream.read()	从输入流中读取下一个字节的数据。
int	FilterInputStream.read(byte[] b)	从此输入流中读取最多 b.length 字节的数据到字节数组中。
int	FilterInputStream.read(byte[] b, int off, int len)	从此输入流中读取最多 len 字节的数据到字节数组中。
int	FilterReader.read()	读取单个字符。
int	FilterReader.read(char[] cbuf, int off, int len)	将字符读入数组的一部分。
abstract int	InputStream.read()	从输入流中读取下一个字节的数据。
int	InputStream.read(byte[] b)	从输入流中读取一定数量的字节并将它们存储到缓冲区数组 b 中。
int	InputStream.read(byte[] b, int off, int len)	从输入流中读取最多 len 字节的数据到字节数组中。
int	InputStreamReader.read()	读取单个字符。
int	InputStreamReader.read(char[] cbuf, int off, int len)	将字符读入数组的一部分。
int	LineNumberInputStream.read()	已弃用。 从此输入流中读取下一个字节的数据。
int	LineNumberInputStream.read(byte[] b, int off, int len)	已弃用。 从此输入流中读取最多 len 字节的数据到字节数组中。
int	LineNumberReader.read()	读取单个字符。
int	LineNumberReader.read(char[] cbuf, int off, int len)	将字符读入数组的一部分。
int	ObjectInput.read()	读取一个字节的数据。
int	ObjectInput.read(byte[] b)	读入字节数组。
int	ObjectInput.read(byte[] b, int off, int len)	读入字节数组。
int	ObjectInputStream.read()	读取一个字节的数据。
int	ObjectInputStream.read(byte[] buf, int off, int len)	读入字节数组。
int	PipedInputStream.read()	从此管道输入流中读取下一个数据字节。
int	PipedInputStream.read(byte[] b, int off, int len)	从此管道输入流中读取最多 len 字节的数据到字节数组中。
int	PipedReader.read()	从此管道流中读取数据的下一个字符。
int	PipedReader.read(char[] cbuf, int off, int len)	将字符读入数组的一部分。
int	PushbackInputStream.read()	从此输入流中读取下一个字节的数据。
int	PushbackInputStream.read(byte[] b, int off, int len)	从此输入流中读取最多 len 字节的数据到字节数组中。
int	PushbackReader.read()	读取单个字符。
int	RandomAccessFile.read()	从此文件中读取一个字节的数据。
int	RandomAccessFile.read(byte[] b)	从此文件中读取最多 b.length 字节的数据到字节数组中。
int	RandomAccessFile.read(byte[] b, int off, int len)	从此文件中读取最多 len 字节的数据到字节数组中。
int	Reader.read()	读取单个字符。
int	Reader.read(char[] cbuf)	将字符读入数组。
abstract int	Reader.read(char[] cbuf, int off, int len)	将字符读入数组的一部分。
int	Reader.read(CharBuffer target)	尝试将字符读入指定的字符缓冲区。
int	SequenceInputStream.read()	从输入流中读取下一个字节的数据。
int	SequenceInputStream.read(byte[] b, int off, int len)	从此输入流中读取最多 len 字节的数据到字节数组中。
int	StringReader.read()	读取单个字符。
int	StringReader.read(char[] cbuf, int off, int len)	将字符读入数组的一部分。
byte[]	InputStream.readAllBytes()	从输入流中读取所有剩余字节。
boolean	DataInput.readBoolean()	读取一个输入字节，如果该字节为非零则返回 true，如果该字节为零则返回 false。
final boolean	DataInputStream.readBoolean()	参见DataInput的readBoolean方法的总契约。
boolean	ObjectInputStream.readBoolean()	读入boolean。
final boolean	RandomAccessFile.readBoolean()	从此文件中读取 boolean。
byte	DataInput.readByte()	读取并返回一个输入字节。
final byte	DataInputStream.readByte()	参见DataInput的readByte方法的总契约。
byte	ObjectInputStream.readByte()	读取一个 8 位字节。
final byte	RandomAccessFile.readByte()	从此文件中读取一个带符号的八位值。
char	DataInput.readChar()	读取两个输入字节并返回一个 char 值。
final char	DataInputStream.readChar()	参见DataInput的readChar方法的总契约。
char	ObjectInputStream.readChar()	读取 16 位字符。
final char	RandomAccessFile.readChar()	从此文件中读取一个字符。
protected ObjectStreamClass	ObjectInputStream.readClassDescriptor()	从序列化流中读取类描述符。
double	DataInput.readDouble()	读取八个输入字节并返回一个 double 值。
final double	DataInputStream.readDouble()	参见DataInput的readDouble方法的总契约。
double	ObjectInputStream.readDouble()	读取 64 位双精度数。
final double	RandomAccessFile.readDouble()	从此文件中读取 double。
void	Externalizable.readExternal(ObjectInput in)	该对象实现了 readExternal 方法，通过调用基本类型的 DataInput 方法和对象、字符串和数组的 readObject 方法来恢复其内容。
ObjectInputStream.GetField	ObjectInputStream.readFields()	从流中读取持久字段并按名称使它们可用。
float	DataInput.readFloat()	读取四个输入字节并返回一个 float 值。
final float	DataInputStream.readFloat()	参见DataInput的readFloat方法的总契约。
float	ObjectInputStream.readFloat()	读取 32 位浮点数。
final float	RandomAccessFile.readFloat()	从该文件中读取 float。
void	DataInput.readFully(byte[] b)	从输入流中读取一些字节并将它们存储到缓冲区数组 b 中。
void	DataInput.readFully(byte[] b, int off, int len)	从输入流中读取 len 个字节。
final void	DataInputStream.readFully(byte[] b)	参见DataInput的readFully方法的总契约。
final void	DataInputStream.readFully(byte[] b, int off, int len)	参见DataInput的readFully方法的总契约。
void	ObjectInputStream.readFully(byte[] buf)	读取字节，阻塞直到读取所有字节。
void	ObjectInputStream.readFully(byte[] buf, int off, int len)	读取字节，阻塞直到读取所有字节。
final void	RandomAccessFile.readFully(byte[] b)	从当前文件指针开始，将 b.length 个字节从此文件读入字节数组。
final void	RandomAccessFile.readFully(byte[] b, int off, int len)	从当前文件指针开始，从该文件中准确读取 len 个字节到字节数组中。
int	DataInput.readInt()	读取四个输入字节并返回一个 int 值。
final int	DataInputStream.readInt()	参见DataInput的readInt方法的总契约。
int	ObjectInputStream.readInt()	读取 32 位 int。
final int	RandomAccessFile.readInt()	从此文件中读取带符号的 32 位整数。
String	BufferedReader.readLine()	读取一行文本。
String	DataInput.readLine()	从输入流中读取下一行文本。
final String	DataInputStream.readLine()	已弃用。 此方法不能正确地将字节转换为字符。
String	LineNumberReader.readLine()	阅读一行文字。
String	ObjectInputStream.readLine()	已弃用。 此方法不能正确地将字节转换为字符。
final String	RandomAccessFile.readLine()	从此文件中读取下一行文本。
long	DataInput.readLong()	读取八个输入字节并返回一个 long 值。
final long	DataInputStream.readLong()	参见DataInput的readLong方法的总契约。
long	ObjectInputStream.readLong()	读取 64 位长。
final long	RandomAccessFile.readLong()	从此文件中读取带符号的 64 位整数。
int	InputStream.readNBytes(byte[] b, int off, int len)	从输入流中将请求的字节数读取到给定的字节数组中。
byte[]	InputStream.readNBytes(int len)	从输入流中读取指定数量的字节。
Object	ObjectInput.readObject()	读取并返回一个对象。
final Object	ObjectInputStream.readObject()	从 ObjectInputStream 中读取一个对象。
protected Object	ObjectInputStream.readObjectOverride()	此方法由使用受保护的无参数构造方法构造 ObjectInputStream 的 ObjectInputStream 的受信任子类调用。
short	DataInput.readShort()	读取两个输入字节并返回一个 short 值。
final short	DataInputStream.readShort()	参见DataInput的readShort方法的总契约。
short	ObjectInputStream.readShort()	读取 16 位短。
final short	RandomAccessFile.readShort()	从此文件中读取带符号的 16 位数字。
protected void	ObjectInputStream.readStreamHeader()	提供了 readStreamHeader 方法以允许子类读取和验证自己的流标头。
Object	ObjectInputStream.readUnshared()	从 ObjectInputStream 中读取一个“非共享”对象。
int	DataInput.readUnsignedByte()	读取一个输入字节，将其零扩展为 int 类型，并返回结果，因此该结果在 0 到 255 范围内。
final int	DataInputStream.readUnsignedByte()	参见DataInput的readUnsignedByte方法的总契约。
int	ObjectInputStream.readUnsignedByte()	读取一个无符号的 8 位字节。
final int	RandomAccessFile.readUnsignedByte()	从此文件中读取一个无符号的八位数字。
int	DataInput.readUnsignedShort()	读取两个输入字节并返回 0 到 65535 范围内的 int 值。
final int	DataInputStream.readUnsignedShort()	参见DataInput的readUnsignedShort方法的总契约。
int	ObjectInputStream.readUnsignedShort()	读取一个无符号的 16 位短整数。
final int	RandomAccessFile.readUnsignedShort()	从此文件中读取一个无符号的 16 位数字。
String	DataInput.readUTF()	读入使用 修改后的 UTF-8 格式编码的字符串。
final String	DataInputStream.readUTF()	参见DataInput的readUTF方法的总契约。
static final String	DataInputStream.readUTF(DataInput in)	从流 in 中读取以 修改后的 UTF-8 格式编码的 Unicode 字符串的表示；然后将此字符串作为 String 返回。
String	ObjectInputStream.readUTF()	读取 修改后的 UTF-8 格式的字符串。
final String	RandomAccessFile.readUTF()	从此文件中读入一个字符串。
boolean	BufferedReader.ready()	告知此流是否已准备好读取。
boolean	CharArrayReader.ready()	告知此流是否已准备好读取。
boolean	FilterReader.ready()	告知此流是否已准备好读取。
boolean	InputStreamReader.ready()	告知此流是否已准备好读取。
boolean	PipedReader.ready()	告诉这个流是否准备好被读取。
boolean	PushbackReader.ready()	告知此流是否已准备好读取。
boolean	Reader.ready()	告知此流是否已准备好读取。
boolean	StringReader.ready()	告知此流是否已准备好读取。
protected void	PipedInputStream.receive(int b)	接收一个字节的数据。
protected Object	ObjectOutputStream.replaceObject(Object obj)	此方法将允许 ObjectOutputStream 的受信任子类在序列化期间用一个对象替换另一个对象。
void	BufferedInputStream.reset()	参见InputStream的reset方法的总契约。
void	BufferedReader.reset()	将流重置为最近的标记。
void	CharArrayReader.reset()	将流重置为最近的标记，如果从未标记过，则重置为开头。
void	FilterInputStream.reset()	将此流重新定位到上次对此输入流调用 mark 方法时的位置。
void	FilterReader.reset()	重置流。
void	InputStream.reset()	将此流重新定位到上次对此输入流调用 mark 方法时的位置。
void	LineNumberInputStream.reset()	已弃用。 将此流重新定位到上次对此输入流调用 mark 方法时的位置。
void	LineNumberReader.reset()	将流重置为最近的标记。
void	ObjectOutputStream.reset()	重置将忽略已写入流的任何对象的状态。
void	PushbackInputStream.reset()	将此流重新定位到上次对此输入流调用 mark 方法时的位置。
void	PushbackReader.reset()	重置流。
void	Reader.reset()	重置流。
void	StringReader.reset()	将流重置为最近的标记，或者如果从未标记过，则重置为字符串的开头。
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	BufferedInputStream.skip(long n)	参见InputStream的skip方法的总契约。
long	CharArrayReader.skip(long n)	跳过字符。
long	FileInputStream.skip(long n)	跳过并丢弃输入流中的 n 字节数据。
long	FilterInputStream.skip(long n)	跳过并丢弃输入流中的 n 字节数据。
long	FilterReader.skip(long n)	跳过字符。
long	InputStream.skip(long n)	跳过并丢弃此输入流中的 n 字节数据。
long	LineNumberInputStream.skip(long n)	已弃用。 跳过并丢弃此输入流中的 n 字节数据。
long	ObjectInput.skip(long n)	跳过 n 个字节的输入。
long	PushbackInputStream.skip(long n)	跳过并丢弃此输入流中的 n 字节数据。
long	Reader.skip(long n)	跳过字符。
long	StringReader.skip(long n)	跳过字符。
int	DataInput.skipBytes(int n)	尝试从输入流中跳过 n 字节的数据，并丢弃跳过的字节。
final int	DataInputStream.skipBytes(int n)	参见DataInput的skipBytes方法的总契约。
int	ObjectInputStream.skipBytes(int len)	跳过字节。
int	RandomAccessFile.skipBytes(int n)	尝试跳过 n 字节的输入并丢弃跳过的字节。
void	InputStream.skipNBytes(long n)	跳过并丢弃来自该输入流的 n 个字节的数据。
long	InputStream.transferTo(OutputStream out)	从此输入流中读取所有字节，并按照读取顺序将字节写入给定的输出流。
long	Reader.transferTo(Writer out)	从此读取器读取所有字符，并按照读取顺序将字符写入给定的写入器。
void	PushbackInputStream.unread(byte[] b)	通过将字节数组复制到推回缓冲区的前面来推回字节数组。
void	PushbackInputStream.unread(byte[] b, int off, int len)	通过将字节数组的一部分复制到回推缓冲区的前面来将其推回。
void	PushbackInputStream.unread(int b)	通过将字节复制到推回缓冲区的前面来推回一个字节。
void	PushbackReader.unread(char[] cbuf)	通过将字符数组复制到推回缓冲区的前面来推回字符数组。
void	PushbackReader.unread(char[] cbuf, int off, int len)	通过将字符数组的一部分复制到回推缓冲区的前面来将其推回。
void	PushbackReader.unread(int c)	通过将单个字符复制到推回缓冲区的前面来推回单个字符。
void	ObjectOutputStream.useProtocolVersion(int version)	指定写入流时要使用的流协议版本。
void	BufferedOutputStream.write(byte[] b, int off, int len)	从偏移量 off 开始的指定字节数组中将 len 字节写入此缓冲输出流。
void	BufferedOutputStream.write(int b)	将指定字节写入此缓冲输出流。
void	BufferedWriter.write(char[] cbuf, int off, int len)	写入字符数组的一部分。
void	BufferedWriter.write(int c)	写入单个字符。
void	BufferedWriter.write(String s, int off, int len)	写入字符串的一部分。
void	DataOutput.write(byte[] b)	将数组 b 中的所有字节写入输出流。
void	DataOutput.write(byte[] b, int off, int len)	按顺序将数组 b 中的 len 个字节写入输出流。
void	DataOutput.write(int b)	将参数 b 的八个低位写入输出流。
void	DataOutputStream.write(byte[] b, int off, int len)	从偏移量 off 开始的指定字节数组中将 len 字节写入基础输出流。
void	DataOutputStream.write(int b)	将指定字节（参数 b 的低八位）写入基础输出流。
void	FileOutputStream.write(byte[] b)	将指定字节数组中的 b.length 个字节写入此文件输出流。
void	FileOutputStream.write(byte[] b, int off, int len)	从偏移量 off 开始的指定字节数组中将 len 字节写入此文件输出流。
void	FileOutputStream.write(int b)	将指定字节写入此文件输出流。
void	FilterOutputStream.write(byte[] b)	将 b.length 字节写入此输出流。
void	FilterOutputStream.write(byte[] b, int off, int len)	从偏移量 off 开始的指定 byte 数组中将 len 字节写入此输出流。
void	FilterOutputStream.write(int b)	将指定的 byte 写入此输出流。
void	FilterWriter.write(char[] cbuf, int off, int len)	写入字符数组的一部分。
void	FilterWriter.write(int c)	写入单个字符。
void	FilterWriter.write(String str, int off, int len)	写入字符串的一部分。
void	ObjectOutput.write(byte[] b)	写入一个字节数组。
void	ObjectOutput.write(byte[] b, int off, int len)	写入一个字节子数组。
void	ObjectOutput.write(int b)	写入一个字节。
abstract void	ObjectOutputStream.PutField.write(ObjectOutput out)	已弃用。 此方法不会以正确的格式写入此 PutField 对象包含的值，并可能导致序列化流损坏。
void	ObjectOutputStream.write(byte[] buf)	写入一个字节数组。
void	ObjectOutputStream.write(byte[] buf, int off, int len)	写入一个字节子数组。
void	ObjectOutputStream.write(int val)	写入一个字节。
void	OutputStream.write(byte[] b)	将指定字节数组中的 b.length 个字节写入此输出流。
void	OutputStream.write(byte[] b, int off, int len)	从偏移量 off 开始的指定字节数组中将 len 个字节写入此输出流。
abstract void	OutputStream.write(int b)	将指定字节写入此输出流。
void	OutputStreamWriter.write(char[] cbuf, int off, int len)	写入字符数组的一部分。
void	OutputStreamWriter.write(int c)	写入单个字符。
void	OutputStreamWriter.write(String str, int off, int len)	写入字符串的一部分。
void	PipedOutputStream.write(byte[] b, int off, int len)	从偏移量 off 开始的指定字节数组中将 len 字节写入此管道输出流。
void	PipedOutputStream.write(int b)	将指定的 byte 写入管道输出流。
void	PipedWriter.write(char[] cbuf, int off, int len)	从偏移量 off 开始的指定字符数组中将 len 个字符写入此管道输出流。
void	PipedWriter.write(int c)	将指定的 char 写入管道输出流。
void	PrintStream.write(byte[] buf)	将指定字节数组中的所有字节写入此流。
void	RandomAccessFile.write(byte[] b)	从当前文件指针开始，将指定字节数组中的 b.length 字节写入此文件。
void	RandomAccessFile.write(byte[] b, int off, int len)	从偏移量 off 开始的指定字节数组中将 len 字节写入此文件。
void	RandomAccessFile.write(int b)	将指定字节写入此文件。
void	Writer.write(char[] cbuf)	写入一个字符数组。
abstract void	Writer.write(char[] cbuf, int off, int len)	写入字符数组的一部分。
void	Writer.write(int c)	写入单个字符。
void	Writer.write(String str)	写一个字符串。
void	Writer.write(String str, int off, int len)	写入字符串的一部分。
void	DataOutput.writeBoolean(boolean v)	将 boolean 值写入此输出流。
final void	DataOutputStream.writeBoolean(boolean v)	将 boolean 作为 1 字节值写入基础输出流。
void	ObjectOutputStream.writeBoolean(boolean val)	写入一个boolean。
final void	RandomAccessFile.writeBoolean(boolean v)	将 boolean 作为单字节值写入文件。
void	DataOutput.writeByte(int v)	将参数 v 的八个低位写入输出流。
final void	DataOutputStream.writeByte(int v)	将 byte 作为 1 字节值写入基础输出流。
void	ObjectOutputStream.writeByte(int val)	写入一个 8 位字节。
final void	RandomAccessFile.writeByte(int v)	将 byte 作为单字节值写入文件。
void	DataOutput.writeBytes(String s)	将字符串写入输出流。
final void	DataOutputStream.writeBytes(String s)	将字符串作为字节序列写出到底层输出流。
void	ObjectOutputStream.writeBytes(String str)	将 String 作为字节序列写入。
final void	RandomAccessFile.writeBytes(String s)	将字符串作为字节序列写入文件。
void	DataOutput.writeChar(int v)	将由两个字节组成的 char 值写入输出流。
final void	DataOutputStream.writeChar(int v)	将 char 作为 2 字节值写入底层输出流，高字节在前。
void	ObjectOutputStream.writeChar(int val)	写入 16 位字符。
final void	RandomAccessFile.writeChar(int v)	将 char 作为两字节值写入文件，高字节在前。
void	DataOutput.writeChars(String s)	将字符串 s 中的每个字符按顺序写入输出流，每个字符两个字节。
final void	DataOutputStream.writeChars(String s)	将字符串作为字符序列写入基础输出流。
void	ObjectOutputStream.writeChars(String str)	将 String 作为字符序列写入。
final void	RandomAccessFile.writeChars(String s)	将字符串作为字符序列写入文件。
protected void	ObjectOutputStream.writeClassDescriptor(ObjectStreamClass desc)	将指定的类描述符写入 ObjectOutputStream。
void	DataOutput.writeDouble(double v)	将由八个字节组成的 double 值写入输出流。
final void	DataOutputStream.writeDouble(double v)	使用类 Double 中的 doubleToLongBits 方法将双精度参数转换为 long，然后将该 long 值作为 8 字节数量（高字节在前）写入基础输出流。
void	ObjectOutputStream.writeDouble(double val)	写入 64 位双精度数。
final void	RandomAccessFile.writeDouble(double v)	使用类 Double 中的 doubleToLongBits 方法将双精度参数转换为 long，然后将该 long 值作为八字节量写入文件，高字节在前。
void	Externalizable.writeExternal(ObjectOutput out)	对象实现 writeExternal 方法来保存它的内容，通过调用 DataOutput 的方法来保存它的原始值，或者调用 ObjectOutput 的 writeObject 方法来保存它的内容，对象、字符串和数组。
void	ObjectOutputStream.writeFields()	将缓冲字段写入流。
void	DataOutput.writeFloat(float v)	将由四个字节组成的 float 值写入输出流。
final void	DataOutputStream.writeFloat(float v)	使用类 Float 中的 floatToIntBits 方法将 float 参数转换为 int，然后将该 int 值作为 4 字节数量（高字节在前）写入基础输出流。
void	ObjectOutputStream.writeFloat(float val)	写入 32 位浮点数。
final void	RandomAccessFile.writeFloat(float v)	使用类 Float 中的 floatToIntBits 方法将 float 参数转换为 int，然后将该 int 值作为四字节量写入文件，高字节在前。
void	DataOutput.writeInt(int v)	将由四个字节组成的 int 值写入输出流。
final void	DataOutputStream.writeInt(int v)	将 int 作为四个字节写入基础输出流，高字节在前。
void	ObjectOutputStream.writeInt(int val)	写入 32 位 int。
final void	RandomAccessFile.writeInt(int v)	将 int 作为四个字节写入文件，高字节在前。
void	DataOutput.writeLong(long v)	将由八个字节组成的 long 值写入输出流。
final void	DataOutputStream.writeLong(long v)	将 long 作为八字节写入底层输出流，高字节在前。
void	ObjectOutputStream.writeLong(long val)	写入 64 位长。
final void	RandomAccessFile.writeLong(long v)	将 long 作为八个字节写入文件，高字节在前。
void	ObjectOutput.writeObject(Object obj)	将对象写入底层存储或流。
final void	ObjectOutputStream.writeObject(Object obj)	将指定对象写入 ObjectOutputStream。
protected void	ObjectOutputStream.writeObjectOverride(Object obj)	子类用于重写默认 writeObject 方法的方法。
void	DataOutput.writeShort(int v)	将两个字节写入输出流以表示参数的值。
final void	DataOutputStream.writeShort(int v)	将 short 作为两个字节写入底层输出流，高字节在前。
void	ObjectOutputStream.writeShort(int val)	写一个 16 位短。
final void	RandomAccessFile.writeShort(int v)	将 short 作为两个字节写入文件，高字节在前。
protected void	ObjectOutputStream.writeStreamHeader()	提供了 writeStreamHeader 方法，因此子类可以将自己的标头附加或添加到流中。
void	ByteArrayOutputStream.writeTo(OutputStream out)	将此 ByteArrayOutputStream 的完整内容写入指定的输出流参数，就像使用 out.write(buf, 0, count) 调用输出流的 write 方法一样。
void	CharArrayWriter.writeTo(Writer out)	将缓冲区的内容写入另一个字符流。
void	ObjectOutputStream.writeUnshared(Object obj)	将“非共享”对象写入 ObjectOutputStream。
void	DataOutput.writeUTF(String s)	将两个字节的长度信息写入输出流，后跟字符串 s 中每个字符的 修改后的 UTF-8 表示。
final void	DataOutputStream.writeUTF(String str)	以与机器无关的方式使用 修改后的 UTF-8 编码将字符串写入基础输出流。
void	ObjectOutputStream.writeUTF(String str)	以 修改后的 UTF-8 格式写入此字符串的原始数据。
final void	RandomAccessFile.writeUTF(String str)	以与机器无关的方式使用 修改后的 UTF-8 编码将字符串写入文件。

java.io 中的构造函数，参数类型为 IOException

修饰符	构造方法	描述
	UncheckedIOException(IOException cause)	构造此类的实例。
	UncheckedIOException(String message, IOException cause)	构造此类的实例。

java.io 中的构造函数抛出 IOException

修饰符	构造方法	描述
	FileReader(File file, Charset charset)	给定要读取的 File 和 charset，创建一个新的 FileReader。
	FileReader(String fileName, Charset charset)	创建一个新的 FileReader ，给定要读取的文件的名称和 charset 。
	FileWriter(File file)	构造一个 FileWriter 给定 File 来写，使用 默认字符集
	FileWriter(File file, boolean append)	使用 默认字符集 构造一个 FileWriter 给定 File 写入和一个boolean指示是否附加写入的数据。
	FileWriter(File file, Charset charset)	给定要写入的 File 和 charset 构造一个 FileWriter。
	FileWriter(File file, Charset charset, boolean append)	构造一个 FileWriter 给定 File 写入， charset 和一个boolean指示是否追加写入的数据。
	FileWriter(String fileName)	构造一个给定文件名的FileWriter，使用默认字符集
	FileWriter(String fileName, boolean append)	使用 默认字符集 构造一个给定文件名的 FileWriter 和一个指示是否附加写入的数据的boolean。
	FileWriter(String fileName, Charset charset)	构造一个给定文件名和 charset 的 FileWriter。
	FileWriter(String fileName, Charset charset, boolean append)	构造一个 FileWriter 给定一个文件名， charset 和一个指示是否附加写入的数据的boolean。
protected	ObjectInputStream()	为完全重新实现 ObjectInputStream 的子类提供一种方法，使其不必分配仅由该 ObjectInputStream 实现使用的私有数据。
	ObjectInputStream(InputStream in)	创建一个从指定 InputStream 读取的 ObjectInputStream。
protected	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)	创建一个 PipedReader 以便它连接到管道编写器 src 。
	PipedReader(PipedWriter src, int pipeSize)	创建一个 PipedReader 以便它连接到管道编写器 src 并使用指定的管道大小作为管道缓冲区。
	PipedWriter(PipedReader snk)	创建连接到指定管道读取器的管道写入器。
	PrintStream(File file, Charset charset)	使用指定的文件和字符集创建一个新的打印流，没有自动行刷新。
	PrintStream(String fileName, Charset charset)	使用指定的文件名和字符集创建一个新的打印流，没有自动行刷新。
	PrintWriter(File file, Charset charset)	使用指定的文件和字符集创建一个新的 PrintWriter，没有自动行刷新。
	PrintWriter(String fileName, Charset charset)	使用指定的文件名和字符集创建一个新的 PrintWriter，没有自动行刷新。

IOException 在 java.lang 中的用法

在 java.lang 中抛出 IOException

修饰符和类型	方法	描述
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)	已弃用。 这种方法容易出错，不应该使用，应该使用相应的方法Runtime.exec(String[]) 或ProcessBuilder 代替。
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)	已弃用。 这种方法容易出错，不应该使用，应该使用相应的方法 Runtime.exec(String[], String[]) 或 ProcessBuilder 代替。
Process	Runtime.exec(String command, String[] envp, File dir)	已弃用。 这种方法容易出错，不应该使用，应该使用相应的方法Runtime.exec(String[], String[], File) 或ProcessBuilder 代替。
protected URL	ClassLoader.findResource(String moduleName, String name)	返回指向此类加载器定义的模块中资源的 URL。
protected Enumeration<URL>	ClassLoader.findResources(String name)	返回代表具有给定名称的所有资源的 URL 对象的枚举。
InputStream	Module.getResourceAsStream(String name)	返回用于读取此模块中资源的输入流。
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()	使用此流程构建器的属性启动新流程。
static List<Process>	ProcessBuilder.startPipeline(List<ProcessBuilder> builders)	为每个 ProcessBuilder 启动一个 Process，创建一个由其标准输出和标准输入流链接的流程管道。

IOException 在 java.lang.management 中的用法

在 java.lang.management 中抛出 IOException

修饰符和类型	方法	描述
static <T extends PlatformManagedObject> T	ManagementFactory.getPlatformMXBean(MBeanServerConnection connection, Class<T> mxbeanInterface)	返回 mxbeanInterface 的平台 MXBean 代理，它被指定为在 Java 虚拟机中有一个实例，代理将通过给定的 MBeanServerConnection 转发方法调用。
static <T extends PlatformManagedObject> List<T>	ManagementFactory.getPlatformMXBeans(MBeanServerConnection connection, Class<T> mxbeanInterface)	返回平台 MXBean 代理的列表，用于通过给定的 MBeanServerConnection 转发 mxbeanInterface 的方法调用。
static <T> T	ManagementFactory.newPlatformMXBeanProxy(MBeanServerConnection connection, String mxbeanName, Class<T> mxbeanInterface)	返回给定 MXBean 名称 的平台 MXBean 接口的代理，该接口通过给定 MBeanServerConnection 转发其方法调用。

IOException 在 java.lang.module 中的用法

在 java.lang.module 中抛出 IOException

修饰符和类型	方法	描述
void	ModuleReader.close()	关闭模块阅读器。
Optional<URI>	ModuleReader.find(String name)	查找资源，将 URI 返回到模块中的资源。
Stream<String>	ModuleReader.list()	列出模块的内容，返回一个元素流，这些元素是模块中所有资源的名称。
default Optional<InputStream>	ModuleReader.open(String name)	打开资源，返回输入流以读取模块中的资源。
abstract ModuleReader	ModuleReference.open()	打开模块内容进行阅读。
static ModuleDescriptor	ModuleDescriptor.read(InputStream in)	从输入流中读取模块声明的二进制形式作为模块描述符。
static ModuleDescriptor	ModuleDescriptor.read(InputStream in, Supplier<Set<String>> packageFinder)	从输入流中读取模块声明的二进制形式作为模块描述符。
default Optional<ByteBuffer>	ModuleReader.read(String name)	读取资源，返回包含资源内容的字节缓冲区。

IOException 在 java.net 中的用法

java.net 中 IOException 的子类

修饰符和类型	类	描述
class	BindException	尝试将套接字绑定到本地地址和端口时发生错误的信号。
class	ConnectException	尝试将套接字连接到远程地址和端口时发生错误的信号。
class	HttpRetryException	抛出表示需要重试 HTTP 请求但由于启用了流模式而无法自动重试。
class	MalformedURLException	抛出以指示出现格式错误的 URL。
class	NoRouteToHostException	尝试将套接字连接到远程地址和端口时发生错误的信号。
class	PortUnreachableException	表示已在连接的数据报上收到 ICMP 端口不可达消息。
class	ProtocolException	抛出表示底层协议有错误，比如TCP错误。
class	SocketException	抛出以指示创建或访问 Socket 时出错。
class	SocketTimeoutException	表示套接字读取或接受超时已发生的信号。
class	UnknownHostException	抛出表示无法确定主机的 IP 地址。
class	UnknownServiceException	抛出表示发生了未知的服务异常。

java.net 中的方法，参数类型为 IOException

修饰符和类型	方法	描述
abstract void	ProxySelector.connectFailed(URI uri, SocketAddress sa, IOException ioe)	调用以指示无法建立到代理/socks 服务的连接。

在 java.net 中抛出 IOException

修饰符和类型	方法	描述
Socket	ServerSocket.accept()	监听与此套接字建立的连接并接受它。
protected abstract void	SocketImpl.accept(SocketImpl s)	接受连接。
protected abstract int	SocketImpl.available()	返回可以无阻塞地从此套接字读取的字节数。
void	ServerSocket.bind(SocketAddress endpoint)	将 ServerSocket 绑定到特定地址（IP 地址和端口号）。
void	ServerSocket.bind(SocketAddress endpoint, int backlog)	将 ServerSocket 绑定到特定地址（IP 地址和端口号）。
void	Socket.bind(SocketAddress bindpoint)	将套接字绑定到本地地址。
protected abstract void	SocketImpl.bind(InetAddress host, int port)	将此套接字绑定到指定的本地 IP 地址和端口号。
void	ServerSocket.close()	关闭这个套接字。
void	Socket.close()	关闭这个套接字。
protected abstract void	SocketImpl.close()	关闭这个套接字。
void	URLClassLoader.close()	关闭此 URLClassLoader，以便它不能再用于加载由此加载程序定义的新类或资源。
void	Socket.connect(SocketAddress endpoint)	将此套接字连接到服务。
void	Socket.connect(SocketAddress endpoint, int timeout)	使用指定的超时值将此套接字连接到服务。
protected abstract void	SocketImpl.connect(String host, int port)	将此套接字连接到指定主机上的指定端口。
protected abstract void	SocketImpl.connect(InetAddress address, int port)	将此套接字连接到指定主机上的指定端口号。
protected abstract void	SocketImpl.connect(SocketAddress address, int timeout)	将此套接字连接到指定主机上的指定端口号。
abstract void	URLConnection.connect()	如果尚未建立此类连接，则打开此 URL 引用的资源的通信链接。
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 文件条目，则返回此连接的 Attributes 对象，否则返回 null。
abstract OutputStream	CacheRequest.getBody()	返回一个可以写入响应主体的 OutputStream。
abstract InputStream	CacheResponse.getBody()	将响应主体作为 InputStream 返回。
Certificate[]	JarURLConnection.getCertificates()	如果此连接的 URL 指向 JAR 文件条目，则返回此连接的 Certificate 对象，否则返回 null。
abstract Object	ContentHandler.getContent(URLConnection urlc)	给定位于对象表示开头的 URL 连接流，此方法读取该流并从中创建一个对象。
Object	ContentHandler.getContent(URLConnection urlc, Class[] classes)	给定一个位于对象表示开头的 URL 连接流，此方法读取该流并创建一个与指定类型之一匹配的对象。
final Object	URL.getContent()	获取此 URL 的内容。
final Object	URL.getContent(Class<?>[] classes)	获取此 URL 的内容。
Object	URLConnection.getContent()	检索此 URL 连接的内容。
Object	URLConnection.getContent(Class<?>[] classes)	检索此 URL 连接的内容。
abstract Map<String,List<String>>	CacheResponse.getHeaders()	将响应标头作为 Map 返回。
InputStream	Socket.getInputStream()	返回此套接字的输入流。
protected abstract InputStream	SocketImpl.getInputStream()	返回此套接字的输入流。
InputStream	URLConnection.getInputStream()	返回从此打开的连接读取的输入流。
JarEntry	JarURLConnection.getJarEntry()	返回此连接的 JAR 条目对象（如果有）。
abstract JarFile	JarURLConnection.getJarFile()	返回此连接的 JAR 文件。
Attributes	JarURLConnection.getMainAttributes()	返回此连接的 JAR 文件的主要属性。
Manifest	JarURLConnection.getManifest()	返回此连接的清单，如果没有则返回 null。
<T> T	DatagramSocket.getOption(SocketOption<T> name)	返回套接字选项的值。
protected <T> T	DatagramSocketImpl.getOption(SocketOption<T> name)	调用以获取套接字选项。
<T> T	ServerSocket.getOption(SocketOption<T> name)	返回套接字选项的值。
<T> T	Socket.getOption(SocketOption<T> name)	返回套接字选项的值。
protected <T> T	SocketImpl.getOption(SocketOption<T> name)	调用以获取套接字选项。
OutputStream	Socket.getOutputStream()	返回此套接字的输出流。
protected abstract OutputStream	SocketImpl.getOutputStream()	返回此套接字的输出流。
OutputStream	URLConnection.getOutputStream()	返回写入此连接的输出流。
Permission	HttpURLConnection.getPermission()	返回一个 SocketPermission 对象，表示连接到目标主机和端口所需的权限。
Permission	URLConnection.getPermission()	此对象所表示的连接所需的权限。
int	HttpURLConnection.getResponseCode()	从 HTTP 响应消息中获取状态代码。
String	HttpURLConnection.getResponseMessage()	获取与服务响应代码一起返回的 HTTP 响应消息（如果有）。
int	ServerSocket.getSoTimeout()	检索 SO_TIMEOUT 的设置。返回 0 意味着该选项被禁用（即无限超时）。
protected abstract int	DatagramSocketImpl.getTimeToLive()	检索 TTL（生存时间）选项。
int	MulticastSocket.getTimeToLive()	获取在套接字上发送的多播数据包的默认生存时间。
protected abstract byte	DatagramSocketImpl.getTTL()	已弃用。 请改用 getTimeToLive。
byte	MulticastSocket.getTTL()	已弃用。 请改用 MulticastSocket.getTimeToLive() 方法，它返回一个int代替字节.
static String	URLConnection.guessContentTypeFromStream(InputStream is)	尝试根据输入流开头的字符确定输入流的类型。
protected final 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	DatagramSocket.joinGroup(SocketAddress mcastaddr, NetworkInterface netIf)	加入多播组。
protected abstract void	DatagramSocketImpl.joinGroup(SocketAddress mcastaddr, NetworkInterface netIf)	加入多播组。
void	MulticastSocket.joinGroup(InetAddress mcastaddr)	已弃用。 此方法不接受加入多播组的网络接口。
void	MulticastSocket.joinGroup(SocketAddress mcastaddr, NetworkInterface netIf)	加入多播组。
protected abstract void	DatagramSocketImpl.leave(InetAddress inetaddr)	离开多播组。
void	DatagramSocket.leaveGroup(SocketAddress mcastaddr, NetworkInterface netIf)	在指定的本地接口上保留多播组。
protected abstract void	DatagramSocketImpl.leaveGroup(SocketAddress mcastaddr, NetworkInterface netIf)	离开多播组。
void	MulticastSocket.leaveGroup(InetAddress mcastaddr)	已弃用。 此方法不接受离开多播组的网络接口。
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)	与 URL.openConnection() 相同，只是连接将通过指定的代理进行；不支持代理的协议处理程序将忽略代理参数并建立正常连接。
protected abstract URLConnection	URLStreamHandler.openConnection(URL u)	打开与 URL 参数引用的对象的连接。
protected URLConnection	URLStreamHandler.openConnection(URL u, Proxy p)	与 openConnection(URL) 相同，只是连接将通过指定的代理进行；不支持代理的协议处理程序将忽略代理参数并建立正常连接。
final 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 必须决定是否将资源存储在其缓存中。
void	DatagramSocket.receive(DatagramPacket p)	从此套接字接收数据报包。
protected abstract void	DatagramSocketImpl.receive(DatagramPacket p)	接收数据报包。
void	DatagramSocket.send(DatagramPacket p)	从此套接字发送数据报包。
protected abstract void	DatagramSocketImpl.send(DatagramPacket p)	发送数据报包。
void	MulticastSocket.send(DatagramPacket p, byte ttl)	已弃用。 请改用以下代码或其等效代码：
void	Socket.sendUrgentData(int data)	在套接字上发送一个字节的紧急数据。
protected abstract void	SocketImpl.sendUrgentData(int data)	在套接字上发送一个字节的紧急数据。
static void	DatagramSocket.setDatagramSocketImplFactory(DatagramSocketImplFactory fac)	已弃用。 使用 DatagramChannel 或直接子类化 DatagramSocket。
<T> DatagramSocket	DatagramSocket.setOption(SocketOption<T> name, T value)	设置套接字选项的值。
protected <T> void	DatagramSocketImpl.setOption(SocketOption<T> name, T value)	调用以设置套接字选项。
<T> ServerSocket	ServerSocket.setOption(SocketOption<T> name, T value)	设置套接字选项的值。
<T> Socket	Socket.setOption(SocketOption<T> name, T value)	设置套接字选项的值。
protected <T> void	SocketImpl.setOption(SocketOption<T> name, T value)	调用以设置套接字选项。
static void	ServerSocket.setSocketFactory(SocketImplFactory fac)	已弃用。 直接使用 ServerSocketFactory 和子类 ServerSocket。
static void	Socket.setSocketImplFactory(SocketImplFactory fac)	已弃用。 直接使用 SocketFactory 和子类 Socket。
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)	已弃用。 请改用 MulticastSocket.setTimeToLive(int) 方法，该方法使用int代替字节作为 ttl 的类型。
void	Socket.shutdownInput()	将此套接字的输入流置于“流的结尾”。
protected void	SocketImpl.shutdownInput()	将此套接字的输入流置于“流的结尾”。
void	Socket.shutdownOutput()	禁用此套接字的输出流。
protected void	SocketImpl.shutdownOutput()	禁用此套接字的输出流。

java.net 中的构造函数抛出 IOException

修饰符	构造方法	描述
	MulticastSocket()	构造多播套接字并将其绑定到本地主机上的任何可用端口。
	MulticastSocket(int port)	构造多播套接字并将其绑定到本地主机上的指定端口。
	MulticastSocket(SocketAddress bindaddr)	创建一个多播套接字，绑定到指定的本地套接字地址。
	ServerSocket()	创建一个未绑定的服务套接字。
	ServerSocket(int port)	创建绑定到指定端口的服务套接字。
	ServerSocket(int port, int backlog)	创建一个服务套接字并将其绑定到指定的本地端口号，具有指定的积压。
	ServerSocket(int port, int backlog, InetAddress bindAddr)	创建具有指定端口、监听积压和要绑定的本地 IP 地址的服务。
	Socket(String host, int port)	创建一个流套接字并将其连接到指定主机上的指定端口号。
	Socket(String host, int port, boolean stream)	已弃用。 使用 DatagramSocket 代替 UDP 传输。
	Socket(String host, int port, InetAddress localAddr, int localPort)	创建套接字并将其连接到指定远程端口上的指定远程主机。
	Socket(InetAddress address, int port)	创建流套接字并将其连接到指定 IP 地址的指定端口号。
	Socket(InetAddress host, int port, boolean stream)	已弃用。 使用 DatagramSocket 代替 UDP 传输。
	Socket(InetAddress address, int port, InetAddress localAddr, int localPort)	创建套接字并将其连接到指定远程端口上的指定远程地址。

IOException 在 java.net.http 中的用法

java.net.http 中 IOException 的子类

修饰符和类型	类	描述
class	HttpConnectTimeoutException	当要发送 HttpRequest 的连接未在指定时间段内成功建立时抛出。
class	HttpTimeoutException	在指定时间段内未收到响应时抛出。
final class	WebSocketHandshakeException	当开始握手失败时抛出。

在 java.net.http 中抛出 IOException

修饰符和类型	方法	描述
abstract <T> HttpResponse<T>	HttpClient.send(HttpRequest request, HttpResponse.BodyHandler<T> responseBodyHandler)	使用此客户端发送给定请求，必要时阻塞以获得响应。

IOException 在 java.nio 中的用法

在 java.nio 中抛出 IOException

修饰符和类型	方法	描述
int	CharBuffer.read(CharBuffer target)	尝试将字符读入指定的字符缓冲区。

IOException 在 java.nio.channels 中的用法

java.nio.channels 中 IOException 的子类

修饰符和类型	类	描述
class	AsynchronousCloseException	当另一个线程关闭通道或它在 I/O 操作中阻塞的通道部分时，一个线程接收到的已检查异常。
class	ClosedByInterruptException	当另一个线程在通道上的 I/O 操作中被阻塞时中断它时，线程接收到的已检查异常。
class	ClosedChannelException	当尝试在已关闭或至少对该操作关闭的通道上调用或完成 I/O 操作时抛出已检查异常。
class	FileLockInterruptionException	当另一个线程在等待获取文件锁时中断它时，一个线程接收到的已检查异常。
class	InterruptedByTimeoutException	在异步操作完成之前超时过去时，线程接收到的已检查异常。

在 java.nio.channels 中抛出 IOException

修饰符和类型	方法	描述
abstract SocketChannel	ServerSocketChannel.accept()	接受与此通道的套接字建立的连接。
final AsynchronousServerSocketChannel	AsynchronousServerSocketChannel.bind(SocketAddress local)	将通道的套接字绑定到本地地址并配置套接字以监听连接。
abstract AsynchronousServerSocketChannel	AsynchronousServerSocketChannel.bind(SocketAddress local, int backlog)	将通道的套接字绑定到本地地址并配置套接字以监听连接。
abstract AsynchronousSocketChannel	AsynchronousSocketChannel.bind(SocketAddress local)
abstract DatagramChannel	DatagramChannel.bind(SocketAddress local)
NetworkChannel	NetworkChannel.bind(SocketAddress local)	将通道的套接字绑定到本地地址。
final ServerSocketChannel	ServerSocketChannel.bind(SocketAddress local)	将通道的套接字绑定到本地地址并配置套接字以监听连接。
abstract ServerSocketChannel	ServerSocketChannel.bind(SocketAddress local, int backlog)	将通道的套接字绑定到本地地址并配置套接字以监听连接。
abstract SocketChannel	SocketChannel.bind(SocketAddress local)	将通道的套接字绑定到本地地址。
abstract MembershipKey	MembershipKey.block(InetAddress source)	阻止来自给定源地址的多播数据报。
void	AsynchronousChannel.close()	关闭此通道。
void	Channel.close()	关闭此通道。
final void	FileLock.close()	此方法调用 FileLock.release() 方法。
void	InterruptibleChannel.close()	关闭此通道。
void	MulticastChannel.close()	关闭此通道。
abstract void	Selector.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	AsynchronousFileChannel.force(boolean metaData)	强制将对此通道文件的任何更新写入包含它的存储设备。
abstract void	FileChannel.force(boolean metaData)	强制将对此通道文件的任何更新写入包含它的存储设备。
abstract SocketAddress	AsynchronousServerSocketChannel.getLocalAddress()	返回此通道的套接字绑定到的套接字地址。
abstract SocketAddress	AsynchronousSocketChannel.getLocalAddress()	返回此通道的套接字绑定到的套接字地址。
abstract SocketAddress	DatagramChannel.getLocalAddress()	返回此通道的套接字绑定到的套接字地址。
SocketAddress	NetworkChannel.getLocalAddress()	返回此通道的套接字绑定到的套接字地址。
abstract SocketAddress	ServerSocketChannel.getLocalAddress()	返回此通道的套接字绑定到的套接字地址。
abstract SocketAddress	SocketChannel.getLocalAddress()	返回此通道的套接字绑定到的套接字地址。
<T> T	NetworkChannel.getOption(SocketOption<T> name)	返回套接字选项的值。
abstract SocketAddress	AsynchronousSocketChannel.getRemoteAddress()	返回此通道的套接字所连接的远程地址。
abstract SocketAddress	DatagramChannel.getRemoteAddress()	返回此通道的套接字所连接的远程地址。
abstract SocketAddress	SocketChannel.getRemoteAddress()	返回此通道的套接字所连接的远程地址。
MembershipKey	MulticastChannel.join(InetAddress group, NetworkInterface interf)	加入多播组以开始接收发送到该组的所有数据报，返回成员密钥。
MembershipKey	MulticastChannel.join(InetAddress group, NetworkInterface interf, InetAddress source)	加入多播组以开始接收从给定源地址发送到该组的数据报。
final FileLock	FileChannel.lock()	获取此通道文件的独占锁。
abstract FileLock	FileChannel.lock(long position, long size, boolean shared)	获取此通道文件的给定区域的锁。
abstract MappedByteBuffer	FileChannel.map(FileChannel.MapMode mode, long position, long size)	将此通道文件的一个区域直接映射到内存中。
MemorySegmentPREVIEW	FileChannel.map(FileChannel.MapMode mode, long offset, long size, SegmentScopePREVIEW session)	预览。 将此通道文件的一个区域映射到一个新的映射内存段，具有给定的偏移量、大小和内存会话。
static AsynchronousFileChannel	AsynchronousFileChannel.open(Path file, OpenOption... options)	打开或创建用于读取和/或写入的文件，返回异步文件通道以访问该文件。
static AsynchronousFileChannel	AsynchronousFileChannel.open(Path file, Set<? extends OpenOption> options, ExecutorService executor, FileAttribute<?>... attrs)	打开或创建用于读取和/或写入的文件，返回异步文件通道以访问该文件。
static AsynchronousServerSocketChannel	AsynchronousServerSocketChannel.open()	打开异步服务套接字通道。
static AsynchronousServerSocketChannel	AsynchronousServerSocketChannel.open(AsynchronousChannelGroup group)	打开异步服务套接字通道。
static AsynchronousSocketChannel	AsynchronousSocketChannel.open()	打开异步套接字通道。
static AsynchronousSocketChannel	AsynchronousSocketChannel.open(AsynchronousChannelGroup group)	打开异步套接字通道。
static DatagramChannel	DatagramChannel.open()	打开数据报通道。
static DatagramChannel	DatagramChannel.open(ProtocolFamily family)	打开数据报通道。
static FileChannel	FileChannel.open(Path path, OpenOption... options)	打开或创建一个文件，返回一个文件通道来访问该文件。
static FileChannel	FileChannel.open(Path path, Set<? extends OpenOption> options, FileAttribute<?>... attrs)	打开或创建一个文件，返回一个文件通道来访问该文件。
static Pipe	Pipe.open()	打开管道。
static Selector	Selector.open()	打开一个选择器。
static ServerSocketChannel	ServerSocketChannel.open()	打开服务套接字通道互联网协议socket。
static ServerSocketChannel	ServerSocketChannel.open(ProtocolFamily family)	打开服务套接字通道。
static SocketChannel	SocketChannel.open()	打开一个套接字通道互联网协议socket。
static SocketChannel	SocketChannel.open(ProtocolFamily family)	打开套接字通道。
static SocketChannel	SocketChannel.open(SocketAddress remote)	打开套接字通道并将其连接到远程地址。
abstract long	FileChannel.position()	返回此通道的文件位置。
abstract FileChannel	FileChannel.position(long newPosition)	设置此通道的文件位置。
long	SeekableByteChannel.position()	返回此通道的位置。
SeekableByteChannel	SeekableByteChannel.position(long newPosition)	设置此通道的位置。
abstract int	DatagramChannel.read(ByteBuffer dst)	从此通道读取数据报。
final long	DatagramChannel.read(ByteBuffer[] dsts)	从此通道读取数据报。
abstract long	DatagramChannel.read(ByteBuffer[] dsts, int offset, int length)	从此通道读取数据报。
abstract int	FileChannel.read(ByteBuffer dst)	从此通道读取一系列字节到给定的缓冲区中。
final long	FileChannel.read(ByteBuffer[] dsts)	从此通道读取一系列字节到给定的缓冲区中。
abstract long	FileChannel.read(ByteBuffer[] dsts, int offset, int length)	从此通道读取字节序列到给定缓冲区的子序列中。
abstract int	FileChannel.read(ByteBuffer dst, long position)	从给定的文件位置开始，从该通道将字节序列读入给定的缓冲区。
int	ReadableByteChannel.read(ByteBuffer dst)	从此通道读取一系列字节到给定的缓冲区中。
long	ScatteringByteChannel.read(ByteBuffer[] dsts)	从此通道读取一系列字节到给定的缓冲区中。
long	ScatteringByteChannel.read(ByteBuffer[] dsts, int offset, int length)	从此通道读取字节序列到给定缓冲区的子序列中。
int	SeekableByteChannel.read(ByteBuffer dst)	从此通道读取一系列字节到给定的缓冲区中。
abstract int	SocketChannel.read(ByteBuffer dst)
final long	SocketChannel.read(ByteBuffer[] dsts)
abstract long	SocketChannel.read(ByteBuffer[] dsts, int offset, int length)
abstract SocketAddress	DatagramChannel.receive(ByteBuffer dst)	通过此通道接收数据报。
abstract void	FileLock.release()	释放这个锁。
abstract int	Selector.select()	选择一组键，其对应的通道已准备好进行 I/O 操作。
abstract int	Selector.select(long timeout)	选择一组键，其对应的通道已准备好进行 I/O 操作。
int	Selector.select(Consumer<SelectionKey> action)	选择相应通道已准备好进行 I/O 操作的键并对其执行操作。
int	Selector.select(Consumer<SelectionKey> action, long timeout)	选择相应通道已准备好进行 I/O 操作的键并对其执行操作。
abstract int	Selector.selectNow()	选择一组键，其对应的通道已准备好进行 I/O 操作。
int	Selector.selectNow(Consumer<SelectionKey> action)	选择相应通道已准备好进行 I/O 操作的键并对其执行操作。
abstract int	DatagramChannel.send(ByteBuffer src, SocketAddress target)	通过此通道发送数据报。
abstract <T> AsynchronousServerSocketChannel	AsynchronousServerSocketChannel.setOption(SocketOption<T> name, T value)
abstract <T> AsynchronousSocketChannel	AsynchronousSocketChannel.setOption(SocketOption<T> name, T value)
abstract <T> DatagramChannel	DatagramChannel.setOption(SocketOption<T> name, T value)
<T> NetworkChannel	NetworkChannel.setOption(SocketOption<T> name, T value)	设置套接字选项的值。
abstract <T> ServerSocketChannel	ServerSocketChannel.setOption(SocketOption<T> name, T value)
abstract <T> SocketChannel	SocketChannel.setOption(SocketOption<T> name, T value)
abstract AsynchronousSocketChannel	AsynchronousSocketChannel.shutdownInput()	在不关闭通道的情况下关闭读取连接。
abstract SocketChannel	SocketChannel.shutdownInput()	在不关闭通道的情况下关闭读取连接。
abstract void	AsynchronousChannelGroup.shutdownNow()	关闭组并关闭组中所有打开的通道。
abstract AsynchronousSocketChannel	AsynchronousSocketChannel.shutdownOutput()	在不关闭通道的情况下关闭写入连接。
abstract SocketChannel	SocketChannel.shutdownOutput()	在不关闭通道的情况下关闭写入连接。
abstract long	AsynchronousFileChannel.size()	返回此通道文件的当前大小。
abstract long	FileChannel.size()	返回此通道文件的当前大小。
long	SeekableByteChannel.size()	返回此通道连接到的实体的当前大小。
abstract long	FileChannel.transferFrom(ReadableByteChannel src, long position, long count)	将字节从给定的可读字节通道传输到该通道的文件中。
abstract long	FileChannel.transferTo(long position, long count, WritableByteChannel target)	将字节从此通道的文件传输到给定的可写字节通道。
abstract AsynchronousFileChannel	AsynchronousFileChannel.truncate(long size)	将此通道的文件截断为给定大小。
abstract FileChannel	FileChannel.truncate(long size)	将此通道的文件截断为给定大小。
SeekableByteChannel	SeekableByteChannel.truncate(long size)	将此通道连接到的实体截断为给定大小。
final FileLock	AsynchronousFileChannel.tryLock()	尝试获取此通道文件的独占锁。
abstract FileLock	AsynchronousFileChannel.tryLock(long position, long size, boolean shared)	尝试获取此通道文件的给定区域的锁。
final FileLock	FileChannel.tryLock()	尝试获取此通道文件的独占锁。
abstract FileLock	FileChannel.tryLock(long position, long size, boolean shared)	尝试获取此通道文件的给定区域的锁。
static AsynchronousChannelGroup	AsynchronousChannelGroup.withCachedThreadPool(ExecutorService executor, int initialSize)	使用给定线程池创建一个异步通道组，该线程池根据需要创建新线程。
static AsynchronousChannelGroup	AsynchronousChannelGroup.withFixedThreadPool(int nThreads, ThreadFactory threadFactory)	创建具有固定线程池的异步通道组。
static AsynchronousChannelGroup	AsynchronousChannelGroup.withThreadPool(ExecutorService executor)	使用给定线程池创建异步通道组。
abstract int	DatagramChannel.write(ByteBuffer src)	将数据报写入此通道。
final long	DatagramChannel.write(ByteBuffer[] srcs)	将数据报写入此通道。
abstract long	DatagramChannel.write(ByteBuffer[] srcs, int offset, int length)	将数据报写入此通道。
abstract int	FileChannel.write(ByteBuffer src)	将给定缓冲区中的字节序列写入此通道。
final long	FileChannel.write(ByteBuffer[] srcs)	将给定缓冲区中的字节序列写入此通道。
abstract long	FileChannel.write(ByteBuffer[] srcs, int offset, int length)	从给定缓冲区的子序列中将字节序列写入此通道。
abstract int	FileChannel.write(ByteBuffer src, long position)	从给定的文件位置开始，从给定的缓冲区向此通道写入一个字节序列。
long	GatheringByteChannel.write(ByteBuffer[] srcs)	将给定缓冲区中的字节序列写入此通道。
long	GatheringByteChannel.write(ByteBuffer[] srcs, int offset, int length)	从给定缓冲区的子序列中将字节序列写入此通道。
int	SeekableByteChannel.write(ByteBuffer src)	将给定缓冲区中的字节序列写入此通道。
abstract int	SocketChannel.write(ByteBuffer src)
final long	SocketChannel.write(ByteBuffer[] srcs)
abstract long	SocketChannel.write(ByteBuffer[] srcs, int offset, int length)
int	WritableByteChannel.write(ByteBuffer src)	将给定缓冲区中的字节序列写入此通道。

IOException 在 java.nio.channels.spi 中的用法

在 java.nio.channels.spi 中抛出 IOException

修饰符和类型	方法	描述
final void	AbstractInterruptibleChannel.close()	关闭此通道。
final void	AbstractSelector.close()	关闭此选择器。
final SelectableChannel	AbstractSelectableChannel.configureBlocking(boolean block)	调整此通道的阻塞模式。
protected abstract void	AbstractInterruptibleChannel.implCloseChannel()	关闭此通道。
protected final void	AbstractSelectableChannel.implCloseChannel()	关闭此通道。
protected abstract void	AbstractSelectableChannel.implCloseSelectableChannel()	关闭这个可选择的通道。
protected abstract void	AbstractSelector.implCloseSelector()	关闭此选择器。
protected abstract void	AbstractSelectableChannel.implConfigureBlocking(boolean block)	调整此通道的阻塞模式。
Channel	SelectorProvider.inheritedChannel()	返回从创建此 Java 虚拟机的实体继承的通道。
abstract AsynchronousChannelGroup	AsynchronousChannelProvider.openAsynchronousChannelGroup(int nThreads, ThreadFactory threadFactory)	构造一个新的具有固定线程池的异步通道组。
abstract AsynchronousChannelGroup	AsynchronousChannelProvider.openAsynchronousChannelGroup(ExecutorService executor, int initialSize)	使用给定的线程池构造一个新的异步通道组。
abstract AsynchronousServerSocketChannel	AsynchronousChannelProvider.openAsynchronousServerSocketChannel(AsynchronousChannelGroup group)	打开异步服务套接字通道。
abstract AsynchronousSocketChannel	AsynchronousChannelProvider.openAsynchronousSocketChannel(AsynchronousChannelGroup group)	打开异步套接字通道。
abstract DatagramChannel	SelectorProvider.openDatagramChannel()	打开数据报通道。
abstract DatagramChannel	SelectorProvider.openDatagramChannel(ProtocolFamily family)	打开数据报通道。
abstract Pipe	SelectorProvider.openPipe()	打开管道。
abstract AbstractSelector	SelectorProvider.openSelector()	打开一个选择器。
abstract ServerSocketChannel	SelectorProvider.openServerSocketChannel()	打开服务套接字通道。
ServerSocketChannel	SelectorProvider.openServerSocketChannel(ProtocolFamily family)	打开服务套接字通道。
abstract SocketChannel	SelectorProvider.openSocketChannel()	打开套接字通道。
SocketChannel	SelectorProvider.openSocketChannel(ProtocolFamily family)	打开套接字通道。

IOException 在 java.nio.charset 中的用法

java.nio.charset 中 IOException 的子类

修饰符和类型	类	描述
class	CharacterCodingException	发生字符编码或解码错误时抛出检查异常。
class	MalformedInputException	当输入字节序列对于给定字符集不合法或输入字符序列不是合法的 16 位 Unicode 序列时抛出检查异常。
class	UnmappableCharacterException	当输入字符（或字节）序列有效但无法映射到输出字节（或字符）序列时抛出检查异常。

IOException 在 java.nio.file 中的用法

java.nio.file 中 IOException 的子类

修饰符和类型	类	描述
class	AccessDeniedException	文件系统操作被拒绝时抛出的检查异常，通常是由于文件权限或其他访问检查。
class	AtomicMoveNotSupportedException	当文件不能作为原子文件系统操作移动时抛出检查异常。
class	DirectoryNotEmptyException	当文件系统操作因目录不为空而失败时抛出已检查的异常。
class	FileAlreadyExistsException	当尝试创建文件或目录并且该名称的文件已经存在时抛出检查异常。
class	FileSystemException	当文件系统操作对一个或两个文件失败时抛出。
class	FileSystemLoopException	遇到文件系统循环或循环时抛出已检查的异常。
class	NoSuchFileException	尝试访问不存在的文件时抛出已检查的异常。
class	NotDirectoryException	当针对目录的文件系统操作因文件不是目录而失败时抛出已检查异常。
class	NotLinkException	当文件系统操作因文件不是符号链接而失败时抛出已检查的异常。

java.nio.file 中返回 IOException 的方法

修饰符和类型	方法	描述
IOException	DirectoryIteratorException.getCause()	返回此异常的原因。

java.nio.file 中的方法，参数类型为 IOException

修饰符和类型	方法	描述
FileVisitResult	FileVisitor.postVisitDirectory(T dir, IOException exc)	在访问了目录中的条目及其所有后代之后为目录调用。
FileVisitResult	SimpleFileVisitor.postVisitDirectory(T dir, IOException exc)	在访问了目录中的条目及其所有后代之后为目录调用。
FileVisitResult	FileVisitor.visitFileFailed(T file, IOException exc)	为无法访问的文件调用。
FileVisitResult	SimpleFileVisitor.visitFileFailed(T file, IOException exc)	为无法访问的文件调用。

在 java.nio.file 中抛出 IOException

修饰符和类型	方法	描述
boolean	DirectoryStream.Filter.accept(T entry)	决定是否应接受或过滤给定的目录条目。
abstract void	FileSystem.close()	关闭此文件系统。
void	WatchService.close()	关闭此监视服务。
static long	Files.copy(InputStream in, Path target, CopyOption... options)	将输入流中的所有字节复制到文件中。
static long	Files.copy(Path source, OutputStream out)	将文件中的所有字节复制到输出流。
static Path	Files.copy(Path source, Path target, CopyOption... options)	将文件复制到目标文件。
static Path	Files.createDirectories(Path dir, FileAttribute<?>... attrs)	通过首先创建所有不存在的父目录来创建目录。
static Path	Files.createDirectory(Path dir, FileAttribute<?>... attrs)	创建一个新目录。
static Path	Files.createFile(Path path, FileAttribute<?>... attrs)	创建一个新的空文件，如果文件已经存在则失败。
static Path	Files.createLink(Path link, Path existing)	为现有文件创建新链接（目录条目）（可选操作）.
static Path	Files.createSymbolicLink(Path link, Path target, FileAttribute<?>... attrs)	创建指向目标的符号链接（可选操作）.
static Path	Files.createTempDirectory(String prefix, FileAttribute<?>... attrs)	在默认的临时文件目录中创建一个新目录，使用给定的前缀生成其名称。
static Path	Files.createTempDirectory(Path dir, String prefix, FileAttribute<?>... attrs)	在指定目录中创建一个新目录，使用给定的前缀生成其名称。
static Path	Files.createTempFile(String prefix, String suffix, FileAttribute<?>... attrs)	在默认临时文件目录中创建一个空文件，使用给定的前缀和后缀生成其名称。
static Path	Files.createTempFile(Path dir, String prefix, String suffix, FileAttribute<?>... attrs)	在指定目录中创建一个新的空文件，使用给定的前缀和后缀字符串生成其名称。
static void	Files.delete(Path path)	删除文件。
void	SecureDirectoryStream.deleteDirectory(T path)	删除目录。
void	SecureDirectoryStream.deleteFile(T path)	删除文件。
static boolean	Files.deleteIfExists(Path path)	删除文件（如果存在）。
static Stream<Path>	Files.find(Path start, int maxDepth, BiPredicate<Path,BasicFileAttributes> matcher, FileVisitOption... options)	通过在以给定起始文件为根的文件树中搜索文件，返回一个用 Path 延迟填充的 Stream。
static Object	Files.getAttribute(Path path, String attribute, LinkOption... options)	读取文件属性的值。
abstract Object	FileStore.getAttribute(String attribute)	读取文件存储属性的值。
long	FileStore.getBlockSize()	返回此文件存储中每个块的字节数。
static FileStore	Files.getFileStore(Path path)	返回代表文件所在文件存储的 FileStore 。
static FileTime	Files.getLastModifiedTime(Path path, LinkOption... options)	返回文件的最后修改时间。
static UserPrincipal	Files.getOwner(Path path, LinkOption... options)	返回文件的所有者。
static Set<PosixFilePermission>	Files.getPosixFilePermissions(Path path, LinkOption... options)	返回文件的 POSIX 文件权限。
abstract long	FileStore.getTotalSpace()	返回文件存储的大小（以字节为单位）。
abstract long	FileStore.getUnallocatedSpace()	返回文件存储中未分配的字节数。
abstract long	FileStore.getUsableSpace()	返回文件存储上此 Java 虚拟机可用的字节数。
static boolean	Files.isHidden(Path path)	告知文件是否被视为 hidden 。
static boolean	Files.isSameFile(Path path, Path path2)	测试两个路径是否找到同一个文件。
static Stream<String>	Files.lines(Path path)	从文件中读取所有行作为 Stream 。
static Stream<String>	Files.lines(Path path, Charset cs)	从文件中读取所有行作为 Stream 。
static Stream<Path>	Files.list(Path dir)	返回一个延迟填充的 Stream ，其元素是目录中的条目。
static long	Files.mismatch(Path path, Path path2)	查找并返回两个文件内容中第一个不匹配字节的位置，如果不匹配则返回 -1L。
static Path	Files.move(Path source, Path target, CopyOption... options)	将文件移动或重命名为目标文件。
void	SecureDirectoryStream.move(T srcpath, SecureDirectoryStream<T> targetdir, T targetpath)	将文件从此目录移动到另一个目录。
static BufferedReader	Files.newBufferedReader(Path path)	打开一个文件进行读取，返回一个 BufferedReader 以高效的方式从文件中读取文本。
static BufferedReader	Files.newBufferedReader(Path path, Charset cs)	打开一个文件进行读取，返回一个 BufferedReader 可用于以有效的方式从文件中读取文本。
static BufferedWriter	Files.newBufferedWriter(Path path, Charset cs, OpenOption... options)	打开或创建一个用于写入的文件，返回一个 BufferedWriter 可用于以有效的方式将文本写入文件。
static BufferedWriter	Files.newBufferedWriter(Path path, OpenOption... options)	打开或创建用于写入的文件，返回 BufferedWriter 以高效方式将文本写入文件。
static SeekableByteChannel	Files.newByteChannel(Path path, OpenOption... options)	打开或创建一个文件，返回一个可搜索的字节通道来访问该文件。
static SeekableByteChannel	Files.newByteChannel(Path path, Set<? extends OpenOption> options, FileAttribute<?>... attrs)	打开或创建一个文件，返回一个可搜索的字节通道来访问该文件。
SeekableByteChannel	SecureDirectoryStream.newByteChannel(T path, Set<? extends OpenOption> options, FileAttribute<?>... attrs)	在此目录中打开或创建一个文件，返回一个可搜索的字节通道以访问该文件。
static DirectoryStream<Path>	Files.newDirectoryStream(Path dir)	打开一个目录，返回一个 DirectoryStream 以遍历目录中的所有条目。
static DirectoryStream<Path>	Files.newDirectoryStream(Path dir, String glob)	打开一个目录，返回一个 DirectoryStream 以迭代目录中的条目。
static DirectoryStream<Path>	Files.newDirectoryStream(Path dir, DirectoryStream.Filter<? super Path> filter)	打开一个目录，返回一个 DirectoryStream 以迭代目录中的条目。
SecureDirectoryStream<T>	SecureDirectoryStream.newDirectoryStream(T path, LinkOption... options)	打开由给定路径标识的目录，返回 SecureDirectoryStream 以迭代目录中的条目。
static FileSystem	FileSystems.newFileSystem(URI uri, Map<String,?> env)	构造一个由URI 标识的新文件系统
static FileSystem	FileSystems.newFileSystem(URI uri, Map<String,?> env, ClassLoader loader)	构造一个由URI 标识的新文件系统
static FileSystem	FileSystems.newFileSystem(Path path)	构造一个新的 FileSystem 来访问文件的内容作为文件系统。
static FileSystem	FileSystems.newFileSystem(Path path, ClassLoader loader)	构造一个新的 FileSystem 来访问文件的内容作为文件系统。
static FileSystem	FileSystems.newFileSystem(Path path, Map<String,?> env)	构造一个新的 FileSystem 来访问文件的内容作为文件系统。
static FileSystem	FileSystems.newFileSystem(Path path, Map<String,?> env, ClassLoader loader)	构造一个新的 FileSystem 来访问文件的内容作为文件系统。
static InputStream	Files.newInputStream(Path path, OpenOption... options)	打开一个文件，返回一个输入流以从文件中读取。
static OutputStream	Files.newOutputStream(Path path, OpenOption... options)	打开或创建文件，返回可用于将字节写入文件的输出流。
abstract WatchService	FileSystem.newWatchService()	构造一个新的WatchService （可选操作）.
FileVisitResult	FileVisitor.postVisitDirectory(T dir, IOException exc)	在访问了目录中的条目及其所有后代之后为目录调用。
FileVisitResult	SimpleFileVisitor.postVisitDirectory(T dir, IOException exc)	在访问了目录中的条目及其所有后代之后为目录调用。
FileVisitResult	FileVisitor.preVisitDirectory(T dir, BasicFileAttributes attrs)	在访问目录中的条目之前为目录调用。
FileVisitResult	SimpleFileVisitor.preVisitDirectory(T dir, BasicFileAttributes attrs)	在访问目录中的条目之前为目录调用。
static String	Files.probeContentType(Path path)	探测文件的内容类型。
static byte[]	Files.readAllBytes(Path path)	从文件中读取所有字节。
static List<String>	Files.readAllLines(Path path)	从文件中读取所有行。
static List<String>	Files.readAllLines(Path path, Charset cs)	从文件中读取所有行。
static <A extends BasicFileAttributes> A	Files.readAttributes(Path path, Class<A> type, LinkOption... options)	作为批量操作读取文件的属性。
static Map<String,Object>	Files.readAttributes(Path path, String attributes, LinkOption... options)	读取一组文件属性作为批量操作。
static String	Files.readString(Path path)	将文件中的所有内容读入字符串，使用 UTF-8 charset 从字节解码为字符。
static String	Files.readString(Path path, Charset cs)	将文件中的所有字符读入字符串，使用指定的 charset 从字节解码为字符。
static Path	Files.readSymbolicLink(Path link)	读取符号链接的目标（可选操作）.
default WatchKey	Path.register(WatchService watcher, WatchEvent.Kind<?>... events)	向监视服务注册此路径所在的文件。
WatchKey	Path.register(WatchService watcher, WatchEvent.Kind<?>[] events, WatchEvent.Modifier... modifiers)	向监视服务注册此路径所在的文件。
WatchKey	Watchable.register(WatchService watcher, WatchEvent.Kind<?>... events)	向监视服务注册对象。
WatchKey	Watchable.register(WatchService watcher, WatchEvent.Kind<?>[] events, WatchEvent.Modifier... modifiers)	向监视服务注册对象。
static Path	Files.setAttribute(Path path, String attribute, Object value, LinkOption... options)	设置文件属性的值。
static Path	Files.setLastModifiedTime(Path path, FileTime time)	更新文件的上次修改时间属性。
static Path	Files.setOwner(Path path, UserPrincipal owner)	更新文件所有者。
static Path	Files.setPosixFilePermissions(Path path, Set<PosixFilePermission> perms)	设置文件的 POSIX 权限。
static long	Files.size(Path path)	返回文件的大小（以字节为单位）。
Path	Path.toRealPath(LinkOption... options)	返回现有文件的 real 路径。
FileVisitResult	FileVisitor.visitFile(T file, BasicFileAttributes attrs)	为目录中的文件调用。
FileVisitResult	SimpleFileVisitor.visitFile(T file, BasicFileAttributes attrs)	为目录中的文件调用。
FileVisitResult	FileVisitor.visitFileFailed(T file, IOException exc)	为无法访问的文件调用。
FileVisitResult	SimpleFileVisitor.visitFileFailed(T file, IOException exc)	为无法访问的文件调用。
static Stream<Path>	Files.walk(Path start, int maxDepth, FileVisitOption... options)	通过遍历以给定起始文件为根的文件树，返回一个用 Path 延迟填充的 Stream。
static Stream<Path>	Files.walk(Path start, FileVisitOption... options)	通过遍历以给定起始文件为根的文件树，返回一个用 Path 延迟填充的 Stream。
static Path	Files.walkFileTree(Path start, FileVisitor<? super Path> visitor)	遍历文件树。
static Path	Files.walkFileTree(Path start, Set<FileVisitOption> options, int maxDepth, FileVisitor<? super Path> visitor)	遍历文件树。
static Path	Files.write(Path path, byte[] bytes, OpenOption... options)	将字节写入文件。
static Path	Files.write(Path path, Iterable<? extends CharSequence> lines, Charset cs, OpenOption... options)	将文本行写入文件。
static Path	Files.write(Path path, Iterable<? extends CharSequence> lines, OpenOption... options)	将文本行写入文件。
static Path	Files.writeString(Path path, CharSequence csq, Charset cs, OpenOption... options)	将 CharSequence 写入文件。
static Path	Files.writeString(Path path, CharSequence csq, OpenOption... options)	将 CharSequence 写入文件。

java.nio.file 中的构造函数，参数类型为 IOException

修饰符	构造方法	描述
	DirectoryIteratorException(IOException cause)	构造此类的实例。

IOException 在 java.nio.file.attribute 中的用法

java.nio.file.attribute 中 IOException 的子类

修饰符和类型	类	描述
class	UserPrincipalNotFoundException	当查找 UserPrincipal 失败时抛出检查异常，因为委托人不存在。

在 java.nio.file.attribute 中抛出 IOException

修饰符和类型	方法	描述
void	UserDefinedFileAttributeView.delete(String name)	删除用户定义的属性。
List<AclEntry>	AclFileAttributeView.getAcl()	读取访问控制列表。
UserPrincipal	FileOwnerAttributeView.getOwner()	读取文件所有者。
List<String>	UserDefinedFileAttributeView.list()	返回包含用户定义属性名称的列表。
abstract GroupPrincipal	UserPrincipalLookupService.lookupPrincipalByGroupName(String group)	按组名查找组主体。
abstract UserPrincipal	UserPrincipalLookupService.lookupPrincipalByName(String name)	按名称查找用户主体。
int	UserDefinedFileAttributeView.read(String name, ByteBuffer dst)	将用户定义属性的值读入缓冲区。
BasicFileAttributes	BasicFileAttributeView.readAttributes()	读取基本文件属性作为批量操作。
DosFileAttributes	DosFileAttributeView.readAttributes()
PosixFileAttributes	PosixFileAttributeView.readAttributes()
void	AclFileAttributeView.setAcl(List<AclEntry> acl)	更新（替换）访问控制列表。
void	DosFileAttributeView.setArchive(boolean value)	更新存档属性的值。
void	PosixFileAttributeView.setGroup(GroupPrincipal group)	更新文件组所有者。
void	DosFileAttributeView.setHidden(boolean value)	更新隐藏属性的值。
void	FileOwnerAttributeView.setOwner(UserPrincipal owner)	更新文件所有者。
void	PosixFileAttributeView.setPermissions(Set<PosixFilePermission> perms)	更新文件权限。
void	DosFileAttributeView.setReadOnly(boolean value)	更新只读属性的值。
void	DosFileAttributeView.setSystem(boolean value)	更新系统属性的值。
void	BasicFileAttributeView.setTimes(FileTime lastModifiedTime, FileTime lastAccessTime, FileTime createTime)	更新任何或所有文件的上次修改时间、上次访问时间和创建时间属性。
int	UserDefinedFileAttributeView.size(String name)	返回用户定义属性值的大小。
int	UserDefinedFileAttributeView.write(String name, ByteBuffer src)	从缓冲区写入用户定义属性的值。

IOException 在 java.nio.file.spi 中的用法

在 java.nio.file.spi 中抛出 IOException

修饰符和类型	方法	描述
abstract void	FileSystemProvider.checkAccess(Path path, AccessMode... modes)	检查文件是否存在，并可选地检查文件的可访问性。
abstract void	FileSystemProvider.copy(Path source, Path target, CopyOption... options)	将文件复制到目标文件。
abstract void	FileSystemProvider.createDirectory(Path dir, FileAttribute<?>... attrs)	创建一个新目录。
void	FileSystemProvider.createLink(Path link, Path existing)	为现有文件创建新链接（目录条目）。
void	FileSystemProvider.createSymbolicLink(Path link, Path target, FileAttribute<?>... attrs)	创建指向目标的符号链接。
abstract void	FileSystemProvider.delete(Path path)	删除文件。
boolean	FileSystemProvider.deleteIfExists(Path path)	删除文件（如果存在）。
abstract FileStore	FileSystemProvider.getFileStore(Path path)	返回代表文件所在文件存储的 FileStore 。
abstract boolean	FileSystemProvider.isHidden(Path path)	告知文件是否被视为 hidden 。
abstract boolean	FileSystemProvider.isSameFile(Path path, Path path2)	测试两个路径是否找到同一个文件。
abstract void	FileSystemProvider.move(Path source, Path target, CopyOption... options)	将文件移动或重命名为目标文件。
AsynchronousFileChannel	FileSystemProvider.newAsynchronousFileChannel(Path path, Set<? extends OpenOption> options, ExecutorService executor, FileAttribute<?>... attrs)	打开或创建用于读取和/或写入的文件，返回异步文件通道以访问该文件。
abstract SeekableByteChannel	FileSystemProvider.newByteChannel(Path path, Set<? extends OpenOption> options, FileAttribute<?>... attrs)	打开或创建一个文件，返回一个可搜索的字节通道来访问该文件。
abstract DirectoryStream<Path>	FileSystemProvider.newDirectoryStream(Path dir, DirectoryStream.Filter<? super Path> filter)	打开一个目录，返回一个 DirectoryStream 以迭代目录中的条目。
FileChannel	FileSystemProvider.newFileChannel(Path path, Set<? extends OpenOption> options, FileAttribute<?>... attrs)	打开或创建用于读取和/或写入的文件，返回文件通道以访问该文件。
abstract FileSystem	FileSystemProvider.newFileSystem(URI uri, Map<String,?> env)	构造一个由 URI 标识的新 FileSystem 对象。
FileSystem	FileSystemProvider.newFileSystem(Path path, Map<String,?> env)	构造一个新的 FileSystem 来访问文件的内容作为文件系统。
InputStream	FileSystemProvider.newInputStream(Path path, OpenOption... options)	打开一个文件，返回一个输入流以从文件中读取。
OutputStream	FileSystemProvider.newOutputStream(Path path, OpenOption... options)	打开或创建文件，返回可用于将字节写入文件的输出流。
abstract String	FileTypeDetector.probeContentType(Path path)	探测给定文件以猜测其内容类型。
abstract <A extends BasicFileAttributes> A	FileSystemProvider.readAttributes(Path path, Class<A> type, LinkOption... options)	作为批量操作读取文件的属性。
abstract Map<String,Object>	FileSystemProvider.readAttributes(Path path, String attributes, LinkOption... options)	读取一组文件属性作为批量操作。
<A extends BasicFileAttributes> A	FileSystemProvider.readAttributesIfExists(Path path, Class<A> type, LinkOption... options)	如果文件存在，则将文件的属性作为批量操作读取。
Path	FileSystemProvider.readSymbolicLink(Path link)	读取符号链接的目标。
abstract void	FileSystemProvider.setAttribute(Path path, String attribute, Object value, LinkOption... options)	设置文件属性的值。

IOException 在 java.rmi 中的用法

java.rmi 中 IOException 的子类

修饰符和类型	类	描述
class	AccessException	java.rmi.Naming 类的某些方法（特别是 bind、rebind 和 unbind）会抛出 AccessException，以指示调用者无权执行方法调用请求的操作。
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	如果在导出远程对象时找不到有效的存根类，则会抛出 StubNotFoundException。
class	UnexpectedException	如果远程方法调用的客户端作为调用结果接收到一个已检查异常，但该检查异常不在远程接口方法的 throws 子句中声明的已检查异常类型中，则抛出 UnexpectedException。
class	UnknownHostException	如果在为远程方法调用创建到远程主机的连接时发生 java.net.UnknownHostException，则会抛出 UnknownHostException。
class	UnmarshalException	如果发生以下任何情况，则在解组远程方法调用的参数或结果时可能会抛出 UnmarshalException： 如果在解组调用标头时发生异常 如果返回值的协议无效 如果发生 java.io.IOException 解组参数（在服务端）或返回值（在客户端）。

在 java.rmi 中抛出 IOException

修饰符和类型	方法	描述
T	MarshalledObject.get()	返回包含的编组对象的新副本。

java.rmi 中的构造函数抛出 IOException

修饰符	构造方法	描述
	MarshalledObject(T obj)	创建一个新的 MarshalledObject，其中包含所提供对象当前状态的序列化表示。

IOException 在 java.rmi.server 中的用法

java.rmi.server 中 IOException 的子类

修饰符和类型	类	描述
class	ExportException	如果尝试导出远程对象失败，则会抛出 ExportException 和 RemoteException。
class	SkeletonMismatchException	已弃用。 没有替代品。
class	SkeletonNotFoundException	已弃用。 没有替代品。
class	SocketSecurityException	已弃用。 这个类已经过时了。

在 java.rmi.server 中抛出 IOException

修饰符和类型	方法	描述
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 ObjID	ObjID.read(ObjectInput in)	通过从 ObjectInput 实例解组二进制表示来构造并返回一个新的 ObjID 实例。
static UID	UID.read(DataInput in)	通过从 DataInput 实例解组二进制表示来构造并返回一个新的 UID 实例。
void	RemoteCall.releaseInputStream()	已弃用。 没有替代品
void	RemoteCall.releaseOutputStream()	已弃用。 没有替代品
static void	RMISocketFactory.setSocketFactory(RMISocketFactory fac)	设置 RMI 从中获取套接字的全局套接字工厂（如果远程对象未与特定的客户端和/或服务套接字工厂相关联）。
void	ObjID.write(ObjectOutput out)	将此 ObjID 的二进制表示编组为 ObjectOutput 实例。
void	UID.write(DataOutput out)	将此 UID 的二进制表示编组为 DataOutput 实例。

IOException 在 java.security 中的用法

在 java.security 中抛出 IOException

修饰符和类型	方法	描述
void	Certificate.decode(InputStream stream)	已弃用，将被删除：此 API 元素可能会在未来版本中删除。 从输入流中解码证书。
void	Certificate.encode(OutputStream stream)	已弃用，将被删除：此 API 元素可能会在未来版本中删除。 将证书编码为可由 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)	从给定的输入流加载密钥库。
void	KeyStoreSpi.engineLoad(KeyStore.LoadStoreParameter param)	使用给定的 KeyStore.LoadStoreParameter 加载密钥库。
boolean	KeyStoreSpi.engineProbe(InputStream stream)	探测指定的输入流以确定它是否包含此实现支持的密钥库。
abstract void	KeyStoreSpi.engineStore(OutputStream stream, char[] password)	将此密钥库存储到给定的输出流，并使用给定的密码保护其完整性。
void	KeyStoreSpi.engineStore(KeyStore.LoadStoreParameter param)	使用给定的 KeyStore.LoadStoreParameter 存储此密钥库。
final byte[]	AlgorithmParameters.getEncoded()	以其主要编码格式返回参数。
final byte[]	AlgorithmParameters.getEncoded(String format)	返回以指定方案编码的参数。
static final KeyStore	KeyStore.getInstance(File file, char[] password)	返回适当密钥库类型的已加载密钥库对象。
static final KeyStore	KeyStore.getInstance(File file, KeyStore.LoadStoreParameter param)	返回适当密钥库类型的已加载密钥库对象。
Object	SignedObject.getObject()	检索封装的对象。
final void	AlgorithmParameters.init(byte[] params)	导入指定的参数，并按照参数的主要解码格式进行解码。
final void	AlgorithmParameters.init(byte[] params, String format)	从params中导入参数，按照指定的解码方案进行解码。
final void	KeyStore.load(InputStream stream, char[] password)	从给定的输入流加载此密钥库。
final void	KeyStore.load(KeyStore.LoadStoreParameter param)	使用给定的 LoadStoreParameter 加载此密钥库。
void	Provider.load(InputStream inStream)	从输入流中读取属性列表（键和元素对）。
int	DigestInputStream.read()	读取一个字节，并更新消息摘要（如果摘要功能打开）。
int	DigestInputStream.read(byte[] b, int off, int len)	读入字节数组，并更新消息摘要（如果摘要功能打开）。
final void	KeyStore.store(OutputStream stream, char[] password)	将此密钥库存储到给定的输出流，并使用给定的密码保护其完整性。
final void	KeyStore.store(KeyStore.LoadStoreParameter param)	使用给定的 LoadStoreParameter 存储此密钥库。
void	DigestOutputStream.write(byte[] b, int off, int len)	使用指定的子数组更新消息摘要（如果摘要功能打开），并且在任何情况下都将子数组写入输出流。
void	DigestOutputStream.write(int b)	使用指定的字节更新消息摘要（如果摘要功能打开），并且在任何情况下都将字节写入输出流。

java.security 中的构造函数抛出 IOException

修饰符	构造方法	描述
	SignedObject(Serializable object, PrivateKey signingKey, Signature signingEngine)	从任何 Serializable 对象构造一个 SignedObject。

IOException 在 java.security.cert 中的用法

在 java.security.cert 中抛出 IOException

修饰符和类型	方法	描述
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 条件。
void	Extension.encode(OutputStream out)	生成扩展的 DER 编码并将其写入输出流。
byte[]	X509CertSelector.getIssuerAsBytes()	将发行者标准作为字节数组返回。
byte[]	X509CertSelector.getSubjectAsBytes()	将主题标准作为字节数组返回。
void	X509CertSelector.setExtendedKeyUsage(Set<String> keyPurposeSet)	设置 extendedKeyUsage 标准。
void	X509CertSelector.setIssuer(byte[] issuerDN)	设置发行者标准。
void	X509CertSelector.setIssuer(String issuerDN)	已弃用。 请改用 X509CertSelector.setIssuer(X500Principal) 或 X509CertSelector.setIssuer(byte[]) 。
void	X509CRLSelector.setIssuerNames(Collection<?> names)	Note: 使用 X509CRLSelector.setIssuers(Collection) 代替或仅在使用此方法时指定专有名称的字节数组形式。
void	X509CertSelector.setNameConstraints(byte[] bytes)	设置名称约束标准。
void	X509CertSelector.setPathToNames(Collection<List<?>> names)	设置 pathToNames 标准。
void	X509CertSelector.setPolicy(Set<String> certPolicySet)	设置策略约束。
void	X509CertSelector.setSubject(byte[] subjectDN)	设置主题标准。
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 标准。

java.security.cert 中的构造函数抛出 IOException

修饰符	构造方法	描述
	PolicyQualifierInfo(byte[] encoded)	从编码字节创建 PolicyQualifierInfo 实例。

IOException 在 java.util 中的用法

java.util 中 IOException 的子类

修饰符和类型	类	描述
class	InvalidPropertiesFormatException	根据 Properties 规范，抛出表示操作无法完成，因为输入不符合属性集合的适当 XML 文档类型。

java.util 中返回 IOException 的方法

修饰符和类型	方法	描述
IOException	Formatter.ioException()	返回此格式化程序的 Appendable 最后抛出的 IOException。
IOException	Scanner.ioException()	返回此 Scanner 的底层 Readable 最后抛出的 IOException。

在 java.util 中抛出 IOException

修饰符和类型	方法	描述
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)	为给定格式和locale的给定包名称实例化资源包，必要时使用给定的类加载器。
void	Properties.store(OutputStream out, String comments)	将此 Properties 表中的此属性列表（键和元素对）以适合使用 load(InputStream) 方法加载到 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 文档。
void	Properties.storeToXML(OutputStream os, String comment, Charset charset)	使用指定的编码发出表示此表中包含的所有属性的 XML 文档。

java.util 中的构造函数抛出 IOException

修饰符	构造方法	描述
	Formatter(File file, Charset charset, Locale l)	使用指定的文件、字符集和locale构造一个新的格式化程序。
	Formatter(String fileName, Charset charset, Locale l)	构造具有指定文件名、字符集和locale的新格式化程序。
	PropertyResourceBundle(InputStream stream)	从 InputStream 创建属性资源包。
	PropertyResourceBundle(Reader reader)	从 Reader 创建属性资源包。
	Scanner(File source, Charset charset)	构造一个新的 Scanner 生成从指定文件扫描的值。
	Scanner(Path source)	构造一个新的 Scanner 生成从指定文件扫描的值。
	Scanner(Path source, String charsetName)	构造一个新的 Scanner 生成从指定文件扫描的值。
	Scanner(Path source, Charset charset)	构造一个新的 Scanner 生成从指定文件扫描的值。

IOException 在 java.util.jar 中的用法

java.util.jar 中 IOException 的子类

修饰符和类型	类	描述
class	JarException	表示在读取或写入 JAR 文件时发生了某种错误。

在 java.util.jar 中抛出 IOException

修饰符和类型	方法	描述
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	JarOutputStream.putNextEntry(ZipEntry ze)	开始写入新的 JAR 文件条目并将流定位到条目数据的开头。
int	JarInputStream.read(byte[] b, int off, int len)	从当前 JAR 条目读取到字节数组，返回膨胀的字节数。
void	Manifest.read(InputStream is)	从指定的 InputStream 中读取清单。
void	Manifest.write(OutputStream out)	将清单写入指定的 OutputStream。

java.util.jar 中的构造函数抛出 IOException

修饰符	构造方法	描述
	JarFile(File file)	创建一个新的 JarFile 以从指定的 File 对象读取。
	JarFile(File file, boolean verify)	创建一个新的 JarFile 以从指定的 File 对象读取。
	JarFile(File file, boolean verify, int mode)	创建一个新的 JarFile 以指定模式从指定的 File 对象读取。
	JarFile(File file, boolean verify, int mode, Runtime.Version version)	创建一个新的 JarFile 以指定模式从指定的 File 对象读取。
	JarFile(String name)	创建一个新的 JarFile 以从指定文件 name 中读取。
	JarFile(String name, boolean verify)	创建一个新的 JarFile 以从指定文件 name 中读取。
	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。

IOException 在 java.util.logging 中的用法

在 java.util.logging 中抛出 IOException

修饰符和类型	方法	描述
void	LogManager.readConfiguration()	读取并初始化日志记录配置。
void	LogManager.readConfiguration(InputStream ins)	从给定的输入流读取并初始化日志记录配置。
void	LogManager.updateConfiguration(InputStream ins, Function<String,BiFunction<String,String,String>> mapper)	更新日志记录配置。
void	LogManager.updateConfiguration(Function<String,BiFunction<String,String,String>> mapper)	更新日志记录配置。

java.util.logging 中的构造函数抛出 IOException

修饰符	构造方法	描述
	FileHandler()	构造一个默认的 FileHandler 。
	FileHandler(String pattern)	初始化 FileHandler 以写入给定的文件名。
	FileHandler(String pattern, boolean append)	初始化 FileHandler 以写入给定的文件名，并带有可选的追加。
	FileHandler(String pattern, int limit, int count)	初始化 FileHandler 以写入一组文件。
	FileHandler(String pattern, int limit, int count, boolean append)	初始化 FileHandler 以写入一组带有可选追加的文件。
	FileHandler(String pattern, long limit, int count, boolean append)	初始化 FileHandler 以写入一组带有可选追加的文件。
	SocketHandler()	创建一个 SocketHandler ，仅使用 LogManager 属性（或其默认值）。
	SocketHandler(String host, int port)	使用指定的主机和端口构造一个 SocketHandler。

IOException 在 java.util.prefs 中的用法

在 java.util.prefs 中抛出 IOException

修饰符和类型	方法	描述
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 文档表示的所有首选项。

IOException 在 java.util.zip 中的用法

java.util.zip 中 IOException 的子类

修饰符和类型	类	描述
class	ZipException	表示发生某种 Zip 异常的信号。

在 java.util.zip 中抛出 IOException

修饰符和类型	方法	描述
int	DeflaterInputStream.available()	到达 EOF 后返回 0，否则始终返回 1。
int	InflaterInputStream.available()	到达 EOF 后返回 0，否则始终返回 1。
int	ZipInputStream.available()	当检测到当前 ZIP 条目的流结尾或 ZipInputStream.closeEntry() 已在当前 ZIP 条目上调用时返回 0，否则返回 1。
void	DeflaterInputStream.close()	关闭此输入流及其基础输入流，丢弃任何未决的未压缩数据。
void	DeflaterOutputStream.close()	将剩余的压缩数据写入输出流并关闭基础流。
void	GZIPInputStream.close()	关闭此输入流并释放与该流关联的所有系统资源。
void	InflaterInputStream.close()	关闭此输入流并释放与该流关联的所有系统资源。
void	InflaterOutputStream.close()	将任何剩余的未压缩数据写入输出流并关闭底层输出流。
void	ZipFile.close()	关闭 ZIP 文件。
void	ZipInputStream.close()	关闭此输入流并释放与该流关联的所有系统资源。
void	ZipOutputStream.close()	关闭 ZIP 输出流以及被过滤的流。
void	ZipInputStream.closeEntry()	关闭当前 ZIP 条目并定位流以读取下一个条目。
void	ZipOutputStream.closeEntry()	关闭当前 ZIP 条目并定位流以写入下一个条目。
protected void	DeflaterOutputStream.deflate()	将下一个压缩数据块写入输出流。
protected void	InflaterInputStream.fill()	用更多数据填充输入缓冲区以解压缩。
void	DeflaterOutputStream.finish()	在不关闭基础流的情况下完成将压缩数据写入输出流。
void	GZIPOutputStream.finish()	在不关闭基础流的情况下完成将压缩数据写入输出流。
void	InflaterOutputStream.finish()	在不关闭基础流的情况下完成将未压缩的数据写入输出流。
void	ZipOutputStream.finish()	在不关闭基础流的情况下完成写入 ZIP 输出流的内容。
void	DeflaterOutputStream.flush()	刷新压缩输出流。
void	InflaterOutputStream.flush()	刷新此输出流，强制写入任何待处理的缓冲输出字节。
InputStream	ZipFile.getInputStream(ZipEntry entry)	返回用于读取指定 zip 文件条目内容的输入流。
ZipEntry	ZipInputStream.getNextEntry()	读取下一个 ZIP 文件条目并将流定位在条目数据的开头。
void	ZipOutputStream.putNextEntry(ZipEntry e)	开始写入新的 ZIP 文件条目并将流定位到条目数据的开头。
int	CheckedInputStream.read()	读取一个字节。
int	CheckedInputStream.read(byte[] buf, int off, int len)	读入字节数组。
int	DeflaterInputStream.read()	从输入流中读取单个字节的压缩数据。
int	DeflaterInputStream.read(byte[] b, int off, int len)	将压缩数据读入字节数组。
int	GZIPInputStream.read(byte[] buf, int off, int len)	将未压缩的数据读入字节数组，返回膨胀的字节数。
int	InflaterInputStream.read()	读取一个字节的未压缩数据。
int	InflaterInputStream.read(byte[] b, int off, int len)	将未压缩的数据读入字节数组，返回膨胀的字节数。
int	ZipInputStream.read()	从当前 ZIP 条目的输入流中读取下一个数据字节。
int	ZipInputStream.read(byte[] b, int off, int len)	从输入流中将请求的字节数读取到当前 ZIP 条目的给定字节数组中，返回膨胀的字节数。
byte[]	ZipInputStream.readAllBytes()	从当前 ZIP 条目的输入流中读取所有剩余字节。
int	ZipInputStream.readNBytes(byte[] b, int off, int len)	从输入流中将请求的字节数读取到当前 ZIP 条目的给定字节数组中，返回膨胀的字节数。
byte[]	ZipInputStream.readNBytes(int len)	从当前 ZIP 条目的输入流中读取指定数量的字节。
void	DeflaterInputStream.reset()	不支持此操作.
void	InflaterInputStream.reset()	将此流重新定位到上次对此输入流调用 mark 方法时的位置。
long	CheckedInputStream.skip(long n)	跳过指定数量的输入字节。
long	DeflaterInputStream.skip(long n)	跳过并丢弃输入流中的数据。
long	InflaterInputStream.skip(long n)	跳过指定字节数的未压缩数据。
long	ZipInputStream.skip(long n)	对于当前 ZIP 条目，跳过并丢弃此输入流中的 n 字节数据。
void	ZipInputStream.skipNBytes(long n)	跳过并丢弃来自当前 ZIP 条目的输入流中的 n 字节数据。
long	ZipInputStream.transferTo(OutputStream out)	从此输入流中读取当前 ZIP 条目的所有字节，并按照读取顺序将字节写入给定的输出流。
void	CheckedOutputStream.write(byte[] b, int off, int len)	写入一个字节数组。
void	CheckedOutputStream.write(int b)	写入一个字节。
void	DeflaterOutputStream.write(byte[] b, int off, int len)	将字节数组写入压缩输出流。
void	DeflaterOutputStream.write(int b)	将一个字节写入压缩输出流。
void	GZIPOutputStream.write(byte[] buf, int off, int len)	将字节数组写入压缩输出流。
void	InflaterOutputStream.write(byte[] b, int off, int len)	将字节数组写入未压缩的输出流。
void	InflaterOutputStream.write(int b)	将一个字节写入未压缩的输出流。
void	ZipOutputStream.write(byte[] b, int off, int len)	将字节数组写入当前 ZIP 条目数据。

java.util.zip 中的构造函数抛出 IOException

修饰符	构造方法	描述
	GZIPInputStream(InputStream in)	创建具有默认缓冲区大小的新输入流。
	GZIPInputStream(InputStream in, int size)	创建具有指定缓冲区大小的新输入流。
	GZIPOutputStream(OutputStream out)	创建具有默认缓冲区大小的新输出流。
	GZIPOutputStream(OutputStream out, boolean syncFlush)	创建具有默认缓冲区大小和指定刷新模式的新输出流。
	GZIPOutputStream(OutputStream out, int size)	创建具有指定缓冲区大小的新输出流。
	GZIPOutputStream(OutputStream out, int size, boolean syncFlush)	创建具有指定缓冲区大小和刷新模式的新输出流。
	ZipFile(File file)	给定指定的 File 对象，打开 ZIP 文件进行读取。
	ZipFile(File file, int mode)	打开一个新的 ZipFile 以指定模式从指定的 File 对象读取。
	ZipFile(File file, int mode, Charset charset)	打开一个新的 ZipFile 以指定模式从指定的 File 对象读取。
	ZipFile(File file, Charset charset)	给定指定的 File 对象，打开 ZIP 文件进行读取。
	ZipFile(String name)	打开一个 zip 文件进行阅读。
	ZipFile(String name, Charset charset)	打开一个 zip 文件进行阅读。

IOException 在 javax.annotation.processing 中的用法

javax.annotation.processing 中 IOException 的子类

修饰符和类型	类	描述
class	FilerException	表示 Filer 检测到打开文件的尝试会违反 Filer 提供的保证。

在 javax.annotation.processing 中抛出 IOException

修饰符和类型	方法	描述
JavaFileObject	Filer.createClassFile(CharSequence name, Element... originatingElements)	创建一个新的类文件，并返回一个对象以允许写入它。
FileObject	Filer.createResource(JavaFileManager.Location location, CharSequence moduleAndPkg, CharSequence relativeName, Element... originatingElements)	创建一个新的用于写入的辅助资源文件并为其返回一个文件对象。
JavaFileObject	Filer.createSourceFile(CharSequence name, Element... originatingElements)	创建一个新的源文件并返回一个对象以允许写入它。
FileObject	Filer.getResource(JavaFileManager.Location location, CharSequence moduleAndPkg, CharSequence relativeName)	返回用于读取现有资源的对象。

IOException 在 javax.crypto 中的用法

在 javax.crypto 中抛出 IOException

修饰符和类型	方法	描述
int	CipherInputStream.available()	返回可以从该输入流中无阻塞地读取的字节数。
void	CipherInputStream.close()	关闭此输入流并释放与该流关联的所有系统资源。
void	CipherOutputStream.close()	关闭此输出流并释放与此流关联的任何系统资源。
void	CipherOutputStream.flush()	通过强制写出封装的 Cipher 对象已处理的任何缓冲输出字节来刷新此输出流。
byte[]	EncryptedPrivateKeyInfo.getEncoded()	返回此对象的 ASN.1 编码。
final Object	SealedObject.getObject(Key key)	检索原始（封装的）对象。
final Object	SealedObject.getObject(Key key, String provider)	检索原始（封装的）对象。
final Object	SealedObject.getObject(Cipher c)	检索原始（封装的）对象。
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)	将指定字节写入此输出流。

javax.crypto 中的构造函数抛出 IOException

修饰符	构造方法	描述
	EncryptedPrivateKeyInfo(byte[] encoded)	从其 ASN.1 编码构造（即解析）EncryptedPrivateKeyInfo。
	SealedObject(Serializable object, Cipher c)	从任何 Serializable 对象构造一个 SealedObject。

IOException 在 javax.imageio 中的用法

javax.imageio 中 IOException 的子类

修饰符和类型	类	描述
class	IIOException	用于指示读取和写入操作的运行时失败的异常类。

在 javax.imageio 中抛出 IOException

修饰符和类型	方法	描述
boolean	ImageWriter.canInsertEmpty(int imageIndex)	如果编写器支持在给定索引处插入新的空图像，则返回 true。
boolean	ImageWriter.canInsertImage(int imageIndex)	如果编写器支持在给定索引处插入新图像，则返回 true。
boolean	ImageWriter.canRemoveImage(int imageIndex)	如果编写器支持删除给定索引处的现有图像，则返回 true。
boolean	ImageWriter.canReplaceImageMetadata(int imageIndex)	如果可以用索引 imageIndex 替换与现有图像关联的图像元数据，则返回 true 。
boolean	ImageWriter.canReplacePixels(int imageIndex)	如果作者允许使用 replacePixels 方法替换给定图像的像素，则返回 true。
boolean	ImageWriter.canReplaceStreamMetadata()	如果可以替换输出中已存在的流元数据，则返回 true。
boolean	ImageWriter.canWriteEmpty()	如果编写器支持将包含具有未定义像素值的单个图像以及关联的元数据和缩略图的完整图像流写入到输出，则返回 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 对象，如果读取器不支持读取元数据、设置为忽略元数据或没有可用元数据，则返回 null。
IIOMetadata	ImageReader.getImageMetadata(int imageIndex, String formatName, Set<String> nodeNames)	返回一个 IIOMetadata 对象，表示与给定图像关联的元数据，或者 null 如果读取器不支持读取元数据或没有可用的元数据。
abstract Iterator<ImageTypeSpecifier>	ImageReader.getImageTypes(int imageIndex)	以 ImageTypeSpecifiers s 的形式返回一个 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 对象，表示与整个输入源相关联的元数据（即，不与任何特定图像相关联），或者 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)	返回给定图像中图块 (0, 0) 左上角的 X 坐标。
int	ImageReader.getTileGridYOffset(int imageIndex)	返回给定图像中图块 (0, 0) 左上角的 Y 坐标。
int	ImageReader.getTileHeight(int imageIndex)	返回给定图像中图块的高度。
int	ImageReader.getTileWidth(int imageIndex)	返回给定图像中图块的宽度。
abstract int	ImageReader.getWidth(int imageIndex)	返回输入源中给定图像的宽度（以像素为单位）。
boolean	ImageReader.hasThumbnails(int imageIndex)	如果给定图像具有与其关联的缩略图预览图像，则返回 true。
boolean	ImageReader.isImageTiled(int imageIndex)	如果图像被组织成，则返回 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)	准备编写器以处理对 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 作为解码提供的 File 与一个 ImageReader 从当前注册中自动选择的结果。
static BufferedImage	ImageIO.read(InputStream input)	返回一个 BufferedImage 作为解码提供的 InputStream 与一个 ImageReader 从当前注册的自动选择的结果。
static BufferedImage	ImageIO.read(URL input)	返回一个 BufferedImage 作为解码提供的 URL 与一个 ImageReader 从当前注册中自动选择的结果。
static BufferedImage	ImageIO.read(ImageInputStream stream)	返回一个 BufferedImage 作为解码提供的 ImageInputStream 与一个 ImageReader 从当前注册的自动选择的结果。
BufferedImage	ImageReader.read(int imageIndex)	读取由 imageIndex 索引的图像并将其作为完整的 BufferedImage 返回，使用默认值 ImageReadParam 。
abstract BufferedImage	ImageReader.read(int imageIndex, ImageReadParam param)	使用提供的 ImageReadParam 读取由 imageIndex 索引的图像并将其作为完整的 BufferedImage 返回。
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)	返回由 thumbnailIndex 索引的缩略图预览图像，与 ImageIndex 索引的图像关联为 BufferedImage。
BufferedImage	ImageReader.readTile(int imageIndex, int tileX, int tileY)	读取 tileX 和 tileY 参数指示的图块，将其作为 BufferedImage 返回。
Raster	ImageReader.readTileRaster(int imageIndex, int tileX, int tileY)	返回一个新的 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)	用新信息替换输出中的流元数据。
static boolean	ImageIO.write(RenderedImage im, String formatName, File output)	使用支持给定格式的任意 ImageWriter 将图像写入 File 。
static boolean	ImageIO.write(RenderedImage im, String formatName, OutputStream output)	使用支持给定格式的任意 ImageWriter 将图像写入 OutputStream 。
static boolean	ImageIO.write(RenderedImage im, String formatName, ImageOutputStream output)	使用支持给定格式的任意 ImageWriter 将图像写入 ImageOutputStream 。
void	ImageWriter.write(RenderedImage image)	将由具有默认元数据和缩略图的单个图像组成的完整图像流附加到输出。
void	ImageWriter.write(IIOImage image)	将包含具有默认元数据和缩略图的单个图像的完整图像流附加到输出。
abstract void	ImageWriter.write(IIOMetadata streamMetadata, IIOImage image, ImageWriteParam param)	将包含单个图像和关联流以及图像元数据和缩略图的完整图像流附加到输出。
void	ImageWriter.writeInsert(int imageIndex, IIOImage image, ImageWriteParam param)	将新图像插入现有图像流。
void	ImageWriter.writeToSequence(IIOImage image, ImageWriteParam param)	将单个图像和可能关联的元数据和缩略图附加到输出。

IOException 在 javax.imageio.metadata 中的用法

javax.imageio.metadata 中 IOException 的子类

修饰符和类型	类	描述
class	IIOInvalidTreeException	当 IIOMetadata 对象尝试解析 IIOMetadataNode 的树失败时，将抛出 IIOInvalidTreeException。

IOException 在 javax.imageio.spi 中的用法

在 javax.imageio.spi 中抛出 IOException

修饰符和类型	方法	描述
abstract boolean	ImageReaderSpi.canDecodeInput(Object source)	如果提供的源对象似乎是此阅读器支持的格式，则返回 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 实现的实例。

IOException 在 javax.imageio.stream 中的用法

在 javax.imageio.stream 中抛出 IOException

修饰符和类型	方法	描述
protected final void	ImageInputStreamImpl.checkClosed()	如果流已关闭，则抛出 IOException。
void	FileCacheImageInputStream.close()	关闭此 FileCacheImageInputStream ，关闭并删除缓存文件。
void	FileCacheImageOutputStream.close()	关闭此 FileCacheImageOutputStream 。
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	MemoryCacheImageOutputStream.flushBefore(long pos)
protected final void	ImageOutputStreamImpl.flushBits()	如果位偏移量不为零，则强制当前字节中的剩余位为 0 并将流位置前进一位。
int	ImageInputStream.getBitOffset()	返回当前位偏移量，作为 0 到 7 之间的整数，包括 0 和 7。
int	ImageInputStreamImpl.getBitOffset()
long	ImageInputStream.getStreamPosition()	返回流的当前字节位置。
long	ImageInputStreamImpl.getStreamPosition()
long	ImageInputStream.length()	返回流的总长度（如果已知）。
int	FileCacheImageInputStream.read()
int	FileCacheImageInputStream.read(byte[] b, int off, int len)
int	FileCacheImageOutputStream.read()
int	FileCacheImageOutputStream.read(byte[] b, int off, int len)
int	FileImageInputStream.read()
int	FileImageInputStream.read(byte[] b, int off, int len)
int	FileImageOutputStream.read()
int	FileImageOutputStream.read(byte[] b, int off, int len)
int	ImageInputStream.read()	从流中读取单个字节并将其作为 0 到 255 之间的整数返回。
int	ImageInputStream.read(byte[] b)	从流中读取最多 b.length 个字节，并将它们存储到从索引 0 开始的 b 中。
int	ImageInputStream.read(byte[] b, int off, int len)	从流中读取最多 len 个字节，并将它们存储到从索引 off 开始的 b 中。
abstract int	ImageInputStreamImpl.read()	从流中读取单个字节并将其作为 0 到 255 之间的 int 返回。
int	ImageInputStreamImpl.read(byte[] b)	调用 read(b, 0, b.length) 的便捷方法。
abstract int	ImageInputStreamImpl.read(byte[] b, int off, int len)	从流中读取最多 len 个字节，并将它们存储到从索引 off 开始的 b 中。
int	MemoryCacheImageInputStream.read()
int	MemoryCacheImageInputStream.read(byte[] b, int off, int len)
int	MemoryCacheImageOutputStream.read()
int	MemoryCacheImageOutputStream.read(byte[] b, int off, int len)
int	ImageInputStream.readBit()	从流中读取单个位并将其作为 int 返回，其值为 0 或 1 。
int	ImageInputStreamImpl.readBit()
long	ImageInputStream.readBits(int numBits)	从流中读取一个位串并将其作为 long 返回，读取的第一位成为输出的最高有效位。
long	ImageInputStreamImpl.readBits(int numBits)
boolean	ImageInputStream.readBoolean()	从流中读取一个字节并返回 boolean 值 true 如果它是非零，则返回 false 如果它是零。
boolean	ImageInputStreamImpl.readBoolean()
byte	ImageInputStream.readByte()	从流中读取一个字节并将其作为 byte 值返回。
byte	ImageInputStreamImpl.readByte()
void	ImageInputStream.readBytes(IIOByteBuffer buf, int len)	从流中读取最多 len 个字节，并修改提供的 IIOByteBuffer 以指示可以找到数据的字节数组、偏移量和长度。
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 个字节，并将它们存储到从索引 0 开始的 b 中。
void	ImageInputStream.readFully(byte[] b, int off, int len)	从流中读取 len 个字节，并将它们存储到从索引 off 开始的 b 中。
void	ImageInputStream.readFully(char[] c, int off, int len)	根据当前字节顺序从流中读取 len 个字符（无符号 16 位整数），并将它们存储到从索引 off 开始的 c 中。
void	ImageInputStream.readFully(double[] d, int off, int len)	根据当前字节顺序从流中读取 len 双精度数（64 位 IEEE 双精度浮点数），并将它们存储到从索引 off 开始的 d 中。
void	ImageInputStream.readFully(float[] f, int off, int len)	根据当前字节顺序从流中读取 len 浮点数（32 位 IEEE 单精度浮点数），并将它们存储到从索引 off 开始的 f 中。
void	ImageInputStream.readFully(int[] i, int off, int len)	根据当前字节顺序从流中读取 len 整数（带符号的 32 位整数），并将它们存储到从索引 off 开始的 i 中。
void	ImageInputStream.readFully(long[] l, int off, int len)	根据当前字节顺序从流中读取 len longs（带符号的 64 位整数），并将它们存储到 l 从索引 off 开始。
void	ImageInputStream.readFully(short[] s, int off, int len)	根据当前字节顺序从流中读取 len 短裤（带符号的 16 位整数），并将它们存储到从索引 off 开始的 s 中。
void	ImageInputStreamImpl.readFully(byte[] b)
void	ImageInputStreamImpl.readFully(byte[] b, int off, int len)
void	ImageInputStreamImpl.readFully(char[] c, int off, int len)
void	ImageInputStreamImpl.readFully(double[] d, int off, int len)
void	ImageInputStreamImpl.readFully(float[] f, int off, int len)
void	ImageInputStreamImpl.readFully(int[] i, int off, int len)
void	ImageInputStreamImpl.readFully(long[] l, int off, int len)
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	FileImageOutputStream.seek(long pos)	设置当前流位置并将位偏移重置为 0。
void	ImageInputStream.seek(long pos)	将当前流位置设置为所需位置。
void	ImageInputStreamImpl.seek(long pos)
void	ImageInputStream.setBitOffset(int bitOffset)	将位偏移量设置为介于 0 和 7 之间的整数，包括 0 和 7。
void	ImageInputStreamImpl.setBitOffset(int bitOffset)
int	ImageInputStream.skipBytes(int n)	将流位置向前移动给定的字节数。
long	ImageInputStream.skipBytes(long n)	将流位置向前移动给定的字节数。
int	ImageInputStreamImpl.skipBytes(int n)	通过调用 seek(getStreamPosition() + n) 前进当前流位置。
long	ImageInputStreamImpl.skipBytes(long n)	通过调用 seek(getStreamPosition() + n) 前进当前流位置。
void	FileCacheImageOutputStream.write(byte[] b, int off, int len)
void	FileCacheImageOutputStream.write(int b)
void	FileImageOutputStream.write(byte[] b, int off, int len)
void	FileImageOutputStream.write(int b)
void	ImageOutputStream.write(byte[] b)	在当前位置将字节序列写入流。
void	ImageOutputStream.write(byte[] b, int off, int len)	在当前位置将字节序列写入流。
void	ImageOutputStream.write(int b)	在当前位置将单个字节写入流。
void	ImageOutputStreamImpl.write(byte[] b)
void	MemoryCacheImageOutputStream.write(byte[] b, int off, int len)
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)	在当前位置将一系列字符写入流。
void	ImageOutputStream.writeChars(String s)	将字符串写入输出流。
void	ImageOutputStreamImpl.writeChars(char[] c, int off, int len)
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)	在当前位置将一系列双精度值写入流。
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)	在当前位置将一系列浮点数写入流。
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)	在当前位置将一系列短裤写入流。
void	ImageOutputStreamImpl.writeShorts(short[] s, int off, int len)
void	ImageOutputStream.writeUTF(String s)	以网络字节顺序将两个字节的长度信息写入输出流，后跟字符串 s 中每个字符的 修改后的 UTF-8 表示。
void	ImageOutputStreamImpl.writeUTF(String s)

javax.imageio.stream 中的构造函数抛出 IOException

修饰符	构造方法	描述
	FileCacheImageInputStream(InputStream stream, File cacheDir)	构造一个将从给定的 InputStream 读取的 FileCacheImageInputStream。
	FileCacheImageOutputStream(OutputStream stream, File cacheDir)	构造将写入给定 outputStream 的 FileCacheImageOutputStream。
	FileImageInputStream(File f)	构造一个将从给定的 File 读取的 FileImageInputStream。
	FileImageOutputStream(File f)	构造一个将写入给定 File 的 FileImageOutputStream。

IOException 在 javax.management 中的用法

在 javax.management 中抛出 IOException

修饰符和类型	方法	描述
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。

IOException 在 javax.management.loading 中的用法

在 javax.management.loading 中抛出 IOException

修饰符和类型	方法	描述
Enumeration<URL>	MLetMBean.getResources(String name)	已弃用，将被删除：此 API 元素可能会在未来版本中删除。 查找具有给定名称的所有资源。
void	MLet.readExternal(ObjectInput in)	已弃用，将被删除：此 API 元素可能会在未来版本中删除。 从给定的 ObjectInput 恢复这个 MLet 的内容。
void	MLet.writeExternal(ObjectOutput out)	已弃用，将被删除：此 API 元素可能会在未来版本中删除。 将此 MLet 的内容保存到给定的 ObjectOutput 中。

IOException 在 javax.management.remote 中的用法

javax.management.remote 中 IOException 的子类

修饰符和类型	类	描述
class	JMXProviderException	当所需协议存在提供程序但由于某种原因无法使用时，JMXConnectorFactory 和 JMXConnectorServerFactory 抛出异常。
class	JMXServerErrorException	当在远程 MBean 服务中处理调用时抛出 Error 时，作为远程 MBeanServer 方法调用的结果抛出异常。

在 javax.management.remote 中抛出 IOException

修饰符和类型	方法	描述
void	JMXConnector.close()	关闭客户端与其服务的连接。
void	JMXConnector.connect()	建立与连接器服务的连接。
void	JMXConnector.connect(Map<String,?> env)	建立与连接器服务的连接。
static JMXConnector	JMXConnectorFactory.connect(JMXServiceURL serviceURL)	在给定地址创建到连接器服务的连接。
static JMXConnector	JMXConnectorFactory.connect(JMXServiceURL serviceURL, Map<String,?> environment)	在给定地址创建到连接器服务的连接。
String	JMXConnector.getConnectionId()	从连接器服务获取此连接的 ID。
MBeanServerConnection	JMXConnector.getMBeanServerConnection()	返回代表远程 MBean 服务的 MBeanServerConnection 对象。
MBeanServerConnection	JMXConnector.getMBeanServerConnection(Subject delegationSubject)	返回代表远程 MBean 服务的 MBeanServerConnection 对象，代表提供的委托主题在该服务上执行操作。
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)	返回此连接器服务的客户端存根。
JMXConnector	JMXConnectorServerMBean.toJMXConnector(Map<String,?> env)	返回此连接器服务的客户端存根。

IOException 在 javax.management.remote.rmi 中的用法

在 javax.management.remote.rmi 中抛出 IOException

修饰符和类型	方法	描述
void	RMIConnection.addNotificationListener(ObjectName name, ObjectName listener, MarshalledObject filter, MarshalledObject handback, Subject delegationSubject)	处理 MBeanServerConnection.addNotificationListener(ObjectName, ObjectName, NotificationFilter, Object) 方法
void	RMIConnectionImpl_Stub.addNotificationListener(ObjectName $param_ObjectName_1, ObjectName $param_ObjectName_2, MarshalledObject $param_MarshalledObject_3, MarshalledObject $param_MarshalledObject_4, Subject $param_Subject_5)
void	RMIConnectionImpl.addNotificationListener(ObjectName name, ObjectName listener, MarshalledObject filter, MarshalledObject handback, Subject delegationSubject)
Integer[]	RMIConnection.addNotificationListeners(ObjectName[] names, MarshalledObject[] filters, Subject[] delegationSubjects)	处理 MBeanServerConnection.addNotificationListener(ObjectName, NotificationListener, NotificationFilter, Object) 方法
Integer[]	RMIConnectionImpl_Stub.addNotificationListeners(ObjectName[] $param_arrayOf_ObjectName_1, MarshalledObject[] $param_arrayOf_MarshalledObject_2, Subject[] $param_arrayOf_Subject_3)
Integer[]	RMIConnectionImpl.addNotificationListeners(ObjectName[] names, MarshalledObject[] filters, Subject[] delegationSubjects)
protected void	RMIServerImpl.clientClosed(RMIConnection client)	makeClient 创建的客户端连接关闭时调用的方法。
void	RMIConnection.close()	关闭此连接。
void	RMIConnectionImpl_Stub.close()
void	RMIConnectionImpl.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()	已弃用。
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	RMIConnection.createMBean(String className, ObjectName name, ObjectName loaderName, MarshalledObject params, String[] signature, Subject delegationSubject)	处理 MBeanServerConnection.createMBean(String, ObjectName, ObjectName, Object[], String[]) 方法
ObjectInstance	RMIConnection.createMBean(String className, ObjectName name, ObjectName loaderName, Subject delegationSubject)	处理 MBeanServerConnection.createMBean(String, ObjectName, ObjectName) 方法
ObjectInstance	RMIConnection.createMBean(String className, ObjectName name, Subject delegationSubject)	处理 MBeanServerConnection.createMBean(String, ObjectName) 方法
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	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	RMIConnectionImpl_Stub.createMBean(String $param_String_1, ObjectName $param_ObjectName_2, ObjectName $param_ObjectName_3, Subject $param_Subject_4)
ObjectInstance	RMIConnectionImpl_Stub.createMBean(String $param_String_1, ObjectName $param_ObjectName_2, Subject $param_Subject_3)
ObjectInstance	RMIConnectionImpl.createMBean(String className, ObjectName name, MarshalledObject params, String[] signature, Subject delegationSubject)
ObjectInstance	RMIConnectionImpl.createMBean(String className, ObjectName name, ObjectName loaderName, MarshalledObject params, String[] signature, Subject delegationSubject)
ObjectInstance	RMIConnectionImpl.createMBean(String className, ObjectName name, ObjectName loaderName, Subject delegationSubject)
ObjectInstance	RMIConnectionImpl.createMBean(String className, ObjectName name, Subject delegationSubject)
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_Stub.fetchNotifications(long $param_long_1, int $param_int_2, long $param_long_3)
NotificationResult	RMIConnectionImpl.fetchNotifications(long clientSequenceNumber, int maxNotifications, long timeout)
Object	RMIConnection.getAttribute(ObjectName name, String attribute, Subject delegationSubject)	处理 MBeanServerConnection.getAttribute(ObjectName, String) 方法
Object	RMIConnectionImpl_Stub.getAttribute(ObjectName $param_ObjectName_1, String $param_String_2, Subject $param_Subject_3)
Object	RMIConnectionImpl.getAttribute(ObjectName name, String attribute, Subject delegationSubject)
AttributeList	RMIConnection.getAttributes(ObjectName name, String[] attributes, Subject delegationSubject)	处理 MBeanServerConnection.getAttributes(ObjectName, String[]) 方法
AttributeList	RMIConnectionImpl_Stub.getAttributes(ObjectName $param_ObjectName_1, String[] $param_arrayOf_String_2, Subject $param_Subject_3)
AttributeList	RMIConnectionImpl.getAttributes(ObjectName name, String[] attributes, Subject delegationSubject)
String	RMIConnection.getConnectionId()	返回连接 ID。
String	RMIConnectionImpl_Stub.getConnectionId()
String	RMIConnectionImpl.getConnectionId()
String	RMIConnector.getConnectionId()
String	RMIConnection.getDefaultDomain(Subject delegationSubject)	处理 MBeanServerConnection.getDefaultDomain() 方法
String	RMIConnectionImpl_Stub.getDefaultDomain(Subject $param_Subject_1)
String	RMIConnectionImpl.getDefaultDomain(Subject delegationSubject)
String[]	RMIConnection.getDomains(Subject delegationSubject)	处理 MBeanServerConnection.getDomains() 方法
String[]	RMIConnectionImpl_Stub.getDomains(Subject $param_Subject_1)
String[]	RMIConnectionImpl.getDomains(Subject delegationSubject)
Integer	RMIConnection.getMBeanCount(Subject delegationSubject)	处理 MBeanServerConnection.getMBeanCount() 方法
Integer	RMIConnectionImpl_Stub.getMBeanCount(Subject $param_Subject_1)
Integer	RMIConnectionImpl.getMBeanCount(Subject delegationSubject)
MBeanInfo	RMIConnection.getMBeanInfo(ObjectName name, Subject delegationSubject)	处理 MBeanServerConnection.getMBeanInfo(ObjectName) 方法
MBeanInfo	RMIConnectionImpl_Stub.getMBeanInfo(ObjectName $param_ObjectName_1, Subject $param_Subject_2)
MBeanInfo	RMIConnectionImpl.getMBeanInfo(ObjectName name, Subject delegationSubject)
MBeanServerConnection	RMIConnector.getMBeanServerConnection()
MBeanServerConnection	RMIConnector.getMBeanServerConnection(Subject delegationSubject)
ObjectInstance	RMIConnection.getObjectInstance(ObjectName name, Subject delegationSubject)	处理 MBeanServerConnection.getObjectInstance(ObjectName) 方法
ObjectInstance	RMIConnectionImpl_Stub.getObjectInstance(ObjectName $param_ObjectName_1, Subject $param_Subject_2)
ObjectInstance	RMIConnectionImpl.getObjectInstance(ObjectName name, Subject delegationSubject)
Object	RMIConnection.invoke(ObjectName name, String operationName, MarshalledObject params, String[] signature, Subject delegationSubject)	处理 MBeanServerConnection.invoke(ObjectName, String, Object[], String[]) 方法
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)
Object	RMIConnectionImpl.invoke(ObjectName name, String operationName, MarshalledObject params, String[] signature, Subject delegationSubject)
boolean	RMIConnection.isInstanceOf(ObjectName name, String className, Subject delegationSubject)	处理 MBeanServerConnection.isInstanceOf(ObjectName, String) 方法
boolean	RMIConnectionImpl_Stub.isInstanceOf(ObjectName $param_ObjectName_1, String $param_String_2, Subject $param_Subject_3)
boolean	RMIConnectionImpl.isInstanceOf(ObjectName name, String className, Subject delegationSubject)
boolean	RMIConnection.isRegistered(ObjectName name, Subject delegationSubject)	处理 MBeanServerConnection.isRegistered(ObjectName) 方法
boolean	RMIConnectionImpl_Stub.isRegistered(ObjectName $param_ObjectName_1, Subject $param_Subject_2)
boolean	RMIConnectionImpl.isRegistered(ObjectName name, Subject delegationSubject)
protected RMIConnection	RMIIIOPServerImpl.makeClient(String connectionId, Subject subject)	已弃用。
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_Stub.newClient(Object $param_Object_1)
RMIConnection	RMIServerImpl.newClient(Object credentials)	创建新的客户端连接。
Set<ObjectInstance>	RMIConnection.queryMBeans(ObjectName name, MarshalledObject query, Subject delegationSubject)	处理 MBeanServerConnection.queryMBeans(ObjectName, QueryExp) 方法
Set	RMIConnectionImpl_Stub.queryMBeans(ObjectName $param_ObjectName_1, MarshalledObject $param_MarshalledObject_2, Subject $param_Subject_3)
Set<ObjectInstance>	RMIConnectionImpl.queryMBeans(ObjectName name, MarshalledObject query, Subject delegationSubject)
Set<ObjectName>	RMIConnection.queryNames(ObjectName name, MarshalledObject query, Subject delegationSubject)	处理 MBeanServerConnection.queryNames(ObjectName, QueryExp) 方法
Set	RMIConnectionImpl_Stub.queryNames(ObjectName $param_ObjectName_1, MarshalledObject $param_MarshalledObject_2, Subject $param_Subject_3)
Set<ObjectName>	RMIConnectionImpl.queryNames(ObjectName name, MarshalledObject query, Subject delegationSubject)
void	RMIConnection.removeNotificationListener(ObjectName name, ObjectName listener, MarshalledObject filter, MarshalledObject handback, Subject delegationSubject)	处理 MBeanServerConnection.removeNotificationListener(ObjectName, ObjectName, NotificationFilter, Object) 方法
void	RMIConnection.removeNotificationListener(ObjectName name, ObjectName listener, Subject delegationSubject)	处理 MBeanServerConnection.removeNotificationListener(ObjectName, ObjectName) 方法
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	RMIConnectionImpl_Stub.removeNotificationListener(ObjectName $param_ObjectName_1, ObjectName $param_ObjectName_2, Subject $param_Subject_3)
void	RMIConnectionImpl.removeNotificationListener(ObjectName name, ObjectName listener, MarshalledObject filter, MarshalledObject handback, Subject delegationSubject)
void	RMIConnectionImpl.removeNotificationListener(ObjectName name, ObjectName listener, Subject delegationSubject)
void	RMIConnection.removeNotificationListeners(ObjectName name, Integer[] listenerIDs, Subject delegationSubject)	处理 removeNotificationListener(ObjectName, NotificationListener) 和 removeNotificationListener(ObjectName, NotificationListener, NotificationFilter, Object) 方法。
void	RMIConnectionImpl_Stub.removeNotificationListeners(ObjectName $param_ObjectName_1, Integer[] $param_arrayOf_Integer_2, Subject $param_Subject_3)
void	RMIConnectionImpl.removeNotificationListeners(ObjectName name, Integer[] listenerIDs, Subject delegationSubject)
void	RMIConnection.setAttribute(ObjectName name, MarshalledObject attribute, Subject delegationSubject)	处理 MBeanServerConnection.setAttribute(ObjectName, Attribute) 方法
void	RMIConnectionImpl_Stub.setAttribute(ObjectName $param_ObjectName_1, MarshalledObject $param_MarshalledObject_2, Subject $param_Subject_3)
void	RMIConnectionImpl.setAttribute(ObjectName name, MarshalledObject attribute, Subject delegationSubject)
AttributeList	RMIConnection.setAttributes(ObjectName name, MarshalledObject attributes, Subject delegationSubject)	处理 MBeanServerConnection.setAttributes(ObjectName, AttributeList) 方法
AttributeList	RMIConnectionImpl_Stub.setAttributes(ObjectName $param_ObjectName_1, MarshalledObject $param_MarshalledObject_2, Subject $param_Subject_3)
AttributeList	RMIConnectionImpl.setAttributes(ObjectName name, MarshalledObject attributes, Subject delegationSubject)
void	RMIConnectorServer.start()	激活连接器服务，即开始监听客户端连接。
void	RMIConnectorServer.stop()	停用连接器服务，即停止监听客户端连接。
JMXConnector	RMIConnectorServer.toJMXConnector(Map<String,?> env)	返回此连接器服务的客户端存根。
Remote	RMIIIOPServerImpl.toStub()	已弃用。
Remote	RMIJRMPServerImpl.toStub()	返回此 RMIServer 对象的可序列化存根。
abstract Remote	RMIServerImpl.toStub()	返回此服务对象的远程存根。
void	RMIConnection.unregisterMBean(ObjectName name, Subject delegationSubject)	处理 MBeanServerConnection.unregisterMBean(ObjectName) 方法
void	RMIConnectionImpl_Stub.unregisterMBean(ObjectName $param_ObjectName_1, Subject $param_Subject_2)
void	RMIConnectionImpl.unregisterMBean(ObjectName name, Subject delegationSubject)

javax.management.remote.rmi 中的构造函数抛出 IOException

修饰符	构造方法	描述
	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)	已弃用。 抛出 UnsupportedOperationException
	RMIJRMPServerImpl(int port, RMIClientSocketFactory csf, RMIServerSocketFactory ssf, Map<String,?> env)	创建一个新的 RMIServer 对象，该对象将使用给定的套接字工厂在给定的端口上导出。

IOException 在 javax.naming.ldap 中的用法

在 javax.naming.ldap 中抛出 IOException

修饰符和类型	方法	描述
abstract void	StartTlsResponse.close()	优雅地关闭 TLS 连接并恢复到基础连接。
abstract SSLSession	StartTlsResponse.negotiate()	使用默认的 SSL 套接字工厂协商 TLS 会话。
abstract SSLSession	StartTlsResponse.negotiate(SSLSocketFactory factory)	使用 SSL 套接字工厂协商 TLS 会话。

javax.naming.ldap 中的构造函数抛出 IOException

修饰符	构造方法	描述
	PagedResultsControl(int pageSize, boolean criticality)	构造一个控件以设置每页结果返回的条目数。
	PagedResultsControl(int pageSize, byte[] cookie, boolean criticality)	构造一个控件以设置每页结果返回的条目数。
	PagedResultsResponseControl(String id, boolean criticality, byte[] value)	构造分页结果响应控件。
	SortControl(String[] sortBy, boolean criticality)	构造一个控件以按升序对属性列表进行排序。
	SortControl(String sortBy, boolean criticality)	构造一个控件以按升序对单个属性进行排序。
	SortControl(SortKey[] sortBy, boolean criticality)	构造一个控件以对排序键列表进行排序。
	SortResponseControl(String id, boolean criticality, byte[] value)	构造一个控件以指示排序请求的结果。

IOException 在 javax.net 中的用法

在 javax.net 中抛出 IOException

修饰符和类型	方法	描述
ServerSocket	ServerSocketFactory.createServerSocket()	返回未绑定的服务套接字。
abstract ServerSocket	ServerSocketFactory.createServerSocket(int port)	返回绑定到指定端口的服务套接字。
abstract ServerSocket	ServerSocketFactory.createServerSocket(int port, int backlog)	返回绑定到指定端口的服务套接字，并使用指定的连接积压。
abstract ServerSocket	ServerSocketFactory.createServerSocket(int port, int backlog, InetAddress ifAddress)	返回绑定到指定端口的服务套接字，具有指定的监听积压和本地 IP。
Socket	SocketFactory.createSocket()	创建一个未连接的套接字。
abstract Socket	SocketFactory.createSocket(String host, int port)	创建套接字并将其连接到指定远程端口上的指定远程主机。
abstract Socket	SocketFactory.createSocket(String host, int port, InetAddress localHost, int localPort)	创建套接字并将其连接到指定远程端口上的指定远程主机。
abstract Socket	SocketFactory.createSocket(InetAddress host, int port)	创建套接字并将其连接到指定地址的指定端口号。
abstract Socket	SocketFactory.createSocket(InetAddress address, int port, InetAddress localAddress, int localPort)	创建套接字并将其连接到指定远程端口上的指定远程地址。

IOException 在 javax.net.ssl 中的用法

javax.net.ssl 中 IOException 的子类

修饰符和类型	类	描述
class	SSLException	指示 SSL 子系统检测到的某种错误。
class	SSLHandshakeException	表示客户端和服务无法协商所需的安全级别。
class	SSLKeyException	报告错误的 SSL 密钥。
class	SSLPeerUnverifiedException	指示对等方的身份尚未验证。
class	SSLProtocolException	报告 SSL 协议运行错误。

在 javax.net.ssl 中抛出 IOException

修饰符和类型	方法	描述
Socket	SSLSocketFactory.createSocket(Socket s, InputStream consumed, boolean autoClose)	创建一个服务模式 Socket 分层在现有连接的套接字上，并且能够读取已经从 Socket 的底层 InputStream 消耗/删除的数据。
abstract Socket	SSLSocketFactory.createSocket(Socket s, String host, int port, boolean autoClose)	在给定端口返回一个套接字，该套接字位于连接到指定主机的现有套接字之上。
abstract void	SSLSocket.startHandshake()	在此连接上启动 SSL 握手。

javax.net.ssl 中的构造函数抛出 IOException

修饰符	构造方法	描述
protected	SSLServerSocket()	仅由子类使用。
protected	SSLServerSocket(int port)	仅由子类使用。
protected	SSLServerSocket(int port, int backlog)	仅由子类使用。
protected	SSLServerSocket(int port, int backlog, InetAddress address)	仅由子类使用。
protected	SSLSocket(String host, int port)	仅由子类使用。
protected	SSLSocket(String host, int port, InetAddress clientAddress, int clientPort)	仅由子类使用。
protected	SSLSocket(InetAddress address, int port)	仅由子类使用。
protected	SSLSocket(InetAddress address, int port, InetAddress clientAddress, int clientPort)	仅由子类使用。

IOException 在 javax.print 中的用法

在 javax.print 中抛出 IOException

修饰符和类型	方法	描述
Doc	MultiDoc.getDoc()	获取当前文档对象。
Object	Doc.getPrintData()	获取打印数据表示对象，该对象包含此 doc 对象的一段打印数据，其格式与支持的 doc flavor 相对应。
Object	SimpleDoc.getPrintData()	获取打印数据表示对象，该对象包含此 doc 对象的一段打印数据，其格式与支持的 doc flavor 相对应。
Reader	Doc.getReaderForText()	获取用于从此文档中提取字符打印数据的读取器。
Reader	SimpleDoc.getReaderForText()	获取用于从此文档中提取字符打印数据的读取器。
InputStream	Doc.getStreamForBytes()	获取用于从此文档中提取字节打印数据的输入流。
InputStream	SimpleDoc.getStreamForBytes()	获取用于从此文档中提取字节打印数据的输入流。
MultiDoc	MultiDoc.next()	转到包含 doc 对象序列中的下一个 doc 对象的 multidoc 对象。

IOException 在 javax.rmi.ssl 中的用法

在 javax.rmi.ssl 中抛出 IOException

修饰符和类型	方法	描述
ServerSocket	SslRMIServerSocketFactory.createServerSocket(int port)	创建接受根据此工厂的 SSL 套接字配置参数配置的 SSL 连接的服务套接字。
Socket	SslRMIClientSocketFactory.createSocket(String host, int port)	创建 SSL 套接字。

IOException 在 javax.security.auth.callback 中的用法

在 javax.security.auth.callback 中抛出 IOException

修饰符和类型	方法	描述
void	CallbackHandler.handle(Callback[] callbacks)	检索或显示在提供的回调中请求的信息。

IOException 在 javax.security.sasl 中的用法

javax.security.sasl 中 IOException 的子类

修饰符和类型	类	描述
class	AuthenticationException	此异常由 SASL 机制实现抛出，以指示 SASL 交换由于与身份验证相关的原因（例如无效身份、密码或密钥）而失败。
class	SaslException	此类表示使用 SASL 时发生的错误。

IOException 在 javax.sound.midi 中的用法

在 javax.sound.midi 中抛出 IOException

修饰符和类型	方法	描述
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)	设置音序器运行的当前序列。
static int	MidiSystem.write(Sequence in, int type, File out)	写入表示 MIDI 文件类型的文件的字节流，该文件类型指示给提供的外部文件。
static int	MidiSystem.write(Sequence in, int fileType, OutputStream out)	写入表示 MIDI 文件类型的文件的字节流，该文件类型指示给提供的输出流。

IOException 在 javax.sound.midi.spi 中的用法

在 javax.sound.midi.spi 中抛出 IOException

修饰符和类型	方法	描述
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 文件。

IOException 在 javax.sound.sampled 中的用法

在 javax.sound.sampled 中抛出 IOException

修饰符和类型	方法	描述
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)	将表示指定文件类型的音频文件的字节流写入提供的输出流。

IOException 在 javax.sound.sampled.spi 中的用法

在 javax.sound.sampled.spi 中抛出 IOException

修饰符和类型	方法	描述
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)	写入表示文件类型的音频文件的字节流，该文件类型指示给提供的输出流。

IOException 在 javax.sql.rowset 中的用法

在 javax.sql.rowset 中抛出 IOException

修饰符和类型	方法	描述
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 对象。

IOException 在 javax.swing 中的用法

在 javax.swing 中抛出 IOException

修饰符和类型	方法	描述
void	ProgressMonitorInputStream.close()	覆盖 FilterInputStream.close 以关闭进度监视器和流。
protected InputStream	JEditorPane.getStream(URL page)	获取给定 URL 的流，该流将由 setPage 方法加载。
void	JEditorPane.read(InputStream in, Object desc)	此方法从流初始化。
int	ProgressMonitorInputStream.read()	覆盖 FilterInputStream.read 以在读取后更新进度监视器。
int	ProgressMonitorInputStream.read(byte[] b)	覆盖 FilterInputStream.read 以在读取后更新进度监视器。
int	ProgressMonitorInputStream.read(byte[] b, int off, int len)	覆盖 FilterInputStream.read 以在读取后更新进度监视器。
void	ProgressMonitorInputStream.reset()	覆盖 FilterInputStream.reset 以重置进度监视器和流。
void	JEditorPane.setPage(String url)	设置当前显示的 URL。
void	JEditorPane.setPage(URL page)	设置当前显示的 URL。
long	ProgressMonitorInputStream.skip(long n)	覆盖 FilterInputStream.skip 以在跳过后更新进度监视器。

javax.swing 中的构造函数抛出 IOException

修饰符	构造方法	描述
	JEditorPane(String url)	基于包含 URL 规范的字符串创建 JEditorPane。
	JEditorPane(URL initialPage)	根据指定的输入 URL 创建一个 JEditorPane。

IOException 在 javax.swing.filechooser 中的用法

在 javax.swing.filechooser 中抛出 IOException

修饰符和类型	方法	描述
abstract File	FileSystemView.createNewFolder(File containingDir)	使用默认文件夹名称创建新文件夹。

IOException 在 javax.swing.plaf.synth 中的用法

在 javax.swing.plaf.synth 中抛出 IOException

修饰符和类型	方法	描述
void	SynthLookAndFeel.load(URL url)	加载将由该 SynthLookAndFeel 使用的一组 SynthStyle 。

IOException 在 javax.swing.text 中的用法

javax.swing.text 中 IOException 的子类

修饰符和类型	类	描述
class	ChangedCharSetException	ChangedCharSetException 顾名思义，就是在改变字符集时抛出的异常。

在 javax.swing.text 中抛出 IOException

修饰符和类型	方法	描述
protected void	AbstractWriter.indent()	是否缩进。
protected void	AbstractWriter.output(char[] content, int start, int length)	写出内容的最后一站。
void	DefaultEditorKit.read(InputStream in, Document doc, int pos)	从给定的流中插入内容，该内容应采用适合此类内容处理程序的格式。
void	DefaultEditorKit.read(Reader in, Document doc, int pos)	插入来自给定流的内容，这些内容将被视为纯文本。
abstract void	EditorKit.read(InputStream 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)	所有的写方法都会调用这个方法。
protected void	AbstractWriter.write(String content)	写出一个字符串。
void	DefaultEditorKit.write(OutputStream out, Document doc, int pos, int len)	以适合此类内容处理程序的格式将文档中的内容写入给定流。
void	DefaultEditorKit.write(Writer out, Document doc, int pos, int len)	将文档中的内容作为纯文本写入给定的流。
abstract void	EditorKit.write(OutputStream out, Document doc, int pos, int len)	以适合此类内容处理程序的格式将文档中的内容写入给定流。
abstract void	EditorKit.write(Writer out, Document doc, int pos, int len)	以适合此类内容处理程序的格式将文档中的内容写入给定流。
void	JTextComponent.write(Writer out)	将模型的内容存储到给定的流中。
protected void	AbstractWriter.writeAttributes(AttributeSet attr)	将属性集写出为“<name>=<value>”对。
void	StyleContext.writeAttributes(ObjectOutputStream out, AttributeSet a)	写出属性的上下文特定处理
static void	StyleContext.writeAttributeSet(ObjectOutputStream out, AttributeSet a)	将一组属性写入给定的对象流以进行序列化。
protected void	AbstractWriter.writeLineSeparator()	写入行分隔符。

IOException 在 javax.swing.text.html 中的用法

在 javax.swing.text.html 中抛出 IOException

修饰符和类型	方法	描述
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)	重写此方法以映射任何字符实体，例如 < 到 &lt;。
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	HTMLEditorKit.write(Writer out, Document doc, int pos, int len)	以适合此类内容处理程序的格式将文档中的内容写入给定流。
void	HTMLWriter.write()	遍历元素树并控制所有标签及其属性的写出。
void	MinimalHTMLWriter.write()	从 StyledDocument 生成 HTML 输出。
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)	根据文本的属性设置为文本生成粗体 <b>、斜体 <i> 和 <u> 标记。
protected void	MinimalHTMLWriter.writeImage(Element elem)	负责处理图标元素；故意未实现。
protected void	MinimalHTMLWriter.writeLeaf(Element elem)	负责写出其他非文本叶元素。
protected void	HTMLWriter.writeLineSeparator()	写入行分隔符。
protected void	MinimalHTMLWriter.writeNonHTMLAttributes(AttributeSet attr)	以符合 HTML 的方式写出剩余的字符级属性（粗体、斜体和下划线以外的属性）。
protected void	HTMLWriter.writeOption(Option option)	写出选项表单元素的内容。
protected void	MinimalHTMLWriter.writeStartParagraph(Element elem)	发出段落的开始标记。
protected void	MinimalHTMLWriter.writeStartTag(String tag)	写出适当缩进的开始标记。
protected void	MinimalHTMLWriter.writeStyles()	写出所有命名样式作为 <style> 标签的内容。

IOException 在 javax.swing.text.html.parser 中的用法

在 javax.swing.text.html.parser 中抛出 IOException

修饰符和类型	方法	描述
static DTD	DTD.getDTD(String name)	返回具有指定 name 的 DTD。
void	DocumentParser.parse(Reader in, HTMLEditorKit.ParserCallback callback, boolean ignoreCharSet)	在给定 DTD 的情况下解析 HTML 流。
void	Parser.parse(Reader in)	在给定 DTD 的情况下解析 HTML 流。
void	ParserDelegator.parse(Reader r, HTMLEditorKit.ParserCallback cb, boolean ignoreCharSet)
String	Parser.parseDTDMarkup()	解析文档类型声明标记声明。
protected boolean	Parser.parseMarkupDeclarations(StringBuffer strBuff)	解析标记声明。
void	DTD.read(DataInputStream in)	从存档格式重新创建 DTD。

IOException 在 javax.swing.text.rtf 中的用法

在 javax.swing.text.rtf 中抛出 IOException

修饰符和类型	方法	描述
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)	将文档中的内容作为纯文本写入给定的流。

IOException 在 javax.tools 中的用法

在 javax.tools 中抛出 IOException

修饰符和类型	方法	描述
void	ForwardingJavaFileManager.close()
void	JavaFileManager.close()	释放此文件管理器直接或间接打开的任何资源。
boolean	ForwardingJavaFileManager.contains(JavaFileManager.Location location, FileObject fo)
default boolean	JavaFileManager.contains(JavaFileManager.Location location, FileObject fo)	确定给定文件对象是否“包含在”指定位置。
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)	为输出返回一个 文件对象，表示给定位置的指定包中的指定 相对名称。
FileObject	ForwardingJavaFileManager.getFileForOutputForOriginatingFiles(JavaFileManager.Location location, String packageName, String relativeName, FileObject... originatingFiles)	为输出返回一个 文件对象，表示给定位置的指定包中的指定 相对名称。
default FileObject	JavaFileManager.getFileForOutputForOriginatingFiles(JavaFileManager.Location location, String packageName, String relativeName, FileObject... originatingFiles)	为输出返回一个 文件对象，表示给定位置的指定包中的指定 相对名称。
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)	为输出返回一个 文件对象，表示给定的面向包的位置中指定种类的指定类。
JavaFileObject	ForwardingJavaFileManager.getJavaFileForOutputForOriginatingFiles(JavaFileManager.Location location, String className, JavaFileObject.Kind kind, FileObject... originatingFiles)	为输出返回一个 文件对象，表示给定的面向包的位置中指定种类的指定类。
default JavaFileObject	JavaFileManager.getJavaFileForOutputForOriginatingFiles(JavaFileManager.Location location, String className, JavaFileObject.Kind kind, FileObject... originatingFiles)	为输出返回一个 文件对象，表示给定的面向包的位置中指定种类的指定类。
JavaFileManager.Location	ForwardingJavaFileManager.getLocationForModule(JavaFileManager.Location location, String moduleName)
JavaFileManager.Location	ForwardingJavaFileManager.getLocationForModule(JavaFileManager.Location location, JavaFileObject fo)
default JavaFileManager.Location	JavaFileManager.getLocationForModule(JavaFileManager.Location location, String moduleName)	获取某个位置中命名模块的位置，该位置可以是面向模块的位置或输出位置。
default JavaFileManager.Location	JavaFileManager.getLocationForModule(JavaFileManager.Location location, JavaFileObject fo)	获取包含要在某个位置中找到的特定文件的模块的位置，该位置可以是面向模块的位置或输出位置。
<S> ServiceLoader<S>	ForwardingJavaFileManager.getServiceLoader(JavaFileManager.Location location, Class<S> service)
default <S> ServiceLoader<S>	JavaFileManager.getServiceLoader(JavaFileManager.Location location, Class<S> service)	从给定位置获取特定服务类的服务加载器。
String	ForwardingJavaFileManager.inferModuleName(JavaFileManager.Location location)
default String	JavaFileManager.inferModuleName(JavaFileManager.Location location)	从 getLocationForModule 或 listModuleLocations 返回的位置推断模块的名称。
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)	在给定的面向包的位置列出与给定条件匹配的所有文件对象。
Iterable<Set<JavaFileManager.Location>>	ForwardingJavaFileManager.listLocationsForModules(JavaFileManager.Location location)
default Iterable<Set<JavaFileManager.Location>>	JavaFileManager.listLocationsForModules(JavaFileManager.Location location)	列出面向模块的位置或输出位置中所有模块的位置。
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	ForwardingFileObject.openReader(boolean ignoreEncodingErrors)
Reader	SimpleJavaFileObject.openReader(boolean ignoreEncodingErrors)	在 Reader 中包装 SimpleJavaFileObject.getCharContent(boolean) 的结果。
Writer	FileObject.openWriter()	返回此文件对象的 Writer。
Writer	ForwardingFileObject.openWriter()
Writer	SimpleJavaFileObject.openWriter()	将 openOutputStream 的结果包装在 Writer 中。
void	StandardJavaFileManager.setLocation(JavaFileManager.Location location, Iterable<? extends File> files)	将给定的搜索路径与给定的位置相关联。
default void	StandardJavaFileManager.setLocationForModule(JavaFileManager.Location location, String moduleName, Collection<? extends Path> paths)	将给定的搜索路径与给定的模块和位置相关联，该模块和位置必须是面向模块的或输出位置。
default void	StandardJavaFileManager.setLocationFromPaths(JavaFileManager.Location location, Collection<? extends Path> paths)	将给定的搜索路径与给定的位置相关联。

IOException 在 javax.xml.parsers 中的用法

在 javax.xml.parsers 中抛出 IOException

修饰符和类型	方法	描述
Document	DocumentBuilder.parse(File f)	将给定文件的内容解析为 XML 文档并返回一个新的 DOM Document 对象。
Document	DocumentBuilder.parse(InputStream is)	将给定 InputStream 的内容解析为 XML 文档并返回一个新的 DOM Document 对象。
Document	DocumentBuilder.parse(InputStream is, String systemId)	将给定 InputStream 的内容解析为 XML 文档并返回一个新的 DOM Document 对象。
Document	DocumentBuilder.parse(String uri)	将给定 URI 的内容解析为 XML 文档并返回一个新的 DOM Document 对象。
abstract Document	DocumentBuilder.parse(InputSource is)	将给定输入源的内容解析为 XML 文档并返回一个新的 DOM Document 对象。
void	SAXParser.parse(File f, HandlerBase hb)	使用指定的 HandlerBase 解析指定为 XML 的文件的内容。
void	SAXParser.parse(File f, DefaultHandler dh)	使用指定的 DefaultHandler 解析指定为 XML 的文件的内容。
void	SAXParser.parse(InputStream is, HandlerBase hb)	使用指定的 HandlerBase 将给定的 InputStream 实例的内容解析为 XML。
void	SAXParser.parse(InputStream is, HandlerBase hb, String systemId)	使用指定的 HandlerBase 将给定的 InputStream 实例的内容解析为 XML。
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(String uri, HandlerBase hb)	使用指定的 HandlerBase 将给定的统一资源标识符 (URI) 描述的内容解析为 XML。
void	SAXParser.parse(String uri, DefaultHandler dh)	使用指定的 DefaultHandler 将给定的统一资源标识符 (URI) 描述的内容解析为 XML。
void	SAXParser.parse(InputSource is, HandlerBase hb)	使用指定的 HandlerBase 将给定的内容 InputSource 解析为 XML。
void	SAXParser.parse(InputSource is, DefaultHandler dh)	使用指定的 DefaultHandler 将给定的内容 InputSource 解析为 XML。

IOException 在 javax.xml.validation 中的用法

在 javax.xml.validation 中抛出 IOException

修饰符和类型	方法	描述
void	Validator.validate(Source source)	验证指定的输入。
abstract void	Validator.validate(Source source, Result result)	验证指定的输入并将增强的验证结果发送到指定的输出。

IOException 在 jdk.jfr 中的用法

在 jdk.jfr 中抛出 IOException

修饰符和类型	方法	描述
static Configuration	Configuration.create(Reader reader)	从字符流中读取配置。
static Configuration	Configuration.create(Path path)	从文件中读取配置。
void	Recording.dump(Path destination)	将录音数据写入文件。
static Configuration	Configuration.getConfiguration(String name)	返回预定义的配置。
InputStream	Recording.getStream(Instant start, Instant end)	为指定的时间间隔创建数据流。
void	Recording.setDestination(Path destination)	设置记录停止时写入数据的位置，如果不转储数据，则设置为null。

IOException 在 jdk.jfr.consumer 中的用法

在 jdk.jfr.consumer 中抛出 IOException

修饰符和类型	方法	描述
void	RecordingFile.close()	关闭此录制文件并释放与其关联的所有系统资源。
void	RecordingStream.dump(Path destination)	将录音数据写入文件。
static EventStream	EventStream.openFile(Path file)	从文件创建事件流。
static EventStream	EventStream.openRepository()	从当前 Java 虚拟机 (JVM) 的存储库创建流。
static EventStream	EventStream.openRepository(Path directory)	从磁盘存储库创建事件流。
static List<RecordedEvent>	RecordingFile.readAllEvents(Path path)	返回文件中所有事件的列表。
RecordedEvent	RecordingFile.readEvent()	读取记录中的下一个事件。
List<EventType>	RecordingFile.readEventTypes()	返回此记录中所有事件类型的列表。
void	RecordingFile.write(Path destination, Predicate<RecordedEvent> filter)	过滤掉事件并将它们写入新文件。

jdk.jfr.consumer 中的构造函数抛出 IOException

修饰符	构造方法	描述
	RecordingFile(Path file)	创建录音文件。

IOException 在 jdk.jshell.execution 中的用法

在 jdk.jshell.execution 中抛出 IOException

修饰符和类型	方法	描述
static void	Util.forwardExecutionControlAndIO(ExecutionControl ec, InputStream inStream, OutputStream outStream, Map<String,Consumer<OutputStream>> outputStreamMap, Map<String,Consumer<InputStream>> inputStreamMap)	将命令从输入转发到指定的 ExecutionControl 实例，然后响应输出。
ExecutionControl	JdiExecutionControlProvider.generate(ExecutionEnv env, Map<String,String> parameters)
static ExecutionControl	Util.remoteInputOutput(InputStream input, OutputStream output, Map<String,OutputStream> outputStreamMap, Map<String,InputStream> inputStreamMap, BiFunction<ObjectInput,ObjectOutput,ExecutionControl> factory)	为给定的打包输入和输出创建一个 ExecutionControl。

IOException 在 jdk.management.jfr 中的用法

在 jdk.management.jfr 中抛出 IOException

修饰符和类型	方法	描述
void	FlightRecorderMXBean.closeRecording(long recordingId)	关闭具有指定 ID 的记录并释放与该记录关联的所有系统资源。
void	FlightRecorderMXBean.closeStream(long streamId)	关闭具有指定 ID 的录制流并释放与该流关联的所有系统资源。
void	FlightRecorderMXBean.copyTo(long recordingId, String outputFile)	将录音数据写入指定文件。
void	RemoteRecordingStream.dump(Path destination)	将录音数据写入文件。
long	FlightRecorderMXBean.openStream(long recordingId, Map<String,String> streamOptions)	为具有指定 ID 的记录打开数据流，或 0 以获取与记录无关的数据。
byte[]	FlightRecorderMXBean.readStream(long streamId)	从具有指定 ID 的流中读取部分数据，如果没有更多数据可用，则返回 null。

jdk.management.jfr 中的构造函数抛出 IOException

修饰符	构造方法	描述
	RemoteRecordingStream(MBeanServerConnection connection)	创建针对已注册 FlightRecorderMXBean 的 MBeanServerConnection 进行操作的事件流。
	RemoteRecordingStream(MBeanServerConnection connection, Path directory)	创建针对已注册 FlightRecorderMXBean 的 MBeanServerConnection 进行操作的事件流。

IOException 在 jdk.net 中的用法

在 jdk.net 中抛出 IOException

修饰符和类型	方法	描述
static <T> T	Sockets.getOption(DatagramSocket s, SocketOption<T> name)	已弃用。 使用 DatagramSocket.getOption(SocketOption) 代替。
static <T> T	Sockets.getOption(ServerSocket s, SocketOption<T> name)	已弃用。 使用 ServerSocket.getOption(SocketOption) 代替。
static <T> T	Sockets.getOption(Socket s, SocketOption<T> name)	已弃用。 使用 Socket.getOption(SocketOption) 代替。
static <T> void	Sockets.setOption(DatagramSocket s, SocketOption<T> name, T value)	已弃用。 使用 DatagramSocket.setOption(SocketOption, Object) 代替。
static <T> void	Sockets.setOption(ServerSocket s, SocketOption<T> name, T value)	已弃用。 使用 ServerSocket.setOption(SocketOption, Object) 代替。
static <T> void	Sockets.setOption(Socket s, SocketOption<T> name, T value)	已弃用。 使用 Socket.setOption(SocketOption, Object) 代替。

IOException 在 jdk.nio 中的用法

在 jdk.nio 中抛出 IOException

修饰符和类型	方法	描述
void	Channels.SelectableChannelCloser.implCloseChannel(SelectableChannel sc)	关闭可选择的通道。
void	Channels.SelectableChannelCloser.implReleaseChannel(SelectableChannel sc)	释放在一个或多个 Selector 注册时关闭的可选通道的文件描述符和任何资源。

IOException 在 org.xml.sax 中的用法

在 org.xml.sax 中抛出 IOException

修饰符和类型	方法	描述
void	Parser.parse(String systemId)	已弃用。 从系统标识符 (URI) 解析 XML 文档。
void	Parser.parse(InputSource source)	已弃用。 解析 XML 文档。
void	XMLReader.parse(String systemId)	从系统标识符 (URI) 解析 XML 文档。
void	XMLReader.parse(InputSource input)	解析 XML 文档。
InputSource	EntityResolver.resolveEntity(String publicId, String systemId)	允许应用程序解析外部实体。

IOException 在 org.xml.sax.ext 中的用法

在 org.xml.sax.ext 中抛出 IOException

修饰符和类型	方法	描述
InputSource	DefaultHandler2.getExternalSubset(String name, String baseURI)	告诉解析器如果文档文本中没有声明外部子集，则不应使用任何外部子集。
InputSource	EntityResolver2.getExternalSubset(String name, String baseURI)	允许应用程序为未明确定义的文档提供外部子集。
InputSource	DefaultHandler2.resolveEntity(String publicId, String systemId)	使用空实体名称和基本 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 解析。

IOException 在 org.xml.sax.helpers 中的用法

在 org.xml.sax.helpers 中抛出 IOException

修饰符和类型	方法	描述
void	ParserAdapter.parse(String systemId)	解析 XML 文档。
void	ParserAdapter.parse(InputSource input)	解析 XML 文档。
void	XMLFilterImpl.parse(String systemId)	解析文档。
void	XMLFilterImpl.parse(InputSource input)	解析文档。
void	XMLReaderAdapter.parse(String systemId)	解析文档。
void	XMLReaderAdapter.parse(InputSource input)	解析文档。
InputSource	DefaultHandler.resolveEntity(String publicId, String systemId)	解析外部实体。
InputSource	XMLFilterImpl.resolveEntity(String publicId, String systemId)	过滤外部实体解析。