java.io
類別 ObjectOutputStream

java.lang.Object
  java.io.OutputStream
      java.io.ObjectOutputStream

所有已實作的介面：

Closeable, DataOutput, Flushable, ObjectOutput, ObjectStreamConstants

public class ObjectOutputStream
extends OutputStream
implements ObjectOutput, ObjectStreamConstants

ObjectOutputStream 將 Java 物件的基本資料型別和圖形寫入 OutputStream。可以使用 ObjectInputStream 讀取（重構）物件。通過在串流中使用檔案可以實作物件的持久存儲。如果串流是網路Socket串流，則可以在另一台主機上或另一個進程中重構物件。

只能將支持 java.io.Serializable 介面的物件寫入串流中。每個 serializable 物件的類別都被編碼，編碼內容包括類別名和類別簽章、物件的欄位值和陣列值，以及從初始物件中參考的其他所有物件的閉套件。

writeObject 方法用於將物件寫入串流中。所有物件（包括 String 和陣列）都可以通過 writeObject 寫入。可將多個物件或基元寫入串流中。必須使用與寫入物件時相同的型別和順序從相應 ObjectInputstream 中讀回物件。

還可以使用 DataOutput 中的適當方法將基本資料型別寫入串流中。還可以使用 writeUTF 方法寫入字元串。

物件的預設序列化機制寫入的內容是：物件的類別，類別簽章，以及非瞬態和非靜態欄位的值。其他物件的參考（瞬態和靜態欄位除外）也會導致寫入那些物件。可使用參考共享機制對單個物件的多個參考進行編碼，這樣即可將物件的圖形恢復為最初寫入它們時的形狀。

例如，要寫入可通過 ObjectInputStream 中的範例讀取的物件，請執行以下操作：

        FileOutputStream fos = new FileOutputStream("t.tmp");
        ObjectOutputStream oos = new ObjectOutputStream(fos);

        oos.writeInt(12345);
        oos.writeObject("Today");
        oos.writeObject(new Date());

        oos.close();
 

在序列化和反序列化過程中需要特殊處理的類別必須實作具有下列準確簽章的特殊方法：

 private void readObject(java.io.ObjectInputStream stream)
     throws IOException, ClassNotFoundException;
 private void writeObject(java.io.ObjectOutputStream stream)
     throws IOException
 private void readObjectNoData() 
     throws ObjectStreamException;
 

writeObject 方法負責寫入特定類別的物件狀態，以便相應的 readObject 方法可以恢復它。該方法本身不必與屬於物件的父級類別或子類別的狀態有關。狀態是通過使用 writeObject 方法或使用 DataOutput 支持的用於基本資料型別的方法將各個欄位寫入 ObjectOutputStream 來保存的。

序列化操作不寫出沒有實作 java.io.Serializable 介面的任何物件的欄位。不可序列化的 Object 的子類別可以是可序列化的。在此情況下，不可序列化的類別必須有一個無參數建構子，以便允許初始化其欄位。在此情況下，子類別負責保存和恢復不可序列化的類別的狀態。經常出現的情況是，該類別的欄位是可存取的（public、package 或 protected），或者存在可用來恢復狀態的 get 和 set 方法。

在 writeObject 和 readObject 方法的實作中拋出 NotSerializableException，可以阻止物件的序列化。ObjectOutputStream 將捕獲異常並中止序列化進程。

實作 Externalizable 介面允許物件假定可以完全控制物件的序列化形式的內容和格式。調用 Externalizable 介面的方法（writeExternal 和 readExternal）來保存和恢復物件的狀態。通過類別實作時，它們可以使用 ObjectOutput 和 ObjectInput 的所有方法讀寫它們自己的狀態。物件負責處理出現的任何版本控制。

Enum 常數的序列化不同於普通的 serializable 或 externalizable 物件。enum 常數的序列化形式只包含其名稱；常數的欄位值不被傳送。為了序列化 enum 常數，ObjectOutputStream 需要寫入由常數的名稱方法返回的字元串。與其他 serializable 或 externalizable 物件一樣，enum 常數可以作為序列化串流中後續出現的 back 參考的目標。用於序列化 enum 常數的進程不可定制；在序列化期間，由 enum 型別定義的全部類別特定的 writeObject 和 writeReplace 方法都將被忽略。類似地，任何 serialPersistentFields 或 serialVersionUID 欄位宣告也將被忽略，所有 enum 型別都有一個 0L 的固定的 serialVersionUID。

基本資料（不包括 serializable 欄位和 externalizable 資料）以塊資料記錄的形式寫入 ObjectOutputStream 中。塊資料記錄由頭部和資料組成。塊資料部分包括標記和跟在部分後面的位元組數。連續的基本寫入資料被合併在一個塊資料記錄中。塊資料記錄的分塊因子為 1024 位元組。每個塊資料記錄都將填滿 1024 位元組，或者在終止塊資料網要時被寫入。調用 ObjectOutputStream 方法 writeObject、defaultWriteObject 和 writeFields 最初只是終止所有現有塊資料記錄。

從以下版本開始：

JDK1.1

另請參見：

DataOutput, ObjectInputStream, Serializable, Externalizable, Serialization Specification, Section 2, Object Output Classes

巢狀類別摘要

static class

ObjectOutputStream.PutField 提供對要寫入 ObjectOutput 的持久欄位的程式存取。

欄位摘要

從介面 java.io.ObjectStreamConstants 繼承的欄位

baseWireHandle, PROTOCOL_VERSION_1, PROTOCOL_VERSION_2, SC_BLOCK_DATA, SC_ENUM, SC_EXTERNALIZABLE, SC_SERIALIZABLE, SC_WRITE_METHOD, STREAM_MAGIC, STREAM_VERSION, SUBCLASS_IMPLEMENTATION_PERMISSION, SUBSTITUTION_PERMISSION, TC_ARRAY, TC_BASE, TC_BLOCKDATA, TC_BLOCKDATALONG, TC_CLASS, TC_CLASSDESC, TC_ENDBLOCKDATA, TC_ENUM, TC_EXCEPTION, TC_LONGSTRING, TC_MAX, TC_NULL, TC_OBJECT, TC_PROXYCLASSDESC, TC_REFERENCE, TC_RESET, TC_STRING

建構子摘要

protected	ObjectOutputStream() 為完全重新實作 ObjectOutputStream 的子類別提供一種方法，讓它不必分派僅由 ObjectOutputStream 的實作使用的私有資料。
	ObjectOutputStream(OutputStream out) 創建寫入指定 OutputStream 的 ObjectOutputStream。

方法摘要

protected void	annotateClass(Class<?> cl) 子類別可以實作此方法，從而允許在串流中存儲類別資料。
protected void	annotateProxyClass(Class<?> cl) 子類別可以實作此方法，從而在串流中存儲定制資料和動態代理類別的描述符。
void	close() 關閉串流。
void	defaultWriteObject() 將當前類別的非靜態和非瞬態欄位寫入此串流。
protected void	drain() 排空 ObjectOutputStream 中的所有已緩衝資料。
protected boolean	enableReplaceObject(boolean enable) 允許串流對串流中的物件進行替換。
void	flush() 刷新該串流的緩衝。
ObjectOutputStream.PutField	putFields() 獲取用於緩衝寫入串流中的持久存儲欄位的物件。
protected Object	replaceObject(Object obj) 在序列化期間，此方法允許 ObjectOutputStream 的受信任子類別使用一個物件替代另一個物件。
void	reset() 重置將丟棄已寫入串流中的所有物件的狀態。
void	useProtocolVersion(int version) 指定要在寫入串流時使用的串流協議版本。
void	write(byte[] buf) 寫入一個 byte 陣列。
void	write(byte[] buf, int off, int len) 寫入位元組的子陣列。
void	write(int val) 寫入一個位元組。
void	writeBoolean(boolean val) 寫入一個 boolean 值。
void	writeByte(int val) 寫入一個 8 位位元組。
void	writeBytes(String str) 以位元組序列形式寫入一個 String。
void	writeChar(int val) 寫入一個 16 位的 char 值。
void	writeChars(String str) 以 char 序列形式寫入一個 String。
protected void	writeClassDescriptor(ObjectStreamClass desc) 將指定的類別描述符寫入 ObjectOutputStream。
void	writeDouble(double val) 寫入一個 64 位的 double 值。
void	writeFields() 將已緩衝的欄位寫入串流中。
void	writeFloat(float val) 寫入一個 32 位的 float 值。
void	writeInt(int val) 寫入一個 32 位的 int 值。
void	writeLong(long val) 寫入一個 64 位的 long 值。
void	writeObject(Object obj) 將指定的物件寫入 ObjectOutputStream。
protected void	writeObjectOverride(Object obj) 子類別用於覆寫預設 writeObject 方法的方法。
void	writeShort(int val) 寫入一個 16 位的 short 值。
protected void	writeStreamHeader() 提供 writeStreamHeader 方法，這樣子類別可以將其自身的頭部添加或預加到串流中。
void	writeUnshared(Object obj) 將“未共享”物件寫入 ObjectOutputStream。
void	writeUTF(String str) 以 UTF-8 修改版格式寫入此 String 的基本資料。

從類別 java.lang.Object 繼承的方法

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

建構子詳細資訊

ObjectOutputStream

public ObjectOutputStream(OutputStream out)
                   throws IOException

創建寫入指定 OutputStream 的 ObjectOutputStream。此建構子將序列化串流部分寫入底層串流；調用者可以通過立即刷新串流，確保在讀取頭部時，用於接收 ObjectInputStreams 建構子不會阻塞。

如果安裝了安全管理器，則在通過覆寫 ObjectOutputStream.putFields 或 ObjectOutputStream.writeUnshared 方法的子類別的建構子來直接或間接調用此建構子時，它將對 "enableSubclassImplementation" SerializablePermission 進行檢查。

參數：

out - 要寫入資料的輸出串流

拋出：

IOException - 如果在寫入串流部分時發生 I/O 錯誤

SecurityException - 如果不受信任的子類別非法覆寫安全敏感方法

NullPointerException - 如果 out 為 null

從以下版本開始：

1.4

另請參見：

ObjectOutputStream(), putFields(), ObjectInputStream.ObjectInputStream(InputStream)

ObjectOutputStream

protected ObjectOutputStream()
                      throws IOException,
                             SecurityException

為完全重新實作 ObjectOutputStream 的子類別提供一種方法，讓它不必分派僅由 ObjectOutputStream 的實作使用的私有資料。

如果已經安裝了安全管理器，則此方法首先利用 SerializablePermission("enableSubclassImplementation") 權限調用安全管理器的 checkPermission 方法，以確保可以啟用子類別化。

拋出：

SecurityException - 如果安全管理器存在，且其 checkPermission 方法不允許啟用子類別化。

IOException

另請參見：

SecurityManager.checkPermission(java.security.Permission), SerializablePermission

方法詳細資訊

useProtocolVersion

public void useProtocolVersion(int version)
                        throws IOException

指定要在寫入串流時使用的串流協議版本。

此例程提供了一個鉤子 (hook)，允許以與舊版的串流格式向後相容的格式寫入當前版的 Serialization。

我們將盡最大努力避免造成額外的向後不相容性；但有時沒有其他替代方法。

參數：

version - 根據 java.io.ObjectStreamConstants 使用 ProtocolVersion。

拋出：

IllegalStateException - 如果在已序列化所有物件後調用。

IllegalArgumentException - 如果傳入的版本無效。

IOException - 如果發生 I/O 錯誤

從以下版本開始：

1.2

另請參見：

ObjectStreamConstants.PROTOCOL_VERSION_1, ObjectStreamConstants.PROTOCOL_VERSION_2

writeObject

public final void writeObject(Object obj)
                       throws IOException

將指定的物件寫入 ObjectOutputStream。物件的類別、類別的簽章，以及類別及其所有父級類別型的非瞬態和非靜態欄位的值都將被寫入。可以使用 writeObject 和 readObject 方法覆寫類別的預設序列化。由此物件參考的物件是以可變遷的方式寫入的，這樣，可以通過 ObjectInputStream 重新建構這些物件的完全等價的圖形。

當 OutputStream 中出現問題或者遇到不應序列化的類別時，將拋出異常。所有異常對於 OutputStream 而言都是致命的，使其處於不確定狀態；並由調用者來忽略或恢復串流的狀態。

指定者：

介面 ObjectOutput 中的 writeObject

參數：

obj - 要寫入的物件

拋出：

InvalidClassException - 序列化操作使用的類別出了問題。

NotSerializableException - 某個要序列化的物件不能實作 java.io.Serializable 介面。

IOException - 由底層 OutputStream 拋出的任何異常。

writeObjectOverride

protected void writeObjectOverride(Object obj)
                            throws IOException

子類別用於覆寫預設 writeObject 方法的方法。此方法由 ObjectInputStream 的受信任子類別調用，可以使用受保護的無參數建構子來建構 ObjectInputStream。子類別需要使用修飾符 "final" 提供覆寫方法。

參數：

obj - 要寫入底層串流的物件

拋出：

IOException - 如果寫入底層串流時發生 I/O 錯誤

從以下版本開始：

1.2

另請參見：

ObjectOutputStream(), writeObject(Object)

writeUnshared

public void writeUnshared(Object obj)
                   throws IOException

將“未共享”物件寫入 ObjectOutputStream。此方法等同於 writeObject，不同點在於它總是將給定物件作為串流中唯一的新物件進行寫入（相對於指向以前序列化實例的 back 參考而言）。尤其是：

• 通過 writeUnshared 寫入的物件總是作為新出現物件（未曾將物件寫入串流中）被序列化，不管該物件以前是否已經被寫入過。
• 如果使用 writeObject 寫入以前通過 writeUnshared 寫入的物件，則可將以前的 writeUnshared 操作視為寫入一個單獨物件。換句話說，ObjectOutputStream 永遠不會產生通過調用 writeUnshared 寫入的物件資料的 back 參考。

雖然通過 writeUnshared 寫入物件本身不能保證反序列化物件時物件參考的唯一性，但它允許在串流中多次定義單個物件，因此接收方對 readUnshared 的多個調用不會引發衝突。注意，上述規則僅應用於通過 writeUnshared 寫入的基層物件,而不能應用於要序列化的物件圖形中的任何可變遷方式參考的子物件。

覆寫此方法的 ObjectOutputStream 子類別只能在處理 "enableSubclassImplementation" SerializablePermission 的安全上下文中建構；在不具有此權限的情況下，任何實例化這種子類別的嘗試都將導致拋出 SecurityException。

參數：

obj - 要寫入串流的物件

拋出：

NotSerializableException - 如果要序列化的圖形中的物件不能實作 Serializable 介面

InvalidClassException - 如果要序列化的物件的類別存在問題

IOException - 如果序列化期間發生 I/O 錯誤

從以下版本開始：

1.4

defaultWriteObject

public void defaultWriteObject()
                        throws IOException

將當前類別的非靜態和非瞬態欄位寫入此串流。此欄位只能從正在序列化的類別的 writeObject 方法中調用。如果從其他地方調用該欄位，則將拋出 NotActiveException。

拋出：

IOException - 如果在寫入底層 OutputStream 中時發生 I/O 錯誤

putFields

public ObjectOutputStream.PutField putFields()
                                      throws IOException

獲取用於緩衝寫入串流中的持久存儲欄位的物件。調用 writeFields 方法時，欄位被寫入串流中。

返回：

保存 serializable 欄位的 Putfield 類別的實例

拋出：

IOException - 如果發生 I/O 錯誤

從以下版本開始：

1.2

writeFields

public void writeFields()
                 throws IOException

將已緩衝的欄位寫入串流中。

拋出：

IOException - 如果在寫入底層串流時發生 I/O 錯誤

NotActiveException - 未調用類別 writeObject 方法來寫入物件的狀態時調用。

從以下版本開始：

1.2

reset

public void reset()
           throws IOException

重置將丟棄已寫入串流中的所有物件的狀態。重新設置狀態，使其與新的 ObjectOutputStream 相同。將串流中的當前點標記為 reset，相應的 ObjectInputStream 也將在這一點重置。以前寫入串流中的物件不再被視為正位於串流中。它們會再次被寫入串流。

拋出：

IOException - 如果在序列化物件時調用 reset()。

annotateClass

protected void annotateClass(Class<?> cl)
                      throws IOException

子類別可以實作此方法，從而允許在串流中存儲類別資料。預設情況下，此方法不執行任何操作。ObjectInputStream 中的相應方法是 resolveClass。對於串流中的每個唯一的類別，此方法只調用一次。類別名和類別簽章已經寫入串流中。此方法可以隨意使用 ObjectOutputStream 來保存它認為合適的類別的任何表示形式（例如類別檔案的位元組）。ObjectInputStream 的相應子類別中的 resolveClass 方法必須讀取並使用由 annotateClass 寫入的資料或物件。

參數：

cl - 註釋定制資料的類別

拋出：

IOException - 底層 OutputStream 拋出任何異常。

annotateProxyClass

protected void annotateProxyClass(Class<?> cl)
                           throws IOException

子類別可以實作此方法，從而在串流中存儲定制資料和動態代理類別的描述符。

對於串流中的每個唯一的代理類別描述符，此方法只調用一次。在 ObjectOutputStream 中，此方法的預設實作不執行任何操作。

ObjectInputStream 中的相應方法是 resolveProxyClass。對於覆寫此方法的 ObjectOutputStream 的給定子類別，ObjectInputStream 的相應子類別中的 resolveProxyClass 方法必須讀取由 annotateProxyClass 寫入的所有資料或物件。

參數：

cl - 註釋定制資料的代理類別

拋出：

IOException - 底層 OutputStream 拋出的任何異常

從以下版本開始：

1.3

另請參見：

ObjectInputStream.resolveProxyClass(String[])

replaceObject

protected Object replaceObject(Object obj)
                        throws IOException

在序列化期間，此方法允許 ObjectOutputStream 的受信任子類別使用一個物件替代另一個物件。在調用 enableReplaceObject 之前，不允許取代物件。enableReplaceObject 方法檢查請求取代的串流是否可以信任。寫入序列化串流的每個物件在第一次出現時被傳遞給 replaceObject。在後續參考中，該物件將由初始調用 replaceObject 所返回的物件取代。為了確保不會無意暴露物件的私有狀態，可以僅讓受信任的串流使用 replaceObject。

ObjectOutputStream.writeObject 方法使用 Object 型別的參數（相對於 Serializable 型別），允許非 serializable 物件由 serializable 物件取代。

在子類別取代物件時，必須確保要麼在反序列化期間進行互補替代，要麼替代對象與存儲參考的每個欄位相容。如果物件的型別不是欄位或陣列元素型別的子類別，則通過引發異常中止序列化並且不存儲物件。

此方法僅在首次遇到每個物件時調用一次。物件的所有後續參考都將被重定向到新物件。此方法應該返回要替代的物件或初始物件。

替代物件時可以返回 null，但是在包含到初始物件的參考的類別中可能導致 NullReferenceException，因為它們可能期望得到物件而不是 null。

參數：

obj - 要取代的物件

返回：

取代指定物件的替換物件

拋出：

IOException - 底層 OutputStream 拋出的任何異常。

enableReplaceObject

protected boolean enableReplaceObject(boolean enable)
                               throws SecurityException

允許串流對串流中的物件進行替換。啟用時，將為正序列化的每個物件調用 replaceObject 方法。

如果 enable 為 true，並且安裝了安全管理器，則此方法首先利用 SerializablePermission("enableSubstitution") 權限調用安全管理器的 checkPermission 方法，以確保允許串流對串流中的物件進行替換。

參數：

enable - 允許取代物件的 boolean 參數

返回：

調用此方法之前的以前的設置

拋出：

SecurityException - 如果安全管理器存在，且其 checkPermission 方法不允許串流對串流中的物件進行替換。

另請參見：

SecurityManager.checkPermission(java.security.Permission), SerializablePermission

writeStreamHeader

protected void writeStreamHeader()
                          throws IOException

提供 writeStreamHeader 方法，這樣子類別可以將其自身的頭部添加或預加到串流中。它可以將幻數 (magic number) 和版本寫入串流。

拋出：

IOException - 如果在寫入底層串流時發生 I/O 錯誤

writeClassDescriptor

protected void writeClassDescriptor(ObjectStreamClass desc)
                             throws IOException

將指定的類別描述符寫入 ObjectOutputStream。類別描述符用於標識寫入串流中的物件的類別。ObjectOutputStream 的子類別可以覆寫此方法，從而定制將類別描述符寫入序列化串流中的方式。然後，應該覆寫 ObjectInputStream 中的相應方法（readClassDescriptor），以便根據其定制的串流表示形式來重構類別描述符。預設情況下，此方法根據 Object Serialization 規範中定義的格式寫入類別描述符。

注意，僅當 ObjectOutputStream 沒有使用舊的序列化串流格式（通過調用 ObjectOutputStream 的 useProtocolVersion 方法設置）時才調用此方法。如果此序列化串流在使用舊的格式（即 PROTOCOL_VERSION_1），則以不可覆寫或自定義的方式在內部寫入類別描述符。

參數：

desc - 要寫入串流的類別描述符

拋出：

IOException - 如果發生 I/O 錯誤。

從以下版本開始：

1.3

另請參見：

ObjectInputStream.readClassDescriptor(), useProtocolVersion(int), ObjectStreamConstants.PROTOCOL_VERSION_1

write

public void write(int val)
           throws IOException

寫入一個位元組。在實際寫入位元組前，此方法將發生阻塞。

指定者：

介面 DataOutput 中的 write

指定者：

介面 ObjectOutput 中的 write

指定者：

類別 OutputStream 中的 write

參數：

val - 要寫入串流中的位元組

拋出：

IOException - 如果發生 I/O 錯誤。

write

public void write(byte[] buf)
           throws IOException

寫入一個 byte 陣列。在實際寫入位元組前，此方法將發生阻塞。

指定者：

介面 DataOutput 中的 write

指定者：

介面 ObjectOutput 中的 write

覆寫：

類別 OutputStream 中的 write

參數：

buf - 要寫入的資料

拋出：

IOException - 如果發生 I/O 錯誤。

另請參見：

OutputStream.write(byte[], int, int)

write

public void write(byte[] buf,
                  int off,
                  int len)
           throws IOException

寫入位元組的子陣列。

指定者：

介面 DataOutput 中的 write

指定者：

介面 ObjectOutput 中的 write

覆寫：

類別 OutputStream 中的 write

參數：

buf - 要寫入的資料

off - 資料中的初始偏移量

len - 寫入的位元組數

拋出：

IOException - 如果發生 I/O 錯誤。

flush

public void flush()
           throws IOException

刷新該串流的緩衝。此操作將寫入所有已緩衝的輸出位元組，並將它們刷新到底層串流中。

指定者：

介面 Flushable 中的 flush

指定者：

介面 ObjectOutput 中的 flush

覆寫：

類別 OutputStream 中的 flush

拋出：

IOException - 如果發生 I/O 錯誤。

drain

protected void drain()
              throws IOException

排空 ObjectOutputStream 中的所有已緩衝資料。與刷新類似，但沒有將刷新傳播到底層串流。

拋出：

IOException - 如果在將資料寫入底層串流時發生 I/O 錯誤

close

public void close()
           throws IOException

關閉串流。必須調用此方法來釋放與此串流有關的所有資源。

指定者：

介面 Closeable 中的 close

指定者：

介面 ObjectOutput 中的 close

覆寫：

類別 OutputStream 中的 close

拋出：

IOException - 如果發生 I/O 錯誤。

writeBoolean

public void writeBoolean(boolean val)
                  throws IOException

寫入一個 boolean 值。

指定者：

介面 DataOutput 中的 writeBoolean

參數：

val - 要寫入的 boolean 值

拋出：

IOException - 如果在將資料寫入底層串流時發生 I/O 錯誤

writeByte

public void writeByte(int val)
               throws IOException

寫入一個 8 位位元組。

指定者：

介面 DataOutput 中的 writeByte

參數：

val - 要寫入的位元組值

拋出：

IOException - 如果在將資料寫入底層串流時發生 I/O 錯誤

writeShort

public void writeShort(int val)
                throws IOException

寫入一個 16 位的 short 值。

指定者：

介面 DataOutput 中的 writeShort

參數：

val - 要寫入的 short 值

拋出：

IOException - 如果在將資料寫入底層串流時發生 I/O 錯誤

writeChar

public void writeChar(int val)
               throws IOException

寫入一個 16 位的 char 值。

指定者：

介面 DataOutput 中的 writeChar

參數：

val - 要寫入的 char 值

拋出：

IOException - 如果在將資料寫入底層串流時發生 I/O 錯誤

writeInt

public void writeInt(int val)
              throws IOException

寫入一個 32 位的 int 值。

指定者：

介面 DataOutput 中的 writeInt

參數：

val - 要寫入的整數值

拋出：

IOException - 如果在將資料寫入底層串流時發生 I/O 錯誤

writeLong

public void writeLong(long val)
               throws IOException

寫入一個 64 位的 long 值。

指定者：

介面 DataOutput 中的 writeLong

參數：

val - 要寫入的 long 值

拋出：

IOException - 如果在將資料寫入底層串流時發生 I/O 錯誤

writeFloat

public void writeFloat(float val)
                throws IOException

寫入一個 32 位的 float 值。

指定者：

介面 DataOutput 中的 writeFloat

參數：

val - 要寫入的 float 值

拋出：

IOException - 如果在將資料寫入底層串流時發生 I/O 錯誤

writeDouble

public void writeDouble(double val)
                 throws IOException

寫入一個 64 位的 double 值。

指定者：

介面 DataOutput 中的 writeDouble

參數：

val - 要寫入的 double 值

拋出：

IOException - 如果在將資料寫入底層串流時發生 I/O 錯誤

writeBytes

public void writeBytes(String str)
                throws IOException

以位元組序列形式寫入一個 String。

指定者：

介面 DataOutput 中的 writeBytes

參數：

str - 要寫入的位元組的 String

拋出：

IOException - 如果在將資料寫入底層串流時發生 I/O 錯誤

writeChars

public void writeChars(String str)
                throws IOException

以 char 序列形式寫入一個 String。

指定者：

介面 DataOutput 中的 writeChars

參數：

str - 要寫入的 char 的 String

拋出：

IOException - 如果在將資料寫入底層串流時發生 I/O 錯誤

writeUTF

public void writeUTF(String str)
              throws IOException

以 UTF-8 修改版格式寫入此 String 的基本資料。注意，將 String 作為基本資料寫入串流中與將它作為 Object 寫入串流中明顯不同。由 writeObject 寫入的 String 實例最初是作為 String 寫入串流中的。然後，writeObject() 調用將對該字元串的參考寫入串流中。

指定者：

介面 DataOutput 中的 writeUTF

參數：

str - 要寫入的 String

拋出：

IOException - 如果在將輸入寫入底層串流時發生 I/O 錯誤