java.nio
類別 ByteBuffer

java.lang.Object
  java.nio.Buffer
      java.nio.ByteBuffer

所有已實作的介面：

Comparable<ByteBuffer>

直接已知子類別：

MappedByteBuffer

public abstract class ByteBuffer
extends Buffer
implements Comparable<ByteBuffer>

位元組緩衝區。

此類別針對位元組緩衝區定義了以下六類別操作：

• 讀寫單個位元組的絕對和相對 get 和 put 方法；

• 將此緩衝區的連續位元組序列傳輸到陣列中的相對批量 get 方法；

• 將 byte 陣列或其他位元組緩衝區中的連續位元組序列傳輸到此緩衝區的相對批量 put 方法；

• 讀寫其他基本型別值，並按照特定的位元組順序在位元組序列之間轉換這些值的絕對和相對 get 和 put 方法；

• 創建視圖緩衝區 的方法，這些方法允許將位元組緩衝區視為包含其他基本型別值的緩衝區；

• 對位元組緩衝區進行 compacting、duplicating 和 slicing 的方法。

位元組緩衝區可以通過 allocation 方法創建，此方法為該緩衝區的內容分派空間，或通過 wrapping 方法將現有的 byte 陣列包裹到緩衝區中來創建。

直接與 非直接緩衝區

位元組緩衝區要麼是直接的，要麼是非直接的。如果為直接位元組緩衝區，則 Java 虛擬機器會盡最大努力直接在此緩衝區上執行本機 I/O 操作。也就是說，在每次調用基礎作業系統的一個本機 I/O 操作之前（或之後），虛擬機器都會盡量避免將緩衝區的內容複製到中間緩衝區中（或從中間緩衝區中複製內容）。

直接位元組緩衝區可以通過調用此類別的 allocateDirect 處理器方法來創建。此方法返回的緩衝區進行分派和取消分派所需成本通常高於非直接緩衝區。直接緩衝區的內容可以駐留在常規的垃圾回收堆積(heap)空間之外，因此，它們對應用程序的記憶體需求量造成的影響可能並不明顯。所以，建議將直接緩衝區主要分派給那些易受基礎系統的本機 I/O 操作影響的大型、持久的緩衝區。一般情況下，最好僅在直接緩衝區能在程序性能方面帶來明顯好處時分派它們。

直接位元組緩衝區還可以通過 mapping 將檔案區域直接映射到記憶體中來創建。Java 平臺的實作有助於通過 JNI 從本機程式碼創建直接位元組緩衝區。如果以上這些緩衝區中的某個緩衝區實例指的是不可存取的記憶體區域，則試圖存取該區域不會更改該緩衝區的內容，並且將會在存取期間或稍後的某個時間導致拋出不確定的異常。

位元組緩衝區是直接緩衝區還是非直接緩衝區可通過調用其 isDirect 方法來確定。提供此方法是為了能夠在性能關鍵型程式碼中執行顯式緩衝區管理。

存取二進制資料

此類別定義了除 boolean 之外，讀寫所有其他基本型別值的方法。這些基本值可以根據緩衝區的當前位元組順序與位元組序列互相進行轉換，並可以通過 order 方法獲取和修改。特定的位元組順序由 ByteOrder 類別的實例表示。位元組緩衝區的初始順序始終是 BIG_ENDIAN。

為了存取異類別二進制資料（即其他型別的值的序列），此類別還針對每種型別定義了一系列絕對和相對的 get 和 put 方法。例如，對於 32 位浮點值，此類別定義了以下方法：

 float  getFloat()
 float  getFloat(int index)
  void  putFloat(float f)
  void  putFloat(int index, float f)

並針對 char、short、int、long 和 double 等型別定義了相應的方法。絕對 get 和 put 方法的 index 參數是根據位元組定義的，而不是根據所讀寫的型別定義的。

為了存取同類別二進制資料（即相同型別的值的序列），此類別還定義了可以為指定型別的緩衝區創建視圖 的方法。視圖緩衝區 只是其內容受該位元組緩衝區支持的另一種緩衝區。位元組緩衝區內容的更改在視圖緩衝區中是可見的，反之亦然；這兩種緩衝區的位置、限制和標記值都是獨立的。例如，asFloatBuffer 方法將創建 FloatBuffer 類別的一個實例，該類別受在其上調用該方法的位元組緩衝區的支持。該類別將為 char、short、int、long 和 double 等型別定義相應的視圖創建方法。

與上述特定於型別的 get 和 put 方法系列相比，視圖緩衝區有以下三大主要優勢：

• 視圖緩衝區不是根據位元組進行索引，而是根據其特定於型別的值的大小進行索引；

• 視圖緩衝區提供了相對批量 get 和 put 方法，這些方法可在緩衝區和陣列或相同型別的其他緩衝區之間傳輸值的連續序列；

• 視圖緩衝區可能更高效，這是因為，當且僅當其支持的位元組緩衝區為直接緩衝區時它才是直接緩衝區。

視圖緩衝區的位元組順序固定為創建該視圖時其位元組緩衝區的位元組順序。

調用的連接

指定此類別中的方法（它們不返回其他值），以返回這些方法被調用時所在的緩衝區。這允許對方法調用進行連接。 例如，語句序列

 bb.putInt(0xCAFEBABE);
 bb.putShort(3);
 bb.putShort(45);

可以由以下單個語句替換

 bb.putInt(0xCAFEBABE).putShort(3).putShort(45);

從以下版本開始：

1.4

方法摘要

static ByteBuffer	allocate(int capacity) 分派一個新的位元組緩衝區。
static ByteBuffer	allocateDirect(int capacity) 分派新的直接位元組緩衝區。
byte[]	array() 返回實作此緩衝區的 byte 陣列（可選操作）。
int	arrayOffset() 返回此緩衝區中的第一個元素在緩衝區的底層實作陣列中的偏移量（可選操作）。
abstract CharBuffer	asCharBuffer() 創建此位元組緩衝區的視圖，作為 char 緩衝區。
abstract DoubleBuffer	asDoubleBuffer() 創建此位元組緩衝區的視圖，作為 double 緩衝區。
abstract FloatBuffer	asFloatBuffer() 創建此位元組緩衝區的視圖，作為 float 緩衝區。
abstract IntBuffer	asIntBuffer() 創建此位元組緩衝區的視圖，作為 int 緩衝區。
abstract LongBuffer	asLongBuffer() 創建此位元組緩衝區的視圖，作為 long 緩衝區。
abstract ByteBuffer	asReadOnlyBuffer() 創建共享此緩衝區內容的新的只讀位元組緩衝區。
abstract ShortBuffer	asShortBuffer() 創建此位元組緩衝區的視圖，作為 short 緩衝區。
abstract ByteBuffer	compact() 壓縮此緩衝區（可選操作）。
int	compareTo(ByteBuffer that) 將此緩衝區與另一個緩衝區進行比較。
abstract ByteBuffer	duplicate() 創建共享此緩衝區內容的新的位元組緩衝區。
boolean	equals(Object ob) 判斷此緩衝區是否與另一個物件相同。
abstract byte	get() 相對 get 方法。
ByteBuffer	get(byte[] dst) 相對批量 get 方法。
ByteBuffer	get(byte[] dst, int offset, int length) 相對批量 get 方法。
abstract byte	get(int index) 絕對 get 方法。
abstract char	getChar() 用於讀取 char 值的相對 get 方法。
abstract char	getChar(int index) 用於讀取 char 值的絕對 get 方法。
abstract double	getDouble() 用於讀取 double 值的相對 get 方法。
abstract double	getDouble(int index) 用於讀取 double 值的絕對 get 方法。
abstract float	getFloat() 用於讀取 float 值的相對 get 方法。
abstract float	getFloat(int index) 用於讀取 float 值的絕對 get 方法。
abstract int	getInt() 用於讀取 int 值的相對 get 方法。
abstract int	getInt(int index) 用於讀取 int 值的絕對 get 方法。
abstract long	getLong() 用於讀取 long 值的相對 get 方法。
abstract long	getLong(int index) 用於讀取 long 值的絕對 get 方法。
abstract short	getShort() 用於讀取 short 值的相對 get 方法。
abstract short	getShort(int index) 用於讀取 short 值的絕對 get 方法。
boolean	hasArray() 判斷是否可通過一個可存取的 byte 陣列實作此緩衝區。
int	hashCode() 返回此緩衝區的當前雜湊碼。
abstract boolean	isDirect() 判斷此位元組緩衝區是否為直接的。
ByteOrder	order() 獲取此緩衝區的位元組順序。
ByteBuffer	order(ByteOrder bo) 修改此緩衝區的位元組順序。
abstract ByteBuffer	put(byte b) 相對 put 方法（可選操作）。
ByteBuffer	put(byte[] src) 相對批量 put 方法（可選操作）。
ByteBuffer	put(byte[] src, int offset, int length) 相對批量 put 方法（可選操作）。
ByteBuffer	put(ByteBuffer src) 相對批量 put 方法（可選操作）。
abstract ByteBuffer	put(int index, byte b) 絕對 put 方法（可選操作）。
abstract ByteBuffer	putChar(char value) 用來寫入 char 值的相對 put 方法（可選操作）。
abstract ByteBuffer	putChar(int index, char value) 用於寫入 char 值的絕對 put 方法（可選操作）。
abstract ByteBuffer	putDouble(double value) 用於寫入 double 值的相對 put 方法（可選操作）。
abstract ByteBuffer	putDouble(int index, double value) 用於寫入 double 值的絕對 put 方法（可選操作）。
abstract ByteBuffer	putFloat(float value) 用於寫入 float 值的相對 put 方法（可選操作）。
abstract ByteBuffer	putFloat(int index, float value) 用於寫入 float 值的絕對 put 方法（可選操作）。
abstract ByteBuffer	putInt(int value) 用於寫入 int 值的相對 put 方法（可選操作）。
abstract ByteBuffer	putInt(int index, int value) 用於寫入 int 值的絕對 put 方法（可選操作）。
abstract ByteBuffer	putLong(int index, long value) 用於寫入 long 值的絕對 put 方法（可選操作）。
abstract ByteBuffer	putLong(long value) 用於寫入 long 值（可先操作） 的相對 put 方法。
abstract ByteBuffer	putShort(int index, short value) 用於寫入 short 值的絕對 put 方法（可選操作）。
abstract ByteBuffer	putShort(short value) 用於寫入 short 值的相對 put 方法（可選操作）。
abstract ByteBuffer	slice() 創建新的位元組緩衝區，其內容是此緩衝區內容的共享子序列。
String	toString() 返回匯總了此緩衝區狀態的字元串。
static ByteBuffer	wrap(byte[] array) 將 byte 陣列包裹到緩衝區中。
static ByteBuffer	wrap(byte[] array, int offset, int length) 將 byte 陣列包裹到緩衝區中。

從類別 java.nio.Buffer 繼承的方法

capacity, clear, flip, hasRemaining, isReadOnly, limit, limit, mark, position, position, remaining, reset, rewind

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

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

方法詳細資訊

allocateDirect

public static ByteBuffer allocateDirect(int capacity)

分派新的直接位元組緩衝區。

新緩衝區的位置將為零，其界限將為其容量，其標記是不確定的。無論它是否具有底層實作陣列，其標記都是不確定的。

參數：

capacity - 新緩衝區的容量，以位元組為單位

返回：

新的位元組緩衝區

拋出：

IllegalArgumentException - 如果 capacity 為負整數

allocate

public static ByteBuffer allocate(int capacity)

分派一個新的位元組緩衝區。

新緩衝區的位置將為零，其界限將為其容量，其標記是不確定的。它將具有一個底層實作陣列，且其 陣列偏移量將為零。

參數：

capacity - 新緩衝區的容量，以位元組為單位

返回：

新的位元組緩衝區

拋出：

IllegalArgumentException - 如果 capacity 為負整數

wrap

public static ByteBuffer wrap(byte[] array,
                              int offset,
                              int length)

將 byte 陣列包裹到緩衝區中。

新的緩衝區將由給定的 byte 陣列支持；也就是說，緩衝區修改將導致陣列修改，反之亦然。新緩衝區的容量將為 array.length，其位置將為 offset，其界限將為 offset + length，其標記是不確定的。其底層實作陣列將為給定陣列，並且其陣列偏移量將為零。

參數：

array - 支持新緩衝區的陣列

offset - 要使用的子陣列的偏移量；必須為非負且不大於 array.length。將新緩衝區的位置設置為此值。

length - 要使用的子陣列的長度；必須為非負且不大於 array.length - offset。將新緩衝區的界限設置為 offset + length。

返回：

新的位元組緩衝區

拋出：

IndexOutOfBoundsException - 如果關於 offset 和 length 參數的前提不成立

wrap

public static ByteBuffer wrap(byte[] array)

將 byte 陣列包裹到緩衝區中。

新的緩衝區將由給定的 byte 陣列支持；也就是說，緩衝區修改將導致陣列修改，反之亦然。新緩衝區的容量和界限將為 array.length，其位置將為零，其標記是不確定的。其底層實作陣列將為給定陣列，並且其陣列偏移量將為零。

參數：

array - 實作此緩衝區的陣列

返回：

新的位元組緩衝區

slice

public abstract ByteBuffer slice()

創建新的位元組緩衝區，其內容是此緩衝區內容的共享子序列。

新緩衝區的內容將從此緩衝區的當前位置開始。此緩衝區內容的更改在新緩衝區中是可見的，反之亦然；這兩個緩衝區的位置、界限和標記值是相互獨立的。

新緩衝區的位置將為零，其容量和界限將為此緩衝區中所剩餘的位元組數量，其標記是不確定的。當且僅當此緩衝區為直接時，新緩衝區才是直接的，當且僅當此緩衝區為只讀時，新緩衝區才是只讀的。

返回：

新的位元組緩衝區

duplicate

public abstract ByteBuffer duplicate()

創建共享此緩衝區內容的新的位元組緩衝區。

新緩衝區的內容將為此緩衝區的內容。此緩衝區內容的更改在新緩衝區中是可見的，反之亦然；這兩個緩衝區的位置、界限和標記值是相互獨立的。

新緩衝區的容量、界限、位置和標記值將與此緩衝區相同。當且僅當此緩衝區為直接時，新緩衝區才是直接的，當且僅當此緩衝區為只讀時，新緩衝區才是只讀的。

返回：

新的位元組緩衝區

asReadOnlyBuffer

public abstract ByteBuffer asReadOnlyBuffer()

創建共享此緩衝區內容的新的只讀位元組緩衝區。

新緩衝區的內容將為此緩衝區的內容。此緩衝區內容的更改在新緩衝區中是可見的，但新緩衝區將是只讀的並且不允許修改共享內容。兩個緩衝區的位置、界限和標記值是相互獨立的。

新緩衝區的容量、界限、位置和標記值將與此緩衝區相同。

如果此緩衝區本身是只讀的，則此方法與 duplicate 方法完全相同。

返回：

新的只讀位元組緩衝區

get

public abstract byte get()

相對 get 方法。讀取此緩衝區當前位置的位元組，然後該位置遞增。

返回：

緩衝區當前位置的位元組

拋出：

BufferUnderflowException - 如果該緩衝區的當前位置不小於其界限

put

public abstract ByteBuffer put(byte b)

相對 put 方法（可選操作）。

將給定的位元組寫入此緩衝區的當前位置，然後該位置遞增。

參數：

b - 要寫入的位元組

返回：

此緩衝區

拋出：

BufferOverflowException - 如果此緩衝區的當前位置不小於其界限

ReadOnlyBufferException - 如果此緩衝區是只讀緩衝區

get

public abstract byte get(int index)

絕對 get 方法。讀取指定索引處的位元組。

參數：

index - 將從中讀取該位元組的索引

返回：

給定索引處的位元組

拋出：

IndexOutOfBoundsException - 如果 index 為負或不小於緩衝區界限

put

public abstract ByteBuffer put(int index,
                               byte b)

絕對 put 方法（可選操作）。

將給定位元組寫入此緩衝區的給定索引處。

參數：

index - 將在該位置寫入位元組的索引

b - 要寫入的位元組值

返回：

此緩衝區

拋出：

IndexOutOfBoundsException - 如果 index 為負或不小於緩衝區界限

ReadOnlyBufferException - 如果此緩衝區是只讀緩衝區

get

public ByteBuffer get(byte[] dst,
                      int offset,
                      int length)

相對批量 get 方法。

此方法將此緩衝區的位元組傳輸到給定的目標陣列中。如果此緩衝中剩餘的位元組少於滿足請求所需的位元組（即如果 length > remaining()），則不傳輸位元組且拋出 BufferUnderflowException。

否則，此方法將此緩衝區中的 length 個位元組複製到給定陣列中，從此緩衝區的當前位置和陣列中的給定偏移量位置開始複製。然後此緩衝區的位置將增加 length。

換句話說，調用此方法的形式為 src.get(dst, off, len)，效果與以下循環語句完全相同：

     for (int i = off; i < off + len; i++)
         dst[i] = src.get(); 

區別在於它首先檢查此緩衝區中是否具有足夠的位元組，這樣可能效率更高。

參數：

dst - 向其中寫入位元組的陣列

offset - 要寫入的第一個位元組在陣列中的偏移量；必須為非負且不大於 dst.length

length - 要寫入到給定陣列中的位元組的最大數量；必須為非負且不大於 dst.length - offset

返回：

此緩衝區

拋出：

BufferUnderflowException - 如果此緩衝區中的剩餘位元組少於 length

IndexOutOfBoundsException - 如果關於 offset 和 length 參數的前提不成立

get

public ByteBuffer get(byte[] dst)

相對批量 get 方法。

此方法將此緩衝區的位元組傳輸到給定的目標陣列中。調用此方法的形式為 src.get(a)，該調用與以下調用完全相同：

     src.get(a, 0, a.length) 

返回：

此緩衝區

拋出：

BufferUnderflowException - 如果此緩衝區中的剩餘位元組少於 length

put

public ByteBuffer put(ByteBuffer src)

相對批量 put 方法（可選操作）。

此方法將給定源緩衝區中的剩餘位元組傳輸到此緩衝區中。如果源緩衝區中的剩餘位元組多於此緩衝區中的剩餘位元組，即如果 src.remaining() > remaining()，則不傳輸位元組且拋出 BufferOverflowException。

否則，此方法將給定緩衝區中的 n = src.remaining() 個位元組複製到此緩衝區中，從每個緩衝區的當前位置開始複製。然後這兩個緩衝區的位置都增加 n。

換句話說，調用此方法的形式為 dst.put(src)，效果與以下循環語句完全相同：

     while (src.hasRemaining())
         dst.put(src.get()); 

區別在於它首先檢查此緩衝區中是否有足夠空間，這樣可能效率更高。

參數：

src - 要從中讀取位元組的源緩衝區；不能為此緩衝區

返回：

此緩衝區

拋出：

BufferOverflowException - 如果此緩衝區沒有足夠的空間來容納源緩衝區中剩餘的位元組

IllegalArgumentException - 如果源緩衝區是此緩衝區

ReadOnlyBufferException - 如果此緩衝區是只讀緩衝區

put

public ByteBuffer put(byte[] src,
                      int offset,
                      int length)

相對批量 put 方法（可選操作）。

此方法將把給定源陣列中的位元組字傳輸到此緩衝區中。如果要從該陣列中複製的位元組多於此緩衝區中的剩餘位元組，即如果 length > remaining()），則不傳輸位元組且將拋出 BufferOverflowException。

否則，此方法將給定陣列中的 length 個位元組複製到此緩衝區中，從陣列中給定偏移量位置和此緩衝區的當前位置開始複製。然後此緩衝區的位置將增加 length。

換句話說，調用此方法的形式為 dst.put(src, off, len)，效果與以下循環語句完全相同：

     for (int i = off; i < off + len; i++)
         dst.put(a[i]); 

區別在於它首先檢查此緩衝區中是否有足夠空間，這樣可能效率更高。

參數：

src - 要從中讀取位元組的陣列

offset - 要讀取的第一個位元組在陣列中的偏移量；必須為非負且不大於 array.length

length - 要從給定陣列讀取的位元組的數量；必須為非負且不大於 array.length - offset

返回：

此緩衝區

拋出：

BufferOverflowException - 如果此緩衝區沒有足夠空間

IndexOutOfBoundsException - 如果關於 offset 和 length 參數的前提不成立

ReadOnlyBufferException - 如果此緩衝區是只讀緩衝區

put

public final ByteBuffer put(byte[] src)

相對批量 put 方法（可選操作）。

此方法將給定的源 byte 陣列的所有內容傳輸到此緩衝區中。調用此方法的形式為 dst.put(a)，該調用與以下調用完全相同：

     dst.put(a, 0, a.length) 

返回：

此緩衝區

拋出：

BufferOverflowException - 如果此緩衝區沒有足夠空間

ReadOnlyBufferException - 如果此緩衝區是只讀緩衝區

hasArray

public final boolean hasArray()

判斷是否可通過一個可存取的 byte 陣列實作此緩衝區。

如果此方法返回 true，則可以安全地調用 array 和 arrayOffset 方法。

指定者：

類別 Buffer 中的 hasArray

返回：

當且僅當存在實作此緩衝區的陣列，並且此緩衝區不是只讀緩衝區時，返回 true

array

public final byte[] array()

返回實作此緩衝區的 byte 陣列（可選操作）。

此緩衝區的內容修改將導致返回的陣列內容修改，反之亦然。

調用此方法之前要調用 hasArray 方法，以確保此緩衝區具有可存取的底層實作陣列。

指定者：

類別 Buffer 中的 array

返回：

實作此緩衝區的陣列

拋出：

ReadOnlyBufferException - 如果存在實作此緩衝區的陣列，但緩衝區是只讀的

UnsupportedOperationException - 如果不存在某個可存取的陣列實作此緩衝區

arrayOffset

public final int arrayOffset()

返回此緩衝區中的第一個元素在緩衝區的底層實作陣列中的偏移量（可選操作）。

如果存在實作此緩衝區的陣列，則緩衝區位置 p 對應於陣列索引 p + arrayOffset()。

調用此方法之前要調用 hasArray 方法，以確保此緩衝區具有可存取的底層實作陣列。

指定者：

類別 Buffer 中的 arrayOffset

返回：

此緩衝區的第一個元素在緩衝區陣列中的偏移量

拋出：

ReadOnlyBufferException - 如果存在實作此緩衝區的陣列，但緩衝區是只讀的

UnsupportedOperationException - 如果不存在某個可存取的陣列實作此緩衝區

compact

public abstract ByteBuffer compact()

壓縮此緩衝區（可選操作）。

將緩衝區的當前位置和界限之間的位元組（如果有）複製到緩衝區的開始處。即將索引 p = position() 處的位元組複製到索引 0 處，將索引 p + 1 處的位元組複製到索引 1 處，依此類別推，直到將索引 limit() - 1 處的位元組複製到索引 n = limit() - 1 - p 處。然後將緩衝區的位置設置為 n+1，並將其界限設置為其容量。如果已定義了標記，則丟棄它。

將緩衝區的位置設置為複製的位元組數，而不是零，以便調用此方法後可以緊接著調用另一個相對 put 方法。

從緩衝區寫入資料之後調用此方法，以防寫入不完整。例如，以下循環語句通過 buf 緩衝區將位元組從一個通道複製到另一個通道：

 buf.clear();          // Prepare buffer for use
  while (in.read(buf) >= 0 || buf.position != 0) {
     buf.flip();
     out.write(buf);
     buf.compact();    // In case of partial write
 }

返回：

此緩衝區

拋出：

ReadOnlyBufferException - 如果此緩衝區是只讀緩衝區

isDirect

public abstract boolean isDirect()

判斷此位元組緩衝區是否為直接的。

指定者：

類別 Buffer 中的 isDirect

返回：

當且僅當此緩衝區為直接時，返回 true

toString

public String toString()

返回匯總了此緩衝區狀態的字元串。

覆寫：

類別 Object 中的 toString

返回：

一個匯總字元串

hashCode

public int hashCode()

返回此緩衝區的當前雜湊碼。

位元組緩衝區的雜湊碼僅取決於其中剩餘的元素；也就是說，取決於從 position() 開始一直到（包括）limit() - 1 處的元素。

因為緩衝區雜湊碼與內容有關，因此建議不要在雜湊映射或其他類似資料結構中將緩衝區用作鍵，除非知道其內容不會發生更改。

覆寫：

類別 Object 中的 hashCode

返回：

此緩衝區的當前雜湊碼。

另請參見：

Object.equals(java.lang.Object), Hashtable

equals

public boolean equals(Object ob)

判斷此緩衝區是否與另一個物件相同。

當且僅當滿足以下條件時兩個位元組緩衝區相同：

1. 它們具有相同的元素型別，

2. 它們具有相同數量的剩餘元素，並且

3. 兩個剩餘元素序列（與它們的起始位置無關）逐點相同。

位元組緩衝區與任何其他型別的物件都不同。

覆寫：

類別 Object 中的 equals

參數：

ob - 此緩衝區要比較的物件

返回：

當且僅當此緩衝區與給定物件相同時，返回 true

另請參見：

Object.hashCode(), Hashtable

compareTo

public int compareTo(ByteBuffer that)

將此緩衝區與另一個緩衝區進行比較。

比較兩個位元組緩衝區的方法是按字典順序比較它們的剩餘元素序列，而不考慮每個序列在其對應緩衝區中的起始位置。

位元組緩衝區不能與任何其他型別的物件進行比較。

指定者：

介面 Comparable<ByteBuffer> 中的 compareTo

參數：

that - 要比較的物件。

返回：

當此緩衝區小於、等於或大於給定緩衝區時，返回負整數、零或正整數

order

public final ByteOrder order()

獲取此緩衝區的位元組順序。

在讀寫多位元組值以及為此位元組緩衝區創建視圖時使用該位元組順序。新創建的位元組緩衝區的順序始終為 BIG_ENDIAN。

返回：

此緩衝區的位元組順序

order

public final ByteBuffer order(ByteOrder bo)

修改此緩衝區的位元組順序。

參數：

bo - 新的位元組順序，要麼是 BIG_ENDIAN，要麼是 LITTLE_ENDIAN

返回：

此緩衝區

getChar

public abstract char getChar()

用於讀取 char 值的相對 get 方法。

讀取此緩衝區的當前位置之後的兩個位元組，根據當前的位元組順序將它們組成 char 值，然後將該位置增加 2。

返回：

緩衝區當前位置的 char 值

拋出：

BufferUnderflowException - 如果此緩衝區中的剩餘位元組數少於 2

putChar

public abstract ByteBuffer putChar(char value)

用來寫入 char 值的相對 put 方法（可選操作）。

將兩個包含指定 char 值的位元組按照當前的位元組順序寫入到此緩衝區的當前位置，然後將該位置增加 2。

參數：

value - 要寫入的 char 值

返回：

此緩衝區

拋出：

BufferOverflowException - 如果此緩衝區中的剩餘位元組數少於 2

ReadOnlyBufferException - 如果此緩衝區是只讀緩衝區

getChar

public abstract char getChar(int index)

用於讀取 char 值的絕對 get 方法。

讀取給定索引處的兩個位元組，並根據當前的位元組順序將它們組成 char 值。

參數：

index - 將從該位置讀取位元組的索引

返回：

給定索引處的 char 值

拋出：

IndexOutOfBoundsException - 如果 index 為負數，或者不小於該緩衝區的界限 - 1 所得的值

putChar

public abstract ByteBuffer putChar(int index,
                                   char value)

用於寫入 char 值的絕對 put 方法（可選操作）。

將兩個包含給定 char 值的位元組按照當前的位元組順序寫入到此緩衝區的給定索引處。

參數：

index - 將在該位置寫入位元組的索引

value - 要寫入的 char 值

返回：

此緩衝區

拋出：

IndexOutOfBoundsException - 如果 index 為負數，或者不小於該緩衝區的界限 - 1 所得的值

ReadOnlyBufferException - 如果此緩衝區是只讀緩衝區

asCharBuffer

public abstract CharBuffer asCharBuffer()

創建此位元組緩衝區的視圖，作為 char 緩衝區。

新緩衝區的內容將從此緩衝區的當前位置開始。此緩衝區內容的更改在新緩衝區中是可見的，反之亦然；這兩個緩衝區的位置、界限和標記值是相互獨立的。

新緩衝區的位置將為零，其容量和界限將為此緩衝區中所剩餘的位元組數的二分之一，其標記是不確定的。當且僅當此緩衝區為直接時，新緩衝區才是直接的，當且僅當此緩衝區為只讀時，新緩衝區才是只讀的。

返回：

新的 char 緩衝區

getShort

public abstract short getShort()

用於讀取 short 值的相對 get 方法。

讀取此緩衝區的當前位置之後的兩個位元組，根據當前的位元組順序將它們組成 short 值，然後將該位置增加 2。

返回：

緩衝區當前位置的 short 值

拋出：

BufferUnderflowException - 如果此緩衝區中的剩餘位元組數少於 2

putShort

public abstract ByteBuffer putShort(short value)

用於寫入 short 值的相對 put 方法（可選操作）。

將兩個包含指定 short 值的位元組按照當前的位元組順序寫入到此緩衝區的當前位置，然後將該位置增加 2。

參數：

value - 要寫入的 short 值

返回：

此緩衝區

拋出：

BufferOverflowException - 如果此緩衝區中的剩餘位元組數少於 2

ReadOnlyBufferException - 如果此緩衝區是只讀緩衝區

getShort

public abstract short getShort(int index)

用於讀取 short 值的絕對 get 方法。

讀取給定索引處的兩個位元組，根據當前的位元組順序將它們組成 short 值。

參數：

index - 將從該位置讀取位元組的索引

返回：

給定索引處的 short 值

拋出：

IndexOutOfBoundsException - 如果 index 為負數，或者不小於該緩衝區的界限 - 1 所得的值

putShort

public abstract ByteBuffer putShort(int index,
                                    short value)

用於寫入 short 值的絕對 put 方法（可選操作）。

將兩個包含給定 short 值的位元組按照當前的位元組順序寫入到此緩衝區的給定索引處。

參數：

index - 將在該位置寫入位元組的索引

value - 要寫入的 short 值

返回：

此緩衝區

拋出：

IndexOutOfBoundsException - 如果 index 為負數，或者不小於該緩衝區的界限 - 1 所得的值

ReadOnlyBufferException - 如果此緩衝區是只讀緩衝區

asShortBuffer

public abstract ShortBuffer asShortBuffer()

創建此位元組緩衝區的視圖，作為 short 緩衝區。

新緩衝區的內容將從此緩衝區的當前位置開始。此緩衝區內容的更改在新緩衝區中是可見的，反之亦然；這兩個緩衝區的位置、界限和標記值是相互獨立的。

新緩衝區的位置將為零，其容量和界限將為此緩衝區中所剩餘的位元組數的二分之一，其標記是不確定的。當且僅當此緩衝區為直接時，新緩衝區才是直接的，當且僅當此緩衝區為只讀時，新緩衝區才是只讀的。

返回：

新的 short 緩衝區

getInt

public abstract int getInt()

用於讀取 int 值的相對 get 方法。

讀取此緩衝區的當前位置之後的 4 個位元組，根據當前的位元組順序將它們組成 int 值，然後將該位置增加 4。

返回：

緩衝區當前位置的 int 值

拋出：

BufferUnderflowException - 如果此緩衝區中的剩餘位元組數少於 4

putInt

public abstract ByteBuffer putInt(int value)

用於寫入 int 值的相對 put 方法（可選操作）。

將 4 個包含給定 int 值的位元組按照當前的位元組順序寫入到此緩衝區的當前位置，然後將該位置增加 4。

參數：

value - 要寫入的 int 值

返回：

此緩衝區

拋出：

BufferOverflowException - 如果此緩衝區中的剩餘位元組數少於 4

ReadOnlyBufferException - 如果此緩衝區是只讀緩衝區

getInt

public abstract int getInt(int index)

用於讀取 int 值的絕對 get 方法。

讀取給定索引處的 4 個位元組，根據當前的位元組順序將它們組成 int 值。

參數：

index - 將從該位置讀取位元組的索引

返回：

給定索引處的 int 值

拋出：

IndexOutOfBoundsException - 如果 index 為負數，或者不小於該緩衝區的界限 - 3 所得的值

putInt

public abstract ByteBuffer putInt(int index,
                                  int value)

用於寫入 int 值的絕對 put 方法（可選操作）。

將 4 個包含給定 int 值的位元組按照當前的位元組順序寫入到此緩衝區的給定索引處。

參數：

index - 將在該位置寫入位元組的索引

value - 要寫入的 int 值

返回：

此緩衝區

拋出：

IndexOutOfBoundsException - 如果 index 為負數，或者不小於該緩衝區的界限 - 3 所得的值

ReadOnlyBufferException - 如果此緩衝區是只讀緩衝區

asIntBuffer

public abstract IntBuffer asIntBuffer()

創建此位元組緩衝區的視圖，作為 int 緩衝區。

新緩衝區的內容將從此緩衝區的當前位置開始。此緩衝區內容的更改在新緩衝區中是可見的，反之亦然；這兩個緩衝區的位置、界限和標記值是相互獨立的。

新緩衝區的位置將為零，其容量和界限將為此緩衝區中所剩餘的位元組數的四分之一，其標記是不確定的。當且僅當此緩衝區為直接時，新緩衝區才是直接的，當且僅當此緩衝區為只讀時，新緩衝區才是只讀的。

返回：

新的 int 緩衝區

getLong

public abstract long getLong()

用於讀取 long 值的相對 get 方法。

讀取此緩衝區的當前位置之後的 8 個位元組，根據當前的位元組順序將它們組成 long 值，然後將該位置增加 8。

返回：

緩衝區當前位置的 long 值

拋出：

BufferUnderflowException - 如果此緩衝區中的剩餘位元組數少於 8

putLong

public abstract ByteBuffer putLong(long value)

用於寫入 long 值（可先操作） 的相對 put 方法。

將 8 個包含給定 long 值的位元組按照當前的位元組順序寫入到此緩衝區的當前位置，然後將該位置增加 8。

參數：

value - 要寫入的 long 值

返回：

此緩衝區

拋出：

BufferOverflowException - 如果此緩衝區中的剩餘位元組數少於 8

ReadOnlyBufferException - 如果此緩衝區是只讀緩衝區

getLong

public abstract long getLong(int index)

用於讀取 long 值的絕對 get 方法。

讀取給定索引處的 8 個位元組，根據當前的位元組順序將它們組成 long 值。

參數：

index - 將從該位置讀取位元組的索引

返回：

給定索引處的 long 值

拋出：

IndexOutOfBoundsException - 如果 index 為負數，或者不小於該緩衝區的界限 - 7 所得的值

putLong

public abstract ByteBuffer putLong(int index,
                                   long value)

用於寫入 long 值的絕對 put 方法（可選操作）。

將 8 個包含給定 long 值的位元組按照當前的位元組順序寫入到此緩衝區的給定索引處。

參數：

index - 將在該位置寫入位元組的索引

value - 要寫入的 long 值

返回：

此緩衝區

拋出：

IndexOutOfBoundsException - 如果 index 為負數，或者不小於該緩衝區的界限 - 7 所得的值

ReadOnlyBufferException - 如果此緩衝區是只讀緩衝區

asLongBuffer

public abstract LongBuffer asLongBuffer()

創建此位元組緩衝區的視圖，作為 long 緩衝區。

新緩衝區的內容將從此緩衝區的當前位置開始。此緩衝區內容的更改在新緩衝區中是可見的，反之亦然；這兩個緩衝區的位置、界限和標記值是相互獨立的。

新緩衝區的位置將為零，其容量和界限將為此緩衝區中所剩餘的位元組數的八分之一，其標記是不確定的。當且僅當此緩衝區為直接時，新緩衝區才是直接的，當且僅當此緩衝區為只讀時，新緩衝區才是只讀的。

返回：

新的 long 緩衝區

getFloat

public abstract float getFloat()

用於讀取 float 值的相對 get 方法。

讀取此緩衝區的當前位置之後的 4 個位元組，根據當前的位元組順序將它們組成 float 值，然後將該位置增加 4。

返回：

緩衝區當前位置的 float 值

拋出：

BufferUnderflowException - 如果此緩衝區中的剩餘位元組數少於 4

putFloat

public abstract ByteBuffer putFloat(float value)

用於寫入 float 值的相對 put 方法（可選操作）。

將 4 個包含給定 float 值的位元組按照當前的位元組順序寫入到此緩衝區的當前位置，然後然後將該位置增加 4。

參數：

value - 要寫入的 float 值

返回：

此緩衝區

拋出：

BufferOverflowException - 如果此緩衝區中的剩餘位元組數少於 4

ReadOnlyBufferException - 如果此緩衝區是只讀緩衝區

getFloat

public abstract float getFloat(int index)

用於讀取 float 值的絕對 get 方法。

讀取給定索引處的 4 個位元組，根據當前的位元組順序將它們組成 float 值。

參數：

index - 將從該位置讀取位元組的索引

返回：

給定索引處的 float 值

拋出：

IndexOutOfBoundsException - 如果 index 為負數，或者不小於該緩衝區的界限 - 3 所得的值

putFloat

public abstract ByteBuffer putFloat(int index,
                                    float value)

用於寫入 float 值的絕對 put 方法（可選操作）。

將 4 個包含給定 float 值的位元組按照當前的位元組順序寫入到此緩衝區的給定索引處。

參數：

index - 將在該位置寫入位元組的索引

value - 要寫入的 float 值

返回：

此緩衝區

拋出：

IndexOutOfBoundsException - 如果 index 為負數，或者不小於該緩衝區的界限 - 3 所得的值

ReadOnlyBufferException - 如果此緩衝區是只讀緩衝區

asFloatBuffer

public abstract FloatBuffer asFloatBuffer()

創建此位元組緩衝區的視圖，作為 float 緩衝區。

新緩衝區的內容將從此緩衝區的當前位置開始。此緩衝區內容的更改在新緩衝區中是可見的，反之亦然；這兩個緩衝區的位置、界限和標記值是相互獨立的。

新緩衝區的位置將為零，其容量和其界限將為此緩衝區中剩餘位元組數的四分之一，其標記是不確定的。當且僅當此緩衝區為直接時，新緩衝區才是直接的，當且僅當此緩衝區為只讀時，新緩衝區才是只讀的。

返回：

新的 float 緩衝區

getDouble

public abstract double getDouble()

用於讀取 double 值的相對 get 方法。

讀取此緩衝區的當前位置之後的 8 個位元組，根據當前的位元組順序將它們組成 double 值，然後將該位置增加 8。

返回：

緩衝區當前位置的 double 值

拋出：

BufferUnderflowException - 如果此緩衝區中的剩餘位元組數少於 8

putDouble

public abstract ByteBuffer putDouble(double value)

用於寫入 double 值的相對 put 方法（可選操作）。

將 8 個包含給定 double 值的位元組按照當前的位元組順序寫入到此緩衝區的當前位置，然後將該位置增加 8。

參數：

value - 要寫入的 double 值

返回：

此緩衝區

拋出：

BufferOverflowException - 如果此緩衝區中的剩餘位元組數少於 8

ReadOnlyBufferException - 如果此緩衝區是只讀緩衝區

getDouble

public abstract double getDouble(int index)

用於讀取 double 值的絕對 get 方法。

讀取給定索引處的 8 個位元組，根據當前的位元組順序將它們組成 double 值。

參數：

index - 將從該位置讀取位元組的索引

返回：

給定索引處的 double 值

拋出：

IndexOutOfBoundsException - 如果 index 為負數，或者不小於該緩衝區的界限 - 7 所得的值

putDouble

public abstract ByteBuffer putDouble(int index,
                                     double value)

用於寫入 double 值的絕對 put 方法（可選操作）。

將 8 個包含給定 double 值的位元組按照當前的位元組順序寫入到此緩衝區的給定索引處。

參數：

index - 將在該位置寫入位元組的索引

value - 要寫入的 double 值

返回：

此緩衝區

拋出：

IndexOutOfBoundsException - 如果 index 為負數，或者不小於該緩衝區的界限 - 7 所得的值

ReadOnlyBufferException - 如果此緩衝區是只讀緩衝區

asDoubleBuffer

public abstract DoubleBuffer asDoubleBuffer()

創建此位元組緩衝區的視圖，作為 double 緩衝區。

新緩衝區的內容將從此緩衝區的當前位置開始。此緩衝區內容的更改在新緩衝區中是可見的，反之亦然；這兩個緩衝區的位置、界限和標記值是相互獨立的。

新緩衝區的位置將為零，其容量和界限將為此緩衝區中所剩餘的位元組數的八分之一，其標記是不確定的。當且僅當此緩衝區為直接時，新緩衝區才是直接的，當且僅當此緩衝區為只讀時，新緩衝區才是只讀的。

返回：

新的 double 緩衝區