類別 java.io.IOException 的使用 (Java 2 Platform SE 6)

概觀

軟體套件

類別

使用

階層樹

已過時

索引

說明

Java^TM 2 Platform
Standard Ed. 6

上一個下一個

框架 無框架

類別 java.io.IOException
的使用

使用 IOException 的軟體套件
java.applet	提供創建 applet 所必需的類別和 applet 用來與其 applet 上下文通信的類別。
java.awt	包含用於創建使用者介面和繪製圖形圖像的全部類別。
java.awt.color	提供用於顏色空間的類別。
java.awt.datatransfer	提供在應用程序之間和在應用程序內部傳輸資料的介面和類別。
java.awt.dnd	Drag 和 Drop 是一種直接操作動作，在許多圖形使用者介面系統中都會遇到它，它提供了一種機制，能夠在兩個與 GUI 中顯示元素邏輯相關的實體之間傳輸資訊。
java.awt.print	為通用的列印 API 提供類別和介面。
java.beans	包含與開發 beans 有關的類別，即基於 JavaBeans^TM 架構的元件。
java.beans.beancontext	提供與 bean 上下文有關的類別和介面。
java.io	通過資料串流、序列化和檔案系統提供系統輸入和輸出。
java.lang	提供利用 Java 程式語言進行程序設計的基礎類別。
java.lang.management	提供管理介面，用於監視和管理 Java 虛擬機器以及 Java 虛擬機器在其上運行的作業系統。
java.net	為實作網路應用程序提供類別。
java.nio	定義作為資料容器的緩衝區，並提供其他 NIO 套件的概觀。
java.nio.channels	定義了各種通道，這些通道表示到能夠執行 I/O 操作的實體（如檔案和Socket）的連接；定義了用於多路傳輸的、非阻塞 I/O 操作的選擇器。
java.nio.channels.spi	用於 `java.nio.channels` 套件的服務提供者類別。
java.nio.charset	定義用來在位元組和 Unicode 字元之間轉換的 charset、解碼器和編碼器。
java.rmi	提供 RMI 套件。
java.rmi.activation	為 RMI 物件啟動提供支持。
java.rmi.server	提供支持伺服器端 RMI 的類別和介面。
java.security	為安全框架提供類別和介面。
java.security.cert	提供用於解析和管理證書、證書撤消列表 (CRL) 和證書路徑的類別和介面。
java.util	包含 collection 框架、遺留的 collection 類別、事件模型、日期和時間設施、國際化和各種實用工具類別（字元串標記產生器、隨機數產生器和位元陣列）。
java.util.jar	提供讀寫 JAR (Java ARchive) 檔案格式的類別，該格式基於具有可選清單檔案的標準 ZIP 檔案格式。
java.util.logging	提供 Java^TM 2 平臺核心日誌工具的類別和介面。
java.util.prefs	此套件允許應用程序存儲並獲取使用者和系統首選項和配置資料。
java.util.zip	提供用於讀寫標準 ZIP 和 GZIP 檔案格式的類別。
javax.activation
javax.activity	包含解組期間通過 ORB 機制拋出的與 Activity 服務有關的異常。
javax.annotation.processing	用來宣告註釋處理器並允許註釋處理器與註釋處理工具環境通信的工具。
javax.crypto	為加密操作提供類別和介面。
javax.imageio	Java Image I/O API 的主要套件。
javax.imageio.metadata	用於處理讀寫元資料的 Java Image I/O API 的套件。
javax.imageio.spi	包含用於 reader、writer、transcoder 和串流的外掛程式介面以及一個運行時註冊表的 Java Image I/O API 套件。
javax.imageio.stream	Java Image I/O API 的一個套件，用來處理從檔案和串流中產生的低層級別 I/O。
javax.management	提供 Java Management Extensions 的核心類別。
javax.management.loading	提供實作高層級動態載入的類別。
javax.management.remote	對 JMX MBean 伺服器進行遠端存取使用的介面。
javax.management.remote.rmi	RMI 連接器是供 JMX Remote API 使用的一種連接器，後者使用 RMI 將客戶端請求傳輸到遠端 MBean 伺服器。
javax.naming.ldap	提供對 LDAPv3 擴展操作和控制元件的支持。
javax.net	提供用於網路應用程序的類別。
javax.net.ssl	提供用於安全Socket層(SSL)套件的類別。
javax.print	為 Java^TM Print Service API 提供了主要類別和介面。
javax.rmi.CORBA	包含用於 RMI-IIOP 的可移植性 API。
javax.rmi.ssl	通過安全Socket層 (SSL) 或傳輸層安全 (TLS) 協議提供 `RMIClientSocketFactory` 和 `RMIServerSocketFactory` 的實作。
javax.security.auth.callback	此套件提供與應用程序進行交互所必需的類別，以便檢索資訊（例如，包括使用者名和密碼的驗證資料）或顯示資訊（例如，錯誤和警告訊息）。
javax.security.sasl	包含用於支持 SASL 的類別和介面。
javax.sound.midi	提供用於 MIDI（音樂樂器數字介面）資料的 I/O、序列化和合成的介面和類別。
javax.sound.midi.spi	在提供新的 MIDI 設備、MIDI 檔案 reader 和 writer、或音資源庫 reader 時提供服務提供者要實作的介面。
javax.sound.sampled	提供用於捕獲、處理和回放取樣的音頻資料的介面和類別。
javax.sound.sampled.spi	在提供新音頻設備、聲音檔案 reader 和 writer，或音頻格式轉換器時，提供將為其創建子類別的服務提供者的抽象類別。
javax.sql.rowset	JDBC `RowSet` 實作的標準介面和基礎類別。
javax.swing	提供一組“輕量級”（全部是 Java 語言）元件，盡量讓這些元件在所有平臺上的工作方式都相同。
javax.swing.filechooser	包含 `JFileChooser` 元件使用的類別和介面。
javax.swing.plaf.synth	Synth 是一個可更換皮膚 (skinnable) 的外觀，在其中可委託所有繪製。
javax.swing.text	提供類別 `HTMLEditorKit` 和創建 HTML 文本編輯器的支持類別。
javax.swing.text.html	提供類別 `HTMLEditorKit` 和創建 HTML 文本編輯器的支持類別。
javax.swing.text.html.parser	提供預設的 HTML 解析器以及支持類別。
javax.swing.text.rtf	提供一個類別 (`RTFEditorKit`)，用於創建富文本格式（Rich-Text-Format）的文本編輯器。
javax.tools	為能夠從程序（例如，編譯器）中調用的工具提供介面。
javax.transaction	包含解組期間通過 ORB 機制拋出的三個異常。
javax.xml.bind	為包含解組、編組和驗證功能的客戶端應用程序提供運行時綁定框架。
javax.xml.parsers	提供允許處理 XML 文檔的類別。
javax.xml.soap	提供用於創建和建構 SOAP 訊息的 API。
javax.xml.validation	此套件提供了用於 XML 文檔驗證的 API。
org.omg.CORBA.portable	提供可移植性層，即可以使一個供應商產生的程式碼運行在另一個供應商 ORB 上的 ORB API 集合。
org.xml.sax	此套件提供了核心 SAX API。
org.xml.sax.ext	此套件包含適合的 SAX 驅動程序不一定支持的 SAX2 設施的介面。
org.xml.sax.helpers	此套件包含“說明器”類別，其中包括對引導基於 SAX 的應用程序的支持。

java.applet 中 IOException 的使用

拋出 IOException 的 java.applet 中的方法
`void`	`AppletContext.setStream(String key, InputStream stream)` 在此 applet 上下文中用指定的鍵關聯指定的串流。

java.awt 中 IOException 的使用

拋出 IOException 的 java.awt 中的方法
`void`	`Desktop.browse(URI uri)` 啟動預設瀏覽器來顯示 `URI`。
`static Font`	`Font.createFont(int fontFormat, File fontFile)` 返回一個使用指定字體型別和指定字體檔案的新 `Font`。
`static Font`	`Font.createFont(int fontFormat, InputStream fontStream)` 返回一個使用指定字體型別和輸入資料的新 `Font`。
`void`	`Desktop.edit(File file)` 啟動關聯編輯器應用程序並打開用於編輯的檔案。
`void`	`Desktop.mail()` 啟動使用者預設郵件客戶端的郵件組合視窗。
`void`	`Desktop.mail(URI mailtoURI)` 啟動使用者預設郵件客戶端的郵件組合視窗，填充由 `mailto:` URI 指定的訊息欄位。
`void`	`Desktop.open(File file)` 啟動關聯應用程序來打開檔案。
`void`	`Desktop.print(File file)` 使用關聯應用程序的列印命令，用本機桌面列印設施來列印檔案。
`protected static void`	`AWTEventMulticaster.save(ObjectOutputStream s, String k, EventListener l)`
`protected void`	`AWTEventMulticaster.saveInternal(ObjectOutputStream s, String k)`
`void`	`SplashScreen.setImageURL(URL imageURL)` 更改閃現螢幕圖像。

java.awt.color 中 IOException 的使用

拋出 IOException 的 java.awt.color 中的方法
`static ICC_Profile`	`ICC_Profile.getInstance(InputStream s)` 建構一個與 InputStream 中的資料相對應的 ICC_Profile。
`static ICC_Profile`	`ICC_Profile.getInstance(String fileName)` 建構一個與檔案中的資料相對應的 ICC_Profile。
`void`	`ICC_Profile.write(OutputStream s)` 將 ICC_Profile 寫入一個 OutputStream。
`void`	`ICC_Profile.write(String fileName)` 將此 ICC_Profile 寫入一個檔案。

java.awt.datatransfer 中 IOException 的使用

拋出 IOException 的 java.awt.datatransfer 中的方法
`Object`	`Clipboard.getData(DataFlavor flavor)` 返回一個物件，表示此剪貼板中指定 `DataFlavor` 型別的當前內容。
`Reader`	`DataFlavor.getReaderForText(Transferable transferable)` 獲取文本 flavor 的 Reader，如果需要，則為期望的 charset（編碼的）解碼。
`Object`	`StringSelection.getTransferData(DataFlavor flavor)` 如果可能，則使用請求的 `DataFlavor` 返回 `Transferable` 的資料。
`Object`	`Transferable.getTransferData(DataFlavor flavor)` 返回一個物件，該物件表示將要被傳輸的資料。
`void`	`DataFlavor.readExternal(ObjectInput is)` 根據 Serialized 狀態還原此 `DataFlavor`。
`void`	`DataFlavor.writeExternal(ObjectOutput os)` 序列化此 `DataFlavor`。

java.awt.dnd 中 IOException 的使用

拋出 IOException 的 java.awt.dnd 中的方法
`Object`	`DropTargetContext.TransferableProxy.getTransferData(DataFlavor df)` 返回一個物件，該物件表示資料是由封裝的 transferable 為所請求的資料 flavor 提供的。

java.awt.print 中 IOException 的使用

返回 IOException 的 java.awt.print 中的方法
`IOException`	`PrinterIOException.getIOException()` 返回終止列印作業的 `IOException`。

參數型別為 IOException 的 java.awt.print 中的建構子
`PrinterIOException(IOException exception)` 建構具有指定 `IOException` 字元串表示形式的新 `PrinterIOException`。

java.beans 中 IOException 的使用

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

java.beans.beancontext 中 IOException 的使用

拋出 IOException 的 java.beans.beancontext 中的方法
`protected void`	`BeanContextServicesSupport.bcsPreDeserializationHook(ObjectInputStream ois)` 在反序列化子級之前，從 BeanContextSupport readObject 中調用。
`protected void`	`BeanContextSupport.bcsPreDeserializationHook(ObjectInputStream ois)` 在調用 defaultReadObject() 之後，但在反序列化任意子級之前，由 readObject 調用。
`protected void`	`BeanContextServicesSupport.bcsPreSerializationHook(ObjectOutputStream oos)` 在序列化子級之前，從 BeanContextSupport writeObject 中調用。
`protected void`	`BeanContextSupport.bcsPreSerializationHook(ObjectOutputStream oos)` 在調用 defaultWriteObject() 之後，但在序列化當前可序列化子級之前，由 writeObject 調用。
`protected void`	`BeanContextSupport.deserialize(ObjectInputStream ois, Collection coll)` readObject 使用此方法來反序列化一個 collection。
`Object`	`BeanContext.instantiateChild(String beanName)` 實例化指定為此 `BeanContext` 的一個子級的 javaBean。
`Object`	`BeanContextSupport.instantiateChild(String beanName)` instantiateChild 方法是 BeanContext 中的便捷鉤子 (hook)，用來簡化將巢狀的 Bean 實例化為 BeanContext 這項任務。
`void`	`BeanContextSupport.readChildren(ObjectInputStream ois)` 在將此類別的實例用作 BeanContext 協議（及其子協議）實作的代理時，在反序列化期間存在一個「先有雞還是先有蛋」的問題。
`protected void`	`BeanContextSupport.serialize(ObjectOutputStream oos, Collection coll)` writeObject 使用此方法來序列化一個 Collection。
`void`	`BeanContextSupport.writeChildren(ObjectOutputStream oos)` 用於序列化此 `BeanContext` 的所有子級。

java.io 中 IOException 的使用

java.io 中 IOException 的子類別
`class`	`CharConversionException` 用於字元轉換異常的基礎類別。
`class`	`EOFException` 當輸入過程中意外到達檔案或串流的末尾時，拋出此異常。
`class`	`FileNotFoundException` 當試圖打開指定路徑名表示的檔案失敗時，拋出此異常。
`class`	`InterruptedIOException` I/O 操作已中斷信號，拋出此異常。
`class`	`InvalidClassException` 當 Serialization 運行時檢測到某個類別具有以下問題之一時，拋出此異常。
`class`	`InvalidObjectException` 指示一個或多個反序列化物件未通過驗證測試。
`class`	`NotActiveException` 當序列化和反序列化不活動時，拋出此異常。
`class`	`NotSerializableException` 當實例需要具有序列化介面時，拋出此異常。
`class`	`ObjectStreamException` 特定於 Object Stream 類別的所有異常的父級類別。
`class`	`OptionalDataException` 指示物件讀取操作失敗的異常，原因是無法讀取串流中的基本資料或已序列化物件的資料末尾。
`class`	`StreamCorruptedException` 當從物件串流中讀取的控制資訊與內部一致性檢查相衝突時，拋出此異常。
`class`	`SyncFailedException` 當 sync 操作失敗時，拋出此異常。
`class`	`UnsupportedEncodingException` 不支持字元編碼。
`class`	`UTFDataFormatException` 在資料輸入串流中或由實作該資料輸入介面的任何類別中以 UTF-8 修改版格式讀取錯誤字元串時，拋出此異常。
`class`	`WriteAbortedException` 在寫入操作過程中拋出 ObjectStreamException 之一的信號。

拋出 IOException 的 java.io 中的方法
`protected void`	`ObjectOutputStream.annotateClass(Class<?> cl)` 子類別可以實作此方法，從而允許在串流中存儲類別資料。
`protected void`	`ObjectOutputStream.annotateProxyClass(Class<?> cl)` 子類別可以實作此方法，從而在串流中存儲定制資料和動態代理類別的描述符。
`Writer`	`Writer.append(char c)` 將指定字元添加到此 writer。
`Writer`	`Writer.append(CharSequence csq)` 將指定字元序列添加到此 writer。
`Writer`	`Writer.append(CharSequence csq, int start, int end)` 將指定字元序列的子序列添加到此 writer.`Appendable`。
`int`	`LineNumberInputStream.available()` 已過時。無阻塞情況下返回可以從此輸入串流中讀取的位元組數。
`int`	`PipedInputStream.available()` 返回可以不受阻塞地從此輸入串流中讀取的位元組數。
`int`	`SequenceInputStream.available()` 返回不受阻塞地從當前底層輸入串流讀取（或跳過）的位元組數的估計值，方法是通過下一次調用當前底層輸入串流的方法。
`int`	`PushbackInputStream.available()` 返回可以不受下一次調用此輸入串流的方法阻塞地從此輸入串流讀取（或跳過）的估計位元組數。
`int`	`ObjectInputStream.available()` 返回可以不受阻塞地讀取的位元組數。
`int`	`ObjectInput.available()` 返回可以無阻塞地讀取的位元組數。
`int`	`BufferedInputStream.available()` 返回可以從此輸入串流讀取（或跳過）、且不受此輸入串流接下來的方法調用阻塞的估計位元組數。
`int`	`FilterInputStream.available()` 返回下一次對此輸入串流調用的方法可以不受阻塞地從此輸入串流讀取（或跳過）的估計剩餘位元組數。
`int`	`FileInputStream.available()` 返回下一次對此輸入串流調用的方法可以不受阻塞地從此輸入串流讀取（或跳過）的估計剩餘位元組數。
`int`	`InputStream.available()` 返回此輸入串流下一個方法調用可以不受阻塞地從此輸入串流讀取（或跳過）的估計位元組數。
`void`	`FilterWriter.close()`
`void`	`PipedInputStream.close()` 關閉此管道輸入串流並釋放與該串流相關的所有系統資源。
`void`	`PipedOutputStream.close()` 關閉此管道輸出串流並釋放與此串流有關的所有系統資源。
`void`	`PipedReader.close()` 關閉此傳送串流並釋放與該串流相關的所有系統資源。
`void`	`PipedWriter.close()` 關閉此管道輸出串流並釋放與此串流相關的所有系統資源。
`void`	`PushbackReader.close()` 關閉該串流並釋放與之關聯的所有系統資源。
`void`	`SequenceInputStream.close()` 關閉此輸入串流並釋放與此串流關聯的所有系統資源。
`void`	`PushbackInputStream.close()` 關閉此輸入串流並釋放與該串流關聯的所有系統資源。
`void`	`StringWriter.close()` 關閉 `StringWriter` 無效。
`void`	`FilterReader.close()`
`void`	`RandomAccessFile.close()` 關閉此隨機存取檔案串流並釋放與該串流關聯的所有系統資源。
`void`	`ByteArrayOutputStream.close()` 關閉 `ByteArrayOutputStream` 無效。
`void`	`ByteArrayInputStream.close()` 關閉 `ByteArrayInputStream` 無效。
`void`	`ObjectInputStream.close()` 關閉輸入串流。
`void`	`ObjectInput.close()` 關閉輸入串流。
`void`	`ObjectOutputStream.close()` 關閉串流。
`void`	`ObjectOutput.close()` 關閉該串流。
`void`	`InputStreamReader.close()`
`void`	`BufferedReader.close()`
`abstract void`	`Reader.close()` 關閉該串流並釋放與之關聯的所有資源。
`void`	`BufferedWriter.close()`
`void`	`OutputStreamWriter.close()`
`abstract void`	`Writer.close()` 關閉此串流，但要先刷新它。
`void`	`FilterOutputStream.close()` 關閉此輸出串流並釋放與此串流有關的所有系統資源。
`void`	`BufferedInputStream.close()` 關閉此輸入串流並釋放與該串流關聯的所有系統資源。
`void`	`FilterInputStream.close()` 關閉此輸入串流並釋放與此串流關聯的所有系統資源。
`void`	`FileOutputStream.close()` 關閉此檔案輸出串流並釋放與此串流有關的所有系統資源。
`void`	`OutputStream.close()` 關閉此輸出串流並釋放與此串流有關的所有系統資源。
`void`	`FileInputStream.close()` 關閉此檔案輸入串流並釋放與此串流有關的所有系統資源。
`void`	`InputStream.close()` 關閉此輸入串流並釋放與該串流關聯的所有系統資源。
`void`	`Closeable.close()` 關閉此串流並釋放與此串流關聯的所有系統資源。
`void`	`PipedOutputStream.connect(PipedInputStream snk)` 將此管道輸出串流連接到接收者。
`void`	`PipedInputStream.connect(PipedOutputStream src)` 使此管道輸入串流連接到管道輸出串流 `src`。
`void`	`PipedWriter.connect(PipedReader snk)` 將此傳送 writer 連接到接收方。
`void`	`PipedReader.connect(PipedWriter src)` 使此傳送 reader 連接到傳送 writer `src`。
`boolean`	`File.createNewFile()` 當且僅當不存在具有此抽象路徑名指定名稱的檔案時，不可分地創建一個新的空檔案。
`static File`	`File.createTempFile(String prefix, String suffix)` 在預設臨時檔案目錄中創建一個空檔案，使用給定前綴和後綴產生其名稱。
`static File`	`File.createTempFile(String prefix, String suffix, File directory)` 在指定目錄中創建一個新的空檔案，使用給定的前綴和後綴字元串產生其名稱。
`abstract boolean`	`ObjectInputStream.GetField.defaulted(String name)` 如果指定的欄位是預設欄位並且在此串流中不存在任何值，則返回 true。
`void`	`ObjectInputStream.defaultReadObject()` 從此串流讀取當前類別的非靜態和非瞬態欄位。
`void`	`ObjectOutputStream.defaultWriteObject()` 將當前類別的非靜態和非瞬態欄位寫入此串流。
`protected void`	`ObjectOutputStream.drain()` 排空 ObjectOutputStream 中的所有已緩衝資料。
`protected void`	`FileOutputStream.finalize()` 清理到檔案的連接，並確保在不再參考此檔案輸出串流時調用此串流的 `close` 方法。
`protected void`	`FileInputStream.finalize()` 確保在不再參考檔案輸入串流時調用其 `close` 方法。
`void`	`FilterWriter.flush()` 刷新該串流的緩衝。
`void`	`PipedOutputStream.flush()` 刷新此輸出串流並強制寫出所有緩衝的輸出位元組。
`void`	`PipedWriter.flush()` 刷新此輸出串流並強制寫出所有緩衝的輸出字元。
`void`	`DataOutputStream.flush()` 清空此資料輸出串流。
`void`	`ObjectOutputStream.flush()` 刷新該串流的緩衝。
`void`	`ObjectOutput.flush()` 刷新該串流的緩衝。
`void`	`BufferedWriter.flush()` 刷新該串流的緩衝。
`void`	`OutputStreamWriter.flush()` 刷新該串流的緩衝。
`abstract void`	`Writer.flush()` 刷新該串流的緩衝。
`void`	`BufferedOutputStream.flush()` 刷新此緩衝的輸出串流。
`void`	`FilterOutputStream.flush()` 刷新此輸出串流，並強制將所有已緩衝的輸出位元組寫入該串流中。
`void`	`OutputStream.flush()` 刷新此輸出串流並強制寫出所有緩衝的輸出位元組。
`void`	`Flushable.flush()` 通過將所有已緩衝輸出寫入底層串流來刷新此串流。
`abstract boolean`	`ObjectInputStream.GetField.get(String name, boolean val)` 從持久欄位獲取指定的 boolean 欄位值。
`abstract byte`	`ObjectInputStream.GetField.get(String name, byte val)` 從持久欄位獲取指定位元組欄位的值。
`abstract char`	`ObjectInputStream.GetField.get(String name, char val)` 從持久欄位獲取指定 char 欄位的值。
`abstract double`	`ObjectInputStream.GetField.get(String name, double val)` 從持久欄位獲取指定 double 欄位的值。
`abstract float`	`ObjectInputStream.GetField.get(String name, float val)` 從持久欄位獲取指定 float 欄位的值。
`abstract int`	`ObjectInputStream.GetField.get(String name, int val)` 從持久欄位獲取指定的 int 欄位值。
`abstract long`	`ObjectInputStream.GetField.get(String name, long val)` 從持久欄位獲取指定 long 欄位的值。
`abstract Object`	`ObjectInputStream.GetField.get(String name, Object val)` 從持久欄位獲取指定 Object 欄位的值。
`abstract short`	`ObjectInputStream.GetField.get(String name, short val)` 從持久欄位獲取指定的 short 欄位值。
`File`	`File.getCanonicalFile()` 返回此抽象路徑名的規範形式。
`String`	`File.getCanonicalPath()` 返回此抽象路徑名的規範路徑名字元串。
`FileDescriptor`	`RandomAccessFile.getFD()` 返回與此串流關聯的不透明檔案描述符物件。
`FileDescriptor`	`FileOutputStream.getFD()` 返回與此串流有關的檔案描述符。
`FileDescriptor`	`FileInputStream.getFD()` 返回表示到檔案系統中實際檔案的連接的 `FileDescriptor` 物件，該檔案系統正被此 `FileInputStream` 使用。
`long`	`RandomAccessFile.getFilePointer()` 返回此檔案中的當前偏移量。
`long`	`RandomAccessFile.length()` 返回此檔案的長度。
`void`	`CharArrayReader.mark(int readAheadLimit)` 標記串流中的當前位置。
`void`	`LineNumberReader.mark(int readAheadLimit)` 標記該串流中的當前位置。
`void`	`PushbackReader.mark(int readAheadLimit)` 標記串流中的當前位置。
`void`	`FilterReader.mark(int readAheadLimit)` 在串流中的當前位置上作標記。
`void`	`StringReader.mark(int readAheadLimit)` 標記串流中的當前位置。
`void`	`BufferedReader.mark(int readAheadLimit)` 標記串流中的當前位置。
`void`	`Reader.mark(int readAheadLimit)` 標記串流中的當前位置。
`void`	`BufferedWriter.newLine()` 寫入一個行分隔符。
`int`	`StreamTokenizer.nextToken()` 從此標記產生器的輸入串流中解析下一個標記。
`ObjectOutputStream.PutField`	`ObjectOutputStream.putFields()` 獲取用於緩衝寫入串流中的持久存儲欄位的物件。
`int`	`CharArrayReader.read()` 讀取單個字元。
`int`	`LineNumberInputStream.read()` 已過時。從此輸入串流讀取下一個資料位元組。
`int`	`LineNumberReader.read()` 讀取單個字元。
`int`	`PipedInputStream.read()` 讀取此管道輸入串流中的下一個資料位元組。
`int`	`PipedReader.read()` 讀取此傳送串流中的下一個資料字元。
`int`	`PushbackReader.read()` 讀取單個字元。
`int`	`SequenceInputStream.read()` 從此輸入串流中讀取下一個資料位元組。
`int`	`PushbackInputStream.read()` 從此輸入串流中讀取下一個資料位元組。
`int`	`FilterReader.read()` 讀取單個字元。
`int`	`StringReader.read()` 讀取單個字元。
`int`	`RandomAccessFile.read()` 從此檔案中讀取一個資料位元組。
`int`	`ObjectInputStream.read()` 讀取資料位元組。
`int`	`ObjectInput.read()` 讀取資料位元組。
`int`	`InputStreamReader.read()` 讀取單個字元。
`int`	`BufferedReader.read()` 讀取單個字元。
`int`	`Reader.read()` 讀取單個字元。
`int`	`BufferedInputStream.read()` 參見 `InputStream` 的 `read` 方法的常規協定。
`int`	`FilterInputStream.read()` 從此輸入串流中讀取下一個資料位元組。
`int`	`FileInputStream.read()` 從此輸入串流中讀取一個資料位元組。
`abstract int`	`InputStream.read()` 從輸入串流中讀取資料的下一個位元組。
`int`	`RandomAccessFile.read(byte[] b)` 將最多 `b.length` 個資料位元組從此檔案讀入 byte 陣列。
`int`	`ObjectInput.read(byte[] b)` 讀入 byte 陣列。
`int`	`DataInputStream.read(byte[] b)` 從套件含的輸入串流中讀取一定數量的位元組，並將它們存儲到緩衝區陣列 `b` 中。
`int`	`FilterInputStream.read(byte[] b)` 從此輸入串流中將 `byte.length` 個位元組的資料讀入一個 byte 陣列中。
`int`	`FileInputStream.read(byte[] b)` 從此輸入串流中將最多 `b.length` 個位元組的資料讀入一個 byte 陣列中。
`int`	`InputStream.read(byte[] b)` 從輸入串流中讀取一定數量的位元組，並將其存儲在緩衝區陣列 `b` 中。
`int`	`LineNumberInputStream.read(byte[] b, int off, int len)` 已過時。將最多 `len` 個資料位元組從此輸入串流讀入 byte 陣列。
`int`	`PipedInputStream.read(byte[] b, int off, int len)` 將最多 `len` 個資料位元組從此管道輸入串流讀入 byte 陣列。
`int`	`SequenceInputStream.read(byte[] b, int off, int len)` 將最多 `len` 個資料位元組從此輸入串流讀入 byte 陣列。
`int`	`PushbackInputStream.read(byte[] b, int off, int len)` 從此輸入串流將最多 `len` 個資料位元組讀入 byte 陣列。
`int`	`RandomAccessFile.read(byte[] b, int off, int len)` 將最多 `len` 個資料位元組從此檔案讀入 byte 陣列。
`int`	`ObjectInputStream.read(byte[] buf, int off, int len)` 讀入 byte 陣列。
`int`	`ObjectInput.read(byte[] b, int off, int len)` 讀入 byte 陣列。
`int`	`DataInputStream.read(byte[] b, int off, int len)` 從套件含的輸入串流中將最多 `len` 個位元組讀入一個 byte 陣列中。
`int`	`BufferedInputStream.read(byte[] b, int off, int len)` 從此位元組輸入串流中給定偏移量處開始將各位元組讀取到指定的 byte 陣列中。
`int`	`FilterInputStream.read(byte[] b, int off, int len)` 從此輸入串流中將 `len` 個位元組的資料讀入一個 byte 陣列中。
`int`	`FileInputStream.read(byte[] b, int off, int len)` 從此輸入串流中將最多 `len` 個位元組的資料讀入一個 byte 陣列中。
`int`	`InputStream.read(byte[] b, int off, int len)` 將輸入串流中最多 `len` 個資料位元組讀入 byte 陣列。
`int`	`Reader.read(char[] cbuf)` 將字元讀入陣列。
`int`	`CharArrayReader.read(char[] b, int off, int len)` 將字元讀入陣列的某一部分。
`int`	`LineNumberReader.read(char[] cbuf, int off, int len)` 將字元讀入陣列中的某一部分。
`int`	`PipedReader.read(char[] cbuf, int off, int len)` 將此傳送串流中最多 `len` 個資料字元讀入字元陣列。
`int`	`PushbackReader.read(char[] cbuf, int off, int len)` 將字元讀入陣列的某一部分。
`int`	`FilterReader.read(char[] cbuf, int off, int len)` 將字元讀入陣列的某一部分。
`int`	`StringReader.read(char[] cbuf, int off, int len)` 將字元讀入陣列的某一部分。
`int`	`InputStreamReader.read(char[] cbuf, int offset, int length)` 將字元讀入陣列中的某一部分。
`int`	`BufferedReader.read(char[] cbuf, int off, int len)` 將字元讀入陣列的某一部分。
`abstract int`	`Reader.read(char[] cbuf, int off, int len)` 將字元讀入陣列的某一部分。
`int`	`Reader.read(CharBuffer target)` 試圖將字元讀入指定的字元緩衝區。
`boolean`	`RandomAccessFile.readBoolean()` 從此檔案讀取一個 `boolean`。
`boolean`	`ObjectInputStream.readBoolean()` 讀取一個 boolean 值。
`boolean`	`DataInputStream.readBoolean()` 參見 `DataInput` 的 `readBoolean` 方法的常規協定。
`boolean`	`DataInput.readBoolean()` 讀取一個輸入位元組，如果該位元組不是零，則返回 `true`，如果是零，則返回 `false`。
`byte`	`RandomAccessFile.readByte()` 從此檔案讀取一個有符號的八位值。
`byte`	`ObjectInputStream.readByte()` 讀取一個 8 位的位元組。
`byte`	`DataInputStream.readByte()` 參見 `DataInput` 的 `readByte` 方法的常規協定。
`byte`	`DataInput.readByte()` 讀取並返回一個輸入位元組。
`char`	`RandomAccessFile.readChar()` 從此檔案讀取一個字元。
`char`	`ObjectInputStream.readChar()` 讀取一個 16 位的 char 值。
`char`	`DataInputStream.readChar()` 參見 `DataInput` 的 `readChar` 方法的常規協定。
`char`	`DataInput.readChar()` 讀取兩個輸入位元組並返回一個 `char` 值。
`protected ObjectStreamClass`	`ObjectInputStream.readClassDescriptor()` 從序列化串流讀取類別描述符。
`double`	`RandomAccessFile.readDouble()` 從此檔案讀取一個 `double`。
`double`	`ObjectInputStream.readDouble()` 讀取一個 64 位的 double 值。
`double`	`DataInputStream.readDouble()` 參見 `DataInput` 的 `readDouble` 方法的常規協定。
`double`	`DataInput.readDouble()` 讀取八個輸入位元組並返回一個 `double` 值。
`void`	`Externalizable.readExternal(ObjectInput in)` 物件實作 readExternal 方法來恢復其內容，它通過調用 DataInput 的方法來恢復其基礎型別，調用 readObject 來恢復物件、字元串和陣列。
`ObjectInputStream.GetField`	`ObjectInputStream.readFields()` 按名稱從串流中讀取持久欄位並使其可用。
`float`	`RandomAccessFile.readFloat()` 從此檔案讀取一個 `float`。
`float`	`ObjectInputStream.readFloat()` 讀取一個 32 位的 float 值。
`float`	`DataInputStream.readFloat()` 參見 `DataInput` 的 `readFloat` 方法的常規協定。
`float`	`DataInput.readFloat()` 讀取四個輸入位元組並返回一個 `float` 值。
`void`	`RandomAccessFile.readFully(byte[] b)` 將 `b.length` 個位元組從此檔案讀入 byte 陣列，並從當前檔案指針開始。
`void`	`ObjectInputStream.readFully(byte[] buf)` 讀取位元組，同時阻塞直至讀取所有位元組。
`void`	`DataInputStream.readFully(byte[] b)` 參見 `DataInput` 的 `readFully` 方法的常規協定。
`void`	`DataInput.readFully(byte[] b)` 從輸入串流中讀取一些位元組，並將它們存儲在緩衝區陣列 `b` 中。
`void`	`RandomAccessFile.readFully(byte[] b, int off, int len)` 將正好 `len` 個位元組從此檔案讀入 byte 陣列，並從當前檔案指針開始。
`void`	`ObjectInputStream.readFully(byte[] buf, int off, int len)` 讀取位元組，同時阻塞直至讀取所有位元組。
`void`	`DataInputStream.readFully(byte[] b, int off, int len)` 參見 `DataInput` 的 `readFully` 方法的常規協定。
`void`	`DataInput.readFully(byte[] b, int off, int len)` 從輸入串流中讀取 `len` 個位元組。
`int`	`RandomAccessFile.readInt()` 從此檔案讀取一個有符號的 32 位整數。
`int`	`ObjectInputStream.readInt()` 讀取一個 32 位的 int 值。
`int`	`DataInputStream.readInt()` 參見 `DataInput` 的 `readInt` 方法的常規協定。
`int`	`DataInput.readInt()` 讀取四個輸入位元組並返回一個 `int` 值。
`String`	`LineNumberReader.readLine()` 讀取文本行。
`String`	`RandomAccessFile.readLine()` 從此檔案讀取文本的下一行。
`String`	`ObjectInputStream.readLine()` 已過時。此方法不能正確地將位元組轉換為字元。請參見 DataInputStream 以獲取詳細資訊和替代方法。
`String`	`DataInputStream.readLine()` 已過時。該方法無法將位元組正確轉換為字元。從 JDK 1.1 開始，讀取文本行的首選方法是使用 `BufferedReader.readLine()` 方法。使用 `DataInputStream` 類別讀取文本行的程序可以改為使用 `BufferedReader` 類別，只要將以下形式的程式碼： DataInputStream d = new DataInputStream(in); 替換為： BufferedReader d = new BufferedReader(new InputStreamReader(in));
`String`	`DataInput.readLine()` 從輸入串流中讀取下一文本行。
`String`	`BufferedReader.readLine()` 讀取一個文本行。
`long`	`RandomAccessFile.readLong()` 從此檔案讀取一個有符號的 64 位整數。
`long`	`ObjectInputStream.readLong()` 讀取一個 64 位的 long 值。
`long`	`DataInputStream.readLong()` 參見 `DataInput` 的 `readLong` 方法的常規協定。
`long`	`DataInput.readLong()` 讀取八個輸入位元組並返回一個 `long` 值。
`Object`	`ObjectInputStream.readObject()` 從 ObjectInputStream 讀取物件。
`Object`	`ObjectInput.readObject()` 讀取並返回物件。
`protected Object`	`ObjectInputStream.readObjectOverride()` 此方法由 ObjectOutputStream 的受信任子類別調用，這些子類別使用受保護的無參數建構子建構 ObjectOutputStream。
`short`	`RandomAccessFile.readShort()` 從此檔案讀取一個有符號的 16 位數。
`short`	`ObjectInputStream.readShort()` 讀取一個 16 位的 short 值。
`short`	`DataInputStream.readShort()` 參見 `DataInput` 的 `readShort` 方法的常規協定。
`short`	`DataInput.readShort()` 讀取兩個輸入位元組並返回一個 `short` 值。
`protected void`	`ObjectInputStream.readStreamHeader()` 提供的 readStreamHeader 方法允許子類別讀取並驗證它們自己的串流頭部。
`Object`	`ObjectInputStream.readUnshared()` 從 ObjectInputStream 讀取“非共享”物件。
`int`	`RandomAccessFile.readUnsignedByte()` 從此檔案讀取一個無符號的八位數。
`int`	`ObjectInputStream.readUnsignedByte()` 讀取一個無符號的 8 位位元組。
`int`	`DataInputStream.readUnsignedByte()` 參見 `DataInput` 的 `readUnsignedByte` 方法的常規協定。
`int`	`DataInput.readUnsignedByte()` 讀取一個輸入位元組，將它左側補零 (zero-extend) 轉變為 `int` 型別，並返回結果，所以結果的範圍是 `0` 到 `255`。
`int`	`RandomAccessFile.readUnsignedShort()` 從此檔案讀取一個無符號的 16 位數。
`int`	`ObjectInputStream.readUnsignedShort()` 讀取一個無符號的 16 位 short 值。
`int`	`DataInputStream.readUnsignedShort()` 參見 `DataInput` 的 `readUnsignedShort` 方法的常規協定。
`int`	`DataInput.readUnsignedShort()` 讀取兩個輸入位元組，並返回 `0` 到 `65535` 範圍內的一個 `int` 值。
`String`	`RandomAccessFile.readUTF()` 從此檔案讀取一個字元串。
`String`	`ObjectInputStream.readUTF()` 讀取 UTF-8 修改版格式的 String。
`String`	`DataInputStream.readUTF()` 參見 `DataInput` 的 `readUTF` 方法的常規協定。
`String`	`DataInput.readUTF()` 讀入一個已使用 UTF-8 修改版格式編碼的字元串。
`static String`	`DataInputStream.readUTF(DataInput in)` 從串流 `in` 中讀取用 UTF-8 修改版格式編碼的 Unicode 字元格式的字元串；然後以 `String` 形式返回此字元串。
`boolean`	`CharArrayReader.ready()` 判斷此串流是否已準備好被讀取。
`boolean`	`PipedReader.ready()` 告知是否準備讀取此串流。
`boolean`	`PushbackReader.ready()` 判斷是否準備讀取此串流。
`boolean`	`FilterReader.ready()` 判斷此串流是否已經準備好用於讀取。
`boolean`	`StringReader.ready()` 判斷此串流是否已經準備好用於讀取。
`boolean`	`InputStreamReader.ready()` 判斷此串流是否已經準備好用於讀取。
`boolean`	`BufferedReader.ready()` 判斷此串流是否已準備好被讀取。
`boolean`	`Reader.ready()` 判斷是否準備讀取此串流。
`protected void`	`PipedInputStream.receive(int b)` 接收資料位元組。
`protected Object`	`ObjectOutputStream.replaceObject(Object obj)` 在序列化期間，此方法允許 ObjectOutputStream 的受信任子類別使用一個物件替代另一個物件。
`void`	`CharArrayReader.reset()` 將該串流重置為最新的標記，如果從未標記過，則將其重置到開頭。
`void`	`LineNumberInputStream.reset()` 已過時。將此串流重新定位到對此輸入串流最後調用 `mark` 方法時的位置。
`void`	`LineNumberReader.reset()` 將該串流重新設置為最新的標記。
`void`	`PushbackReader.reset()` 重置該串流。
`void`	`PushbackInputStream.reset()` 將此串流重新定位到最後一次對此輸入串流調用 `mark` 方法時的位置。
`void`	`FilterReader.reset()` 重置該串流。
`void`	`StringReader.reset()` 將該串流重置為最新的標記，如果從未標記過，則將其重置到該字元串的開頭。
`void`	`ObjectOutputStream.reset()` 重置將丟棄已寫入串流中的所有物件的狀態。
`void`	`BufferedReader.reset()` 將串流重置到最新的標記。
`void`	`Reader.reset()` 重置該串流。
`void`	`BufferedInputStream.reset()` 參見 `InputStream` 的 `reset` 方法的常規協定。
`void`	`FilterInputStream.reset()` 將此串流重新定位到對此輸入串流最後調用 `mark` 方法時的位置。
`void`	`InputStream.reset()` 將此串流重新定位到最後一次對此輸入串流調用 `mark` 方法時的位置。
`protected Class<?>`	`ObjectInputStream.resolveClass(ObjectStreamClass desc)` 載入指定串流類別描述的本地等價類別。
`protected Object`	`ObjectInputStream.resolveObject(Object obj)` 在反序列化期間，此方法允許 ObjectInputStream 的受信任子類別使用一個物件替代另一個。
`protected Class<?>`	`ObjectInputStream.resolveProxyClass(String[] interfaces)` 返回一個代理類別，該類別實作在代理類別描述符中命名的介面；子類別可以實作此方法，以便從串流及動態代理類別的描述符中讀取自定義資料，允許它們使用介面和代理類別的替換載入機制。
`void`	`RandomAccessFile.seek(long pos)` 設置到此檔案開頭測量到的檔案指針偏移量，在該位置發生下一個讀取或寫入操作。
`void`	`RandomAccessFile.setLength(long newLength)` 設置此檔案的長度。
`long`	`CharArrayReader.skip(long n)` 跳過字元。
`long`	`LineNumberInputStream.skip(long n)` 已過時。跳過和放棄此輸入串流中的 `n` 個資料位元組。
`long`	`LineNumberReader.skip(long n)` 跳過字元。
`long`	`PushbackReader.skip(long n)` 跳過字元。
`long`	`PushbackInputStream.skip(long n)` 從此輸入串流中跳過並丟棄 `n` 個資料位元組。
`long`	`FilterReader.skip(long n)` 跳過某些字元。
`long`	`StringReader.skip(long ns)` 跳過串流中指定數量的字元。
`long`	`ObjectInput.skip(long n)` 跳過輸入的 n 個位元組。
`long`	`BufferedReader.skip(long n)` 跳過字元。
`long`	`Reader.skip(long n)` 跳過字元。
`long`	`BufferedInputStream.skip(long n)` 參見 `InputStream` 的 `skip` 方法的常規協定。
`long`	`FilterInputStream.skip(long n)` 跳過和丟棄此輸入串流中資料的 `n` 個位元組。
`long`	`FileInputStream.skip(long n)` 從輸入串流中跳過並丟棄 `n` 個位元組的資料。
`long`	`InputStream.skip(long n)` 跳過和丟棄此輸入串流中資料的 `n` 個位元組。
`int`	`RandomAccessFile.skipBytes(int n)` 嘗試跳過輸入的 `n` 個位元組以丟棄跳過的位元組。
`int`	`ObjectInputStream.skipBytes(int len)` 跳過位元組。
`int`	`DataInputStream.skipBytes(int n)` 參見 `DataInput` 的 `skipBytes` 方法的常規協定。
`int`	`DataInput.skipBytes(int n)` 試圖在輸入串流中跳過資料的 `n` 個位元組，並丟棄跳過的位元組。
`void`	`PushbackInputStream.unread(byte[] b)` 推回一個 byte 陣列：將其複製到推回緩衝區之前。
`void`	`PushbackInputStream.unread(byte[] b, int off, int len)` 推回 byte 陣列的某一部分：將其複製到推回緩衝區之前。
`void`	`PushbackReader.unread(char[] cbuf)` 推回一個字元陣列，方法是將其複製到推回緩衝區前面。
`void`	`PushbackReader.unread(char[] cbuf, int off, int len)` 推回字元陣列的某一部分，方法是將其複製到推回緩衝區的前面。
`void`	`PushbackReader.unread(int c)` 推回單個字元：將其複製到推回緩衝區的前面。
`void`	`PushbackInputStream.unread(int b)` 推回一個位元組：將其複製到推回緩衝區之前。
`void`	`ObjectOutputStream.useProtocolVersion(int version)` 指定要在寫入串流時使用的串流協議版本。
`void`	`RandomAccessFile.write(byte[] b)` 將 `b.length` 個位元組從指定 byte 陣列寫入到此檔案，並從當前檔案指針開始。
`void`	`ObjectOutputStream.write(byte[] buf)` 寫入一個 byte 陣列。
`void`	`ObjectOutput.write(byte[] b)` 寫入 byte 陣列。
`void`	`DataOutput.write(byte[] b)` 將陣列 `b` 中的所有位元組寫入輸出串流。
`void`	`FilterOutputStream.write(byte[] b)` 將 `b.length` 個位元組寫入此輸出串流。
`void`	`FileOutputStream.write(byte[] b)` 將 `b.length` 個位元組從指定 byte 陣列寫入此檔案輸出串流中。
`void`	`OutputStream.write(byte[] b)` 將 `b.length` 個位元組從指定的 byte 陣列寫入此輸出串流。
`void`	`PipedOutputStream.write(byte[] b, int off, int len)` 將 `len` 位元組從初始偏移量為 `off` 的指定 byte 陣列寫入該管道輸出串流。
`void`	`DataOutputStream.write(byte[] b, int off, int len)` 將指定 byte 陣列中從偏移量 `off` 開始的 `len` 個位元組寫入基礎輸出串流。
`void`	`RandomAccessFile.write(byte[] b, int off, int len)` 將 `len` 個位元組從指定 byte 陣列寫入到此檔案，並從偏移量 `off` 處開始。
`void`	`ObjectOutputStream.write(byte[] buf, int off, int len)` 寫入位元組的子陣列。
`void`	`ObjectOutput.write(byte[] b, int off, int len)` 寫入位元組的子陣列。
`void`	`DataOutput.write(byte[] b, int off, int len)` 將陣列 `b` 中的 `len` 個位元組按順序寫入輸出串流。
`void`	`BufferedOutputStream.write(byte[] b, int off, int len)` 將指定 byte 陣列中從偏移量 `off` 開始的 `len` 個位元組寫入此緩衝的輸出串流。
`void`	`FilterOutputStream.write(byte[] b, int off, int len)` 將指定 `byte` 陣列中從偏移量 `off` 開始的 `len` 個位元組寫入此輸出串流。
`void`	`FileOutputStream.write(byte[] b, int off, int len)` 將指定 byte 陣列中從偏移量 `off` 開始的 `len` 個位元組寫入此檔案輸出串流。
`void`	`OutputStream.write(byte[] b, int off, int len)` 將指定 byte 陣列中從偏移量 `off` 開始的 `len` 個位元組寫入此輸出串流。
`void`	`Writer.write(char[] cbuf)` 寫入字元陣列。
`void`	`FilterWriter.write(char[] cbuf, int off, int len)` 將字元寫入陣列的某一部分。
`void`	`PipedWriter.write(char[] cbuf, int off, int len)` 將 `len` 字元從指定初始偏移量為 `off` 的字元陣列寫入到此管道輸出串流。
`void`	`BufferedWriter.write(char[] cbuf, int off, int len)` 寫入字元陣列的某一部分。
`void`	`OutputStreamWriter.write(char[] cbuf, int off, int len)` 寫入字元陣列的某一部分。
`abstract void`	`Writer.write(char[] cbuf, int off, int len)` 寫入字元陣列的某一部分。
`void`	`FilterWriter.write(int c)` 寫入單個字元。
`void`	`PipedOutputStream.write(int b)` 將指定 `byte` 寫入傳送的輸出串流。
`void`	`PipedWriter.write(int c)` 將指定的 `char` 寫入管道輸出串流。
`void`	`DataOutputStream.write(int b)` 將指定位元組（參數 `b` 的八個低位）寫入基礎輸出串流。
`void`	`RandomAccessFile.write(int b)` 向此檔案寫入指定的位元組。
`void`	`ObjectOutputStream.write(int val)` 寫入一個位元組。
`void`	`ObjectOutput.write(int b)` 寫入位元組。
`void`	`DataOutput.write(int b)` 將參數 `b` 的八個低位寫入輸出串流。
`void`	`BufferedWriter.write(int c)` 寫入單個字元。
`void`	`OutputStreamWriter.write(int c)` 寫入單個字元。
`void`	`Writer.write(int c)` 寫入單個字元。
`void`	`BufferedOutputStream.write(int b)` 將指定的位元組寫入此緩衝的輸出串流。
`void`	`FilterOutputStream.write(int b)` 將指定 `byte` 寫入此輸出串流。
`void`	`FileOutputStream.write(int b)` 將指定位元組寫入此檔案輸出串流。
`abstract void`	`OutputStream.write(int b)` 將指定的位元組寫入此輸出串流。
`abstract void`	`ObjectOutputStream.PutField.write(ObjectOutput out)` 已過時。此方法不能以正確格式寫入 `PutField` 物件中包含的值，並且可能導致序列化串流的損壞。寫入 `PutField` 資料的正確方法是調用 `ObjectOutputStream.writeFields()` 方法。
`void`	`Writer.write(String str)` 寫入字元串。
`void`	`FilterWriter.write(String str, int off, int len)` 寫入一部分字元串。
`void`	`BufferedWriter.write(String s, int off, int len)` 寫入字元串的某一部分。
`void`	`OutputStreamWriter.write(String str, int off, int len)` 寫入字元串的某一部分。
`void`	`Writer.write(String str, int off, int len)` 寫入字元串的某一部分。
`void`	`DataOutputStream.writeBoolean(boolean v)` 將一個 `boolean` 值以 1-byte 值形式寫入基礎輸出串流。
`void`	`RandomAccessFile.writeBoolean(boolean v)` 按單位元組值將 `boolean` 寫入該檔案。
`void`	`ObjectOutputStream.writeBoolean(boolean val)` 寫入一個 boolean 值。
`void`	`DataOutput.writeBoolean(boolean v)` 將一個 `boolean` 值寫入輸出串流。
`void`	`DataOutputStream.writeByte(int v)` 將一個 `byte` 值以 1-byte 值形式寫出到基礎輸出串流中。
`void`	`RandomAccessFile.writeByte(int v)` 按單位元組值將 `byte` 寫入該檔案。
`void`	`ObjectOutputStream.writeByte(int val)` 寫入一個 8 位位元組。
`void`	`DataOutput.writeByte(int v)` 將參數 `v` 的八個低位寫入輸出串流。
`void`	`DataOutputStream.writeBytes(String s)` 將字元串按位元組順序寫出到基礎輸出串流中。
`void`	`RandomAccessFile.writeBytes(String s)` 按位元組序列將該字元串寫入該檔案。
`void`	`ObjectOutputStream.writeBytes(String str)` 以位元組序列形式寫入一個 String。
`void`	`DataOutput.writeBytes(String s)` 將一個字元串寫入輸出串流。
`void`	`DataOutputStream.writeChar(int v)` 將一個 `char` 值以 2-byte 值形式寫入基礎輸出串流中，先寫入高位元組。
`void`	`RandomAccessFile.writeChar(int v)` 按雙位元組值將 `char` 寫入該檔案，先寫高位元組。
`void`	`ObjectOutputStream.writeChar(int val)` 寫入一個 16 位的 char 值。
`void`	`DataOutput.writeChar(int v)` 將一個 `char` 值寫入輸出串流，該值由兩個位元組組成。
`void`	`DataOutputStream.writeChars(String s)` 將字元串按字元順序寫入基礎輸出串流。
`void`	`RandomAccessFile.writeChars(String s)` 按字元序列將一個字元串寫入該檔案。
`void`	`ObjectOutputStream.writeChars(String str)` 以 char 序列形式寫入一個 String。
`void`	`DataOutput.writeChars(String s)` 將字元串 `s` 中的所有字元按順序寫入輸出串流，每個字元用兩個位元組表示。
`protected void`	`ObjectOutputStream.writeClassDescriptor(ObjectStreamClass desc)` 將指定的類別描述符寫入 ObjectOutputStream。
`void`	`DataOutputStream.writeDouble(double v)` 使用 `Double` 類別中的 `doubleToLongBits` 方法將 double 參數轉換為一個 `long` 值，然後將該 `long` 值以 8-byte 值形式寫入基礎輸出串流中，先寫入高位元組。
`void`	`RandomAccessFile.writeDouble(double v)` 使用 `Double` 類別中的 `doubleToLongBits` 方法將雙精度參數轉換為一個 `long`，然後按八位元組數量將該 `long` 值寫入該檔案，先定高位元組。
`void`	`ObjectOutputStream.writeDouble(double val)` 寫入一個 64 位的 double 值。
`void`	`DataOutput.writeDouble(double v)` 將一個 `double` 值寫入輸出串流，該值由八個位元組組成。
`void`	`Externalizable.writeExternal(ObjectOutput out)` 該物件可實作 writeExternal 方法來保存其內容，它可以通過調用 DataOutput 的方法來保存其基本值，或調用 ObjectOutput 的 writeObject 方法來保存物件、字元串和陣列。
`void`	`ObjectOutputStream.writeFields()` 將已緩衝的欄位寫入串流中。
`void`	`DataOutputStream.writeFloat(float v)` 使用 `Float` 類別中的 `floatToIntBits` 方法將 float 參數轉換為一個 `int` 值，然後將該 `int` 值以 4-byte 值形式寫入基礎輸出串流中，先寫入高位元組。
`void`	`RandomAccessFile.writeFloat(float v)` 使用 `Float` 類別中的 `floatToIntBits` 方法將浮點參數轉換為一個 `int`，然後按四位元組數量將該 `int` 值寫入該檔案，先寫高位元組。
`void`	`ObjectOutputStream.writeFloat(float val)` 寫入一個 32 位的 float 值。
`void`	`DataOutput.writeFloat(float v)` 將一個 `float` 值寫入輸出串流，該值由四個位元組組成。
`void`	`DataOutputStream.writeInt(int v)` 將一個 `int` 值以 4-byte 值形式寫入基礎輸出串流中，先寫入高位元組。
`void`	`RandomAccessFile.writeInt(int v)` 按四個位元組將 `int` 寫入該檔案，先寫高位元組。
`void`	`ObjectOutputStream.writeInt(int val)` 寫入一個 32 位的 int 值。
`void`	`DataOutput.writeInt(int v)` 將一個 `int` 值寫入輸出串流，該值由四個位元組組成。
`void`	`DataOutputStream.writeLong(long v)` 將一個 `long` 值以 8-byte 值形式寫入基礎輸出串流中，先寫入高位元組。
`void`	`RandomAccessFile.writeLong(long v)` 按八個位元組將 `long` 寫入該檔案，先寫高位元組。
`void`	`ObjectOutputStream.writeLong(long val)` 寫入一個 64 位的 long 值。
`void`	`DataOutput.writeLong(long v)` 將一個 `long` 值寫入輸出串流，該值由八個位元組組成。
`void`	`ObjectOutputStream.writeObject(Object obj)` 將指定的物件寫入 ObjectOutputStream。
`void`	`ObjectOutput.writeObject(Object obj)` 將物件寫入底層存儲或串流。
`protected void`	`ObjectOutputStream.writeObjectOverride(Object obj)` 子類別用於覆寫預設 writeObject 方法的方法。
`void`	`DataOutputStream.writeShort(int v)` 將一個 `short` 值以 2-byte 值形式寫入基礎輸出串流中，先寫入高位元組。
`void`	`RandomAccessFile.writeShort(int v)` 按兩個位元組將 `short` 寫入該檔案，先寫高位元組。
`void`	`ObjectOutputStream.writeShort(int val)` 寫入一個 16 位的 short 值。
`void`	`DataOutput.writeShort(int v)` 將兩個位元組寫入輸出串流，用它們表示參數值。
`protected void`	`ObjectOutputStream.writeStreamHeader()` 提供 writeStreamHeader 方法，這樣子類別可以將其自身的頭部添加或預加到串流中。
`void`	`ByteArrayOutputStream.writeTo(OutputStream out)` 將此 byte 陣列輸出串流的全部內容寫入到指定的輸出串流參數中，這與使用 `out.write(buf, 0, count)` 調用該輸出串流的 write 方法效果一樣。
`void`	`CharArrayWriter.writeTo(Writer out)` 將緩衝區的內容寫入另一個字元串流。
`void`	`ObjectOutputStream.writeUnshared(Object obj)` 將“未共享”物件寫入 ObjectOutputStream。
`void`	`DataOutputStream.writeUTF(String str)` 以與機器無關方式使用 UTF-8 修改版編碼將一個字元串寫入基礎輸出串流。
`void`	`RandomAccessFile.writeUTF(String str)` 使用 modified UTF-8 編碼以與機器無關的方式將一個字元串寫入該檔案。
`void`	`ObjectOutputStream.writeUTF(String str)` 以 UTF-8 修改版格式寫入此 String 的基本資料。
`void`	`DataOutput.writeUTF(String s)` 將表示長度資訊的兩個位元組寫入輸出串流，後跟字元串 `s` 中每個字元的 UTF-8 修改版表示形式。

拋出 IOException 的 java.io 中的建構子
`FileWriter(File file)` 根據給定的 File 物件建構一個 FileWriter 物件。
`FileWriter(File file, boolean append)` 根據給定的 File 物件建構一個 FileWriter 物件。
`FileWriter(String fileName)` 根據給定的檔案名建構一個 FileWriter 物件。
`FileWriter(String fileName, boolean append)` 根據給定的檔案名以及指示是否附加寫入資料的 boolean 值來建構 FileWriter 物件。
`ObjectInputStream()` 為完全重新實作 ObjectInputStream 的子類別提供一種方式，讓它不必分派僅由 ObjectInputStream 的實作使用的私有資料。
`ObjectInputStream(InputStream in)` 創建從指定 InputStream 讀取的 ObjectInputStream。
`ObjectOutputStream()` 為完全重新實作 ObjectOutputStream 的子類別提供一種方法，讓它不必分派僅由 ObjectOutputStream 的實作使用的私有資料。
`ObjectOutputStream(OutputStream out)` 創建寫入指定 OutputStream 的 ObjectOutputStream。
`PipedInputStream(PipedOutputStream src)` 創建 `PipedInputStream`，使其連接到管道輸出串流 `src`。
`PipedInputStream(PipedOutputStream src, int pipeSize)` 創建一個 `PipedInputStream`，使其連接到管道輸出串流 `src`，並對管道緩衝區使用指定的管道大小。
`PipedOutputStream(PipedInputStream snk)` 創建連接到指定管道輸入串流的管道輸出串流。
`PipedReader(PipedWriter src)` 創建連接到傳送 writer `src` 的 `PipedReader`。
`PipedReader(PipedWriter src, int pipeSize)` 創建一個 `PipedReader`，使其連接到管道 writer `src`，並對管道緩衝區使用指定的管道大小。
`PipedWriter(PipedReader snk)` 創建傳送 writer，使其連接到指定的傳送 reader。

java.lang 中 IOException 的使用

拋出 IOException 的 java.lang 中的方法
`Appendable`	`Appendable.append(char c)` 向此 `Appendable` 添加指定字元。
`Appendable`	`Appendable.append(CharSequence csq)` 向此 `Appendable` 添加指定的字元序列。
`Appendable`	`Appendable.append(CharSequence csq, int start, int end)` 向此 `Appendable` 添加指定字元序列的子序列。
`Process`	`Runtime.exec(String command)` 在單獨的進程中執行指定的字元串命令。
`Process`	`Runtime.exec(String[] cmdarray)` 在單獨的進程中執行指定命令和變數。
`Process`	`Runtime.exec(String[] cmdarray, String[] envp)` 在指定環境的獨立進程中執行指定命令和變數。
`Process`	`Runtime.exec(String[] cmdarray, String[] envp, File dir)` 在指定環境和工作目錄的獨立進程中執行指定的命令和變數。
`Process`	`Runtime.exec(String command, String[] envp)` 在指定環境的單獨進程中執行指定的字元串命令。
`Process`	`Runtime.exec(String command, String[] envp, File dir)` 在有指定環境和工作目錄的獨立進程中執行指定的字元串命令。
`protected Enumeration<URL>`	`ClassLoader.findResources(String name)` 返回表示所有具有給定名稱的資源的 `URL` 物件的列舉。
`Enumeration<URL>`	`ClassLoader.getResources(String name)` 尋找所有給定名稱的資源。
`static Enumeration<URL>`	`ClassLoader.getSystemResources(String name)` 從用來載入類別的搜尋路徑中尋找所有具有指定名稱的資源。
`static Channel`	`System.inheritedChannel()` 返回從創建此 Java 虛擬機器的實體中繼承的通道。
`int`	`Readable.read(CharBuffer cb)` 試圖將字元讀入指定的字元緩衝區。
`Process`	`ProcessBuilder.start()` 使用此進程產生器的屬性啟動一個新進程。

java.lang.management 中 IOException 的使用

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

static



<T> T

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

返回用於給定 MXBean 名稱的平臺 MXBean 介面的代理，以便通過給定 MBeanServerConnection 轉發其方法調用。

java.net 中 IOException 的使用

java.net 中 IOException 的子類別
`class`	`BindException` 試圖將Socket綁定到本地位址和埠號時發生錯誤的情況下，拋出此異常。
`class`	`HttpRetryException` 拋出此異常指示 HTTP 請求需要重試，但由於啟用了串流網要而無法自動重試。
`class`	`MalformedURLException` 拋出這一異常指示出現了錯誤的 URL。
`class`	`NoRouteToHostException` 試圖將Socket連接到遠端位址和埠號時發生錯誤的情況下，拋出此異常。
`class`	`PortUnreachableException` 在連接的資料電報上已接收到 ICMP Port Unreachable 訊息時，拋出該異常。
`class`	`ProtocolException` 拋出此異常指示在底層協議中存在錯誤，如 TCP 錯誤。
`class`	`SocketException` 拋出此異常指示在底層協議中存在錯誤，如 TCP 錯誤。
`class`	`SocketTimeoutException` 如果在讀取或接受Socket時發生逾時，則拋出此異常。
`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()` 偵聽並接受到此Socket的連接。
`protected abstract void`	`SocketImpl.accept(SocketImpl s)` 接受連接。
`protected abstract int`	`SocketImpl.available()` 返回可以不受阻塞地從此Socket中讀取的位元組數。
`protected abstract void`	`SocketImpl.bind(InetAddress host, int port)` 將此Socket綁定到指定的本地 IP 位址和埠號號。
`void`	`ServerSocket.bind(SocketAddress endpoint)` 將 `ServerSocket` 綁定到特定位址（IP 位址和埠號號）。
`void`	`Socket.bind(SocketAddress bindpoint)` 將Socket綁定到本地位址。
`void`	`ServerSocket.bind(SocketAddress endpoint, int backlog)` 將 `ServerSocket` 綁定到特定位址（IP 位址和埠號號）。
`void`	`ServerSocket.close()` 關閉此Socket。
`protected abstract void`	`SocketImpl.close()` 關閉此Socket。
`void`	`Socket.close()` 關閉此Socket。
`abstract void`	`URLConnection.connect()` 打開到此 URL 參考的資源的通信連接（如果尚未建立這樣的連接）。
`protected abstract void`	`SocketImpl.connect(InetAddress address, int port)` 將此Socket連接到指定主機上的指定埠號號。
`void`	`Socket.connect(SocketAddress endpoint)` 將此Socket連接到伺服器。
`protected abstract void`	`SocketImpl.connect(SocketAddress address, int timeout)` 將此Socket連接到指定主機上的指定埠號號。
`void`	`Socket.connect(SocketAddress endpoint, int timeout)` 將此Socket連接到伺服器，並指定一個逾時值。
`protected abstract void`	`SocketImpl.connect(String host, int port)` 將此Socket連接到指定主機上的指定埠號。
`protected abstract void`	`SocketImpl.create(boolean stream)` 創建一個串流或資料電報Socket。
`Enumeration<URL>`	`URLClassLoader.findResources(String name)` 返回表示 URL 搜尋路徑中具有指定名稱的所有資源的 URL 列舉。
`abstract Map<String,List<String>>`	`CookieHandler.get(URI uri, Map<String,List<String>> requestHeaders)` 從請求頭中指定 uri 的 cookie 快取記憶體中獲取所有可用的 cookie。
`Map<String,List<String>>`	`CookieManager.get(URI uri, Map<String,List<String>> requestHeaders)`
`abstract CacheResponse`	`ResponseCache.get(URI uri, String rqstMethod, Map<String,List<String>> rqstHeaders)` 根據請求的 uri、請求方法和請求頭獲取快取記憶體的回應。
`Attributes`	`JarURLConnection.getAttributes()` 如果此連接的 URL 指向 JAR 檔案條目，則返回其 Attribute 物件；否則返回 null。
`abstract OutputStream`	`CacheRequest.getBody()` 返回可以將回應正文寫入其中的 OutputStream。
`abstract InputStream`	`CacheResponse.getBody()` 以 InputStream 的形式返迴響應正文。
`Certificate[]`	`JarURLConnection.getCertificates()` 如果此連接的 URL 指向 JAR 檔案條目，則返回其 Certificate 物件；否則返回 null。
`Object`	`URLConnection.getContent()` 獲取此 URL 連接的內容。
`Object`	`URL.getContent()` 獲取此 URL 的內容。
`Object`	`URLConnection.getContent(Class[] classes)` 獲取此 URL 連接的內容。
`Object`	`URL.getContent(Class[] classes)` 獲取此 URL 的內容。
`abstract Object`	`ContentHandler.getContent(URLConnection urlc)` 如果給出位於物件表示形式開頭的 URL 連接串流，則此方法讀取該串流並根據其創建物件。
`Object`	`ContentHandler.getContent(URLConnection urlc, Class[] classes)` 如果給出位於物件表示形式開頭的 URL 連接串流，則此方法讀取該串流並創建與給定型別之一比對的物件。
`abstract Map<String,List<String>>`	`CacheResponse.getHeaders()` 以 Map 的形式返迴響應頭。
`protected abstract InputStream`	`SocketImpl.getInputStream()` 返回此Socket的輸入串流。
`InputStream`	`Socket.getInputStream()` 返回此Socket的輸入串流。
`InputStream`	`URLConnection.getInputStream()` 返回從此打開的連接讀取的輸入串流。
`JarEntry`	`JarURLConnection.getJarEntry()` 返回此連接的 JAR 條目物件（如果有）。
`abstract JarFile`	`JarURLConnection.getJarFile()` 返回此連接的 JAR 檔案。
`Attributes`	`JarURLConnection.getMainAttributes()` 返回此連接的 JAR 檔案的主要 Attribute。
`Manifest`	`JarURLConnection.getManifest()` 返回此連接的 Manifest；如果沒有，則返回 null。
`protected abstract OutputStream`	`SocketImpl.getOutputStream()` 返回此Socket的輸出串流。
`OutputStream`	`Socket.getOutputStream()` 返回此Socket的輸出串流。
`OutputStream`	`URLConnection.getOutputStream()` 返回寫入到此連接的輸出串流。
`Permission`	`HttpURLConnection.getPermission()`
`Permission`	`URLConnection.getPermission()` 返回一個權限物件，其代表建立此物件表示的連接所需的權限。
`int`	`HttpURLConnection.getResponseCode()` 從 HTTP 回應訊息獲取狀態碼。
`String`	`HttpURLConnection.getResponseMessage()` 獲取與來自伺服器的回應程式碼一起返回的 HTTP 回應訊息（如果有）。
`int`	`ServerSocket.getSoTimeout()` 獲取 SO_TIMEOUT 的設置。
`protected abstract int`	`DatagramSocketImpl.getTimeToLive()` 獲取 TTL （生存時間）選項。
`int`	`MulticastSocket.getTimeToLive()` 獲取在Socket上發出的多點傳送資料封包的預設生存時間。
`protected abstract byte`	`DatagramSocketImpl.getTTL()` 已過時。使用 getTimeToLive 代替。
`byte`	`MulticastSocket.getTTL()` 已過時。使用 getTimeToLive 方法來代替，該方法返回 int（而不是 byte）。
`static String`	`URLConnection.guessContentTypeFromStream(InputStream is)` 根據輸入串流的開始字元嘗試確定輸入串流的型別。
`protected void`	`ServerSocket.implAccept(Socket s)` ServerSocket 的子類別使用此方法覆寫 accept() 以返回它們自己的Socket子類別。
`boolean`	`InetAddress.isReachable(int timeout)` 測試是否可以達到該位址。
`boolean`	`InetAddress.isReachable(NetworkInterface netif, int ttl, int timeout)` 測試是否可以達到該位址。
`protected abstract void`	`DatagramSocketImpl.join(InetAddress inetaddr)` 加入多點傳送組。
`void`	`MulticastSocket.joinGroup(InetAddress mcastaddr)` 加入多點傳送組。
`protected abstract void`	`DatagramSocketImpl.joinGroup(SocketAddress mcastaddr, NetworkInterface netIf)` 加入多點傳送組。
`void`	`MulticastSocket.joinGroup(SocketAddress mcastaddr, NetworkInterface netIf)` 加入指定介面上的指定多點傳送組。
`protected abstract void`	`DatagramSocketImpl.leave(InetAddress inetaddr)` 退出多點傳送組。
`void`	`MulticastSocket.leaveGroup(InetAddress mcastaddr)` 離開多點傳送組。
`protected abstract void`	`DatagramSocketImpl.leaveGroup(SocketAddress mcastaddr, NetworkInterface netIf)` 退出多點傳送組。
`void`	`MulticastSocket.leaveGroup(SocketAddress mcastaddr, NetworkInterface netIf)` 離開指定本地介面上的多點傳送組。
`protected abstract void`	`SocketImpl.listen(int backlog)` 將傳入連接指示（連接請求）的最大佇列長度設置為 `count` 參數。
`URLConnection`	`URL.openConnection()` 返回一個 `URLConnection` 物件，它表示到 `URL` 所參考的遠端物件的連接。
`URLConnection`	`URL.openConnection(Proxy proxy)` 與 openConnection() 類似，所不同是連接通過指定的代理建立；不支持代理方式的協議處理程序將忽略該代理參數並建立正常的連接。
`protected abstract URLConnection`	`URLStreamHandler.openConnection(URL u)` 打開一個到 `URL` 參數參考的物件的連接。
`protected URLConnection`	`URLStreamHandler.openConnection(URL u, Proxy p)` 與 openConnection(URL) 相同，不同點在於：通過指定的代理進行連接；不支持代理方式的協議處理程序將忽略該代理參數並進行正常的連接。
`InputStream`	`URL.openStream()` 打開到此 `URL` 的連接並返回一個用於從該連接讀入的 `InputStream`。
`protected abstract int`	`DatagramSocketImpl.peek(InetAddress i)` 查看包來自哪裡。
`protected abstract int`	`DatagramSocketImpl.peekData(DatagramPacket p)` 查看包來自哪裡。
`abstract void`	`CookieHandler.put(URI uri, Map<String,List<String>> responseHeaders)` 將回應頭中出現的所有可用 cookie（例如名為 Set-Cookie2 的回應頭欄位）設置到 cookie 快取記憶體中。
`void`	`CookieManager.put(URI uri, Map<String,List<String>> responseHeaders)`
`abstract CacheRequest`	`ResponseCache.put(URI uri, URLConnection conn)` 協議處理程序在獲得資源後調用此方法，ResponseCache 必須決定是否在其快取記憶體中存儲資源。
`protected abstract void`	`DatagramSocketImpl.receive(DatagramPacket p)` 接收資料電報封包。
`void`	`DatagramSocket.receive(DatagramPacket p)` 從此Socket接收資料電報封包。
`protected abstract void`	`DatagramSocketImpl.send(DatagramPacket p)` 發送資料電報封包。
`void`	`DatagramSocket.send(DatagramPacket p)` 從此Socket發送資料電報封包。
`void`	`MulticastSocket.send(DatagramPacket p, byte ttl)` 已過時。使用以下程式碼或其等效程式碼：...... int ttl = mcastSocket.getTimeToLive(); mcastSocket.setTimeToLive(newttl); mcastSocket.send(p); mcastSocket.setTimeToLive(ttl); ......
`protected abstract void`	`SocketImpl.sendUrgentData(int data)` 在Socket上發送一個緊急資料位元組。
`void`	`Socket.sendUrgentData(int data)` 在Socket上發送一個緊急資料位元組。
`static void`	`DatagramSocket.setDatagramSocketImplFactory(DatagramSocketImplFactory fac)` 為應用程序設置資料電報Socket實作處理器。
`static void`	`ServerSocket.setSocketFactory(SocketImplFactory fac)` 為應用程序設置伺服器Socket實作處理器。
`static void`	`Socket.setSocketImplFactory(SocketImplFactory fac)` 為應用程序設置客戶端Socket實作處理器。
`protected abstract void`	`DatagramSocketImpl.setTimeToLive(int ttl)` 設置 TTL （生存時間）選項。
`void`	`MulticastSocket.setTimeToLive(int ttl)` 設置在此 `MulticastSocket` 上發出的多點傳送資料封包的預設生存時間，以便控制多點傳送的範圍。
`protected abstract void`	`DatagramSocketImpl.setTTL(byte ttl)` 已過時。使用 setTimeToLive 代替。
`void`	`MulticastSocket.setTTL(byte ttl)` 已過時。使用 setTimeToLive 方法來代替，該方法使用 int（而不用 byte）作為 ttl 的型別。
`protected void`	`SocketImpl.shutdownInput()` 將此Socket的輸入串流置於“串流的末尾”。
`void`	`Socket.shutdownInput()` 此Socket的輸入串流置於“串流的末尾”。
`protected void`	`SocketImpl.shutdownOutput()` 禁用此Socket的輸出串流。
`void`	`Socket.shutdownOutput()` 禁用此Socket的輸出串流。

拋出 IOException 的 java.net 中的建構子
`MulticastSocket()` 創建多點傳送Socket。
`MulticastSocket(int port)` 創建多點傳送Socket並將其綁定到特定埠號。
`MulticastSocket(SocketAddress bindaddr)` 創建綁定到指定Socket位址的 MulticastSocket。
`ServerSocket()` 創建非綁定伺服器Socket。
`ServerSocket(int port)` 創建綁定到特定埠號的伺服器Socket。
`ServerSocket(int port, int backlog)` 利用指定的 backlog 創建伺服器Socket並將其綁定到指定的本地埠號號。
`ServerSocket(int port, int backlog, InetAddress bindAddr)` 使用指定的埠號、偵聽 backlog 和要綁定到的本地 IP 位址創建伺服器。
`Socket(InetAddress address, int port)` 創建一個串流Socket並將其連接到指定 IP 位址的指定埠號號。
`Socket(InetAddress host, int port, boolean stream)` 已過時。 Use DatagramSocket instead for UDP transport.
`Socket(InetAddress address, int port, InetAddress localAddr, int localPort)` 創建一個Socket並將其連接到指定遠端位址上的指定遠端埠號。
`Socket(String host, int port)` 創建一個串流Socket並將其連接到指定主機上的指定埠號號。
`Socket(String host, int port, boolean stream)` 已過時。使用 DatagramSocket 取代 UDP 傳輸。
`Socket(String host, int port, InetAddress localAddr, int localPort)` 創建一個Socket並將其連接到指定遠端主機上的指定遠端埠號。

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()` 接受到此通道Socket的連接。
`abstract void`	`Selector.close()` 關閉此選擇器。
`void`	`InterruptibleChannel.close()` 關閉此通道。
`void`	`Channel.close()` 關閉此通道。
`abstract SelectableChannel`	`SelectableChannel.configureBlocking(boolean block)` 調整此通道的阻塞網要。
`abstract DatagramChannel`	`DatagramChannel.connect(SocketAddress remote)` 連接此通道的Socket。
`abstract boolean`	`SocketChannel.connect(SocketAddress remote)` 連接此通道的Socket。
`abstract DatagramChannel`	`DatagramChannel.disconnect()` 斷開此通道Socket的連接。
`abstract boolean`	`SocketChannel.finishConnect()` 完成Socket通道的連接過程。
`abstract void`	`FileChannel.force(boolean metaData)` 強制將所有對此通道的檔案更新寫入包含該檔案的存儲設備中。
`FileLock`	`FileChannel.lock()` 獲取對此通道的檔案的獨佔鎖定。
`abstract FileLock`	`FileChannel.lock(long position, long size, boolean shared)` 獲取此通道的檔案給定區域上的鎖定。
`abstract MappedByteBuffer`	`FileChannel.map(FileChannel.MapMode mode, long position, long size)` 將此通道的檔案區域直接映射到記憶體中。
`static DatagramChannel`	`DatagramChannel.open()` 打開資料電報通道。
`static Pipe`	`Pipe.open()` 打開一個管道。
`static Selector`	`Selector.open()` 打開一個選擇器。
`static ServerSocketChannel`	`ServerSocketChannel.open()` 打開伺服器Socket通道。
`static SocketChannel`	`SocketChannel.open()` 打開Socket通道。
`static SocketChannel`	`SocketChannel.open(SocketAddress remote)` 打開Socket通道並將其連接到遠端位址。
`abstract long`	`FileChannel.position()` 返回此通道的檔案位置。
`abstract FileChannel`	`FileChannel.position(long newPosition)` 設置此通道的檔案位置。
`abstract int`	`DatagramChannel.read(ByteBuffer dst)` 從此通道讀取資料電報。
`abstract int`	`SocketChannel.read(ByteBuffer dst)`
`abstract int`	`FileChannel.read(ByteBuffer dst)` 將位元組序列從此通道讀入給定的緩衝區。
`int`	`ReadableByteChannel.read(ByteBuffer dst)` 將位元組序列從此通道中讀入給定的緩衝區。
`long`	`DatagramChannel.read(ByteBuffer[] dsts)` 從此通道讀取資料電報。
`long`	`SocketChannel.read(ByteBuffer[] dsts)`
`long`	`FileChannel.read(ByteBuffer[] dsts)` 將位元組序列從此通道讀入給定的緩衝區。
`long`	`ScatteringByteChannel.read(ByteBuffer[] dsts)` 將位元組序列從此通道讀入給定的緩衝區。
`abstract long`	`DatagramChannel.read(ByteBuffer[] dsts, int offset, int length)` 從此通道讀取資料電報。
`abstract long`	`SocketChannel.read(ByteBuffer[] dsts, int offset, int length)`
`abstract long`	`FileChannel.read(ByteBuffer[] dsts, int offset, int length)` 將位元組序列從此通道讀入給定緩衝區的子序列中。
`long`	`ScatteringByteChannel.read(ByteBuffer[] dsts, int offset, int length)` 將位元組序列從此通道讀入給定緩衝區的子序列中。
`abstract int`	`FileChannel.read(ByteBuffer dst, long position)` 從給定的檔案位置開始，從此通道讀取位元組序列,並寫入給定的緩衝區。
`abstract SocketAddress`	`DatagramChannel.receive(ByteBuffer dst)` 通過此通道接收資料電報。
`abstract void`	`FileLock.release()` 釋放此鎖定。
`abstract int`	`Selector.select()` 選擇一組鍵，其相應的通道已為 I/O 操作準備就緒。
`abstract int`	`Selector.select(long timeout)` 選擇一組鍵，其相應的通道已為 I/O 操作準備就緒。
`abstract int`	`Selector.selectNow()` 選擇一組鍵，其相應的通道已為 I/O 操作準備就緒。
`abstract int`	`DatagramChannel.send(ByteBuffer src, SocketAddress target)` 通過此通道發送資料電報。
`abstract long`	`FileChannel.size()` 返回此通道的檔案的當前大小。
`abstract long`	`FileChannel.transferFrom(ReadableByteChannel src, long position, long count)` 將位元組從給定的可讀取位元組通道傳輸到此通道的檔案中。
`abstract long`	`FileChannel.transferTo(long position, long count, WritableByteChannel target)` 將位元組從此通道的檔案傳輸到給定的可寫入位元組通道。
`abstract FileChannel`	`FileChannel.truncate(long size)` 將此通道的檔案截取為給定大小。
`FileLock`	`FileChannel.tryLock()` 試圖獲取對此通道的檔案的獨佔鎖定。
`abstract FileLock`	`FileChannel.tryLock(long position, long size, boolean shared)` 試圖獲取對此通道的檔案給定區域的鎖定。
`abstract int`	`DatagramChannel.write(ByteBuffer src)` 將資料電報寫入此通道。
`abstract int`	`SocketChannel.write(ByteBuffer src)`
`abstract int`	`FileChannel.write(ByteBuffer src)` 將位元組序列從給定的緩衝區寫入此通道。
`int`	`WritableByteChannel.write(ByteBuffer src)` 將位元組序列從給定的緩衝區中寫入此通道。
`long`	`DatagramChannel.write(ByteBuffer[] srcs)` 將資料電報寫入此通道。
`long`	`SocketChannel.write(ByteBuffer[] srcs)`
`long`	`FileChannel.write(ByteBuffer[] srcs)` 將位元組序列從給定的緩衝區寫入此通道。
`long`	`GatheringByteChannel.write(ByteBuffer[] srcs)` 將位元組序列從給定的緩衝區寫入此通道。
`abstract long`	`DatagramChannel.write(ByteBuffer[] srcs, int offset, int length)` 將資料電報寫入此通道。
`abstract long`	`SocketChannel.write(ByteBuffer[] srcs, int offset, int length)`
`abstract long`	`FileChannel.write(ByteBuffer[] srcs, int offset, int length)` 將位元組序列從給定緩衝區的子序列寫入此通道。
`long`	`GatheringByteChannel.write(ByteBuffer[] srcs, int offset, int length)` 將位元組序列從給定緩衝區的子序列寫入此通道。
`abstract int`	`FileChannel.write(ByteBuffer src, long position)` 從給定的檔案位置開始，將位元組序列從給定緩衝區寫入此通道。

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

拋出 IOException 的 java.nio.channels.spi 中的方法
`void`	`AbstractSelector.close()` 關閉此選擇器。
`void`	`AbstractInterruptibleChannel.close()` 關閉此通道。
`SelectableChannel`	`AbstractSelectableChannel.configureBlocking(boolean block)` 調整此通道的阻塞網要。
`protected void`	`AbstractSelectableChannel.implCloseChannel()` 關閉此通道。
`protected abstract void`	`AbstractInterruptibleChannel.implCloseChannel()` 關閉此通道。
`protected abstract void`	`AbstractSelectableChannel.implCloseSelectableChannel()` 關閉此可選擇通道。
`protected abstract void`	`AbstractSelector.implCloseSelector()` 關閉此選擇器。
`protected abstract void`	`AbstractSelectableChannel.implConfigureBlocking(boolean block)` 調整此通道的阻塞網要。
`Channel`	`SelectorProvider.inheritedChannel()` 返回從創建此 Java 虛擬機器的實體中繼承的通道。
`abstract DatagramChannel`	`SelectorProvider.openDatagramChannel()` 打開資料電報通道。
`abstract Pipe`	`SelectorProvider.openPipe()` 打開一個管道。
`abstract AbstractSelector`	`SelectorProvider.openSelector()` 打開一個選擇器。
`abstract ServerSocketChannel`	`SelectorProvider.openServerSocketChannel()` 打開伺服器Socket通道。
`abstract SocketChannel`	`SelectorProvider.openSocketChannel()` 打開Socket通道。

java.nio.charset 中 IOException 的使用

java.nio.charset 中 IOException 的子類別
`class`	`CharacterCodingException` 出現字元編碼或解碼錯誤時，拋出此經過檢查的異常。
`class`	`MalformedInputException` 當輸入位元組序列對於給定 charset 來說是不合法的，或者輸入字元序列不是合法的 16 位 Unicode 序列時，拋出此經過檢查的異常。
`class`	`UnmappableCharacterException` 當輸入字元（或位元組）序列有效，但不能被映射為輸出位元組（或字元）序列時，拋出此經過檢查的異常。

java.rmi 中 IOException 的使用

java.rmi 中 IOException 的子類別
`class`	`AccessException` `AccessException` 由 `java.rmi.Naming` 類別（特別是 `bind`、`rebind` 和 `unbind`）的某些方法和 `java.rmi.activation.ActivationSystem` 介面的方法拋出，以指示調用方不允許執行該方法調用所請求的操作。
`class`	`ConnectException` 如果拒絕遠端主機對連接的遠端方法調用，則拋出 `ConnectException`。
`class`	`ConnectIOException` 如果在連接到遠端主機以便進行遠端方法調用時發生 `IOException`，則拋出 `ConnectIOException`。
`class`	`MarshalException` 如果在編組遠端調用標題、參數或遠端方法調用的返回值時發生 `java.io.IOException`，則拋出 `MarshalException`。
`class`	`NoSuchObjectException` 如果試圖調用遠端虛擬機器上已不存在的物件上的方法，則拋出 `NoSuchObjectException`。
`class`	`RemoteException` `RemoteException` 是許多與通信相關的異常的通用父級類別，這些異常可能會在執行遠端方法調用期間發生。
`class`	`ServerError` 當在伺服器上處理遠端方法調用時（既可以是解編參數、執行遠端方法本身時，也可以是編組返回值時），如果拋出 `Error`，則作為遠端方法調用的結果，將拋出 `ServerError`。
`class`	`ServerException` 在伺服器上處理遠端方法調用（既可以在解編參數時，也可以是在執行遠端方法本身時）時，如果拋出 `RemoteException`，則作為遠端方法調用的結果，也會拋出 `ServerException`。
`class`	`ServerRuntimeException` 已過時。無替換版本
`class`	`StubNotFoundException` 如果在導入某個遠端物件時無法找到該物件的有效 stub 類別，則拋出 `StubNotFoundException`。
`class`	`UnexpectedException` 如果遠端方法調用的客戶機因為該調用而收到一個未經檢查的異常（該異常不屬於遠端介面方法的 `throws` 語句中宣告的經檢查的異常型別），則拋出 `UnexpectedException`。
`class`	`UnmarshalException` 在解組參數時或者如果發生以下任何情況導致遠端方法調用，則拋出 `UnmarshalException`：如果在解組調用標題時發生異常如果返回值的協議無效如果解組參數（在伺服器端）或返回值（在客戶機端）時發生 `java.io.IOException`。

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

拋出 IOException 的 java.rmi 中的建構子
`MarshalledObject(T obj)` 創建一個新的 `MarshalledObject`，它包含所提供物件的當前狀態的序列化表示形式。

java.rmi.activation 中 IOException 的使用

java.rmi.activation 中 IOException 的子類別
`class`	`ActivateFailedException` 在一個對可啟動物件的遠端調用過程中，當啟動失敗時，此異常由 RMI 運行時拋出。

java.rmi.server 中 IOException 的使用

java.rmi.server 中 IOException 的子類別
`class`	`ExportException` `ExportException` 是在嘗試導出遠端物件失敗時拋出的 `RemoteException`。
`class`	`SkeletonMismatchException` 已過時。無替代版本。在 Java 2 平臺 1.2 版及更高版本中，遠端方法調用不再需要 Skeleton。
`class`	`SkeletonNotFoundException` 已過時。無替代版本在 Java 2 平臺 1.2 版及更高版本中，遠端方法調用不再需要 Skeleton。
`class`	`SocketSecurityException` 已廢棄的 `ExportException` 的子類別。

拋出 IOException 的 java.rmi.server 中的方法
`ServerSocket`	`RMIServerSocketFactory.createServerSocket(int port)` 在指定埠號上（埠號 0 指示匿名埠號）創建伺服器Socket。
`abstract ServerSocket`	`RMISocketFactory.createServerSocket(int port)` 在指定埠號上（埠號 0 指示匿名埠號）創建伺服器Socket。
`Socket`	`RMIClientSocketFactory.createSocket(String host, int port)` 創建連接到指定主機和埠號的客戶機Socket。
`abstract Socket`	`RMISocketFactory.createSocket(String host, int port)` 創建連接到指定主機和埠號的客戶機Socket。
`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 從中獲取Socket的全體Socket處理器（如果遠端對象與指定客戶機和/或伺服器Socket處理器無關）。
`void`	`UID.write(DataOutput out)` 將此 `UID` 的二進製表示形式編組為一個 `DataOutput` 實例。
`void`	`ObjID.write(ObjectOutput out)` 將此 `ObjID` 的二進製表示形式編組為一個 `ObjectOutput` 實例。

java.security 中 IOException 的使用

拋出 IOException 的 java.security 中的方法
`void`	`Certificate.decode(InputStream stream)` 已過時。從輸入串流解碼證書。
`void`	`Certificate.encode(OutputStream stream)` 已過時。以 `decode` 方法可以解碼的格式將證書編碼到輸出串流。
`protected abstract byte[]`	`AlgorithmParametersSpi.engineGetEncoded()` 返回基本編碼格式的參數。
`protected abstract byte[]`	`AlgorithmParametersSpi.engineGetEncoded(String format)` 返回以指定格式編碼的參數。
`protected abstract void`	`AlgorithmParametersSpi.engineInit(byte[] params)` 根據參數的基本解碼格式導入指定的參數並對其解碼。
`protected abstract void`	`AlgorithmParametersSpi.engineInit(byte[] params, String format)` 根據指定的解碼格式從 `params` 導入參數並對其解碼。
`abstract void`	`KeyStoreSpi.engineLoad(InputStream stream, char[] password)` 從給定的輸入串流中載入此 KeyStore。
`void`	`KeyStoreSpi.engineLoad(KeyStore.LoadStoreParameter param)` 使用給定的 `KeyStore.LoadStoreParameter` 載入該 keystore。
`void`	`KeyStoreSpi.engineStore(KeyStore.LoadStoreParameter param)` 使用給定的 `KeyStore.LoadStoreParmeter` 存儲此 keystore。
`abstract void`	`KeyStoreSpi.engineStore(OutputStream stream, char[] password)` 將此 keystore 存儲到給定輸出串流中，並用給定的密碼保護其完整性。
`byte[]`	`AlgorithmParameters.getEncoded()` 返回基本編碼格式的參數。
`byte[]`	`AlgorithmParameters.getEncoded(String format)` 返回以指定方案編碼的參數。
`Object`	`SignedObject.getObject()` 獲取已封裝的物件。
`void`	`AlgorithmParameters.init(byte[] params)` 根據參數的基本解碼格式導入指定的參數並對其解碼。
`void`	`AlgorithmParameters.init(byte[] params, String format)` 根據指定的解碼方案從 `params` 導入參數並對其解碼。
`void`	`Provider.load(InputStream inStream)` 從輸入串流中讀取屬性列表（鍵和元素對）。
`void`	`KeyStore.load(InputStream stream, char[] password)` 從給定輸入串流中載入此 KeyStore。
`void`	`KeyStore.load(KeyStore.LoadStoreParameter param)` 使用給定 `LoadStoreParameter` 載入此 keystore。
`int`	`DigestInputStream.read()` 讀取位元組並更新訊息摘要（如果開啟了摘要功能）。
`int`	`DigestInputStream.read(byte[] b, int off, int len)` 讀入 byte 陣列並更新訊息摘要（如果開啟了摘要功能）。
`void`	`KeyStore.store(KeyStore.LoadStoreParameter param)` 使用給定 `LoadStoreParameter` 存儲此 keystore。
`void`	`KeyStore.store(OutputStream stream, char[] password)` 將此 keystore 存儲到給定輸出串流，並用給定密碼保護其完整性。
`void`	`DigestOutputStream.write(byte[] b, int off, int len)` 使用指定的子陣列更新訊息摘要（如果開啟了摘要功能），並將子陣列寫入輸出串流（不管是否開啟了摘要功能）。
`void`	`DigestOutputStream.write(int b)` 使用指定的位元組更新訊息摘要（如果開啟了摘要功能），並將位元組寫入輸出串流（不管是否開啟了摘要功能）。

拋出 IOException 的 java.security 中的建構子
`SignedObject(Serializable object, PrivateKey signingKey, Signature signingEngine)` 通過任何可序列化物件建構 SignedObject。

java.security.cert 中 IOException 的使用

拋出 IOException 的 java.security.cert 中的方法
`void`	`X509CRLSelector.addIssuerName(byte[] name)` 向 issuerNames 標準中添加名稱。
`void`	`X509CRLSelector.addIssuerName(String name)` 已過時，使用 X509CRLSelector.addIssuer(X500Principal) 或 X509CRLSelector.addIssuerName(byte[]) 替代。
`void`	`X509CertSelector.addPathToName(int type, byte[] name)` 向 pathToNames 標準中添加一個名稱。
`void`	`X509CertSelector.addPathToName(int type, String name)` 向 pathToNames 標準中添加一個名稱。
`void`	`X509CertSelector.addSubjectAlternativeName(int type, byte[] name)` 向 subjectAlternativeNames 標準中添加一個名稱。
`void`	`X509CertSelector.addSubjectAlternativeName(int type, String name)` 向 subjectAlternativeNames 標準中添加一個名稱。
`byte[]`	`X509CertSelector.getIssuerAsBytes()` 返回以 byte 陣列表示的 issuer 標準。
`byte[]`	`X509CertSelector.getSubjectAsBytes()` 以 byte 陣列的形式返回 subject 標準。
`void`	`X509CertSelector.setExtendedKeyUsage(Set<String> keyPurposeSet)` 設置 extendedKeyUsage 標準。
`void`	`X509CertSelector.setIssuer(byte[] issuerDN)` 設置 issuer 標準。
`void`	`X509CertSelector.setIssuer(String issuerDN)` 已過時，使用 X509CertSelector.setIssuer(X500Principal) 或 X509CertSelector.setIssuer(byte[]) 替代。
`void`	`X509CRLSelector.setIssuerNames(Collection<?> names)` 注意：請使用 X509CRLSelector.setIssuers(Collection) 方法，或者使用此方法時僅指定 byte 陣列形式的標識名。
`void`	`X509CertSelector.setNameConstraints(byte[] bytes)` 設置 NameConstraints 標準。
`void`	`X509CertSelector.setPathToNames(Collection<List<?>> names)` 設置 pathToNames 標準。
`void`	`X509CertSelector.setPolicy(Set<String> certPolicySet)` 設置策略限制。
`void`	`X509CertSelector.setSubject(byte[] subjectDN)` 設置 subject 標準。
`void`	`X509CertSelector.setSubject(String subjectDN)` 已過時，使用 X509CertSelector.setSubject(X500Principal) 或 X509CertSelector.setSubject(byte[]) 替代。
`void`	`X509CertSelector.setSubjectAlternativeNames(Collection<List<?>> names)` 設置 subjectAlternativeNames 標準。
`void`	`X509CertSelector.setSubjectPublicKey(byte[] key)` 設置 subjectPublicKey 標準。
`void`	`X509CertSelector.setSubjectPublicKeyAlgID(String oid)` 設置 subjectPublicKeyAlgID 標準。

拋出 IOException 的 java.security.cert 中的建構子
`PolicyQualifierInfo(byte[] encoded)` 根據已編碼的位元組創建一個 `PolicyQualifierInfo` 實例。

java.util 中 IOException 的使用

java.util 中 IOException 的子類別
`class`	`InvalidPropertiesFormatException` 當按照 `Properties` 規範，輸入內容不符合屬性集的正確 XML 文檔型別，從而無法完成操作時，拋出此異常。

返回 IOException 的 java.util 中的方法
`IOException`	`Formatter.ioException()` 返回由此 formatter 的 `Appendable` 方法上次拋出的 `IOException` 異常。
`IOException`	`Scanner.ioException()` 返回此 `Scanner` 的底層 `Readable` 最後拋出的 `IOException`。

拋出 IOException 的 java.util 中的方法
`void`	`Properties.load(InputStream inStream)` 從輸入串流中讀取屬性列表（鍵和元素對）。
`void`	`Properties.load(Reader reader)` 按簡單的導向行的格式從輸入字元串流中讀取屬性列表（鍵和元素對）。
`void`	`Properties.loadFromXML(InputStream in)` 將指定輸入串流中由 XML 文檔所表示的所有屬性載入到此屬性表中。
`ResourceBundle`	`ResourceBundle.Control.newBundle(String baseName, Locale locale, String format, ClassLoader loader, boolean reload)` 針對給定格式和語言環境的給定套件名稱，實例化一個資源包，如有必要，可使用給定的類別載入器。
`void`	`Properties.store(OutputStream out, String comments)` 以適合使用 `load(InputStream)` 方法載入到 `Properties` 表中的格式，將此 `Properties` 表中的屬性列表（鍵和元素對）寫入輸出串流。
`void`	`Properties.store(Writer writer, String comments)` 以適合使用 `load(Reader)` 方法的格式，將此 `Properties` 表中的屬性列表（鍵和元素對）寫入輸出字元。
`void`	`Properties.storeToXML(OutputStream os, String comment)` 發出一個表示此表中包含的所有屬性的 XML 文檔。
`void`	`Properties.storeToXML(OutputStream os, String comment, String encoding)` 使用指定的編碼發出一個表示此表中包含的所有屬性的 XML 文檔。

拋出 IOException 的 java.util 中的建構子
`PropertyResourceBundle(InputStream stream)` 根據 `InputStream` 創建屬性資源套件。
`PropertyResourceBundle(Reader reader)` 根據 `Reader` 創建屬性資源套件。

java.util.jar 中 IOException 的使用

java.util.jar 中 IOException 的子類別
`class`	`JarException` 讀取或寫入 JAR 檔案時，如果發生某種錯誤，則拋出此異常。

拋出 IOException 的 java.util.jar 中的方法
`Attributes`	`JarEntry.getAttributes()` 返回此條目的 `Manifest` `Attributes`；如果沒有，則返回 `null`。
`InputStream`	`JarFile.getInputStream(ZipEntry ze)` 返回用於讀取指定 zip 檔案條目內容的輸入串流。
`Manifest`	`JarFile.getManifest()` 返回 jar 檔案清單；如果沒有，則返回 `null`。
`ZipEntry`	`JarInputStream.getNextEntry()` 讀取下一個 ZIP 檔案條目，並將串流定位於此條目資料的開始處。
`JarEntry`	`JarInputStream.getNextJarEntry()` 讀取下一個 JAR 檔案條目，並將串流定位於此條目資料的開始處。
`void`	`Pack200.Packer.pack(JarFile in, OutputStream out)` 接收 JarFile 並將其轉換為 Pack200 存檔。
`void`	`Pack200.Packer.pack(JarInputStream in, OutputStream out)` 接收 JarInputStream 並將其轉換成 Pack200 存檔。
`void`	`JarOutputStream.putNextEntry(ZipEntry ze)` 開始寫入新的 JAR 檔案條目，並將串流定位到條目資料的開始處。
`int`	`JarInputStream.read(byte[] b, int off, int len)` 從當前 JAR 檔案條目讀入位元組陣列。
`void`	`Manifest.read(InputStream is)` 從指定的 InputStream 讀取 Manifest。
`void`	`Pack200.Unpacker.unpack(File in, JarOutputStream out)` 讀取 Pack200 存檔，並將已編碼的 JAR 寫入 JarOutputStream。
`void`	`Pack200.Unpacker.unpack(InputStream in, JarOutputStream out)` 讀取 Pack200 存檔，並將已編碼的 JAR 寫入 JarOutputStream。
`void`	`Manifest.write(OutputStream out)` 將 Manifest 寫入指定的 OutputStream。

拋出 IOException 的 java.util.jar 中的建構子
`JarFile(File file)` 創建一個要從指定的 `File` 物件讀取的新的 `JarFile`。
`JarFile(File file, boolean verify)` 創建一個要從指定的 `File` 物件讀取的新的 `JarFile`。
`JarFile(File file, boolean verify, int mode)` 創建一個要從指定的 `File` 物件中以指定網要讀取的新的 `JarFile`。
`JarFile(String name)` 創建一個要從指定的檔案 `name` 讀取的新的 `JarFile`。
`JarFile(String name, boolean verify)` 創建一個要從指定的檔案 `name` 讀取的新的 `JarFile`。
`JarInputStream(InputStream in)` 創建新的 `JarInputStream` 並讀取可選的清單。
`JarInputStream(InputStream in, boolean verify)` 創建新的 `JarInputStream` 並讀取可選的清單。
`JarOutputStream(OutputStream out)` 創建不帶清單的新的 `JarOutputStream`。
`JarOutputStream(OutputStream out, Manifest man)` 使用指定的 `Manifest` 創建新的 `JarOutputStream`。
`Manifest(InputStream is)` 從指定的輸入串流建構新的 Manifest。

java.util.logging 中 IOException 的使用

拋出 IOException 的 java.util.logging 中的方法
`void`	`LogManager.readConfiguration()` 重新初始化日誌屬性並重新讀取日誌配置。
`void`	`LogManager.readConfiguration(InputStream ins)` 從給定串流重新初始化並重新讀取日誌配置，該配置為 java.util.Properties 格式。

拋出 IOException 的 java.util.logging 中的建構子
`FileHandler()` 建構一個預設的 `FileHandler`。
`FileHandler(String pattern)` 初始化要寫入給定檔案名的 `FileHandler` 。
`FileHandler(String pattern, boolean append)` 初始化要寫入給定檔案名的 `FileHandler`（使用可選的 append）。
`FileHandler(String pattern, int limit, int count)` 初始化要寫入檔案集的 `FileHandler`。
`FileHandler(String pattern, int limit, int count, boolean append)` 初始化要寫入檔案集的 `FileHandler`（使用可選的 append）。
`SocketHandler()` 僅使用 `LogManager` 屬性（或其預設值）創建 `SocketHandler`。
`SocketHandler(String host, int port)` 建構一個帶有指定主機和埠號的 `SocketHandler`。

java.util.prefs 中 IOException 的使用

拋出 IOException 的 java.util.prefs 中的方法
`void`	`AbstractPreferences.exportNode(OutputStream os)` 根據 `Preferences.exportNode(OutputStream)` 中的規範實作 `exportNode` 方法。
`abstract void`	`Preferences.exportNode(OutputStream os)` 在指定輸出串流上發出表示此節點（不是其子節點）中包含的所有首選項的 XML 文檔。
`void`	`AbstractPreferences.exportSubtree(OutputStream os)` 根據 `Preferences.exportSubtree(OutputStream)` 中的規範實作 `exportSubtree` 方法。
`abstract void`	`Preferences.exportSubtree(OutputStream os)` 發出表示此節點及其所有子節點中包含的全部首選項的 XML 文檔。
`static void`	`Preferences.importPreferences(InputStream is)` 導入指定輸入串流中由 XML 文檔表示的所有首選項。

java.util.zip 中 IOException 的使用

java.util.zip 中 IOException 的子類別
`class`	`ZipException` 如果某種 ZIP 異常發生，則拋出此錯誤。

拋出 IOException 的 java.util.zip 中的方法
`int`	`DeflaterInputStream.available()` 在到達 EOF 後返回 0；否則始終返回 1。
`int`	`ZipInputStream.available()` 在 EOF 到達當前條目資料後，返回 0；否則，始終返回 1。
`int`	`InflaterInputStream.available()` 在到達 EOF 後返回 0；否則始終返回 1。
`void`	`DeflaterInputStream.close()` 關閉此輸入串流和它的底層輸入串流，丟棄掛起的未壓縮資料。
`void`	`InflaterOutputStream.close()` 將剩餘未壓縮資料寫入輸出串流並關閉底層輸出串流。
`void`	`ZipOutputStream.close()` 關閉 ZIP 輸出串流和正在過濾的串流。
`void`	`DeflaterOutputStream.close()` 將剩餘壓縮資料寫入輸出串流並關閉底層串流。
`void`	`GZIPInputStream.close()` 關閉此輸入串流並釋放與該串流關聯的所有系統資源。
`void`	`ZipInputStream.close()` 關閉此輸入串流並釋放與此串流關聯的所有系統資源。
`void`	`InflaterInputStream.close()` 關閉此輸入串流並釋放與該串流關聯的所有系統資源。
`void`	`ZipFile.close()` 關閉 ZIP 檔案。
`void`	`ZipOutputStream.closeEntry()` 關閉當前 ZIP 條目並定位串流以寫入下一個條目。
`void`	`ZipInputStream.closeEntry()` 關閉當前 ZIP 條目並定位串流以讀取下一個條目。
`protected void`	`DeflaterOutputStream.deflate()` 將下一個壓縮資料塊寫入輸出串流。
`protected void`	`InflaterInputStream.fill()` 使用更多要解壓縮的資料填充輸入緩衝區。
`protected void`	`ZipFile.finalize()` 確保不再參考此 ZIP 檔案時調用它的 `close` 方法。
`void`	`GZIPOutputStream.finish()` 完成將壓縮資料寫入輸出串流的操作，無需關閉底層串流。
`void`	`InflaterOutputStream.finish()` 完成將未壓縮資料寫入輸出串流的操作，無需關閉底層串流。
`void`	`ZipOutputStream.finish()` 完成寫入 ZIP 輸出串流的內容，無需關閉底層串流。
`void`	`DeflaterOutputStream.finish()` 完成將壓縮資料寫入輸出串流的操作，無需關閉底層串流。
`void`	`InflaterOutputStream.flush()` 刷新此輸出串流，並強制寫出掛起的所有緩衝輸出位元組。
`InputStream`	`ZipFile.getInputStream(ZipEntry entry)` 返回輸入串流以讀取指定 ZIP 檔案條目的內容。
`ZipEntry`	`ZipInputStream.getNextEntry()` 讀取下一個 ZIP 檔案條目並將串流定位到該條目資料的開始處。
`void`	`ZipOutputStream.putNextEntry(ZipEntry e)` 開始寫入新的 ZIP 檔案條目並將串流定位到條目資料的開始處。
`int`	`CheckedInputStream.read()` 讀取位元組。
`int`	`DeflaterInputStream.read()` 從輸入串流讀取一個壓縮資料的單個位元組。
`int`	`InflaterInputStream.read()` 讀取未壓縮資料的位元組。
`int`	`CheckedInputStream.read(byte[] buf, int off, int len)` 讀入位元組陣列。
`int`	`DeflaterInputStream.read(byte[] b, int off, int len)` 將壓縮資料讀入 byte 陣列。
`int`	`GZIPInputStream.read(byte[] buf, int off, int len)` 將未壓縮資料讀入位元組陣列。
`int`	`ZipInputStream.read(byte[] b, int off, int len)` 從當前 ZIP 條目讀入位元組陣列。
`int`	`InflaterInputStream.read(byte[] b, int off, int len)` 將未壓縮資料讀入位元組陣列。
`void`	`DeflaterInputStream.reset()` 不支持此操作。
`void`	`InflaterInputStream.reset()` 將此串流重新定位到對此輸入串流最後調用 `mark` 方法時的位置。
`long`	`CheckedInputStream.skip(long n)` 跳過指定的輸入位元組數。
`long`	`DeflaterInputStream.skip(long n)` 從輸入串流中跳過並丟棄資料。
`long`	`ZipInputStream.skip(long n)` 跳過當前 ZIP 條目中指定的位元組數。
`long`	`InflaterInputStream.skip(long n)` 跳過指定的未壓縮資料的位元組數。
`void`	`CheckedOutputStream.write(byte[] b, int off, int len)` 寫入位元組陣列。
`void`	`GZIPOutputStream.write(byte[] buf, int off, int len)` 將位元組陣列寫入壓縮輸出串流。
`void`	`InflaterOutputStream.write(byte[] b, int off, int len)` 將 byte 陣列寫入未壓縮輸出串流。
`void`	`ZipOutputStream.write(byte[] b, int off, int len)` 將位元組陣列寫入當前 ZIP 條目資料。
`void`	`DeflaterOutputStream.write(byte[] b, int off, int len)` 將位元組陣列寫入壓縮的輸出串流。
`void`	`CheckedOutputStream.write(int b)` 寫入位元組。
`void`	`InflaterOutputStream.write(int b)` 將位元組寫入未壓縮輸出串流。
`void`	`DeflaterOutputStream.write(int b)` 將位元組寫入壓縮的輸出串流。

拋出 IOException 的 java.util.zip 中的建構子
`GZIPInputStream(InputStream in)` 使用預設緩衝區大小創建新的輸入串流。
`GZIPInputStream(InputStream in, int size)` 使用指定緩衝區大小創建新的輸入串流。
`GZIPOutputStream(OutputStream out)` 使用預設緩衝區大小創建新的輸出串流。
`GZIPOutputStream(OutputStream out, int size)` 使用指定緩衝區大小創建新的輸出串流。
`ZipFile(File file)` 打開供閱讀的 ZIP 檔案，由指定的 File 物件給出。
`ZipFile(File file, int mode)` 打開新的 `ZipFile` 以使用指定網要從指定 `File` 物件讀取。
`ZipFile(String name)` 打開 ZIP 檔案進行閱讀。

javax.activation 中 IOException 的使用

javax.activation 中 IOException 的子類別
`class`	`UnsupportedDataTypeException` 當請求操作不支持請求的資料型別時，拋出此異常。

拋出 IOException 的 javax.activation 中的方法
`Object`	`CommandInfo.getCommandObject(DataHandler dh, ClassLoader loader)` 返回已實例化的 JavaBean 元件。
`Object`	`DataHandler.getContent()` 以其首選 Object 的形式返回資料。
`Object`	`DataContentHandler.getContent(DataSource ds)` 返回一個物件，該物件表示其首選形式的資料。
`InputStream`	`DataHandler.getInputStream()` 獲取此物件的 InputSteam。
`InputStream`	`DataSource.getInputStream()` 此方法返回一個表示資料的 `InputStream`；如果無法提供，則拋出適當的異常。
`InputStream`	`FileDataSource.getInputStream()` 此方法將返回一個表示資料的 InputStream；如果不能返回，則拋出 IOException。
`InputStream`	`URLDataSource.getInputStream()` URL 的 getInputStream 方法。
`OutputStream`	`DataHandler.getOutputStream()` 獲取此 DataHandler 的 OutputStream，以允許覆寫底層資料。
`OutputStream`	`DataSource.getOutputStream()` 此方法返回一個可以寫入資料的 `OutputStream`，如果無法返回，則拋出適當的異常。
`OutputStream`	`FileDataSource.getOutputStream()` 此方法將返回一個表示資料的 OutputStream；如果不能返回，則拋出 IOException。
`OutputStream`	`URLDataSource.getOutputStream()` URL 的 getOutputStream 方法。
`Object`	`DataHandler.getTransferData(DataFlavor flavor)` 返回一個物件，該物件表示要傳輸的資料。
`Object`	`DataContentHandler.getTransferData(DataFlavor df, DataSource ds)` 返回一個物件，該物件表示將要傳輸的資料。
`void`	`MimeType.readExternal(ObjectInput in)` 對象可實作 readExternal 方法來恢復其內容：對於基本型別，調用 DataInput 的方法；對於物件、字元串和陣列，調用 readObject。
`void`	`CommandObject.setCommandContext(String verb, DataHandler dh)` 用請求處理的動詞和描述將要操作的資料的 DataHandler 來初始化 Command。
`void`	`MimeType.writeExternal(ObjectOutput out)` 對象可實作 writeExternal 方法來保存其內容：對於其基本值，調用 DataOutput 的方法；對於物件、字元串和陣列，調用 ObjectOutput 的 writeObject 方法。
`void`	`DataContentHandler.writeTo(Object obj, String mimeType, OutputStream os)` 將物件轉換為指定 MIME 型別的位元組串流，並將其寫入輸出串流。
`void`	`DataHandler.writeTo(OutputStream os)` 將資料寫入 `OutputStream`。

拋出 IOException 的 javax.activation 中的建構子
`MailcapCommandMap(String fileName)` 允許調用者指定 mailcap 檔案路徑的建構子。
`MimetypesFileTypeMap(String mimeTypeFileName)` 用從指定檔案中添加的程式條目建構 MimetypesFileTypeMap。

javax.activity 中 IOException 的使用

javax.activity 中 IOException 的子類別
`class`	`ActivityCompletedException` 任何存取 Activity 上下文的方法都可能拋出此異常，它指示不能繼續在 Activity 內部執行操作。
`class`	`ActivityRequiredException` 如果方法沒有接收到它所要求的 Activity 上下文，則容器將拋出此異常。
`class`	`InvalidActivityException` 任何存取 Activity 上下文的方法都可能拋出此異常，它指示嘗試調用或與嘗試調用相關的 Activity 上下文與 Activity 的當前狀態不相容。

javax.annotation.processing 中 IOException 的使用

javax.annotation.processing 中 IOException 的子類別
`class`	`FilerException` 指示一個檢測到試圖打開某一檔案的 `Filer`，該檔案違反 `Filer` 提供的保證。

拋出 IOException 的 javax.annotation.processing 中的方法
`JavaFileObject`	`Filer.createClassFile(CharSequence name, Element... originatingElements)` 創建一個新的類別檔案，並返回一個物件以允許寫入它。
`FileObject`	`Filer.createResource(JavaFileManager.Location location, CharSequence pkg, CharSequence relativeName, Element... originatingElements)` 創建一個用於寫入操作的新輔助資源檔案，並為它返回一個檔案物件。
`JavaFileObject`	`Filer.createSourceFile(CharSequence name, Element... originatingElements)` 創建一個新的源檔案，並返回一個物件以允許寫入它。
`FileObject`	`Filer.getResource(JavaFileManager.Location location, CharSequence pkg, CharSequence relativeName)` 返回一個用於讀取現有資源的物件。

javax.crypto 中 IOException 的使用

拋出 IOException 的 javax.crypto 中的方法
`int`	`CipherInputStream.available()` 返回不發生阻塞地從此輸入串流讀取的位元組數。
`void`	`CipherInputStream.close()` 關閉該輸入串流並釋放任何與該串流關聯的系統資源。
`void`	`CipherOutputStream.close()` 關閉此輸出串流並釋放任何與此串流關聯的系統資源。
`void`	`CipherOutputStream.flush()` 強制寫出已由封裝的密碼物件處理的任何快取記憶體輸出位元組來刷新此輸出串流。
`byte[]`	`EncryptedPrivateKeyInfo.getEncoded()` 返回此物件的 ASN.1 編碼。
`Object`	`SealedObject.getObject(Cipher c)` 獲取原始（封裝的）物件。
`Object`	`SealedObject.getObject(Key key)` 獲取原始（封裝的）物件。
`Object`	`SealedObject.getObject(Key key, String provider)` 獲取原始（封裝的）物件。
`int`	`CipherInputStream.read()` 從該輸入串流讀取下一資料位元組。
`int`	`CipherInputStream.read(byte[] b)` 從該輸入串流將 `b.length` 個資料位元組讀入到位元組陣列中。
`int`	`CipherInputStream.read(byte[] b, int off, int len)` 從該輸入串流將 `len` 個位元組資料讀入到位元組陣列中。
`long`	`CipherInputStream.skip(long n)` 跳過不發生阻塞地從該輸入串流讀取的位元組中的 `n` 個位元組的輸入。
`void`	`CipherOutputStream.write(byte[] b)` 從指定的位元組陣列中將 `b.length` 個位元組寫入此輸出串流。
`void`	`CipherOutputStream.write(byte[] b, int off, int len)` 將指定的位元組陣列中從 `off` 偏移量開始的 `len` 個位元組寫入此輸出串流。
`void`	`CipherOutputStream.write(int b)` 將指定的位元組寫入此輸出串流。

拋出 IOException 的 javax.crypto 中的建構子
`EncryptedPrivateKeyInfo(byte[] encoded)` 根據其 ASN.1 編碼建構（即解析）`EncryptedPrivateKeyInfo`。
`SealedObject(Serializable object, Cipher c)` 從任何 Serializable 物件建構一個 SealedObject。

javax.imageio 中 IOException 的使用

javax.imageio 中 IOException 的子類別
`class`	`IIOException` 該異常類別用於發出關於讀取和寫入操作的運行時故障的信號。

拋出 IOException 的 javax.imageio 中的方法
`boolean`	`ImageWriter.canInsertEmpty(int imageIndex)` 如果 writer 支持在給定索引處插入新的空圖像，則返回 `true`。
`boolean`	`ImageWriter.canInsertImage(int imageIndex)` 如果 writer 支持在給定索引處插入新圖像，則返回 `true`。
`boolean`	`ImageWriter.canRemoveImage(int imageIndex)` 如果 writer 支持在給定索引處移除現有圖像，則返回 `true`。
`boolean`	`ImageWriter.canReplaceImageMetadata(int imageIndex)` 如果有可能使用索引 `imageIndex` 替換與現有圖像有關的圖像元資料，則返回 `true`。
`boolean`	`ImageWriter.canReplacePixels(int imageIndex)` 如果 writer 允許使用 `replacePixels` 方法替換給定圖像的索引，則返回 `true`。
`boolean`	`ImageWriter.canReplaceStreamMetadata()` 如果有可能替換已存在於輸出中的串流元資料，則返回 `true`。
`boolean`	`ImageWriter.canWriteEmpty()` 如果 writer 支持寫入由單個圖像組成的完整圖像串流，則返回 `true`，這些物件帶有要輸出的不確定像素值、有關元資料和縮略圖。
`static ImageInputStream`	`ImageIO.createImageInputStream(Object input)` 返回一個 `ImageInputStream`，它將從給定 `Object` 中獲取輸入。
`static ImageOutputStream`	`ImageIO.createImageOutputStream(Object output)` 返回一個 `ImageOutputStream`，它將其輸出發送到給定 `Object`。
`void`	`ImageWriter.endInsertEmpty()` 完成對新圖像的插入，該操作是從以前調用 `prepareInsertEmpty` 開始的。
`void`	`ImageWriter.endReplacePixels()` 終止調用 `replacePixels` 的序列。
`void`	`ImageWriter.endWriteEmpty()` 完成對新圖像的寫入，該操作是從優先調用 `prepareWriteEmpty` 開始的。
`void`	`ImageWriter.endWriteSequence()` 完成以 `prepareWriteSequence` 開頭的一系列圖像的寫入。
`float`	`ImageReader.getAspectRatio(int imageIndex)` 以 `float` 的形式返回給定圖像的高寬比（即寬度除以高度）。
`String`	`ImageReader.getFormatName()` 返回一個標識輸入源格式的 `String`。
`abstract int`	`ImageReader.getHeight(int imageIndex)` 返回輸入源中的給定圖像的高度，以像素為單位。
`abstract IIOMetadata`	`ImageReader.getImageMetadata(int imageIndex)` 返回包含與給定圖像關聯的元資料的 `IIOMetadata` 物件，如果 reader 不支持讀取元資料、被設置為忽略元資料，或者沒有元資料可用，則返回 `null`。
`IIOMetadata`	`ImageReader.getImageMetadata(int imageIndex, String formatName, Set<String> nodeNames)` 返回表示與給定圖像關聯的元資料的 `IIOMetadata` 物件，如果 reader 不支持讀取元資料或者沒有元資料可用，則返回 `null`。
`abstract Iterator<ImageTypeSpecifier>`	`ImageReader.getImageTypes(int imageIndex)` 以 `ImageTypeSpecifier` 形式返回包含可能的圖像型別的 `Iterator`，給定圖像可能被解碼成這些型別。
`abstract int`	`ImageReader.getNumImages(boolean allowSearch)` 返回當前輸入源中可用的圖像數，不包括縮略圖。
`int`	`ImageReader.getNumThumbnails(int imageIndex)` 返回與給定圖像關聯的縮略圖預覽圖像的數量。
`ImageTypeSpecifier`	`ImageReader.getRawImageType(int imageIndex)` 返回一個 `ImageTypeSpecifier`，指示最能代表圖像“原始”內部格式的 `SampleModel` 和 `ColorModel`。
`abstract IIOMetadata`	`ImageReader.getStreamMetadata()` 返回一個 `IIOMetadata` 物件，它表示作為一個整體與輸入源關聯的元資料（即不與任何特定圖像關聯）；如果 reader 不支持讀取元資料、被設置為忽略元資料，或者沒有元資料可用，則返回 `null`。
`IIOMetadata`	`ImageReader.getStreamMetadata(String formatName, Set<String> nodeNames)` 返回一個 `IIOMetadata` 物件，它表示作為一個整體與輸入源關聯的元資料（即不與任何特定圖像關聯）。
`int`	`ImageReader.getThumbnailHeight(int imageIndex, int thumbnailIndex)` 返回通過索引 `thumbnailIndex` 指定的縮略圖預覽圖像的高度，其與通過索引 `ImageIndex` 指定的圖像關聯。
`int`	`ImageReader.getThumbnailWidth(int imageIndex, int thumbnailIndex)` 返回通過索引 `thumbnailIndex` 指定的縮略圖預覽圖像的寬度，其與通過索引 `ImageIndex` 指定的圖像關聯。
`int`	`ImageReader.getTileGridXOffset(int imageIndex)` 返回給定圖像中 tile (0, 0) 的左上角的 X 坐標。
`int`	`ImageReader.getTileGridYOffset(int imageIndex)` 返回給定圖像中 tile (0, 0) 的左上角的 Y 坐標。
`int`	`ImageReader.getTileHeight(int imageIndex)` 返回給定圖像中 tile 的高度。
`int`	`ImageReader.getTileWidth(int imageIndex)` 返回給定圖像中 tile 的寬度。
`abstract int`	`ImageReader.getWidth(int imageIndex)` 返回輸入源中的給定圖像的寬度，以像素為單位。
`boolean`	`ImageReader.hasThumbnails(int imageIndex)` 如果給定圖像具有與之關聯的縮略圖預覽圖像，則返回 `true`。
`boolean`	`ImageReader.isImageTiled(int imageIndex)` 如果圖像被組織成 tile（即等大小的非重疊矩形），則返回 `true`。
`boolean`	`ImageReader.isRandomAccessEasy(int imageIndex)` 如果給定圖像的存儲格式不會給像素的隨機存取帶來內在妨礙，則返回 `true`。
`void`	`ImageWriter.prepareInsertEmpty(int imageIndex, ImageTypeSpecifier imageType, int width, int height, IIOMetadata imageMetadata, List<? extends BufferedImage> thumbnails, ImageWriteParam param)` 從將帶有不確定像素值的新圖像插入現有圖像串流中開始。
`void`	`ImageWriter.prepareReplacePixels(int imageIndex, Rectangle region)` 準備好 writer，處理一系列對 `replacePixels` 方法的調用。
`void`	`ImageWriter.prepareWriteEmpty(IIOMetadata streamMetadata, ImageTypeSpecifier imageType, int width, int height, IIOMetadata imageMetadata, List<? extends BufferedImage> thumbnails, ImageWriteParam param)` 從寫入完整圖像串流開始，該圖像串流由帶有要輸出的不確定像素值、有關元資料和縮略圖的單個圖像組成。
`void`	`ImageWriter.prepareWriteSequence(IIOMetadata streamMetadata)` 使用提供的串流元資料物件準備一個串流，以接受一系列的後續 `writeToSequence` 調用。
`static BufferedImage`	`ImageIO.read(File input)` 返回一個 `BufferedImage`，作為使用 `ImageReader`（它是從當前已註冊 ImageReader 中自動選擇的）解碼所提供 `File` 的結果。
`static BufferedImage`	`ImageIO.read(ImageInputStream stream)` 返回一個 `BufferedImage`，作為使用 `ImageReader`（它是從當前已註冊 ImageReader 中自動選擇的）解碼所提供 `ImageInputStream` 的結果。
`static BufferedImage`	`ImageIO.read(InputStream input)` 返回一個 `BufferedImage`，作為使用 `ImageReader`（它是從當前已註冊 ImageReader 中自動選擇的）解碼所提供 `InputStream` 的結果。
`BufferedImage`	`ImageReader.read(int imageIndex)` 使用預設 `ImageReadParam` 讀取通過索引 `imageIndex` 指定的圖像，並將其作為一個完整的 `BufferedImage` 返回。
`abstract BufferedImage`	`ImageReader.read(int imageIndex, ImageReadParam param)` 使用所提供的 `ImageReadParam` 讀取通過索引 `imageIndex` 指定的物件，並將它作為一個完整的 `BufferedImage` 返回。
`static BufferedImage`	`ImageIO.read(URL input)` 返回一個 `BufferedImage`，作為使用 `ImageReader`（它是從當前已註冊 ImageReader 中自動選擇的）解碼所提供 `URL` 的結果。
`IIOImage`	`ImageReader.readAll(int imageIndex, ImageReadParam param)` 使用所提供的 `ImageReadParam` 讀取通過索引 `imageIndex` 指定的圖像，並返回包含圖像、縮略圖和相關圖像元資料的 `IIOImage`。
`Iterator<IIOImage>`	`ImageReader.readAll(Iterator<? extends ImageReadParam> params)` 以 `IIOImage` 物件形式返回包含輸入源中所有圖像、縮略圖和元資料的 `Iterator`，從 `getMinIndex` 給定的索引開始。
`RenderedImage`	`ImageReader.readAsRenderedImage(int imageIndex, ImageReadParam param)` 返回一個 `RenderedImage` 物件，該物件包含通過索引 `imageIndex` 指定的圖像的內容。
`Raster`	`ImageReader.readRaster(int imageIndex, ImageReadParam param)` 返回包含圖像串流中原始像素資料的新 `Raster` 物件，不應用任何顏色轉換。
`BufferedImage`	`ImageReader.readThumbnail(int imageIndex, int thumbnailIndex)` 以 `BufferedImage` 形式返回通過索引 `thumbnailIndex` 指定的縮略圖預覽圖像，其與通過索引 `ImageIndex` 指定的圖像關聯。
`BufferedImage`	`ImageReader.readTile(int imageIndex, int tileX, int tileY)` 讀取由 `tileX` 和 `tileY` 參數指示的 tile，並以 `BufferedImage` 形式返回。
`Raster`	`ImageReader.readTileRaster(int imageIndex, int tileX, int tileY)` 返回包含 tile 中的原始像素資料的新 `Raster` 物件，不應用任何顏色轉換。
`void`	`ImageWriter.removeImage(int imageIndex)` 從串流中移除圖像。
`void`	`ImageWriter.replaceImageMetadata(int imageIndex, IIOMetadata imageMetadata)` 替換與現有圖像有關的圖像元資料。
`void`	`ImageWriter.replacePixels(Raster raster, ImageWriteParam param)` 用給定 `Raster` 部分替換已出現在輸出中的圖像部分。
`void`	`ImageWriter.replacePixels(RenderedImage image, ImageWriteParam param)` 用給定圖像部分替換已出現在輸出中的圖像部分。
`void`	`ImageWriter.replaceStreamMetadata(IIOMetadata streamMetadata)` 使用新資訊替換輸出中的串流元資料。
`void`	`ImageWriter.write(IIOImage image)` 將包含帶有預設元資料和縮略圖的單個圖像的完整圖像串流添加到輸出中。
`abstract void`	`ImageWriter.write(IIOMetadata streamMetadata, IIOImage image, ImageWriteParam param)` 添加一個完整的圖像串流，該圖像串流包含一幅圖像、相關的串流、圖像元資料和要輸出的縮略圖。
`void`	`ImageWriter.write(RenderedImage image)` 將由帶有預設元資料和縮略圖的單個圖像組成的完整圖像串流添加到輸出中。
`static boolean`	`ImageIO.write(RenderedImage im, String formatName, File output)` 使用支持給定格式的任意 `ImageWriter` 將一個圖像寫入 `File`。
`static boolean`	`ImageIO.write(RenderedImage im, String formatName, ImageOutputStream output)` 使用支持給定格式的任意 `ImageWriter` 將一個圖像寫入 `ImageOutputStream`。
`static boolean`	`ImageIO.write(RenderedImage im, String formatName, OutputStream output)` 使用支持給定格式的任意 `ImageWriter` 將一個圖像寫入 `OutputStream`。
`void`	`ImageWriter.writeInsert(int imageIndex, IIOImage image, ImageWriteParam param)` 將新的圖像插入現有圖像串流。
`void`	`ImageWriter.writeToSequence(IIOImage image, ImageWriteParam param)` 將單幅圖像、可能相關的元資料和縮略圖添加到輸出中。

javax.imageio.metadata 中 IOException 的使用

javax.imageio.metadata 中 IOException 的子類別
`class`	`IIOInvalidTreeException` 當 `IIOMetadata` 物件嘗試解析 `IIOMetadataNode` 的階層樹失敗時，將拋出 `IIOInvalidTreeException`。

javax.imageio.spi 中 IOException 的使用

拋出 IOException 的 javax.imageio.spi 中的方法
`abstract boolean`	`ImageReaderSpi.canDecodeInput(Object source)` 如果給定的源物件看起來是此 reader 支持的格式，則返回 `true`。
`ImageInputStream`	`ImageInputStreamSpi.createInputStreamInstance(Object input)` 返回與此服務提供者關聯的 `ImageInputStream` 實作的實例。
`abstract ImageInputStream`	`ImageInputStreamSpi.createInputStreamInstance(Object input, boolean useCache, File cacheDir)` 返回與此服務提供者關聯的 `ImageInputStream` 實作的實例。
`ImageOutputStream`	`ImageOutputStreamSpi.createOutputStreamInstance(Object output)` 返回與此服務提供者關聯的 `ImageOutputStream` 實作的實例。
`abstract ImageOutputStream`	`ImageOutputStreamSpi.createOutputStreamInstance(Object output, boolean useCache, File cacheDir)` 返回與此服務提供者關聯的 `ImageOutputStream` 實作的實例。
`ImageReader`	`ImageReaderSpi.createReaderInstance()` 返回與此服務提供者關聯的 `ImageReader` 實作的實例。
`abstract ImageReader`	`ImageReaderSpi.createReaderInstance(Object extension)` 返回與此服務提供者關聯的 `ImageReader` 實作的實例。
`ImageWriter`	`ImageWriterSpi.createWriterInstance()` 返回與此服務提供者關聯的 `ImageWriter` 實作的實例。
`abstract ImageWriter`	`ImageWriterSpi.createWriterInstance(Object extension)` 返回與此服務提供者關聯的 `ImageWriter` 實作的實例。

javax.imageio.stream 中 IOException 的使用

拋出 IOException 的 javax.imageio.stream 中的方法
`protected void`	`ImageInputStreamImpl.checkClosed()` 如果已經關閉串流，則拋出 `IOException`。
`void`	`FileCacheImageInputStream.close()` 關閉此 `FileCacheImageInputStream`，關閉並移除快取記憶體檔案。
`void`	`FileCacheImageOutputStream.close()` 關閉此 `FileCacheImageOututStream`。
`void`	`FileImageInputStream.close()`
`void`	`FileImageOutputStream.close()`
`void`	`ImageInputStream.close()` 關閉串流。
`void`	`ImageInputStreamImpl.close()`
`void`	`MemoryCacheImageInputStream.close()` 關閉此 `MemoryCacheImageInputStream`，釋放快取記憶體。
`void`	`MemoryCacheImageOutputStream.close()` 關閉此 `MemoryCacheImageOutputStream`。
`void`	`ImageInputStream.flush()` 丟棄當前串流位置之前的串流初始部分。
`void`	`ImageInputStreamImpl.flush()`
`void`	`FileCacheImageOutputStream.flushBefore(long pos)`
`void`	`ImageInputStream.flushBefore(long pos)` 丟棄所指示位置之前的串流初始部分。
`void`	`ImageInputStreamImpl.flushBefore(long pos)`
`void`	`ImageOutputStream.flushBefore(long pos)` 刷新給定位置之前所有資料的緩衝並轉到底層目標（如 `OutputStream` 或 `File`）。
`void`	`MemoryCacheImageInputStream.flushBefore(long pos)`
`void`	`MemoryCacheImageOutputStream.flushBefore(long pos)`
`protected void`	`ImageOutputStreamImpl.flushBits()` 如果位偏移量為非零，則將當前位元組中的剩餘位強制歸 0，並將串流位置前移一個位元組。
`int`	`ImageInputStream.getBitOffset()` 以整數的形式返回當前位偏移量，該整數在 0 到 7 之間（包含兩者）。
`int`	`ImageInputStreamImpl.getBitOffset()`
`long`	`ImageInputStream.getStreamPosition()` 返回串流的當前位元組位置。
`long`	`ImageInputStreamImpl.getStreamPosition()`
`long`	`ImageInputStream.length()` 返回串流的總長度（如果已知）。
`int`	`FileCacheImageInputStream.read()`
`int`	`FileCacheImageOutputStream.read()`
`int`	`FileImageInputStream.read()`
`int`	`FileImageOutputStream.read()`
`int`	`ImageInputStream.read()` 從串流中讀取單個位元組，並以整數（0 到 255 之間）形式返回該位元組。
`abstract int`	`ImageInputStreamImpl.read()` 從串流中讀取單個位元組，並以 `int`（0 到 255 之間）形式返回該位元組。
`int`	`MemoryCacheImageInputStream.read()`
`int`	`MemoryCacheImageOutputStream.read()`
`int`	`ImageInputStream.read(byte[] b)` 從串流中讀取至多 `b.length` 個位元組，並將其存儲到 `b` 中（從索引 0 開始）。
`int`	`ImageInputStreamImpl.read(byte[] b)` 調用 `read(b, 0, b.length)` 的便捷方法。
`int`	`FileCacheImageInputStream.read(byte[] b, int off, int len)`
`int`	`FileCacheImageOutputStream.read(byte[] b, int off, int len)`
`int`	`FileImageInputStream.read(byte[] b, int off, int len)`
`int`	`FileImageOutputStream.read(byte[] b, int off, int len)`
`int`	`ImageInputStream.read(byte[] b, int off, int len)` 從串流中讀取至多 `len` 個位元組，並將其存儲到 `b` 中（從索引 `off` 開始）。
`abstract int`	`ImageInputStreamImpl.read(byte[] b, int off, int len)` 從串流中讀取至多 `len` 個位元組，並將其存儲到 `b` 中（從 `off` 索引處開始）。
`int`	`MemoryCacheImageInputStream.read(byte[] b, int off, int len)`
`int`	`MemoryCacheImageOutputStream.read(byte[] b, int off, int len)`
`int`	`ImageInputStream.readBit()` 從串流中讀取單個位元組，並以 `int`（`0` 或 `1`）的形式返回該位元組。
`int`	`ImageInputStreamImpl.readBit()`
`long`	`ImageInputStream.readBits(int numBits)` 從串流中讀取位串 (bitstring) 並以 `long` 的形式返回，使第一個讀取的位成為輸出的最高有效位。
`long`	`ImageInputStreamImpl.readBits(int numBits)`
`boolean`	`ImageInputStream.readBoolean()` 從串流中讀取一個位元組，如果其不為 0，則返回 `boolean` 值 `true`；如果為 0，則返回 `false`。
`boolean`	`ImageInputStreamImpl.readBoolean()`
`byte`	`ImageInputStream.readByte()` 從串流中讀取一個位元組，並以 `byte` 值的形式返回該位元組。
`byte`	`ImageInputStreamImpl.readByte()`
`void`	`ImageInputStream.readBytes(IIOByteBuffer buf, int len)` 從串流中讀取至多 `len` 個位元組，並修改提供的 `IIOByteBuffer` 以指示可以找到資料的 byte 陣列、偏移量和長度。
`void`	`ImageInputStreamImpl.readBytes(IIOByteBuffer buf, int len)`
`char`	`ImageInputStream.readChar()` 與 `readUnsignedShort` 等效，唯一的不同在於它的結果使用 `char` 資料型別返回。
`char`	`ImageInputStreamImpl.readChar()`
`double`	`ImageInputStream.readDouble()` 從串流中讀取 8 個位元組，根據當前位元組順序將其連接（概念上），然後以 `double` 值的形式返回結果。
`double`	`ImageInputStreamImpl.readDouble()`
`float`	`ImageInputStream.readFloat()` 從串流中讀取 4 個位元組，根據當前位元組順序將其連接（概念上），然後以 `float` 值的形式返回結果。
`float`	`ImageInputStreamImpl.readFloat()`
`void`	`ImageInputStream.readFully(byte[] b)` 從串流中讀取 `b.length` 個位元組，並將其存儲到 `b` 中（從索引 `0` 開始）。
`void`	`ImageInputStreamImpl.readFully(byte[] b)`
`void`	`ImageInputStream.readFully(byte[] b, int off, int len)` 從串流中讀取 `len` 個位元組，並將其存儲到 `b` 中（從索引 `off` 開始）。
`void`	`ImageInputStreamImpl.readFully(byte[] b, int off, int len)`
`void`	`ImageInputStream.readFully(char[] c, int off, int len)` 根據當前位元組順序從串流中讀取 `len` 個 char（無符號 16 位整數），並將其存儲到 `c` 中（從索引 `off` 開始）。
`void`	`ImageInputStreamImpl.readFully(char[] c, int off, int len)`
`void`	`ImageInputStream.readFully(double[] d, int off, int len)` 根據當前位元組順序從串流中讀取 `len` 個 double（64 位 IEEE 雙精度浮點值），並將其存儲到 `d` 中（從索引 `off` 開始）。
`void`	`ImageInputStreamImpl.readFully(double[] d, int off, int len)`
`void`	`ImageInputStream.readFully(float[] f, int off, int len)` 根據當前位元組順序從串流中讀取 `len` 個 float（32 位 IEEE 單精度浮點值），並將其存儲到 `f` 中（從索引 `off` 開始）。
`void`	`ImageInputStreamImpl.readFully(float[] f, int off, int len)`
`void`	`ImageInputStream.readFully(int[] i, int off, int len)` 根據當前位元組順序從串流中讀取 `len` 個 int（有符號 32 位整數），並將其存儲到 `i` 中（從索引 `off` 開始）。
`void`	`ImageInputStreamImpl.readFully(int[] i, int off, int len)`
`void`	`ImageInputStream.readFully(long[] l, int off, int len)` 根據當前位元組順序從串流中讀取 `len` 個 long（有符號 64 位整數），並將其存儲到 `l` 中（從索引 `off` 開始）。
`void`	`ImageInputStreamImpl.readFully(long[] l, int off, int len)`
`void`	`ImageInputStream.readFully(short[] s, int off, int len)` 根據當前位元組順序從串流中讀取 `len` 個 short（有符號 16 位整數），並將其存儲到 `s` 中（從索引 `off` 開始）。
`void`	`ImageInputStreamImpl.readFully(short[] s, int off, int len)`
`int`	`ImageInputStream.readInt()` 從串流中讀取 4 個位元組，根據當前位元組順序將其連接（概念上），然後以 `int` 值的形式返回結果。
`int`	`ImageInputStreamImpl.readInt()`
`String`	`ImageInputStream.readLine()` 從輸入串流中讀取文本的下一行。
`String`	`ImageInputStreamImpl.readLine()`
`long`	`ImageInputStream.readLong()` 從串流中讀取 8 個位元組，根據當前位元組順序將其連接（概念上），然後以 `long` 值的形式返回結果。
`long`	`ImageInputStreamImpl.readLong()`
`short`	`ImageInputStream.readShort()` 從串流中讀取兩個位元組，根據當前位元組順序將其連接（概念上），然後以 `short` 值的形式返回結果。
`short`	`ImageInputStreamImpl.readShort()`
`int`	`ImageInputStream.readUnsignedByte()` 從串流中讀取一個位元組，將其轉換為 int（概念上），使用 `0xff` 屏蔽以便去掉所有符號擴展位，然後以 `byte` 值的形式返回。
`int`	`ImageInputStreamImpl.readUnsignedByte()`
`long`	`ImageInputStream.readUnsignedInt()` 從串流中讀取 4 個位元組，根據當前位元組順序將其連接（概念上），將得到的值轉換為 long，使用 `0xffffffffL` 屏蔽以便去掉所有符號擴展位，然後以無符號 `long` 值的形式返回結果。
`long`	`ImageInputStreamImpl.readUnsignedInt()`
`int`	`ImageInputStream.readUnsignedShort()` 從串流中讀取兩個位元組，根據當前位元組順序將其連接（概念上），將得到的值轉換為 `int`，使用 `0xffff` 屏蔽以便去掉所有符號擴展位，然後以無符號 `int` 值的形式返回結果。
`int`	`ImageInputStreamImpl.readUnsignedShort()`
`String`	`ImageInputStream.readUTF()` 讀入一個已使用 UTF-8 修改版格式編碼的字元串。
`String`	`ImageInputStreamImpl.readUTF()`
`void`	`ImageInputStream.reset()` 返回在最近一次非比對地調用 `mark` 時指向上一個位置（包括位偏移量）的串流指針。
`void`	`ImageInputStreamImpl.reset()` 根據標記的堆疊(stack)空間重置當前串流位元組和位位置。
`void`	`FileCacheImageOutputStream.seek(long pos)` 設置當前串流位置並將位偏移量重置為 0。
`void`	`FileImageInputStream.seek(long pos)`
`void`	`FileImageOutputStream.seek(long pos)` 設置當前串流位置並將位偏移量重置為 0。
`void`	`ImageInputStream.seek(long pos)` 將當前串流位置設置為所需的位置。
`void`	`ImageInputStreamImpl.seek(long pos)`
`void`	`ImageInputStream.setBitOffset(int bitOffset)` 將位偏移量設置為 0 到 7 之間（包含兩者）的整數。
`void`	`ImageInputStreamImpl.setBitOffset(int bitOffset)`
`int`	`ImageInputStream.skipBytes(int n)` 將串流位置向前移動給定的位元組數。
`int`	`ImageInputStreamImpl.skipBytes(int n)` 通過調用 `seek(getStreamPosition() + n)` 推進當前串流位置。
`long`	`ImageInputStream.skipBytes(long n)` 將串流位置向前移動給定的位元組數。
`long`	`ImageInputStreamImpl.skipBytes(long n)` 通過調用 `seek(getStreamPosition() + n)` 推進當前串流位置。
`void`	`ImageOutputStream.write(byte[] b)` 將位元組序列寫入到串流中的當前位置。
`void`	`ImageOutputStreamImpl.write(byte[] b)`
`void`	`FileCacheImageOutputStream.write(byte[] b, int off, int len)`
`void`	`FileImageOutputStream.write(byte[] b, int off, int len)`
`void`	`ImageOutputStream.write(byte[] b, int off, int len)` 將位元組序列寫入到串流中的當前位置。
`abstract void`	`ImageOutputStreamImpl.write(byte[] b, int off, int len)`
`void`	`MemoryCacheImageOutputStream.write(byte[] b, int off, int len)`
`void`	`FileCacheImageOutputStream.write(int b)`
`void`	`FileImageOutputStream.write(int b)`
`void`	`ImageOutputStream.write(int b)` 將單個位元組寫入到串流中的當前位置。
`abstract void`	`ImageOutputStreamImpl.write(int b)`
`void`	`MemoryCacheImageOutputStream.write(int b)`
`void`	`ImageOutputStream.writeBit(int bit)` 將單個位（由參數的最低有效位給定）寫入到串流的當前位元組位置中的當前位偏移量。
`void`	`ImageOutputStreamImpl.writeBit(int bit)`
`void`	`ImageOutputStream.writeBits(long bits, int numBits)` 將一個位序列（由 `bits` 參數的 `numBits` 個最低有效位按從左到右的順序給定）寫入到串流的當前位元組位置中的當前位偏移量。
`void`	`ImageOutputStreamImpl.writeBits(long bits, int numBits)`
`void`	`ImageOutputStream.writeBoolean(boolean v)` 將一個 `boolean` 值寫入到串流中。
`void`	`ImageOutputStreamImpl.writeBoolean(boolean v)`
`void`	`ImageOutputStream.writeByte(int v)` 將 `v` 的 8 個低位寫入到串流中。
`void`	`ImageOutputStreamImpl.writeByte(int v)`
`void`	`ImageOutputStream.writeBytes(String s)` 將一個字元串寫入輸出串流。
`void`	`ImageOutputStreamImpl.writeBytes(String s)`
`void`	`ImageOutputStream.writeChar(int v)` 此方法與 `writeShort` 同義。
`void`	`ImageOutputStreamImpl.writeChar(int v)`
`void`	`ImageOutputStream.writeChars(char[] c, int off, int len)` 將 char 序列寫入到串流中的當前位置。
`void`	`ImageOutputStreamImpl.writeChars(char[] c, int off, int len)`
`void`	`ImageOutputStream.writeChars(String s)` 將一個字元串寫入輸出串流。
`void`	`ImageOutputStreamImpl.writeChars(String s)`
`void`	`ImageOutputStream.writeDouble(double v)` 將一個 `double` 值寫入輸出串流，該值由四個位元組組成。
`void`	`ImageOutputStreamImpl.writeDouble(double v)`
`void`	`ImageOutputStream.writeDoubles(double[] d, int off, int len)` 將 double 序列寫入到串流中的當前位置。
`void`	`ImageOutputStreamImpl.writeDoubles(double[] d, int off, int len)`
`void`	`ImageOutputStream.writeFloat(float v)` 將一個 `float` 值（由四個位元組組成）寫入輸出串流。
`void`	`ImageOutputStreamImpl.writeFloat(float v)`
`void`	`ImageOutputStream.writeFloats(float[] f, int off, int len)` 將 float 序列寫入到串流中的當前位置。
`void`	`ImageOutputStreamImpl.writeFloats(float[] f, int off, int len)`
`void`	`ImageOutputStream.writeInt(int v)` 將 `v` 的 32 個位寫入到串流中。
`void`	`ImageOutputStreamImpl.writeInt(int v)`
`void`	`ImageOutputStream.writeInts(int[] i, int off, int len)` 將 int 序列寫入到串流中的當前位置。
`void`	`ImageOutputStreamImpl.writeInts(int[] i, int off, int len)`
`void`	`ImageOutputStream.writeLong(long v)` 將 `v` 的 64 個位寫入到串流中。
`void`	`ImageOutputStreamImpl.writeLong(long v)`
`void`	`ImageOutputStream.writeLongs(long[] l, int off, int len)` 將 long 序列寫入到串流中的當前位置。
`void`	`ImageOutputStreamImpl.writeLongs(long[] l, int off, int len)`
`void`	`ImageOutputStream.writeShort(int v)` 將 `v` 的 16 個低位寫入到串流中。
`void`	`ImageOutputStreamImpl.writeShort(int v)`
`void`	`ImageOutputStream.writeShorts(short[] s, int off, int len)` 將 short 序列寫入到串流中的當前位置。
`void`	`ImageOutputStreamImpl.writeShorts(short[] s, int off, int len)`
`void`	`ImageOutputStream.writeUTF(String s)` 將表示長度資訊的兩個位元組按網路位元組順序寫入輸出串流，後跟字元串 `s` 中每個字元的 UTF-8 修改版表示形式。
`void`	`ImageOutputStreamImpl.writeUTF(String s)`

拋出 IOException 的 javax.imageio.stream 中的建構子
`FileCacheImageInputStream(InputStream stream, File cacheDir)` 建構一個將從給定 `InputStream` 進行讀取的 `FileCacheImageInputStream`。
`FileCacheImageOutputStream(OutputStream stream, File cacheDir)` 建構一個將向給定 `outputStream` 進行寫入的 `FileCacheImageOutputStream`。
`FileImageInputStream(File f)` 建構一個將從給定 `File` 進行讀取的 `FileImageInputStream`。
`FileImageOutputStream(File f)` 建構一個將向給定 `File` 進行寫入的 `FileImageOutputStream`。

javax.management 中 IOException 的使用

拋出 IOException 的 javax.management 中的方法
`void`	`MBeanServerConnection.addNotificationListener(ObjectName name, NotificationListener listener, NotificationFilter filter, Object handback)` 向已註冊的 MBean 添加一個偵聽器。
`void`	`MBeanServerConnection.addNotificationListener(ObjectName name, ObjectName listener, NotificationFilter filter, Object handback)` 向已註冊的 MBean 添加一個偵聽器。
`ObjectInstance`	`MBeanServerConnection.createMBean(String className, ObjectName name)` 在 MBean 伺服器中實例化並註冊一個 MBean。
`ObjectInstance`	`MBeanServerConnection.createMBean(String className, ObjectName name, Object[] params, String[] signature)` 在 MBean 伺服器中實例化並註冊一個 MBean。
`ObjectInstance`	`MBeanServerConnection.createMBean(String className, ObjectName name, ObjectName loaderName)` 在 MBean 伺服器中實例化並註冊一個 MBean。
`ObjectInstance`	`MBeanServerConnection.createMBean(String className, ObjectName name, ObjectName loaderName, Object[] params, String[] signature)` 在 MBean 伺服器中實例化並註冊一個 MBean。
`Object`	`MBeanServerConnection.getAttribute(ObjectName name, String attribute)` 獲得指定 MBean 的特定屬性值。
`AttributeList`	`MBeanServerConnection.getAttributes(ObjectName name, String[] attributes)` 獲得指定 MBean 的多個屬性值。
`String`	`MBeanServerConnection.getDefaultDomain()` 返回對 MBean 命名時使用的預設域。
`String[]`	`MBeanServerConnection.getDomains()` 返回其中所有 MBean 當前已註冊的域的列表。
`Integer`	`MBeanServerConnection.getMBeanCount()` 返回 MBean 伺服器中已註冊的 MBean 數目。
`MBeanInfo`	`MBeanServerConnection.getMBeanInfo(ObjectName name)` 此方法發現了 MBean 為管理而公開的屬性和操作。
`ObjectInstance`	`MBeanServerConnection.getObjectInstance(ObjectName name)` 獲得向 MBean 伺服器註冊的給定 MBean 的 `ObjectInstance`。
`Object`	`MBeanServerConnection.invoke(ObjectName name, String operationName, Object[] params, String[] signature)` 在 MBean 上調用某個操作。
`boolean`	`MBeanServerConnection.isInstanceOf(ObjectName name, String className)` 如果指定的 MBean 是指定類別的一個實例，則返回 true；否則返回 false。
`boolean`	`MBeanServerConnection.isRegistered(ObjectName name)` 檢查某個 MBean（通過其物件名標識）是否已向 MBean 伺服器註冊。
`Set<ObjectInstance>`	`MBeanServerConnection.queryMBeans(ObjectName name, QueryExp query)` 獲得該 MBean 伺服器所控制的 MBean。
`Set<ObjectName>`	`MBeanServerConnection.queryNames(ObjectName name, QueryExp query)` 獲得該 MBean 伺服器所控制的 MBean 的名稱。
`void`	`MBeanServerConnection.removeNotificationListener(ObjectName name, NotificationListener listener)` 從已註冊的 MBean 中移除一個偵聽器。
`void`	`MBeanServerConnection.removeNotificationListener(ObjectName name, NotificationListener listener, NotificationFilter filter, Object handback)` 從已註冊的 MBean 中移除一個偵聽器。
`void`	`MBeanServerConnection.removeNotificationListener(ObjectName name, ObjectName listener)` 從已註冊的 MBean 中移除一個偵聽器。
`void`	`MBeanServerConnection.removeNotificationListener(ObjectName name, ObjectName listener, NotificationFilter filter, Object handback)` 從已註冊的 MBean 中移除一個偵聽器。
`void`	`MBeanServerConnection.setAttribute(ObjectName name, Attribute attribute)` 設置指定 MBean 的特定屬性值。
`AttributeList`	`MBeanServerConnection.setAttributes(ObjectName name, AttributeList attributes)` 設置指定 MBean 的多個屬性值。
`void`	`MBeanServerConnection.unregisterMBean(ObjectName name)` 從 MBean 伺服器中註銷一個 MBean。

javax.management.loading 中 IOException 的使用

拋出 IOException 的 javax.management.loading 中的方法
`Enumeration<URL>`	`MLetMBean.getResources(String name)` 尋找所有具有給定名稱的資源。
`void`	`MLet.readExternal(ObjectInput in)` 從給定的 `ObjectInput` 恢復此 MLet 的內容。
`void`	`MLet.writeExternal(ObjectOutput out)` 將此 MLet 的內容保存到給定的 `ObjectOutput`。

javax.management.remote 中 IOException 的使用

javax.management.remote 中 IOException 的子類別
`class`	`JMXProviderException` 當提供者存在所需的協議但由於某種原因不能使用時由 `JMXConnectorFactory` 和 `JMXConnectorServerFactory` 拋出的異常。
`class`	`JMXServerErrorException` 在處理遠端 MBean 伺服器中的調用的過程中拋出了 `Error` 時，遠端 `MBeanServer` 方法調用導致拋出的異常。

拋出 IOException 的 javax.management.remote 中的方法
`void`	`JMXConnector.close()` 關閉客戶端到其伺服器的連接。
`void`	`JMXConnector.connect()` 建立到連接器伺服器的連接。
`static JMXConnector`	`JMXConnectorFactory.connect(JMXServiceURL serviceURL)` 創建到位於給定位址的連接器伺服器的連接。
`static JMXConnector`	`JMXConnectorFactory.connect(JMXServiceURL serviceURL, Map<String,?> environment)` 創建到位於給定位址的連接器伺服器的連接。
`void`	`JMXConnector.connect(Map<String,?> env)` 建立到連接器伺服器的連接。
`String`	`JMXConnector.getConnectionId()` 獲得來自連接器伺服器的連接 ID。
`MBeanServerConnection`	`JMXConnector.getMBeanServerConnection()` 返回一個代表遠端 MBean 伺服器的 `MBeanServerConnection` 物件。
`MBeanServerConnection`	`JMXConnector.getMBeanServerConnection(Subject delegationSubject)` 返回 `MBeanServerConnection` 物件，它表示在其上執行代表提供的委託主題操作的遠端 MBean 伺服器。
`static JMXConnector`	`JMXConnectorFactory.newJMXConnector(JMXServiceURL serviceURL, Map<String,?> environment)` 為位於給定位址的連接器伺服器創建一個連接器客戶端。
`JMXConnector`	`JMXConnectorProvider.newJMXConnector(JMXServiceURL serviceURL, Map<String,?> environment)` 創建一個新的可隨時連接到位於給定位址的連接器伺服器的連接器客戶端。
`static JMXConnectorServer`	`JMXConnectorServerFactory.newJMXConnectorServer(JMXServiceURL serviceURL, Map<String,?> environment, MBeanServer mbeanServer)` 創建位於給定位址的連接器伺服器。
`JMXConnectorServer`	`JMXConnectorServerProvider.newJMXConnectorServer(JMXServiceURL serviceURL, Map<String,?> environment, MBeanServer mbeanServer)` 創建位於給定位址的新連接器伺服器。
`void`	`JMXConnectorServerMBean.start()` 啟動連接器伺服器，即開始偵聽客戶端連接。
`void`	`JMXConnectorServerMBean.stop()` 取消啟動連接器伺服器，即停止對客戶端連接的偵聽。
`JMXConnector`	`JMXConnectorServer.toJMXConnector(Map<String,?> env)` 返回此連接器伺服器的客戶端 stub。
`JMXConnector`	`JMXConnectorServerMBean.toJMXConnector(Map<String,?> env)` 返回此連接器伺服器的客戶端 stub。

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

拋出 IOException 的 javax.management.remote.rmi 中的方法
`void`	`RMIConnection.addNotificationListener(ObjectName name, ObjectName listener, MarshalledObject filter, MarshalledObject handback, Subject delegationSubject)` 處理 `MBeanServerConnection.addNotificationListener(ObjectName, ObjectName, NotificationFilter, Object)` 方法。
`void`	`RMIConnectionImpl.addNotificationListener(ObjectName name, ObjectName listener, MarshalledObject filter, MarshalledObject handback, Subject delegationSubject)`
`void`	`RMIConnectionImpl_Stub.addNotificationListener(ObjectName $param_ObjectName_1, ObjectName $param_ObjectName_2, MarshalledObject $param_MarshalledObject_3, MarshalledObject $param_MarshalledObject_4, Subject $param_Subject_5)`
`Integer[]`	`RMIConnection.addNotificationListeners(ObjectName[] names, MarshalledObject[] filters, Subject[] delegationSubjects)` 處理 `MBeanServerConnection.addNotificationListener(ObjectName, NotificationListener, NotificationFilter, Object)` 方法。
`Integer[]`	`RMIConnectionImpl.addNotificationListeners(ObjectName[] names, MarshalledObject[] filters, Subject[] delegationSubjects)`
`Integer[]`	`RMIConnectionImpl_Stub.addNotificationListeners(ObjectName[] $param_arrayOf_ObjectName_1, MarshalledObject[] $param_arrayOf_MarshalledObject_2, Subject[] $param_arrayOf_Subject_3)`
`protected void`	`RMIServerImpl.clientClosed(RMIConnection client)` 關閉由 `makeClient` 創建的客戶端連接時調用的方法。
`void`	`RMIConnection.close()` 關閉此連接。
`void`	`RMIConnectionImpl.close()`
`void`	`RMIConnectionImpl_Stub.close()`
`void`	`RMIConnector.close()`
`void`	`RMIServerImpl.close()` 關閉此連接伺服器。
`protected void`	`RMIIIOPServerImpl.closeClient(RMIConnection client)`
`protected void`	`RMIJRMPServerImpl.closeClient(RMIConnection client)`
`protected abstract void`	`RMIServerImpl.closeClient(RMIConnection client)` 關閉由 `makeClient` 建立的客戶端連接。
`protected void`	`RMIIIOPServerImpl.closeServer()` 由 `RMIServerImpl.close()` 調用以通過取消導出此物件關閉連接器伺服器。
`protected void`	`RMIJRMPServerImpl.closeServer()` 由 `RMIServerImpl.close()` 調用以通過取消導出此物件關閉連接器伺服器。
`protected abstract void`	`RMIServerImpl.closeServer()` 由 `RMIServerImpl.close()` 調用以關閉連接器伺服器。
`void`	`RMIConnector.connect()`
`void`	`RMIConnector.connect(Map<String,?> environment)`
`ObjectInstance`	`RMIConnection.createMBean(String className, ObjectName name, MarshalledObject params, String[] signature, Subject delegationSubject)` 處理 `MBeanServerConnection.createMBean(String, ObjectName, Object[], String[])` 方法。
`ObjectInstance`	`RMIConnectionImpl.createMBean(String className, ObjectName name, MarshalledObject params, String[] signature, Subject delegationSubject)`
`ObjectInstance`	`RMIConnectionImpl_Stub.createMBean(String $param_String_1, ObjectName $param_ObjectName_2, MarshalledObject $param_MarshalledObject_3, String[] $param_arrayOf_String_4, Subject $param_Subject_5)`
`ObjectInstance`	`RMIConnection.createMBean(String className, ObjectName name, ObjectName loaderName, MarshalledObject params, String[] signature, Subject delegationSubject)` 處理 `MBeanServerConnection.createMBean(String, ObjectName, ObjectName, Object[], String[])` 方法。
`ObjectInstance`	`RMIConnectionImpl.createMBean(String className, ObjectName name, ObjectName loaderName, MarshalledObject params, String[] signature, Subject delegationSubject)`
`ObjectInstance`	`RMIConnectionImpl_Stub.createMBean(String $param_String_1, ObjectName $param_ObjectName_2, ObjectName $param_ObjectName_3, MarshalledObject $param_MarshalledObject_4, String[] $param_arrayOf_String_5, Subject $param_Subject_6)`
`ObjectInstance`	`RMIConnection.createMBean(String className, ObjectName name, ObjectName loaderName, Subject delegationSubject)` 處理 `MBeanServerConnection.createMBean(String, ObjectName, ObjectName)` 方法。
`ObjectInstance`	`RMIConnectionImpl.createMBean(String className, ObjectName name, ObjectName loaderName, Subject delegationSubject)`
`ObjectInstance`	`RMIConnectionImpl_Stub.createMBean(String $param_String_1, ObjectName $param_ObjectName_2, ObjectName $param_ObjectName_3, Subject $param_Subject_4)`
`ObjectInstance`	`RMIConnection.createMBean(String className, ObjectName name, Subject delegationSubject)` 處理 `MBeanServerConnection.createMBean(String, ObjectName)` 方法。
`ObjectInstance`	`RMIConnectionImpl.createMBean(String className, ObjectName name, Subject delegationSubject)`
`ObjectInstance`	`RMIConnectionImpl_Stub.createMBean(String $param_String_1, ObjectName $param_ObjectName_2, Subject $param_Subject_3)`
`protected void`	`RMIIIOPServerImpl.export()`
`protected void`	`RMIJRMPServerImpl.export()`
`protected abstract void`	`RMIServerImpl.export()` 導出此 RMI 物件。
`NotificationResult`	`RMIConnection.fetchNotifications(long clientSequenceNumber, int maxNotifications, long timeout)` 檢索來自連接器伺服器的通知。
`NotificationResult`	`RMIConnectionImpl.fetchNotifications(long clientSequenceNumber, int maxNotifications, long timeout)`
`NotificationResult`	`RMIConnectionImpl_Stub.fetchNotifications(long $param_long_1, int $param_int_2, long $param_long_3)`
`Object`	`RMIConnection.getAttribute(ObjectName name, String attribute, Subject delegationSubject)` 處理 `MBeanServerConnection.getAttribute(ObjectName, String)` 方法。
`Object`	`RMIConnectionImpl.getAttribute(ObjectName name, String attribute, Subject delegationSubject)`
`Object`	`RMIConnectionImpl_Stub.getAttribute(ObjectName $param_ObjectName_1, String $param_String_2, Subject $param_Subject_3)`
`AttributeList`	`RMIConnection.getAttributes(ObjectName name, String[] attributes, Subject delegationSubject)` 處理 `MBeanServerConnection.getAttributes(ObjectName, String[])` 方法。
`AttributeList`	`RMIConnectionImpl.getAttributes(ObjectName name, String[] attributes, Subject delegationSubject)`
`AttributeList`	`RMIConnectionImpl_Stub.getAttributes(ObjectName $param_ObjectName_1, String[] $param_arrayOf_String_2, Subject $param_Subject_3)`
`String`	`RMIConnection.getConnectionId()` 返回連接 ID。
`String`	`RMIConnectionImpl.getConnectionId()`
`String`	`RMIConnectionImpl_Stub.getConnectionId()`
`String`	`RMIConnector.getConnectionId()`
`String`	`RMIConnection.getDefaultDomain(Subject delegationSubject)` 處理 `MBeanServerConnection.getDefaultDomain()` 方法。
`String`	`RMIConnectionImpl.getDefaultDomain(Subject delegationSubject)`
`String`	`RMIConnectionImpl_Stub.getDefaultDomain(Subject $param_Subject_1)`
`String[]`	`RMIConnection.getDomains(Subject delegationSubject)` 處理 `MBeanServerConnection.getDomains()` 方法。
`String[]`	`RMIConnectionImpl.getDomains(Subject delegationSubject)`
`String[]`	`RMIConnectionImpl_Stub.getDomains(Subject $param_Subject_1)`
`Integer`	`RMIConnection.getMBeanCount(Subject delegationSubject)` 處理 `MBeanServerConnection.getMBeanCount()` 方法。
`Integer`	`RMIConnectionImpl.getMBeanCount(Subject delegationSubject)`
`Integer`	`RMIConnectionImpl_Stub.getMBeanCount(Subject $param_Subject_1)`
`MBeanInfo`	`RMIConnection.getMBeanInfo(ObjectName name, Subject delegationSubject)` 處理 `MBeanServerConnection.getMBeanInfo(ObjectName)` 方法。
`MBeanInfo`	`RMIConnectionImpl.getMBeanInfo(ObjectName name, Subject delegationSubject)`
`MBeanInfo`	`RMIConnectionImpl_Stub.getMBeanInfo(ObjectName $param_ObjectName_1, Subject $param_Subject_2)`
`MBeanServerConnection`	`RMIConnector.getMBeanServerConnection()`
`MBeanServerConnection`	`RMIConnector.getMBeanServerConnection(Subject delegationSubject)`
`ObjectInstance`	`RMIConnection.getObjectInstance(ObjectName name, Subject delegationSubject)` 處理 `MBeanServerConnection.getObjectInstance(ObjectName)` 方法。
`ObjectInstance`	`RMIConnectionImpl.getObjectInstance(ObjectName name, Subject delegationSubject)`
`ObjectInstance`	`RMIConnectionImpl_Stub.getObjectInstance(ObjectName $param_ObjectName_1, Subject $param_Subject_2)`
`Object`	`RMIConnection.invoke(ObjectName name, String operationName, MarshalledObject params, String[] signature, Subject delegationSubject)` 處理 `MBeanServerConnection.invoke(ObjectName, String, Object[], String[])` 方法。
`Object`	`RMIConnectionImpl.invoke(ObjectName name, String operationName, MarshalledObject params, String[] signature, Subject delegationSubject)`
`Object`	`RMIConnectionImpl_Stub.invoke(ObjectName $param_ObjectName_1, String $param_String_2, MarshalledObject $param_MarshalledObject_3, String[] $param_arrayOf_String_4, Subject $param_Subject_5)`
`boolean`	`RMIConnection.isInstanceOf(ObjectName name, String className, Subject delegationSubject)` 處理 `MBeanServerConnection.isInstanceOf(ObjectName, String)` 方法。
`boolean`	`RMIConnectionImpl.isInstanceOf(ObjectName name, String className, Subject delegationSubject)`
`boolean`	`RMIConnectionImpl_Stub.isInstanceOf(ObjectName $param_ObjectName_1, String $param_String_2, Subject $param_Subject_3)`
`boolean`	`RMIConnection.isRegistered(ObjectName name, Subject delegationSubject)` 處理 `MBeanServerConnection.isRegistered(ObjectName)` 方法。
`boolean`	`RMIConnectionImpl.isRegistered(ObjectName name, Subject delegationSubject)`
`boolean`	`RMIConnectionImpl_Stub.isRegistered(ObjectName $param_ObjectName_1, Subject $param_Subject_2)`
`protected RMIConnection`	`RMIIIOPServerImpl.makeClient(String connectionId, Subject subject)` 創建一個如同從 IIOP 導出的 RMI 物件的新客戶端連接。
`protected RMIConnection`	`RMIJRMPServerImpl.makeClient(String connectionId, Subject subject)` 創建一個如同從 JRMP 導出的 RMI 物件的新的客戶端連接。
`protected abstract RMIConnection`	`RMIServerImpl.makeClient(String connectionId, Subject subject)` 創建一個新的客戶端連接。
`RMIConnection`	`RMIServer.newClient(Object credentials)` 建立一個使用該 RMI 連接器的新連接。
`RMIConnection`	`RMIServerImpl.newClient(Object credentials)` 創建一個新的客戶端連接。
`RMIConnection`	`RMIServerImpl_Stub.newClient(Object $param_Object_1)`
`Set<ObjectInstance>`	`RMIConnection.queryMBeans(ObjectName name, MarshalledObject query, Subject delegationSubject)` 處理 `MBeanServerConnection.queryMBeans(ObjectName, QueryExp)` 方法。
`Set<ObjectInstance>`	`RMIConnectionImpl.queryMBeans(ObjectName name, MarshalledObject query, Subject delegationSubject)`
`Set`	`RMIConnectionImpl_Stub.queryMBeans(ObjectName $param_ObjectName_1, MarshalledObject $param_MarshalledObject_2, Subject $param_Subject_3)`
`Set<ObjectName>`	`RMIConnection.queryNames(ObjectName name, MarshalledObject query, Subject delegationSubject)` 處理 `MBeanServerConnection.queryNames(ObjectName, QueryExp)` 方法。
`Set<ObjectName>`	`RMIConnectionImpl.queryNames(ObjectName name, MarshalledObject query, Subject delegationSubject)`
`Set`	`RMIConnectionImpl_Stub.queryNames(ObjectName $param_ObjectName_1, MarshalledObject $param_MarshalledObject_2, Subject $param_Subject_3)`
`void`	`RMIConnection.removeNotificationListener(ObjectName name, ObjectName listener, MarshalledObject filter, MarshalledObject handback, Subject delegationSubject)` 處理 `MBeanServerConnection.removeNotificationListener(ObjectName, ObjectName, NotificationFilter, Object)` 方法。
`void`	`RMIConnectionImpl.removeNotificationListener(ObjectName name, ObjectName listener, MarshalledObject filter, MarshalledObject handback, Subject delegationSubject)`
`void`	`RMIConnectionImpl_Stub.removeNotificationListener(ObjectName $param_ObjectName_1, ObjectName $param_ObjectName_2, MarshalledObject $param_MarshalledObject_3, MarshalledObject $param_MarshalledObject_4, Subject $param_Subject_5)`
`void`	`RMIConnection.removeNotificationListener(ObjectName name, ObjectName listener, Subject delegationSubject)` 處理 `MBeanServerConnection.removeNotificationListener(ObjectName, ObjectName)` 方法。
`void`	`RMIConnectionImpl.removeNotificationListener(ObjectName name, ObjectName listener, Subject delegationSubject)`
`void`	`RMIConnectionImpl_Stub.removeNotificationListener(ObjectName $param_ObjectName_1, ObjectName $param_ObjectName_2, Subject $param_Subject_3)`
`void`	`RMIConnection.removeNotificationListeners(ObjectName name, Integer[] listenerIDs, Subject delegationSubject)` 處理 `removeNotificationListener(ObjectName, NotificationListener)` 和 `removeNotificationListener(ObjectName, NotificationListener, NotificationFilter, Object)` 方法。
`void`	`RMIConnectionImpl.removeNotificationListeners(ObjectName name, Integer[] listenerIDs, Subject delegationSubject)`
`void`	`RMIConnectionImpl_Stub.removeNotificationListeners(ObjectName $param_ObjectName_1, Integer[] $param_arrayOf_Integer_2, Subject $param_Subject_3)`
`void`	`RMIConnection.setAttribute(ObjectName name, MarshalledObject attribute, Subject delegationSubject)` 處理 `MBeanServerConnection.setAttribute(ObjectName, Attribute)` 方法。
`void`	`RMIConnectionImpl.setAttribute(ObjectName name, MarshalledObject attribute, Subject delegationSubject)`
`void`	`RMIConnectionImpl_Stub.setAttribute(ObjectName $param_ObjectName_1, MarshalledObject $param_MarshalledObject_2, Subject $param_Subject_3)`
`AttributeList`	`RMIConnection.setAttributes(ObjectName name, MarshalledObject attributes, Subject delegationSubject)` 處理 `MBeanServerConnection.setAttributes(ObjectName, AttributeList)` 方法。
`AttributeList`	`RMIConnectionImpl.setAttributes(ObjectName name, MarshalledObject attributes, Subject delegationSubject)`
`AttributeList`	`RMIConnectionImpl_Stub.setAttributes(ObjectName $param_ObjectName_1, MarshalledObject $param_MarshalledObject_2, Subject $param_Subject_3)`
`void`	`RMIConnectorServer.start()` 啟動連接器伺服器，即啟動對客戶端連接的偵聽。
`void`	`RMIConnectorServer.stop()` 取消啟動連接器伺服器，即停止對客戶端連接的偵聽。
`JMXConnector`	`RMIConnectorServer.toJMXConnector(Map<String,?> env)` 返回此連接器伺服器的客戶端 stub。
`Remote`	`RMIIIOPServerImpl.toStub()` 返回一個 IIOP stub。
`Remote`	`RMIJRMPServerImpl.toStub()` 返回此 `RMIServer` 物件的可序列化的 stub。
`abstract Remote`	`RMIServerImpl.toStub()` 返回此伺服器物件的可遠端化的 stub。
`void`	`RMIConnection.unregisterMBean(ObjectName name, Subject delegationSubject)` 處理 `MBeanServerConnection.unregisterMBean(ObjectName)` 方法。
`void`	`RMIConnectionImpl.unregisterMBean(ObjectName name, Subject delegationSubject)`
`void`	`RMIConnectionImpl_Stub.unregisterMBean(ObjectName $param_ObjectName_1, Subject $param_Subject_2)`

拋出 IOException 的 javax.management.remote.rmi 中的建構子
`RMIConnectorServer(JMXServiceURL url, Map<String,?> environment)` 建立 `RMIConnectorServer`。
`RMIConnectorServer(JMXServiceURL url, Map<String,?> environment, MBeanServer mbeanServer)` 為給定的 MBean 伺服器建立一個 `RMIConnectorServer`。
`RMIConnectorServer(JMXServiceURL url, Map<String,?> environment, RMIServerImpl rmiServerImpl, MBeanServer mbeanServer)` 為給定的 MBean 伺服器建立一個 `RMIConnectorServer`。
`RMIIIOPServerImpl(Map<String,?> env)` 創建新的 `RMIServerImpl`。
`RMIJRMPServerImpl(int port, RMIClientSocketFactory csf, RMIServerSocketFactory ssf, Map<String,?> env)` 創建一個新的 `RMIServer` 物件，它將使用給定的Socket處理器從給定埠號導出。

javax.naming.ldap 中 IOException 的使用

拋出 IOException 的 javax.naming.ldap 中的方法
`abstract void`	`StartTlsResponse.close()` 妥善地關閉 TLS 連接並轉換回底層連接。
`abstract SSLSession`	`StartTlsResponse.negotiate()` 使用預設的 SSL Socket處理器協商 TLS Session。
`abstract SSLSession`	`StartTlsResponse.negotiate(SSLSocketFactory factory)` 使用 SSL Socket處理器協商 TLS Session。

拋出 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()` 返回未綁定的伺服器Socket。
`abstract ServerSocket`	`ServerSocketFactory.createServerSocket(int port)` 返回綁定到指定埠號的伺服器Socket。
`abstract ServerSocket`	`ServerSocketFactory.createServerSocket(int port, int backlog)` 返回綁定到指定埠號的伺服器Socket，並且使用指定的連接 backlog。
`abstract ServerSocket`	`ServerSocketFactory.createServerSocket(int port, int backlog, InetAddress ifAddress)` 返回綁定到指定埠號的伺服器Socket，該Socket帶有指定的偵聽 backlog 和本地 IP。
`Socket`	`SocketFactory.createSocket()` 創建一個未連接的Socket。
`abstract Socket`	`SocketFactory.createSocket(InetAddress host, int port)` 創建一個Socket並把它連接到指定位址上的指定埠號號。
`abstract Socket`	`SocketFactory.createSocket(InetAddress address, int port, InetAddress localAddress, int localPort)` 創建一個Socket並把它連接到指定遠端埠號上的指定遠端位址。
`abstract Socket`	`SocketFactory.createSocket(String host, int port)` 創建一個Socket並把它連接到指定遠端主機上的指定遠端埠號。
`abstract Socket`	`SocketFactory.createSocket(String host, int port, InetAddress localHost, int localPort)` 創建一個Socket並把它連接到指定遠端主機上的指定遠端埠號。

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)` 返回在連接到指定主機的給定埠號的現有Socket上分層的Socket。
`abstract void`	`SSLSocket.startHandshake()` 在此連接上開始 SSL 連繫交換。

拋出 IOException 的 javax.net.ssl 中的建構子
`SSLServerSocket()` 僅供子類別使用。
`SSLServerSocket(int port)` 僅供子類別使用。
`SSLServerSocket(int port, int backlog)` 僅供子類別使用。
`SSLServerSocket(int port, int backlog, InetAddress address)` 僅供子類別使用。
`SSLSocket(InetAddress address, int port)` 僅供子類別使用。
`SSLSocket(InetAddress address, int port, InetAddress clientAddress, int clientPort)` 僅供子類別使用。
`SSLSocket(String host, int port)` 僅供子類別使用。
`SSLSocket(String host, int port, InetAddress clientAddress, int clientPort)` 僅供子類別使用。

javax.print 中 IOException 的使用

拋出 IOException 的 javax.print 中的方法
`Doc`	`MultiDoc.getDoc()` 獲取當前的 doc 物件。
`Object`	`Doc.getPrintData()` 獲得列印資料表示形式物件，該物件包含此 doc 物件的部分列印資料，其格式對應於受支持的 DocFlavor。
`Object`	`SimpleDoc.getPrintData()`
`Reader`	`Doc.getReaderForText()` 獲得一個從此 doc 中提取字元列印資料的 reader。
`Reader`	`SimpleDoc.getReaderForText()` 獲得一個從此 doc 中提取字元列印資料的 reader。
`InputStream`	`Doc.getStreamForBytes()` 獲得一個從此 doc 中提取 byte 列印資料的輸入串流。
`InputStream`	`SimpleDoc.getStreamForBytes()` 獲得一個從此 doc 中提取 byte 列印資料的輸入串流。
`MultiDoc`	`MultiDoc.next()` 轉到包含 doc 物件序列中下一個 doc 物件的 multidoc 物件。

javax.rmi.CORBA 中 IOException 的使用

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

javax.rmi.ssl 中 IOException 的使用

拋出 IOException 的 javax.rmi.ssl 中的方法
`ServerSocket`	`SslRMIServerSocketFactory.createServerSocket(int port)` 創建一個伺服器Socket，該Socket接受根據此處理器的 SSL Socket配置參數配置的 SSL 連接。
`Socket`	`SslRMIClientSocketFactory.createSocket(String host, int port)` 創建一個 SSL Socket。

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

拋出 IOException 的 javax.security.auth.callback 中的方法
`void`	`CallbackHandler.handle(Callback[] callbacks)` 獲取或顯示在提供的 Callback 中請求的資訊。

javax.security.sasl 中 IOException 的使用

javax.security.sasl 中 IOException 的子類別
`class`	`AuthenticationException` 此異常由 SASL 機制實作拋出，指示由於和驗證有關的原因（如無效的標識、口令或密鑰），SASL 交換已失敗。
`class`	`SaslException` 此類別表示在使用 SASL 時所發生的錯誤。

javax.sound.midi 中 IOException 的使用

拋出 IOException 的 javax.sound.midi 中的方法
`static MidiFileFormat`	`MidiSystem.getMidiFileFormat(File file)` 獲得指定 `File` 的 MIDI 檔案格式。
`static MidiFileFormat`	`MidiSystem.getMidiFileFormat(InputStream stream)` 獲得指定的輸入串流中資料的 MIDI 檔案格式。
`static MidiFileFormat`	`MidiSystem.getMidiFileFormat(URL url)` 獲得指定 URL 中資料的 MIDI 檔案格式。
`static Sequence`	`MidiSystem.getSequence(File file)` 從指定的 `File` 獲得 MIDI 序列。
`static Sequence`	`MidiSystem.getSequence(InputStream stream)` 從指定的輸入串流獲得 MIDI 序列。
`static Sequence`	`MidiSystem.getSequence(URL url)` 從指定的 URL 獲得 MIDI 序列。
`static Soundbank`	`MidiSystem.getSoundbank(File file)` 通過從指定的 `File` 讀取來建構一個 `Soundbank`。
`static Soundbank`	`MidiSystem.getSoundbank(InputStream stream)` 通過從指定的串流讀取來建構一個 MIDI 音資源庫。
`static Soundbank`	`MidiSystem.getSoundbank(URL url)` 通過從指定的 URL 處讀取來建構一個 `Soundbank`。
`void`	`Sequencer.setSequence(InputStream stream)` 設置 sequencer 所操作的當前 sequence。
`static int`	`MidiSystem.write(Sequence in, int type, File out)` 將表示所指示 MIDI 檔案型別的檔案的位元組串流寫入提供的外部檔案。
`static int`	`MidiSystem.write(Sequence in, int fileType, OutputStream out)` 將表示所指示 MIDI 檔案型別的檔案的位元組串流寫入提供的輸出串流。

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

拋出 IOException 的 javax.sound.midi.spi 中的方法
`abstract MidiFileFormat`	`MidiFileReader.getMidiFileFormat(File file)` 獲得提供的 `File` 的 MIDI 檔案格式。
`abstract MidiFileFormat`	`MidiFileReader.getMidiFileFormat(InputStream stream)` 獲得所提供的輸入串流的 MIDI 檔案格式。
`abstract MidiFileFormat`	`MidiFileReader.getMidiFileFormat(URL url)` 獲得提供的 URL 的 MIDI 檔案格式。
`abstract Sequence`	`MidiFileReader.getSequence(File file)` 從提供的 `File` 獲得 MIDI 序列。
`abstract Sequence`	`MidiFileReader.getSequence(InputStream stream)` 從提供的輸入串流獲得 MIDI 序列。
`abstract Sequence`	`MidiFileReader.getSequence(URL url)` 從提供的 URL 獲得 MIDI 序列。
`abstract Soundbank`	`SoundbankReader.getSoundbank(File file)` 從提供的 `File` 獲得音資源庫物件。
`abstract Soundbank`	`SoundbankReader.getSoundbank(InputStream stream)` 從提供的 `InputStream` 獲得音資源庫物件。
`abstract Soundbank`	`SoundbankReader.getSoundbank(URL url)` 從提供的 URL 獲得音資源庫物件。
`abstract int`	`MidiFileWriter.write(Sequence in, int fileType, File out)` 寫入表示指示為所提供外部檔案的檔案型別的 MIDI 檔案的位元組串流。
`abstract int`	`MidiFileWriter.write(Sequence in, int fileType, OutputStream out)` 寫入表示指示為所提供輸出串流的檔案型別的 MIDI 檔案的位元組串流。

javax.sound.sampled 中 IOException 的使用

拋出 IOException 的 javax.sound.sampled 中的方法
`int`	`AudioInputStream.available()` 返回可不受阻塞地從此音頻輸入串流中讀取（或跳過）的最大位元組數。
`void`	`AudioInputStream.close()` 關閉此音頻輸入串流並釋放與該串流關聯的所有系統資源。
`static AudioFileFormat`	`AudioSystem.getAudioFileFormat(File file)` 獲得指定 `File` 的音頻檔案格式。
`static AudioFileFormat`	`AudioSystem.getAudioFileFormat(InputStream stream)` 獲得提供的音頻輸入串流的音頻檔案格式。
`static AudioFileFormat`	`AudioSystem.getAudioFileFormat(URL url)` 獲得指定 URL 的音頻檔案格式。
`static AudioInputStream`	`AudioSystem.getAudioInputStream(File file)` 從提供的 `File` 獲得音頻輸入串流。
`static AudioInputStream`	`AudioSystem.getAudioInputStream(InputStream stream)` 從提供的輸入串流獲得音頻輸入串流。
`static AudioInputStream`	`AudioSystem.getAudioInputStream(URL url)` 從提供的 URL 獲得音頻輸入串流。
`void`	`Clip.open(AudioInputStream stream)` 使用出現在所提供的音頻輸入串流中的格式和音頻資料打開剪輯。
`int`	`AudioInputStream.read()` 從音頻輸入串流讀取資料下一個位元組。
`int`	`AudioInputStream.read(byte[] b)` 從音頻輸入串流讀取一定數量的位元組，並將其存儲在緩衝區陣列 `b` 中。
`int`	`AudioInputStream.read(byte[] b, int off, int len)` 從音頻串流讀取指定的最大數量的資料位元組，並將其放入給定的位元組陣列中。
`void`	`AudioInputStream.reset()` 將此音頻輸入串流重新定位到上一次調用其 `mark` 方法時的位置。
`long`	`AudioInputStream.skip(long n)` 跳過並丟棄此音頻輸入串流中指定數量的位元組。
`static int`	`AudioSystem.write(AudioInputStream stream, AudioFileFormat.Type fileType, File out)` 將表示指定檔案型別的音頻檔案的位元組串流寫入所提供的外部檔案。
`static int`	`AudioSystem.write(AudioInputStream stream, AudioFileFormat.Type fileType, OutputStream out)` 將表示指定檔案型別的音頻檔案的位元組串流寫入所提供的輸出串流。

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

拋出 IOException 的 javax.sound.sampled.spi 中的方法
`abstract AudioFileFormat`	`AudioFileReader.getAudioFileFormat(File file)` 獲得所提供 `File` 的音頻檔案格式。
`abstract AudioFileFormat`	`AudioFileReader.getAudioFileFormat(InputStream stream)` 獲得所提供輸入串流的音頻檔案格式。
`abstract AudioFileFormat`	`AudioFileReader.getAudioFileFormat(URL url)` 獲得所提供 URL 的音頻檔案格式。
`abstract AudioInputStream`	`AudioFileReader.getAudioInputStream(File file)` 從所提供的 `File` 獲得音頻輸入串流。
`abstract AudioInputStream`	`AudioFileReader.getAudioInputStream(InputStream stream)` 從所提供的輸入串流中獲得音頻輸入串流。
`abstract AudioInputStream`	`AudioFileReader.getAudioInputStream(URL url)` 從所提供的 URL 獲得音頻輸入串流。
`abstract int`	`AudioFileWriter.write(AudioInputStream stream, AudioFileFormat.Type fileType, File out)` 將表示所指示檔案格式的音頻檔案的位元組串流寫入所提供的外部檔案。
`abstract int`	`AudioFileWriter.write(AudioInputStream stream, AudioFileFormat.Type fileType, OutputStream out)` 將表示所指示檔案型別的音頻檔案的位元組串流寫入所提供的輸出串流。

javax.sql.rowset 中 IOException 的使用

拋出 IOException 的 javax.sql.rowset 中的方法
`void`	`WebRowSet.readXml(InputStream iStream)` 讀取基於串流的 XML 輸入，以填充此 `WebRowSet` 物件。
`void`	`WebRowSet.writeXml(OutputStream oStream)` 以 XML 格式將此 `WebRowSet` 物件的資料、屬性和元資料寫入給定的 `OutputStream` 物件。
`void`	`WebRowSet.writeXml(ResultSet rs, OutputStream oStream)` 使用給定 `ResultSet` 物件的內容填充此 `WebRowSet` 物件，並以 XML 格式將其資料、屬性和元資料寫入給定的 `OutputStream` 物件。

javax.swing 中 IOException 的使用

拋出 IOException 的 javax.swing 中的方法
`void`	`ProgressMonitorInputStream.close()` 覆寫 `FilterInputStream.close`，以便關閉進度監視器以及串流。
`protected InputStream`	`JEditorPane.getStream(URL page)` 獲取給定 URL 的串流，該 URL 是將要由 `setPage` 方法載入的。
`int`	`ProgressMonitorInputStream.read()` 覆寫 `FilterInputStream.read`，以便在讀取之後更新進度監視器。
`int`	`ProgressMonitorInputStream.read(byte[] b)` 覆寫 `FilterInputStream.read`，以讀取之後更新進度監視器。
`int`	`ProgressMonitorInputStream.read(byte[] b, int off, int len)` 覆寫 `FilterInputStream.read`，以便在讀取之後更新進度監視器。
`void`	`JEditorPane.read(InputStream in, Object desc)` 此方法根據串流進行初始化。
`void`	`ProgressMonitorInputStream.reset()` 覆寫 `FilterInputStream.reset`，以重置進度監視器以及串流。
`void`	`JEditorPane.setPage(String url)` 設置當前要顯示的 URL。
`void`	`JEditorPane.setPage(URL page)` 設置當前要顯示的 URL。
`long`	`ProgressMonitorInputStream.skip(long n)` 覆寫 `FilterInputStream.skip`，以便在跳過之後更新進度監視器。

拋出 IOException 的 javax.swing 中的建構子
`JEditorPane(String url)` 根據包含 URL 規範的字元串創建一個 `JEditorPane`。
`JEditorPane(URL initialPage)` 根據用作輸入的指定 URL 創建一個 `JEditorPane`。

javax.swing.filechooser 中 IOException 的使用

拋出 IOException 的 javax.swing.filechooser 中的方法
`abstract File`	`FileSystemView.createNewFolder(File containingDir)` 創建具有預設目錄名稱的新目錄。

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

拋出 IOException 的 javax.swing.plaf.synth 中的方法
`void`	`SynthLookAndFeel.load(URL url)` 載入此 `SynthLookAndFeel` 將使用的 `SynthStyle` 集合。

javax.swing.text 中 IOException 的使用

javax.swing.text 中 IOException 的子類別
`class`	`ChangedCharSetException` 顧名思義，ChangedCharSetException 是字元集改變時拋出的異常。

拋出 IOException 的 javax.swing.text 中的方法
`protected void`	`AbstractWriter.indent()` 執行縮進。
`protected void`	`AbstractWriter.output(char[] content, int start, int length)` 寫出內容過程的最後一步。
`void`	`DefaultEditorKit.read(InputStream in, Document doc, int pos)` 插入取自給定串流的內容，其格式需要適合此型別的內容處理程序。
`abstract void`	`EditorKit.read(InputStream in, Document doc, int pos)` 插入來自給定串流的內容，其格式需要適合此型別的內容處理程序。
`void`	`DefaultEditorKit.read(Reader in, Document doc, int pos)` 插入取自給定串流的內容，它將被視為純文本。
`abstract void`	`EditorKit.read(Reader in, Document doc, int pos)` 插入來自給定串流的內容，其格式需要適合此型別的內容處理程序。
`void`	`JTextComponent.read(Reader in, Object desc)` 根據串流進行初始化。
`void`	`StyleContext.readAttributes(ObjectInputStream in, MutableAttributeSet a)` 讀入屬性的特定於上下文的處理。
`static void`	`StyleContext.readAttributeSet(ObjectInputStream in, MutableAttributeSet a)` 從以前通過 `writeAttributeSet` 寫出的給定物件輸入串流中讀取一個屬性集。
`protected void`	`AbstractWriter.text(Element elem)` 寫出文本。
`protected abstract void`	`AbstractWriter.write()` 需要由子類別實作此抽象方法。
`protected void`	`AbstractWriter.write(char ch)` 寫出字元。
`protected void`	`AbstractWriter.write(char[] chars, int startIndex, int length)` 所有 write 方法都調用到此方法。
`void`	`DefaultEditorKit.write(OutputStream out, Document doc, int pos, int len)` 將文檔中的內容以適合此型別內容處理程序的格式寫入給定的串流。
`abstract void`	`EditorKit.write(OutputStream out, Document doc, int pos, int len)` 將文檔中的內容以適合此型別內容處理程序的格式寫入給定的串流。
`protected void`	`AbstractWriter.write(String content)` 寫出字元串。
`void`	`JTextComponent.write(Writer out)` 將模型的內容存儲到給定的串流中。
`void`	`DefaultEditorKit.write(Writer out, Document doc, int pos, int len)` 將取自文檔的內容以純文本格式寫入給定串流。
`abstract void`	`EditorKit.write(Writer out, Document doc, int pos, int len)` 將文檔中的內容以適合此型別內容處理程序的格式寫入給定的串流。
`protected void`	`AbstractWriter.writeAttributes(AttributeSet attr)` 以 " =" 對的形式寫出屬性集。
`void`	`StyleContext.writeAttributes(ObjectOutputStream out, AttributeSet a)` 寫出屬性的特定於上下文的處理。
`static void`	`StyleContext.writeAttributeSet(ObjectOutputStream out, AttributeSet a)` 將屬性集寫入到給定的物件串流以便序列化。
`protected void`	`AbstractWriter.writeLineSeparator()` 寫入行分隔符。

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

拋出 IOException 的 javax.swing.text.html 中的方法
`protected void`	`HTMLWriter.closeOutUnwantedEmbeddedTags(AttributeSet attr)` 搜尋屬性集和存儲在標記向量中的每個標記。
`protected void`	`HTMLWriter.comment(Element elem)` 寫出註釋。
`protected void`	`HTMLWriter.emptyTag(Element elem)` 寫出所有空元素（沒有對應結束標記的所有標記）。
`protected void`	`MinimalHTMLWriter.endFontTag()` 此方法已不再使用，而用寫出 <span> 來替換。
`protected void`	`HTMLWriter.endTag(Element elem)` 寫出元素的結束標記。
`void`	`HTMLDocument.insertAfterEnd(Element elem, String htmlText)` 將指定為字元串的 HTML 插入給定元素的起始處之後。
`void`	`HTMLDocument.insertAfterStart(Element elem, String htmlText)` 將指定為字元串的 HTML 插入元素的起始處。
`void`	`HTMLDocument.insertBeforeEnd(Element elem, String htmlText)` 將指定為字元串的 HTML 插入元素的結尾處。
`void`	`HTMLDocument.insertBeforeStart(Element elem, String htmlText)` 將指定為字元串的 HTML 插入給定元素的起始處之前。
`void`	`HTMLEditorKit.insertHTML(HTMLDocument doc, int offset, String html, int popDepth, int pushDepth, HTML.Tag insertTag)` 將 HTML 插入現有文檔。
`void`	`StyleSheet.loadRules(Reader in, URL ref)` 載入 CSS1 語法中指定的規則集合。
`protected void`	`HTMLWriter.output(char[] chars, int start, int length)` 覆寫此方法來映射任何字元實體，例如 < 映射到 <。
`abstract void`	`HTMLEditorKit.Parser.parse(Reader r, HTMLEditorKit.ParserCallback cb, boolean ignoreCharSet)` 解析給定的串流並通過解析的結果驅動給定的回調。
`void`	`HTMLEditorKit.read(Reader in, Document doc, int pos)` 插入來自給定串流的內容。
`protected void`	`HTMLWriter.selectContent(AttributeSet attr)` 寫出 SELECT 表單元素的內容。
`void`	`HTMLDocument.setInnerHTML(Element elem, String htmlText)` 用指定為 HTML 字元串的內容替換給定元素的子元素。
`void`	`HTMLDocument.setOuterHTML(Element elem, String htmlText)` 用指定為 HTML 字元串的內容替換父元素中的給定元素。
`protected void`	`MinimalHTMLWriter.startFontTag(String style)` 此方法已不再使用，而用寫出 <span> 來替換。
`protected void`	`HTMLWriter.startTag(Element elem)` 寫出元素的開始標記。
`protected void`	`HTMLWriter.text(Element elem)` 寫出文本。
`protected void`	`MinimalHTMLWriter.text(Element elem)` 寫出文本。
`protected void`	`HTMLWriter.textAreaContent(AttributeSet attr)` 寫出 TEXTAREA 表單元素中所包含的文本。
`void`	`HTMLWriter.write()` 對 Element 階層樹進行迭代並控制所有標記及其屬性的寫出。
`void`	`MinimalHTMLWriter.write()` 從 StyledDocument 產生 HTML 輸出。
`void`	`HTMLEditorKit.write(Writer out, Document doc, int pos, int len)` 以適合此類別內容處理程序的格式，將文檔中的內容寫入給定串流。
`protected void`	`HTMLWriter.writeAttributes(AttributeSet attr)` 寫出屬性集。
`protected void`	`MinimalHTMLWriter.writeAttributes(AttributeSet attr)` 寫出以下型別的所有屬性：StyleConstants.ParagraphConstants、StyleConstants.CharacterConstants、StyleConstants.FontConstants、StyleConstants.ColorConstants。
`protected void`	`MinimalHTMLWriter.writeBody()` 對文檔中的元素進行迭代，並基於元素是分支元素還是葉元素來處理它們。
`protected void`	`MinimalHTMLWriter.writeComponent(Element elem)` 負責處理 Component Elements；有意不實作它。
`protected void`	`MinimalHTMLWriter.writeContent(Element elem, boolean needsIndenting)` 以與 HTML 相容的方式寫出屬性集。
`protected void`	`HTMLWriter.writeEmbeddedTags(AttributeSet attr)` 搜尋 AttributeSet 中的嵌入式標記並寫出它們。
`protected void`	`MinimalHTMLWriter.writeEndParagraph()` 發出 <p> 標記的結束標記。
`protected void`	`MinimalHTMLWriter.writeEndTag(String endTag)` 寫出適當縮進的結束標記。
`protected void`	`MinimalHTMLWriter.writeHeader()` 寫出 <head> 和 <style> 標記，然後調用 writeStyles()，以寫出所有命名的樣式，這些樣式作為 <style> 標記的內容。
`protected void`	`MinimalHTMLWriter.writeHTMLTags(AttributeSet attr)` 基於文本的屬性設置產生文本的 bold <b>、italic <i> 和 <u> 標記。
`protected void`	`MinimalHTMLWriter.writeImage(Element elem)` 負責處理 Icon Elements；有意不實作它。
`protected void`	`MinimalHTMLWriter.writeLeaf(Element elem)` 負責寫出其他非文本葉元素。
`protected void`	`HTMLWriter.writeLineSeparator()` 寫出行分隔符。
`protected void`	`MinimalHTMLWriter.writeNonHTMLAttributes(AttributeSet attr)` 以與 HTML 相容的方式寫出其餘的字元級屬性（bold、italic 和 underline 之外的屬性）。
`protected void`	`HTMLWriter.writeOption(Option option)` 寫出 Option 表單元素的內容。
`protected void`	`MinimalHTMLWriter.writeStartParagraph(Element elem)` 發出段落的開始標記。
`protected void`	`MinimalHTMLWriter.writeStartTag(String tag)` 寫出適當縮進的開始標記。
`protected void`	`MinimalHTMLWriter.writeStyles()` 寫出所有命名的樣式，這些樣式作為 <style> 標記的內容。

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

拋出 IOException 的 javax.swing.text.html.parser 中的方法
`static DTD`	`DTD.getDTD(String name)` 返回具有指定 `name` 的 DTD。
`void`	`Parser.parse(Reader in)` 在給定 DTD 的情況下，解析 HTML 串流。
`void`	`DocumentParser.parse(Reader in, HTMLEditorKit.ParserCallback callback, boolean ignoreCharSet)`
`void`	`ParserDelegator.parse(Reader r, HTMLEditorKit.ParserCallback cb, boolean ignoreCharSet)`
`String`	`Parser.parseDTDMarkup()` 解析 Document Type Declaration 標記宣告。
`protected boolean`	`Parser.parseMarkupDeclarations(StringBuffer strBuff)` 解析標記宣告。
`void`	`DTD.read(DataInputStream in)` 根據存檔格式重新創建一個 DTD。

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

拋出 IOException 的 javax.swing.text.rtf 中的方法
`void`	`RTFEditorKit.read(InputStream in, Document doc, int pos)` 插入來自給定串流的內容，該內容的格式需要適合於此類別內容處理程序。
`void`	`RTFEditorKit.read(Reader in, Document doc, int pos)` 插入來自給定串流的內容，該內容將被視為純文本。
`void`	`RTFEditorKit.write(OutputStream out, Document doc, int pos, int len)` 以適合此類別內容處理程序的格式，將文檔中的內容寫入給定串流。
`void`	`RTFEditorKit.write(Writer out, Document doc, int pos, int len)` 將文檔中的內容作為純文本寫入給定的串流。

javax.tools 中 IOException 的使用

拋出 IOException 的 javax.tools 中的方法
`void`	`ForwardingJavaFileManager.close()`
`void`	`JavaFileManager.close()` 釋放此檔案管理器直接或間接打開的所有資源。
`void`	`ForwardingJavaFileManager.flush()`
`void`	`JavaFileManager.flush()` 刷新此檔案管理器直接或間接為輸出打開的所有資源。
`CharSequence`	`FileObject.getCharContent(boolean ignoreEncodingErrors)` 返回此檔案物件的字元內容（如果有）。
`CharSequence`	`ForwardingFileObject.getCharContent(boolean ignoreEncodingErrors)`
`CharSequence`	`SimpleJavaFileObject.getCharContent(boolean ignoreEncodingErrors)` 此實作總是拋出 UnsupportedOperationException。
`FileObject`	`ForwardingJavaFileManager.getFileForInput(JavaFileManager.Location location, String packageName, String relativeName)`
`FileObject`	`JavaFileManager.getFileForInput(JavaFileManager.Location location, String packageName, String relativeName)` 獲取輸入的檔案物件，它表示給定位置處指定包中的指定相對名稱。
`FileObject`	`ForwardingJavaFileManager.getFileForOutput(JavaFileManager.Location location, String packageName, String relativeName, FileObject sibling)`
`FileObject`	`JavaFileManager.getFileForOutput(JavaFileManager.Location location, String packageName, String relativeName, FileObject sibling)` 獲取輸出的檔案物件，它表示給定位置處指定包中的指定相對名稱。
`JavaFileObject`	`ForwardingJavaFileManager.getJavaFileForInput(JavaFileManager.Location location, String className, JavaFileObject.Kind kind)`
`JavaFileObject`	`JavaFileManager.getJavaFileForInput(JavaFileManager.Location location, String className, JavaFileObject.Kind kind)` 獲取輸入的檔案物件，它表示給定位置處指定型別的指定類別。
`JavaFileObject`	`ForwardingJavaFileManager.getJavaFileForOutput(JavaFileManager.Location location, String className, JavaFileObject.Kind kind, FileObject sibling)`
`JavaFileObject`	`JavaFileManager.getJavaFileForOutput(JavaFileManager.Location location, String className, JavaFileObject.Kind kind, FileObject sibling)` 獲取輸出的檔案物件，它表示給定位置處指定型別的指定類別。
`Iterable<JavaFileObject>`	`ForwardingJavaFileManager.list(JavaFileManager.Location location, String packageName, Set<JavaFileObject.Kind> kinds, boolean recurse)`
`Iterable<JavaFileObject>`	`JavaFileManager.list(JavaFileManager.Location location, String packageName, Set<JavaFileObject.Kind> kinds, boolean recurse)` 列出給定位置處符合給定標準的所有檔案物件。
`InputStream`	`FileObject.openInputStream()` 獲取此檔案物件的 InputStream。
`InputStream`	`ForwardingFileObject.openInputStream()`
`InputStream`	`SimpleJavaFileObject.openInputStream()` 此實作總是拋出 UnsupportedOperationException。
`OutputStream`	`FileObject.openOutputStream()` 獲取此檔案物件的 OutputStream。
`OutputStream`	`ForwardingFileObject.openOutputStream()`
`OutputStream`	`SimpleJavaFileObject.openOutputStream()` 此實作總是拋出 UnsupportedOperationException。
`Reader`	`FileObject.openReader(boolean ignoreEncodingErrors)` 獲取此物件的 reader。
`Reader`	`ForwardingFileObject.openReader(boolean ignoreEncodingErrors)`
`Reader`	`SimpleJavaFileObject.openReader(boolean ignoreEncodingErrors)` 在 Reader 中包裹 SimpleJavaFileObject.getCharContent(boolean) 的結果。
`Writer`	`FileObject.openWriter()` 獲取此檔案物件的 Writer。
`Writer`	`ForwardingFileObject.openWriter()`
`Writer`	`SimpleJavaFileObject.openWriter()` 在 Writer 中包裹 openOutputStream 的結果。
`void`	`StandardJavaFileManager.setLocation(JavaFileManager.Location location, Iterable<? extends File> path)` 將給定路徑與給定位置關聯。

javax.transaction 中 IOException 的使用

javax.transaction 中 IOException 的子類別
`class`	`InvalidTransactionException` 此異常指示該請求帶來了無效的事務上下文。
`class`	`TransactionRequiredException` 此異常指示某個請求帶來了 null 事務上下文，但目標物件需要啟動的事務。
`class`	`TransactionRolledbackException` 此異常指示與請求處理關聯的事務已回滾，或已標記為回滾。

javax.xml.bind 中 IOException 的使用

拋出 IOException 的 javax.xml.bind 中的方法
`abstract Result`	`SchemaOutputResolver.createOutput(String namespaceUri, String suggestedFileName)` 確定寫入網要檔案（由給定名稱空間 URI 指定）的位置，並以 `Result` 物件的形式返回它。
`void`	`JAXBContext.generateSchema(SchemaOutputResolver outputResolver)` 產生此上下文的網要文檔。

javax.xml.parsers 中 IOException 的使用

拋出 IOException 的 javax.xml.parsers 中的方法
`Document`	`DocumentBuilder.parse(File f)` 將給定檔案的內容解析為一個 XML 文檔，並且返回一個新的 DOM `Document` 物件。
`void`	`SAXParser.parse(File f, DefaultHandler dh)` 使用指定的 `DefaultHandler` 將指定檔案的內容解析為 XML。
`void`	`SAXParser.parse(File f, HandlerBase hb)` 使用指定的 `HandlerBase` 將指定檔案的內容解析為 XML。
`abstract Document`	`DocumentBuilder.parse(InputSource is)` 將給定輸入源的內容解析為一個 XML 文檔，並且返回一個新的 DOM `Document` 物件。
`void`	`SAXParser.parse(InputSource is, DefaultHandler dh)` 使用指定的 `DefaultHandler` 將給定 `InputSource` 的內容解析為 XML。
`void`	`SAXParser.parse(InputSource is, HandlerBase hb)` 使用指定的 `HandlerBase` 將給定 `InputSource` 的內容解析為 XML。
`Document`	`DocumentBuilder.parse(InputStream is)` 將給定 `InputStream` 的內容解析為一個 XML 文檔，並且返回一個新的 DOM `Document` 物件。
`void`	`SAXParser.parse(InputStream is, DefaultHandler dh)` 使用指定的 `DefaultHandler` 將給定的 `InputStream` 實例的內容解析為 XML。
`void`	`SAXParser.parse(InputStream is, DefaultHandler dh, String systemId)` 使用指定的 `DefaultHandler` 將給定的 `InputStream` 實例的內容解析為 XML。
`void`	`SAXParser.parse(InputStream is, HandlerBase hb)` 使用指定的 `HandlerBase` 將給定的 `InputStream` 實例的內容解析為 XML。
`void`	`SAXParser.parse(InputStream is, HandlerBase hb, String systemId)` 使用指定的 `HandlerBase` 將給定的 `InputStream` 實例的內容解析為 XML。
`Document`	`DocumentBuilder.parse(InputStream is, String systemId)` 將給定 `InputStream` 的內容解析為一個 XML 文檔，並且返回一個新的 DOM `Document` 物件。
`Document`	`DocumentBuilder.parse(String uri)` 將給定 URI 的內容解析為一個 XML 文檔，並且返回一個新的 DOM `Document` 物件。
`void`	`SAXParser.parse(String uri, DefaultHandler dh)` 使用指定的 `DefaultHandler` 將給定統一資源標識符 (URI) 描述的內容解析為 XML。
`void`	`SAXParser.parse(String uri, HandlerBase hb)` 使用指定的 `HandlerBase` 將給定統一資源標識符 (URI) 描述的內容解析為 XML。

javax.xml.soap 中 IOException 的使用

拋出 IOException 的 javax.xml.soap 中的方法
`abstract SOAPMessage`	`MessageFactory.createMessage(MimeHeaders headers, InputStream in)` 將給定 `InputStream` 物件的內容內部化到新的 `SOAPMessage` 物件，並返回該 `SOAPMessage` 物件。
`abstract void`	`SOAPMessage.writeTo(OutputStream out)` 將此 `SOAPMessage` 物件寫入給定輸出串流。

javax.xml.validation 中 IOException 的使用

拋出 IOException 的 javax.xml.validation 中的方法
`void`	`Validator.validate(Source source)` 驗證指定的輸入。
`abstract void`	`Validator.validate(Source source, Result result)` 驗證指定輸入並將擴充的驗證結果發送到指定輸出。

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

拋出 IOException 的 org.omg.CORBA.portable 中的方法
`int`	`InputStream.read()`
`void`	`OutputStream.write(int b)` 將一個 integer（陣列長度）寫入此串流。

org.xml.sax 中 IOException 的使用

拋出 IOException 的 org.xml.sax 中的方法
`void`	`Parser.parse(InputSource source)` 已過時。解析 XML 文檔。
`void`	`XMLReader.parse(InputSource input)` 解析 XML 文檔。
`void`	`Parser.parse(String systemId)` 已過時。從系統標識符 (URI) 解析 XML 文檔。
`void`	`XMLReader.parse(String systemId)` 從系統標識符 (URI) 解析 XML 文檔。
`InputSource`	`EntityResolver.resolveEntity(String publicId, String systemId)` 允許應用程序解析外部實體。

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

拋出 IOException 的 org.xml.sax.ext 中的方法
`InputSource`	`DefaultHandler2.getExternalSubset(String name, String baseURI)` 告知解析器如果在文檔文本中沒有宣告任何外部子集，則不應使用任何外部子集。
`InputSource`	`EntityResolver2.getExternalSubset(String name, String baseURI)` 允許應用程序為不能顯式定義外部子集的文檔提供外部子集。
`InputSource`	`DefaultHandler2.resolveEntity(String publicId, String systemId)` 使用 null 實體名稱和基 URI 調用 `EntityResolver2.resolveEntity()`。
`InputSource`	`DefaultHandler2.resolveEntity(String name, String publicId, String baseURI, String systemId)` 告知解析器根據 baseURI 解析 systemId，並從產生的絕對 URI 讀取實體文本。
`InputSource`	`EntityResolver2.resolveEntity(String name, String publicId, String baseURI, String systemId)` 允許應用程序把對外部實體的參考映射到輸入源，或告知解析器它應使用常規 URI 解析。

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

拋出 IOException 的 org.xml.sax.helpers 中的方法
`void`	`ParserAdapter.parse(InputSource input)` 解析 XML 文檔。
`void`	`XMLFilterImpl.parse(InputSource input)` 解析一個文檔。
`void`	`XMLReaderAdapter.parse(InputSource input)` 解析文檔。
`void`	`ParserAdapter.parse(String systemId)` 解析 XML 文檔。
`void`	`XMLFilterImpl.parse(String systemId)` 解析一個文檔。
`void`	`XMLReaderAdapter.parse(String systemId)` 解析文檔。
`InputSource`	`DefaultHandler.resolveEntity(String publicId, String systemId)` 解析外部實體。
`InputSource`	`XMLFilterImpl.resolveEntity(String publicId, String systemId)` 過濾一個外部實體解析。

概觀

軟體套件

類別

使用

階層樹

已過時

索引

說明

Java^TM 2 Platform
Standard Ed. 6

上一個下一個

框架 無框架

提交錯誤或意見

類別 java.io.IOException的使用

類別 java.io.IOException
的使用