java.nio
類別 LongBuffer

java.lang.Object
  java.nio.Buffer
      java.nio.LongBuffer

所有已實作的介面：

Comparable<LongBuffer>

public abstract class LongBuffer
extends Buffer
implements Comparable<LongBuffer>

long 緩衝區。

此類別定義了 long 緩衝區上的四類別操作：

讀寫單個 long 的絕對和相對 get 和 put 方法；

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

將 long 陣列或其他 long 緩衝區中的連續 long 序列傳輸到此緩衝區的相對批量 put 方法；以及

long 緩衝區的 compacting、duplicating 和 slicing 方法。

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

像位元組緩衝區一樣，long 緩衝區要麼是直接的，要麼是非直接的。通過此類別的 wrap 方法創建的 long 緩衝區將是非直接的。當且僅當位元組緩衝區本身為直接時，作為位元組緩衝區的視圖創建的 long 緩衝區才是直接的。通過調用 isDirect 方法可以確定 long 緩衝區是否為直接的。

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

從以下版本開始：

1.4

方法摘要

static LongBuffer	allocate(int capacity) 分派新的 long 緩衝區。
long[]	array() 返回實作此緩衝區的 long 陣列（可選操作）。
int	arrayOffset() 返回此緩衝區中第一個元素在緩衝區的支持陣列中的偏移量（可選操作）。
abstract LongBuffer	asReadOnlyBuffer() 創建共享此緩衝區內容的新的只讀 long 緩衝區。
abstract LongBuffer	compact() 壓縮此緩衝區（可選操作）。
int	compareTo(LongBuffer that) 將此緩衝區與另一個緩衝區進行比較。
abstract LongBuffer	duplicate() 創建共享此緩衝區內容的新的 long 緩衝區。
boolean	equals(Object ob) 判斷此緩衝區是否與另一個物件相同。
abstract long	get() 相對 get 方法。
abstract long	get(int index) 絕對 get 方法。
LongBuffer	get(long[] dst) 相對批量 get 方法。
LongBuffer	get(long[] dst, int offset, int length) 相對批量 get 方法。
boolean	hasArray() 判斷是否可通過一個可存取的 long 陣列實作此緩衝區。
int	hashCode() 返回此緩衝區的當前雜湊碼。
abstract boolean	isDirect() 判斷此 long 緩衝區是否為直接的。
abstract ByteOrder	order() 獲取此緩衝區的位元組順序。
abstract LongBuffer	put(int index, long l) 絕對 put 方法（可選操作）。
abstract LongBuffer	put(long l) 相對 put 方法（可選操作）。
LongBuffer	put(long[] src) 相對批量 put 方法（可選操作）。
LongBuffer	put(long[] src, int offset, int length) 相對批量 put 方法（可選操作）。
LongBuffer	put(LongBuffer src) 相對批量 put 方法（可選操作）。
abstract LongBuffer	slice() 創建新的 long 緩衝區，其內容是此緩衝區內容的共享子序列。
String	toString() 返回總結了此緩衝區狀態的字元串。
static LongBuffer	wrap(long[] array) 將 long 陣列包裹到緩衝區中。
static LongBuffer	wrap(long[] array, int offset, int length) 將 long 陣列包裹到緩衝區中。

從類別 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

方法詳細資訊

allocate

public static LongBuffer allocate(int capacity)

分派新的 long 緩衝區。

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

參數：

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

返回：

新的 long 緩衝區

拋出：

IllegalArgumentException - 如果 capacity 為負整數

wrap

public static LongBuffer wrap(long[] array,
                              int offset,
                              int length)

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

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

參數：

array - 支持新緩衝區的陣列

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

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

返回：

新的 long 緩衝區

拋出：

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

wrap

public static LongBuffer wrap(long[] array)

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

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

參數：

array - 實作此緩衝區的陣列

返回：

新的 long 緩衝區

slice

public abstract LongBuffer slice()

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

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

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

返回：

新的 long 緩衝區

duplicate

public abstract LongBuffer duplicate()

創建共享此緩衝區內容的新的 long 緩衝區。

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

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

返回：

新的 long 緩衝區

asReadOnlyBuffer

public abstract LongBuffer asReadOnlyBuffer()

創建共享此緩衝區內容的新的只讀 long 緩衝區。

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

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

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

返回：

新的只讀 long 緩衝區

get

public abstract long get()

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

返回：

緩衝區當前位置的 long

拋出：

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

put

public abstract LongBuffer put(long l)

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

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

參數：

l - 要寫入的 long

返回：

此緩衝區

拋出：

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

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

get

public abstract long get(int index)

絕對 get 方法。讀取給定索引處的 long。

參數：

index - 將讀取 long 的位置的索引

返回：

給定索引處的 long

拋出：

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

put

public abstract LongBuffer put(int index,
                               long l)

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

將給定 long 寫入此緩衝區的給定索引處。

參數：

index - 將在該位置寫入 long

l - 要寫入的 long 值

返回：

此緩衝區

拋出：

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

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

get

public LongBuffer get(long[] dst,
                      int offset,
                      int length)

相對批量 get 方法。

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

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

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

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

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

參數：

dst - 將寫入 long 的陣列

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

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

返回：

此緩衝區

拋出：

BufferUnderflowException - 如果此緩衝區中的剩餘 long 少於 length

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

get

public LongBuffer get(long[] dst)

相對批量 get 方法。

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

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

返回：

此緩衝區

拋出：

BufferUnderflowException - 如果此緩衝區中的剩餘 long 少於 length

put

public LongBuffer put(LongBuffer src)

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

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

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

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

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

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

參數：

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

返回：

此緩衝區

拋出：

BufferOverflowException - 如果對於源緩衝區中剩餘的 long，此緩衝區沒有足夠空間

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

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

put

public LongBuffer put(long[] src,
                      int offset,
                      int length)

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

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

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

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

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

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

參數：

src - 要從中讀取 long 的陣列

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

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

返回：

此緩衝區

拋出：

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

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

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

put

public final LongBuffer put(long[] src)

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

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

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

返回：

此緩衝區

拋出：

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

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

hasArray

public final boolean hasArray()

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

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

指定者：

類別 Buffer 中的 hasArray

返回：

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

array

public final long[] array()

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

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

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

指定者：

類別 Buffer 中的 array

返回：

實作此緩衝區的陣列

拋出：

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

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

arrayOffset

public final int arrayOffset()

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

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

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

指定者：

類別 Buffer 中的 arrayOffset

返回：

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

拋出：

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

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

compact

public abstract LongBuffer compact()

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

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

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

返回：

此緩衝區

拋出：

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

isDirect

public abstract boolean isDirect()

判斷此 long 緩衝區是否為直接的。

指定者：

類別 Buffer 中的 isDirect

返回：

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

toString

public String toString()

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

覆寫：

類別 Object 中的 toString

返回：

一個總結字元串

hashCode

public int hashCode()

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

long 緩衝區的雜湊碼只取決於其剩餘元素；即取決於從 position() 開始一直到（包括）limit() - 1 處的元素。

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

覆寫：

類別 Object 中的 hashCode

返回：

此緩衝區的當前雜湊碼

另請參見：

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

equals

public boolean equals(Object ob)

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

兩個 long 緩衝區是相同的，當且僅當：

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

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

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

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

覆寫：

類別 Object 中的 equals

參數：

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

返回：

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

另請參見：

Object.hashCode(), Hashtable

compareTo

public int compareTo(LongBuffer that)

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

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

long 緩衝區不能與其他型別的物件進行比較。

指定者：

介面 Comparable<LongBuffer> 中的 compareTo

參數：

that - 要比較的物件。

返回：

如果此緩衝區小於、等於或大於給定緩衝區，則相應返回負整數、零或正整數

order

public abstract ByteOrder order()

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

通過分派或通過包裹現有 long 陣列而創建的 long 緩衝區的位元組順序是底層硬體的本機順序。作為位元組緩衝區的視圖而創建的 long 緩衝區的位元組順序是創建視圖時位元組緩衝區的位元組順序。

返回：

此緩衝區的位元組順序