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

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 实例。