1. 首页
  2. JavaAPI

Java 类 java.io.IOException 的使用（JDK5）

148 阅读 0 评论

所有类

概述  软件包  类   使用  树  已过时  索引  帮助 

类 java.io.IOException
的使用

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

java.applet 中 IOException 的使用
 

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

java.awt 中 IOException 的使用
 

抛出 IOException 的 java.awt 中的方法
static Font Font.createFont(int fontFormat, File fontFile)
          返回一个使用指定字体类型和指定字体文件的新 Font。
static Font Font.createFont(int fontFormat, InputStream fontStream)
          返回一个使用指定字体类型和输入数据的新 Font。
protected static void AWTEventMulticaster.save(ObjectOutputStream s, String k, EventListener l)
           
protected  void AWTEventMulticaster.saveInternal(ObjectOutputStream s, String k)
           
 

java.awt.color 中 IOException 的使用
 

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

java.awt.datatransfer 中 IOException 的使用
 

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

java.awt.dnd 中 IOException 的使用
 

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

java.awt.print 中 IOException 的使用
 

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

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

java.beans 中 IOException 的使用
 

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

java.beans.beancontext 中 IOException 的使用
 

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

java.io 中 IOException 的使用
 

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

抛出 IOException 的 java.io 中的方法
protected  void ObjectOutputStream.annotateClass(Class<?> cl)
          子类可以实现此方法，从而允许在流中存储类数据。
protected  void ObjectOutputStream.annotateProxyClass(Class<?> cl)
          一些子类可以实现此方法，从而在流中存储定制数据和动态代理类的描述符。
 Writer Writer.append(char c)
          将指定字符追加到此 writer。
 Writer Writer.append(CharSequence csq)
          将指定字符序列追加到此 writer。
 Writer Writer.append(CharSequence csq, int start, int end)
          将指定字符序列的子序列追加到此 writer.Appendable。
 int InputStream.available()
          返回此输入流方法的下一个调用方可以不受阻塞地从此输入流读取（或跳过）的字节数。
 int FileInputStream.available()
          返回可以不受阻塞地从此文件输入流中读取的字节数。
 int FilterInputStream.available()
          返回可以不受阻塞地从此输入流中读取的字节数。
 int BufferedInputStream.available()
          返回可以不受阻塞地从此输入流读取的字节数。
 int PushbackInputStream.available()
          返回可以不受阻塞地从此输入流读取的字节数。
 int ObjectInput.available()
          返回可以无阻塞地读取的字节数。
 int ObjectInputStream.available()
          返回可以不受阻塞地读取的字节数。
 int SequenceInputStream.available()
          返回当前流中可用的字节数。
 int PipedInputStream.available()
          返回可以不受阻塞地从此输入流中读取的字节数量。
 int LineNumberInputStream.available()
          已过时。 无阻塞情况下返回可以从此输入流中读取的字节数。
 void Closeable.close()
          关闭此流并释放与此流关联的所有系统资源。
 void InputStream.close()
          关闭此输入流并释放与该流关联的所有系统资源。
 void FileInputStream.close()
          关闭此文件输入流并释放与此流有关的所有系统资源。
 void OutputStream.close()
          关闭此输出流并释放与此流有关的所有系统资源。
 void FileOutputStream.close()
          关闭此文件输出流并释放与此流有关的所有系统资源。
 void FilterInputStream.close()
          关闭此输入流并释放与此流关联的所有系统资源。
 void BufferedInputStream.close()
          关闭此输入流并释放与该流关联的所有系统资源。
 void FilterOutputStream.close()
          关闭此输出流并释放与此流有关的所有系统资源。
abstract  void Writer.close()
          关闭此流，但要先刷新它。
 void OutputStreamWriter.close()
          关闭该流。
 void BufferedWriter.close()
          关闭该流。
 void ByteArrayInputStream.close()
          关闭 ByteArrayInputStream 无效。
 void ByteArrayOutputStream.close()
          关闭 ByteArrayOutputStream 无效。
abstract  void Reader.close()
          关闭该流。
 void InputStreamReader.close()
          关闭该流。
 void BufferedReader.close()
          关闭该流。
 void RandomAccessFile.close()
          关闭此随机存取文件流并释放与该流关联的所有系统资源。
 void FilterReader.close()
          关闭该流。
 void StringWriter.close()
          关闭 StringWriter 无效。
 void PushbackInputStream.close()
          关闭此输入流并释放与此流关联的所有系统资源。
 void ObjectInput.close()
          关闭输入流。
 void ObjectInputStream.close()
          关闭输入流。
 void ObjectOutput.close()
          关闭该流。
 void ObjectOutputStream.close()
          关闭流。
 void SequenceInputStream.close()
          关闭此输入流并释放与此流关联的所有系统资源。
 void PushbackReader.close()
          关闭该流。
 void PipedWriter.close()
          关闭此传送输出流并释放与此流相关的所有系统资源。
 void PipedReader.close()
          关闭此传送流并释放与该流相关的所有系统资源。
 void PipedOutputStream.close()
          关闭此传送输出流并释放与此流相关的所有系统资源。
 void PipedInputStream.close()
          关闭此传送输入流并释放与该流相关的所有系统资源。
 void FilterWriter.close()
          关闭该流。
 void PipedOutputStream.connect(PipedInputStream snk)
          将此传送输出流连接到接收者。
 void PipedInputStream.connect(PipedOutputStream src)
          使此传送输入流连接到传送输出流 src。
 void PipedWriter.connect(PipedReader snk)
          将此传送 writer 连接到接收方。
 void PipedReader.connect(PipedWriter src)
          使此传送 reader 连接到传送 writer src。
 boolean File.createNewFile()
          当且仅当不存在具有此抽象路径名指定的名称的文件时，原子地创建由此抽象路径名指定的一个新的空文件。
static File File.createTempFile(String prefix, String suffix)
          在默认临时文件目录中创建一个空文件，使用给定前缀和后缀生成其名称。
static File File.createTempFile(String prefix, String suffix, File directory)
           在指定目录中创建一个新的空文件，使用给定的前缀和后缀字符串生成其名称。
abstract  boolean ObjectInputStream.GetField.defaulted(String name)
          如果指定的字段是默认字段并且在此流中不存在任何值，则返回 true。
 void ObjectInputStream.defaultReadObject()
          从此流读取当前类的非静态和非瞬态字段。
 void ObjectOutputStream.defaultWriteObject()
          将当前类的非静态和非瞬态字段写入此流。
protected  void ObjectOutputStream.drain()
          排空 ObjectOutputStream 中的所有已缓冲数据。
protected  void FileInputStream.finalize()
          确保在不再引用文件输入流时调用其 close 方法。
protected  void FileOutputStream.finalize()
          清理到文件的连接，并确保在不再引用此文件输出流时调用此流的 close 方法。
 void Flushable.flush()
          通过将所有已缓冲输出写入基础流来刷新此流。
 void OutputStream.flush()
          刷新此输出流并强制写出所有缓冲的输出字节。
 void FilterOutputStream.flush()
          刷新此输出流，并强制将所有已缓冲的输出字节写入该流中。
 void BufferedOutputStream.flush()
          刷新此缓冲的输出流。
abstract  void Writer.flush()
          刷新此流。
 void OutputStreamWriter.flush()
          刷新该流的缓冲。
 void BufferedWriter.flush()
          刷新该流的缓冲。
 void ObjectOutput.flush()
          刷新该流的缓冲。
 void ObjectOutputStream.flush()
          刷新该流的缓冲。
 void DataOutputStream.flush()
          清空此数据输出流。
 void PipedWriter.flush()
          刷新此输出流并强制写出所有缓冲的输出字符。
 void PipedOutputStream.flush()
          刷新此输出流并强制写出所有缓冲的输出字节。
 void FilterWriter.flush()
          刷新该流的缓冲。
abstract  boolean ObjectInputStream.GetField.get(String name, boolean val)
          从持久字段获取指定的 boolean 字段值。
abstract  byte ObjectInputStream.GetField.get(String name, byte val)
          从持久字段获取指定字节字段的值。
abstract  char ObjectInputStream.GetField.get(String name, char val)
          从持久字段获取指定 char 字段的值。
abstract  double ObjectInputStream.GetField.get(String name, double val)
          从持久字段获取指定 double 字段的值。
abstract  float ObjectInputStream.GetField.get(String name, float val)
          从持久字段获取指定 float 字段的值。
abstract  int ObjectInputStream.GetField.get(String name, int val)
          从持久字段获取指定的 int 字段值。
abstract  long ObjectInputStream.GetField.get(String name, long val)
          从持久字段获取指定 long 字段的值。
abstract  Object ObjectInputStream.GetField.get(String name, Object val)
          从持久字段获取指定 Object 字段的值。
abstract  short ObjectInputStream.GetField.get(String name, short val)
          从持久字段获取指定的 short 字段值。
 File File.getCanonicalFile()
          返回此抽象路径名的规范形式。
 String File.getCanonicalPath()
          返回抽象路径名的规范路径名字符串。
 FileDescriptor FileInputStream.getFD()
          返回表示到文件系统中实际文件的连接的 FileDescriptor 对象，该文件系统正被此 FileInputStream 使用。
 FileDescriptor FileOutputStream.getFD()
          返回与此流有关的文件描述符。
 FileDescriptor RandomAccessFile.getFD()
          返回与此流关联的不透明文件描述符对象。
 long RandomAccessFile.getFilePointer()
          返回此文件中的当前偏移量。
 long RandomAccessFile.length()
          返回此文件的长度。
 void Reader.mark(int readAheadLimit)
          标记流中的当前位置。
 void BufferedReader.mark(int readAheadLimit)
          标记流中的当前位置。
 void StringReader.mark(int readAheadLimit)
          标记流中的当前位置。
 void FilterReader.mark(int readAheadLimit)
          在流中的当前位置上作标记。
 void PushbackReader.mark(int readAheadLimit)
          标记流中的当前位置。
 void LineNumberReader.mark(int readAheadLimit)
          标记该流中的当前位置。
 void CharArrayReader.mark(int readAheadLimit)
          标记流中的当前位置。
 void BufferedWriter.newLine()
          写入一个行分隔符。
 int StreamTokenizer.nextToken()
          从此标记生成器的输入流中分析下一个标记。
 ObjectOutputStream.PutField ObjectOutputStream.putFields()
          检索用于缓冲写入流中的持久存储字段的对象。
abstract  int InputStream.read()
          从输入流读取下一个数据字节。
 int FileInputStream.read()
          从此输入流中读取一个数据字节。
 int FilterInputStream.read()
          从此输入流中读取下一个数据字节。
 int BufferedInputStream.read()
          参见 InputStream 的 read 方法的常规协定。
 int Reader.read()
          读取单个字符。
 int InputStreamReader.read()
          读取单个字符。
 int BufferedReader.read()
          读取单个字符。
 int RandomAccessFile.read()
          从此文件中读取一个数据字节。
 int StringReader.read()
          读取单个字符。
 int FilterReader.read()
          读取单个字符。
 int PushbackInputStream.read()
          从此输入流中读取下一个数据字节。
 int ObjectInput.read()
          读取数据字节。
 int ObjectInputStream.read()
          读取数据字节。
 int SequenceInputStream.read()
          从此输入流中读取下一个数据字节。
 int PushbackReader.read()
          读取单个字符。
 int PipedReader.read()
          读取此传送流中的下一个数据字符。
 int PipedInputStream.read()
          读取此传送输入流中的下一个数据字节。
 int LineNumberReader.read()
          读取单个字符。
 int LineNumberInputStream.read()
          已过时。 从此输入流读取下一个数据字节。
 int CharArrayReader.read()
          读取单个字符。
 int InputStream.read(byte[] b)
          从输入流中读取一定数量的字节并将其存储在缓冲区数组 b 中。
 int FileInputStream.read(byte[] b)
          从此输入流中将最多 b.length 个字节的数据读入一个字节数组中。
 int FilterInputStream.read(byte[] b)
          从此输入流中将 byte.length 个字节的数据读入一个字节数组中。
 int DataInputStream.read(byte[] b)
          从所包含的输入流中读取一定数量的字节，并将它们存储到缓冲区数组 b 中。
 int RandomAccessFile.read(byte[] b)
          将最多 b.length 个数据字节从此文件读入字节数组。
 int ObjectInput.read(byte[] b)
          读入字节数组。
 int InputStream.read(byte[] b, int off, int len)
          将输入流中最多 len 个数据字节读入字节数组。
 int FileInputStream.read(byte[] b, int off, int len)
          从此输入流中将最多 len 个字节的数据读入一个字节数组中。
 int FilterInputStream.read(byte[] b, int off, int len)
          从此输入流中将 len 个字节的数据读入一个字节数组中。
 int BufferedInputStream.read(byte[] b, int off, int len)
          在此字节输入流中从给定的偏移量开始将各字节读取到指定的 byte 数组中。
 int DataInputStream.read(byte[] b, int off, int len)
          从所包含的输入流中将 len 个字节读入一个字节数组中。
 int RandomAccessFile.read(byte[] b, int off, int len)
          将最多 len 个数据字节从此文件读入字节数组。
 int PushbackInputStream.read(byte[] b, int off, int len)
          从此输入流将最多 len 个数据字节读入字节数组。
 int ObjectInput.read(byte[] b, int off, int len)
          读入字节数组。
 int ObjectInputStream.read(byte[] buf, int off, int len)
          读入字节数组。
 int SequenceInputStream.read(byte[] b, int off, int len)
          将最多 len 个数据字节从此输入流读入字节数组。
 int PipedInputStream.read(byte[] b, int off, int len)
          将最多 len 个数据字节从此传送输入流读入字节数组。
 int LineNumberInputStream.read(byte[] b, int off, int len)
          已过时。 将最多 len 个数据字节从此输入流读入字节数组。
 int Reader.read(char[] cbuf)
          将字符读入数组。
abstract  int Reader.read(char[] cbuf, int off, int len)
          将字符读入数组的某一部分。
 int InputStreamReader.read(char[] cbuf, int offset, int length)
          将字符读入数组中的某一部分。
 int BufferedReader.read(char[] cbuf, int off, int len)
          将字符读入数组的某一部分。
 int StringReader.read(char[] cbuf, int off, int len)
          将字符读入数组的某一部分。
 int FilterReader.read(char[] cbuf, int off, int len)
          将字符读入数组的某一部分。
 int PushbackReader.read(char[] cbuf, int off, int len)
          将字符读入数组的某一部分。
 int PipedReader.read(char[] cbuf, int off, int len)
          将此传送流中最多 len 数据字符读入字符数组。
 int LineNumberReader.read(char[] cbuf, int off, int len)
          将字符读入数组中的某一部分。
 int CharArrayReader.read(char[] b, int off, int len)
          将字符读入数组的某一部分。
 int Reader.read(CharBuffer target)
          试图将字符读入指定的字符缓冲区。
 boolean DataInput.readBoolean()
          读取一个输入字节，如果该字节不是零，则返回 true，如果是零，则返回 false。
 boolean DataInputStream.readBoolean()
          参见 DataInput 的 readBoolean 方法的常规协定。
 boolean RandomAccessFile.readBoolean()
          从此文件读取一个 boolean。
 boolean ObjectInputStream.readBoolean()
          以 boolean 形式读取。
 byte DataInput.readByte()
          读取并返回一个输入字节。
 byte DataInputStream.readByte()
          参见 DataInput 的 readByte 方法的常规协定。
 byte RandomAccessFile.readByte()
          从此文件读取一个有符号的八位值。
 byte ObjectInputStream.readByte()
          读取一个 8 位的字节。
 char DataInput.readChar()
          读取一个输入的 char 并返回该 char 值。
 char DataInputStream.readChar()
          参见 DataInput 的 readChar 方法的常规协定。
 char RandomAccessFile.readChar()
          从此文件读取一个 Unicode 字符。
 char ObjectInputStream.readChar()
          读取一个 16 位的 char 值。
protected  ObjectStreamClass ObjectInputStream.readClassDescriptor()
          从序列化流读取类描述符。
 double DataInput.readDouble()
          读取八个输入字节并返回一个 double 值。
 double DataInputStream.readDouble()
          参见 DataInput 的 readDouble 方法的常规协定。
 double RandomAccessFile.readDouble()
          从此文件读取一个 double。
 double ObjectInputStream.readDouble()
          读取一个 64 位的 double 值。
 void Externalizable.readExternal(ObjectInput in)
          对象实现 readExternal 方法来恢复其内容，它通过调用 DataInput 的方法来恢复其基础类型，调用 readObject 来恢复对象、字符串和数组。
 ObjectInputStream.GetField ObjectInputStream.readFields()
          按名称从流中读取持久字段并使其可用。
 float DataInput.readFloat()
          读取四个输入字节并返回一个 float 值。
 float DataInputStream.readFloat()
          参见 DataInput 的 readFloat 方法的常规协定。
 float RandomAccessFile.readFloat()
          从此文件读取一个 float。
 float ObjectInputStream.readFloat()
          读取一个 32 位的 float 值。
 void DataInput.readFully(byte[] b)
          从输入流中读取一些字节，并将它们存储到缓冲区数组 b 中。
 void DataInputStream.readFully(byte[] b)
          参见 DataInput 的 readFully 方法的常规协定。
 void RandomAccessFile.readFully(byte[] b)
          将 b.length 个字节从此文件读入字节数组，并从当前文件指针开始。
 void ObjectInputStream.readFully(byte[] buf)
          读取字节，在读取所有字节前将发生阻塞。
 void DataInput.readFully(byte[] b, int off, int len)
          从输入流中读取 len 个字节。
 void DataInputStream.readFully(byte[] b, int off, int len)
          参见 DataInput 的 readFully 方法的常规协定。
 void RandomAccessFile.readFully(byte[] b, int off, int len)
          将正好 len 个字节从此文件读入字节数组，并从当前文件指针开始。
 void ObjectInputStream.readFully(byte[] buf, int off, int len)
          读取字节，在读取所有字节之前将发生阻塞。
 int DataInput.readInt()
          读取四个输入字节并返回一个 int 值。
 int DataInputStream.readInt()
          参见 DataInput 的 readInt 方法的常规协定。
 int RandomAccessFile.readInt()
          从此文件读取一个有符号的 32 位整数。
 int ObjectInputStream.readInt()
          读取一个 32 位的 int 值。
 String DataInput.readLine()
          从输入流中读取下一文本行。
 String DataInputStream.readLine()
          已过时。 该方法无法将字节正确转换为字符。从 JDK 1.1 开始，读取文本行的首选方法是使用 BufferedReader.readLine() 方法。对于使用 DataInputStream 类读取文本行的程序，可以转而使用 BufferedReader 类，实现方式是通过将以下形式的代码： 
     DataInputStream d = new DataInputStream(in);
替换为： 
     BufferedReader d
          = new BufferedReader(new InputStreamReader(in));
 String BufferedReader.readLine()
          读取一个文本行。
 String RandomAccessFile.readLine()
          从此文件读取文本的下一行。
 String ObjectInputStream.readLine()
          已过时。 此方法不能正确地将字节转换为字符。请参见 DataInputStream 以获取详细信息和替代方法。
 String LineNumberReader.readLine()
          读取文本行。
 long DataInput.readLong()
          读取八个输入字节并返回一个 long 值。
 long DataInputStream.readLong()
          参见 DataInput 的 readLong 方法的常规协定。
 long RandomAccessFile.readLong()
          从此文件读取一个有符号的 64 位整数。
 long ObjectInputStream.readLong()
          读取一个 64 位的 long 值。
 Object ObjectInput.readObject()
          读取并返回对象。
 Object ObjectInputStream.readObject()
          从 ObjectInputStream 读取对象。
protected  Object ObjectInputStream.readObjectOverride()
          此方法由使用受保护的无参数构造方法构造 ObjectOutputStream 的 ObjectOutputStream 的受信任子类调用。
 short DataInput.readShort()
          读取两个输入字节并返回一个 short 值。
 short DataInputStream.readShort()
          参见 DataInput 的 readShort 方法的常规协定。
 short RandomAccessFile.readShort()
          从此文件读取一个有符号的 16 位数。
 short ObjectInputStream.readShort()
          读取一个 16 位的 short 值。
protected  void ObjectInputStream.readStreamHeader()
          提供的 readStreamHeader 方法允许子类读取并验证它们自己的流头部。
 Object ObjectInputStream.readUnshared()
          从 ObjectInputStream 读取“非共享”对象。
 int DataInput.readUnsignedByte()
          读取一个输入字节，将它左侧补零 (zero-extend) 转变为 int 类型，并返回结果，所以结果的范围是 0 到 255。
 int DataInputStream.readUnsignedByte()
          参见 DataInput 的 readUnsignedByte 方法的常规协定。
 int RandomAccessFile.readUnsignedByte()
          从此文件读取一个无符号的八位数。
 int ObjectInputStream.readUnsignedByte()
          读取一个无符号的 8 位字节。
 int DataInput.readUnsignedShort()
          读取两个输入字节，并返回 0 到 65535 范围内的一个 int 值。
 int DataInputStream.readUnsignedShort()
          参见 DataInput 的 readUnsignedShort 方法的常规协定。
 int RandomAccessFile.readUnsignedShort()
          从此文件读取一个无符号的 16 位数。
 int ObjectInputStream.readUnsignedShort()
          读取一个无符号的 16 位 short 值。
 String DataInput.readUTF()
          读入一个已使用 UTF-8 修改版格式编码的字符串。
 String DataInputStream.readUTF()
          参见 DataInput 的 readUTF 方法的常规协定。
 String RandomAccessFile.readUTF()
          从此文件读取一个字符串。
 String ObjectInputStream.readUTF()
          读取 UTF-8 修改版格式的 String。
static String DataInputStream.readUTF(DataInput in)
          从流 in 中读取用 UTF-8 修改版格式编码的 Unicode 字符格式的字符串；然后以 String 形式返回此字符串。
 boolean Reader.ready()
          判断是否准备读取此流。
 boolean InputStreamReader.ready()
          告知是否准备读取此流。
 boolean BufferedReader.ready()
          判断此流是否已准备好被读取。
 boolean StringReader.ready()
          告知是否准备读取此流。
 boolean FilterReader.ready()
          判断此流是否已经准备好用于读取。
 boolean PushbackReader.ready()
          判断是否准备读取此流。
 boolean PipedReader.ready()
          告知是否准备读取此流。
 boolean CharArrayReader.ready()
          判断此流是否已准备好被读取。
protected  void PipedInputStream.receive(int b)
          接收数据字节。
protected  Object ObjectOutputStream.replaceObject(Object obj)
          在序列化期间，此方法允许 ObjectOutputStream 的受信任子类使用一个对象替代另一个对象。
 void InputStream.reset()
          将此流重新定位到对此输入流最后调用 mark 方法时的位置。
 void FilterInputStream.reset()
          将此流重新定位到对此输入流最后调用 mark 方法时的位置。
 void BufferedInputStream.reset()
          参见 InputStream 的 reset 方法的常规协定。
 void Reader.reset()
          重置该流。
 void BufferedReader.reset()
          将流重置为最新的标记。
 void StringReader.reset()
          将该流重置为最新的标记，如果从未标记过，则将其重置到该字符串的开头。
 void FilterReader.reset()
          重置该流。
 void PushbackInputStream.reset()
          将此流重新定位到对此输入流最后调用 mark 方法时的位置。
 void ObjectOutputStream.reset()
          重置将丢弃已写入流中的所有对象的状态。
 void PushbackReader.reset()
          重置该流。
 void LineNumberReader.reset()
          将该流重新设置为最新的标记。
 void LineNumberInputStream.reset()
          已过时。 将此流重新定位到对此输入流最后调用 mark 方法时的位置。
 void CharArrayReader.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 InputStream.skip(long n)
          跳过和放弃此输入流中的 n 个数据字节。
 long FileInputStream.skip(long n)
          从输入流中跳过并丢弃 n 个字节的数据。
 long FilterInputStream.skip(long n)
          从输入流中跳过并丢弃 n 个字节的数据。
 long BufferedInputStream.skip(long n)
          参见 InputStream 的 skip 方法的常规协定。
 long Reader.skip(long n)
          跳过字符。
 long BufferedReader.skip(long n)
          跳过字符。
 long StringReader.skip(long ns)
          跳过流中指定数量的字符。
 long FilterReader.skip(long n)
          跳过某些字符。
 long PushbackInputStream.skip(long n)
          从此输入流中跳过并丢弃 n 个数据字节。
 long ObjectInput.skip(long n)
          跳过输入的 n 个字节。
 long PushbackReader.skip(long n)
          跳过字符。
 long LineNumberReader.skip(long n)
          跳过字符。
 long LineNumberInputStream.skip(long n)
          已过时。 跳过和放弃此输入流中的 n 个数据字节。
 long CharArrayReader.skip(long n)
          跳过字符。
 int DataInput.skipBytes(int n)
          试图在输入流中跳过数据的 n 个字节，并丢弃跳过的字节。
 int DataInputStream.skipBytes(int n)
          参见 DataInput 的 skipBytes 方法的常规协定。
 int RandomAccessFile.skipBytes(int n)
          尝试跳过输入的 n 个字节以丢弃跳过的字节。
 int ObjectInputStream.skipBytes(int len)
          跳过字节，在跳过所有字节之前将发生阻塞。
 void PushbackInputStream.unread(byte[] b)
          推回一个字节数组，方法是将其复制到推回缓冲区前面。
 void PushbackInputStream.unread(byte[] b, int off, int len)
          推回字节数组的某一部分，方法是将其复制到推回缓冲区前面。
 void PushbackReader.unread(char[] cbuf)
          推回一个字符数组，方法是将其复制到推回缓冲区前面。
 void PushbackReader.unread(char[] cbuf, int off, int len)
          推回字符数组的某一部分，方法是将其复制到推回缓冲区的前面。
 void PushbackInputStream.unread(int b)
          推回一个字节，方法是将其复制到推回缓冲区前面。
 void PushbackReader.unread(int c)
          推回单个字符。
 void ObjectOutputStream.useProtocolVersion(int version)
          指定要在写入流时使用的流协议版本。
 void OutputStream.write(byte[] b)
          将 b.length 个字节从指定的字节数组写入此输出流。
 void FileOutputStream.write(byte[] b)
          将 b.length 个字节从指定字节数组写入此文件输出流中。
 void FilterOutputStream.write(byte[] b)
          将 b.length 个字节写入此输出流。
 void DataOutput.write(byte[] b)
          将数组 b 中的所有字节写入输出流。
 void RandomAccessFile.write(byte[] b)
          将 b.length 个字节从指定字节数组写入到此文件，并从当前文件指针开始。
 void ObjectOutput.write(byte[] b)
          写入字节数组。
 void ObjectOutputStream.write(byte[] buf)
          写入一个字节数组。
 void OutputStream.write(byte[] b, int off, int len)
          将指定字节数组中从偏移量 off 开始的 len 个字节写入此输出流。
 void FileOutputStream.write(byte[] b, int off, int len)
          将指定字节数组中从偏移量 off 开始的 len 个字节写入此文件输出流。
 void FilterOutputStream.write(byte[] b, int off, int len)
          将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。
 void BufferedOutputStream.write(byte[] b, int off, int len)
          将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此缓冲的输出流。
 void DataOutput.write(byte[] b, int off, int len)
          将数组 b 中的 len 个字节按顺序写入输出流。
 void RandomAccessFile.write(byte[] b, int off, int len)
          将 len 个字节从指定字节数组写入到此文件，并从偏移量 off 处开始。
 void ObjectOutput.write(byte[] b, int off, int len)
          写入字节的子数组。
 void ObjectOutputStream.write(byte[] buf, int off, int len)
          写入字节的子数组。
 void DataOutputStream.write(byte[] b, int off, int len)
          将指定字节数组中从偏移量 off 开始的 len 个字节写入基础输出流。
 void PipedOutputStream.write(byte[] b, int off, int len)
          将 len 字节从指定的初始偏移量为 off 的字节数组写入到该传送输出流。
 void Writer.write(char[] cbuf)
          写入字符数组。
abstract  void Writer.write(char[] cbuf, int off, int len)
          写入字符数组的某一部分。
 void OutputStreamWriter.write(char[] cbuf, int off, int len)
          写入字符数组的某一部分。
 void BufferedWriter.write(char[] cbuf, int off, int len)
          写入字符数组的某一部分。
 void PipedWriter.write(char[] cbuf, int off, int len)
          将 len 字符从指定初始偏移量为 off 的字符数组写入到此传送输出流。
 void FilterWriter.write(char[] cbuf, int off, int len)
          将字符写入数组的某一部分。
abstract  void OutputStream.write(int b)
          将指定的字节写入此输出流。
 void FileOutputStream.write(int b)
          将指定字节写入此文件输出流。
 void FilterOutputStream.write(int b)
          将指定 byte 写入此输出流。
 void BufferedOutputStream.write(int b)
          将指定的字节写入此缓冲的输出流。
 void Writer.write(int c)
          写入单个字符。
 void OutputStreamWriter.write(int c)
          写入单个字符。
 void BufferedWriter.write(int c)
          写入单个字符。
 void DataOutput.write(int b)
          将参数 b 的八个低位写入输出流。
 void RandomAccessFile.write(int b)
          向此文件写入指定的字节。
 void ObjectOutput.write(int b)
          写入字节。
 void ObjectOutputStream.write(int val)
          写入一个字节。
 void DataOutputStream.write(int b)
          将指定字节（参数 b 的八个低位）写入基础输出流。
 void PipedWriter.write(int c)
          将指定的 char 写入传送输出流。
 void PipedOutputStream.write(int b)
          将指定 byte 写入传送的输出流。
 void FilterWriter.write(int c)
          写入单个字符。
abstract  void ObjectOutputStream.PutField.write(ObjectOutput out)
          已过时。 此方法不能以正确格式写入 PutField 对象中包含的值，并且可能导致序列化流的损坏。写入 PutField 数据的正确方法是调用 ObjectOutputStream.writeFields() 方法。
 void Writer.write(String str)
          写入字符串。
 void Writer.write(String str, int off, int len)
          写入字符串的某一部分。
 void OutputStreamWriter.write(String str, int off, int len)
          写入字符串的某一部分。
 void BufferedWriter.write(String s, int off, int len)
          写入字符串的某一部分。
 void FilterWriter.write(String str, int off, int len)
          写入一部分字符串。
 void DataOutput.writeBoolean(boolean v)
          将一个 boolean 值写入输出流。
 void RandomAccessFile.writeBoolean(boolean v)
          按单字节值将 boolean 写入该文件。
 void ObjectOutputStream.writeBoolean(boolean val)
          写入一个 boolean 值。
 void DataOutputStream.writeBoolean(boolean v)
          将一个 boolean 值以 1-byte 值形式写入基础输出流。
 void DataOutput.writeByte(int v)
          将参数 v 的八个低位写入输出流。
 void RandomAccessFile.writeByte(int v)
          按单字节值将 byte 写入该文件。
 void ObjectOutputStream.writeByte(int val)
          写入一个 8 位字节。
 void DataOutputStream.writeByte(int v)
          将一个 byte 值以 1-byte 值形式写出到基础输出流中。
 void DataOutput.writeBytes(String s)
          将一个字符串写入输出流。
 void RandomAccessFile.writeBytes(String s)
          按字节序列将该字符串写入该文件。
 void ObjectOutputStream.writeBytes(String str)
          以字节序列形式写入一个 String。
 void DataOutputStream.writeBytes(String s)
          将字符串按字节顺序写出到基础输出流中。
 void DataOutput.writeChar(int v)
          将一个 char 值写入输出流，该值由两个字节组成。
 void RandomAccessFile.writeChar(int v)
          按双字节值将 char 写入该文件，先写高字节。
 void ObjectOutputStream.writeChar(int val)
          写入一个 16 位的 char 值。
 void DataOutputStream.writeChar(int v)
          将一个 char 值以 2-byte 值形式写入基础输出流中，先写入高字节。
 void DataOutput.writeChars(String s)
          将字符串 s 中的所有字符按顺序写入输出流，每个字符用两个字节表示。
 void RandomAccessFile.writeChars(String s)
          按字符序列将一个字符串写入该文件。
 void ObjectOutputStream.writeChars(String str)
          以 char 序列形式写入一个 String。
 void DataOutputStream.writeChars(String s)
          将字符串按字符顺序写入基础输出流。
protected  void ObjectOutputStream.writeClassDescriptor(ObjectStreamClass desc)
          将指定的类描述符写入 ObjectOutputStream。
 void DataOutput.writeDouble(double v)
          将一个 double 值写入输出流，该值由八个字节组成。
 void RandomAccessFile.writeDouble(double v)
          使用 Double 类中的 doubleToLongBits 方法将双精度参数转换为一个 long，然后按八字节数量将该 long 值写入该文件，先定高字节。
 void ObjectOutputStream.writeDouble(double val)
          写入一个 64 位的 double 值。
 void DataOutputStream.writeDouble(double v)
          使用 Double 类中的 doubleToLongBits 方法将 double 参数转换为一个 long 值，然后将该 long 值以 8-byte 值形式写入基础输出流中，先写入高字节。
 void Externalizable.writeExternal(ObjectOutput out)
          该对象可实现 writeExternal 方法来保存其内容，它可以通过调用 DataOutput 的方法来保存其基本值，或调用 ObjectOutput 的 writeObject 方法来保存对象、字符串和数组。
 void ObjectOutputStream.writeFields()
          将已缓冲的字段写入流中。
 void DataOutput.writeFloat(float v)
          将一个 float 值写入输出流，该值由四个字节组成。
 void RandomAccessFile.writeFloat(float v)
          使用 Float 类中的 floatToIntBits 方法将浮点参数转换为一个 int，然后按四字节数量将该 int 值写入该文件，先写高字节。
 void ObjectOutputStream.writeFloat(float val)
          写入一个 32 位的 float 值。
 void DataOutputStream.writeFloat(float v)
          使用 Float 类中的 floatToIntBits 方法将 float 参数转换为一个 int 值，然后将该 int 值以 4-byte 值形式写入基础输出流中，先写入高字节。
 void DataOutput.writeInt(int v)
          将一个 int 值写入输出流，该值由四个字节组成。
 void RandomAccessFile.writeInt(int v)
          按四个字节将 int 写入该文件，先写高字节。
 void ObjectOutputStream.writeInt(int val)
          写入一个 32 位的 int 值。
 void DataOutputStream.writeInt(int v)
          将一个 int 值以 4-byte 值形式写入基础输出流中，先写入高字节。
 void DataOutput.writeLong(long v)
          将一个 long 值写入输出流，该值由八个字节组成。
 void RandomAccessFile.writeLong(long v)
          按八个字节将 long 写入该文件，先写高字节。
 void ObjectOutputStream.writeLong(long val)
          写入一个 64 位的 long 值。
 void DataOutputStream.writeLong(long v)
          将一个 long 值以 8-byte 值形式写入基础输出流中，先写入高字节。
 void ObjectOutput.writeObject(Object obj)
          将对象写入基础存储或流。
 void ObjectOutputStream.writeObject(Object obj)
          将指定的对象写入 ObjectOutputStream。
protected  void ObjectOutputStream.writeObjectOverride(Object obj)
          子类用于重写默认 writeObject 方法的方法。
 void DataOutput.writeShort(int v)
          将两个字节写入输出流，用它们表示参数值。
 void RandomAccessFile.writeShort(int v)
          按两个字节将 short 写入该文件，先写高字节。
 void ObjectOutputStream.writeShort(int val)
          写入一个 16 位的 short 值。
 void DataOutputStream.writeShort(int v)
          将一个 short 值以 2-byte 值形式写入基础输出流中，先写入高字节。
protected  void ObjectOutputStream.writeStreamHeader()
          提供 writeStreamHeader 方法，这样子类可以将其部分追加或预加到流中。
 void ByteArrayOutputStream.writeTo(OutputStream out)
          将此字节数组输出流的全部内容写入到指定的输出流参数中，这与使用 out.write(buf, 0, count) 调用该输出流的 write 方法效果一样。
 void CharArrayWriter.writeTo(Writer out)
          将缓冲区的内容写入另一个字符流。
 void ObjectOutputStream.writeUnshared(Object obj)
          将“未共享”对象写入 ObjectOutputStream。
 void DataOutput.writeUTF(String str)
          将表示长度信息的两个字节写入输出流，后跟字符串 s 中每个字符的 UTF-8 修改版表示形式。
 void RandomAccessFile.writeUTF(String str)
          使用 modified UTF-8 编码以与机器无关的方式将一个字符串写入该文件。
 void ObjectOutputStream.writeUTF(String str)
          以 UTF-8 修改版格式写入此 String 的基本数据。
 void DataOutputStream.writeUTF(String str)
          以与机器无关方式使用 UTF-8 修改版编码将一个字符串写入基础输出流。
 

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

java.lang 中 IOException 的使用
 

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

java.lang.management 中 IOException 的使用
 

抛出 IOException 的 java.lang.management 中的方法
static
<T> T
ManagementFactory.newPlatformMXBeanProxy(MBeanServerConnection connection, String mxbeanName, Class<T> mxbeanInterface)
          返回用于给定 MXBean 名称的平台 MXBean 接口的代理，以便通过给定 MBeanServerConnection 转发其方法调用。
 

java.net 中 IOException 的使用
 

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

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

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

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

java.nio 中 IOException 的使用
 

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

java.nio.channels 中 IOException 的使用
 

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

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

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

抛出 IOException 的 java.nio.channels.spi 中的方法
 void AbstractInterruptibleChannel.close()
          关闭此通道。
 void AbstractSelector.close()
          关闭此选择器。
 SelectableChannel AbstractSelectableChannel.configureBlocking(boolean block)
          调整此通道的阻塞模式。
protected abstract  void AbstractInterruptibleChannel.implCloseChannel()
          关闭此通道。
protected  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  DatagramChannel SelectorProvider.openDatagramChannel()
          打开数据报通道。
abstract  Pipe SelectorProvider.openPipe()
          打开一个管道。
abstract  AbstractSelector SelectorProvider.openSelector()
          打开一个选择器。
abstract  ServerSocketChannel SelectorProvider.openServerSocketChannel()
          打开服务器套接字通道。
abstract  SocketChannel SelectorProvider.openSocketChannel()
          打开套接字通道。
 

java.nio.charset 中 IOException 的使用
 

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

java.rmi 中 IOException 的使用
 

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

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

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

java.rmi.activation 中 IOException 的使用
 

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

java.rmi.server 中 IOException 的使用
 

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

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

java.security 中 IOException 的使用
 

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

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

java.security.cert 中 IOException 的使用
 

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

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

java.util 中 IOException 的使用
 

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

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

抛出 IOException 的 java.util 中的方法
 void Properties.load(InputStream inStream)
          从输入流中读取属性列表（键和元素对）。
 void Properties.loadFromXML(InputStream in)
          将指定输入流中由 XML 文档所表示的所有属性加载到此属性表中。
 void Properties.store(OutputStream out, String comments)
          以适合使用 load 方法加载到 Properties 表中的格式，将此 Properties 表中的属性列表（键和元素对）写入输出流。
 void Properties.storeToXML(OutputStream os, String comment)
          发出一个表示此表中包含的所有属性的 XML 文档。
 void Properties.storeToXML(OutputStream os, String comment, String encoding)
          使用指定的编码发出一个表示此表中包含的所有属性的 XML 文档。
 

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

java.util.jar 中 IOException 的使用
 

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

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

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

java.util.logging 中 IOException 的使用
 

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

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

java.util.prefs 中 IOException 的使用
 

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

java.util.zip 中 IOException 的使用
 

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

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

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

javax.activity 中 IOException 的使用
 

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

javax.crypto 中 IOException 的使用
 

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

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

javax.imageio 中 IOException 的使用
 

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

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

javax.imageio.metadata 中 IOException 的使用
 

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

javax.imageio.spi 中 IOException 的使用
 

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

javax.imageio.stream 中 IOException 的使用
 

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

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

javax.management 中 IOException 的使用
 

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

javax.management.loading 中 IOException 的使用
 

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

javax.management.remote 中 IOException 的使用
 

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

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

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

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

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

javax.naming.ldap 中 IOException 的使用
 

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

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

javax.net 中 IOException 的使用
 

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

javax.net.ssl 中 IOException 的使用
 

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

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

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

javax.print 中 IOException 的使用
 

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

javax.rmi.CORBA 中 IOException 的使用
 

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

javax.rmi.ssl 中 IOException 的使用
 

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

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

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

javax.security.sasl 中 IOException 的使用
 

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

javax.sound.midi 中 IOException 的使用
 

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

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

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

javax.sound.sampled 中 IOException 的使用
 

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

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

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

javax.sql.rowset 中 IOException 的使用
 

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

javax.swing 中 IOException 的使用
 

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

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

javax.swing.filechooser 中 IOException 的使用
 

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

javax.swing.text 中 IOException 的使用
 

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

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

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

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

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

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

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

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

javax.transaction 中 IOException 的使用
 

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

javax.xml.parsers 中 IOException 的使用
 

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

javax.xml.validation 中 IOException 的使用
 

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

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

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

org.xml.sax 中 IOException 的使用
 

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

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

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

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

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

所有类
概述  软件包  类   使用  树  已过时  索引  帮助 

微信小程序

微信扫一扫体验

微信公众账号

微信扫一扫加关注

 发表
评论 返回
顶部