一、概述

java.lang.Object
  java.nio.Buffer
      java.nio.ShortBuffer

public abstract class ShortBuffer extends Buffer implements Comparable<ShortBuffer>

short 緩沖區。

此類定義了 short 緩沖區上的四類操作：

讀寫單個 short 的絕對和相對 get 和
put 方法。

將此緩沖區的連續 short 序列傳輸到數組中的相對批量 get 方法。

將 short 數組或其它 short 緩沖區中的連續 short 序列傳輸到此緩沖區的相對批量 put 方法；以及

short 緩沖區的 compacting、duplicating 和
slicing 方法。

short 緩沖區能夠通過 allocation 創建。此方法通過
wrapping 將一個現有 short 數組包裝到緩沖區中來為緩沖區內容分配空間，或者通過創建現有字節緩沖區的視圖來創建。

像字節緩沖區一樣，short 緩沖區要么是直接的，要么是非直接的。通過此類的
wrap 方法創建的 short 緩沖區將是非直接的。

當且僅當字節緩沖區本身為直接時，作為字節緩沖區的視圖創建的 short 緩沖區才是直接的。通過調用
isDirect 方法能夠確定 short 緩沖區是否為直接的。

指定此類中的方法（它們不返回其它值）。以返回這些方法被調用時所在的緩沖區。這同意對方法調用進行鏈接。

二、概述

1、public static ShortBuffer
allocate(int?capacity)

分配新的 short 緩沖區。

新緩沖區的位置將為零，其界限將為其容量。其標記是沒有定義的。它將具有一個底層實現數組。且其數組偏移量將為零。

參數：capacity - 新緩沖區的容量。以 short 為單位 返回：新的 short 緩沖區 拋出： IllegalArgumentException - 假設
capacity 為負整數

2、public static ShortBuffer
wrap(short[]?array,? int?offset,int?length)

將 short 數組包裝到緩沖區中。

給定的 short 數組將支持新緩沖區。即緩沖區改動將導致數組改動，反之亦然。新緩沖區的容量將為 array.length，其位置將為
offset。其界限將為 offset + length，其標記是沒有定義的。其底層實現數組將為給定數組，而且其數組偏移量將為零。

參數：array - 支持新緩沖區的數組offset - 要使用的子數組的偏移量；必須為非負且不大于 array.length。

將新緩沖區的位置設置為此值。

length - 要使用的子數組的長度。必須為非負且不大于 array.length - offset。將新緩沖區的界限設置為
offset + length。 返回：新的 short 緩沖區 拋出： IndexOutOfBoundsException - 假設關于
offset 和 length 參數的前提不成立
3、public static ShortBuffer
wrap(short[]?array)

將 short 數組包裝到緩沖區中。

給定的 short 數組將支持新緩沖區；即緩沖區改動將導致數組改動，反之亦然。新緩沖區的容量和界限將為 array.length。其位置將為零。其標記是沒有定義的。其底層實現數組將為給定數組，而且其數組偏移量將為零。

參數：array - 實現此緩沖區的數組 返回：新的 short 緩沖區
4、public abstract ShortBuffer
slice()

創建新的 short 緩沖區。其內容是此緩沖區內容的共享子序列。

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

新緩沖區的位置將為零。其容量和界限將為此緩沖區中所剩余的 short 數量，其標記是沒有定義的。

當且僅當此緩沖區為直接時，新緩沖區才是直接的，當且僅當此緩沖區為僅僅讀時，新緩沖區才是僅僅讀的。

返回：新的 short 緩沖區
5、public abstract ShortBuffer
duplicate()

創建共享此緩沖區內容的新的 short 緩沖區。

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

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

當且僅當此緩沖區為直接時。新緩沖區才是直接的，當且僅當此緩沖區為僅僅讀時。新緩沖區才是僅僅讀的。

返回：新的 short 緩沖區

6、public abstract ShortBuffer
asReadOnlyBuffer()

創建共享此緩沖區內容的新的僅僅讀 short 緩沖區。

新緩沖區的內容將為此緩沖區的內容。此緩沖區內容的更改在新緩沖區中是可見的。但新緩沖區將是僅僅讀的而且不同意改動共享內容。兩個緩沖區的位置、界限和標記值是相互獨立的。

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

假設此緩沖區本身是僅僅讀的。則此方法與 duplicate 方法全然同樣。

返回：新的僅僅讀 short 緩沖區
7、public abstract short get()

相對 get 方法。

讀取此緩沖區當前位置的 short，然后該位置遞增。

返回：緩沖區當前位置的 short 拋出： BufferUnderflowException - 假設緩沖區當前位置不小于其界限

8、public abstract ShortBuffer
put(short?s)

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

將給定 short 寫入此緩沖區的當前位置，然后該位置遞增。

參數：s - 要寫入的 short 返回：此緩沖區 拋出： BufferOverflowException - 假設此緩沖區的當前位置不小于界限
ReadOnlyBufferException - 假設此緩沖區是僅僅讀的
9、public abstract short get(int?index)

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

參數：index - 將讀取 short 的位置的索引 返回：給定索引處的 short 拋出： IndexOutOfBoundsException - 假設
index 為負或不小于緩沖區界限
10、public abstract ShortBuffer
put(int?index,?short?s)

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

將給定 short 寫入此緩沖區的給定索引處。

參數：index - 將在該位置寫入 shorts - 要寫入的 short 值 返回：此緩沖區 拋出： IndexOutOfBoundsException - 假設
index 為負或不小于緩沖區界限 ReadOnlyBufferException - 假設此緩沖區是僅僅讀的

11、public ShortBuffer
get(short[]?dst,int?offset,int?length)

相對批量 get 方法。

此方法將此緩沖區的 short 傳輸到給定的目標數組中。

假設緩沖區中剩余的 short 少于滿足請求所需的 short，即假設 length?>?remaining()，則不傳輸 short 且拋出
BufferUnderflowException。

否則，此方法將此緩沖區中的 length 個 short 拷貝到給定數組中，從此緩沖區的當前位置和數組中的給定偏移量位置開始復制。然后此緩沖區的位置遞增
length。

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

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

差別在于它首先檢查此緩沖區中是否具有足夠的 short。這樣可能效率更高。

參數：dst - 要寫入 short 的數組offset - 要寫入的第一個 short 在數組中的偏移量；必須為非負且不大于 dst.lengthlength - 要寫入給定數組中的 short 的最大數量。必須為非負且不大于 dst.length - offset
返回：此緩沖區 拋出： BufferUnderflowException - 假設此緩沖區中的剩余 short 少于
length IndexOutOfBoundsException - 假設關于
offset 和 length 參數的前提不成立
12、public ShortBuffer
get(short[]?dst)

相對批量 get 方法。

此方法將此緩沖區的 short 傳輸到給定的目標數組中。調用此方法的形式為 src.get(a)，該調用與下面調用全然同樣：

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

返回：此緩沖區 拋出： BufferUnderflowException - 假設此緩沖區中的剩余 short 少于
length

13、public ShortBuffer
put(ShortBuffer?src)

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

此方法將給定源緩沖區中的剩余 short 傳輸到此緩沖區中。假設源緩沖區中的剩余 short 多于此緩沖區中的剩余 short 空間，即 src.remaining()?>?remaining()，則不傳輸 short 且拋出
BufferOverflowException。

否則，此方法將給定緩沖區中的 n?=?src.remaining() 個 short 拷貝到此緩沖區中，從每一個緩沖區的當前位置開始復制。然后這兩個緩沖區的位置均遞增
n。

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

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

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

參數：src - 要從中讀取 short 的源緩沖區；不能為此緩沖區 返回：此緩沖區 拋出： BufferOverflowException - 假設對于源緩沖區中剩余的 short，此緩沖區沒有足夠空間
IllegalArgumentException - 假設源緩沖區是此緩沖區
ReadOnlyBufferException - 假設此緩沖區是僅僅讀的

14、public ShortBuffer
put(short[]?src,?int?offset,int?length)

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

此方法將給定源數組中的 short 傳輸到此緩沖區中。假設要從數組復制的 short 多于此緩沖區中的剩余 short 空間。即假設 length?>?remaining()，則不傳輸 short 且拋出
BufferOverflowException。

否則，此方法將給定數組中的 length 個 short 拷貝到此緩沖區中，從數組中給定偏移量位置和此緩沖區的當前位置開始復制。

然后此緩沖區的位置遞增
length。

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

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

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

參數：src - 要從中讀取 short 的數組offset - 要讀取的第一個 short 在數組中的偏移量；必須為非負且不大于 array.lengthlength - 要從給定數組讀取的 short 數量；必須為非負且不大于 array.length - offset
返回：此緩沖區 拋出： BufferOverflowException - 假設此緩沖區沒有足夠空間
IndexOutOfBoundsException - 假設關于
offset 和 length 參數的前提不成立 ReadOnlyBufferException - 假設此緩沖區是僅僅讀的
15、public final ShortBuffer
put(short[]?src)

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

此方法將給定源 short 數組中的全部內容傳輸到此緩沖區中。調用此方法的形式為 dst.put(a)，該調用與下面調用全然同樣：

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

返回：此緩沖區 拋出： BufferOverflowException - 假設此緩沖區沒有足夠空間
ReadOnlyBufferException - 假設此緩沖區是僅僅讀的

16、public final boolean hasArray()

推斷是否可通過一個可訪問的 short 數組實現此緩沖區。

假設此方法返回 true，則能夠安全地調用 array 和
arrayOffset 方法。

指定者：類 Buffer 中的
hasArray

返回：當且僅當存在實現此緩沖區的數組，而且此緩沖區不是僅僅讀緩沖區時，返回 true
17、public final short[] array()

返回實現此緩沖區的 short 數組（可選操作）。

此緩沖區的內容改動將導致返回的數組內容改動。反之亦然。

調用此方法之前要調用 hasArray 方法，以確保此緩沖區具有可訪問的底層實現數組。

指定者：類 Buffer 中的
array

返回：實現此緩沖區的數組 拋出： ReadOnlyBufferException - 假設存在實現此緩沖區的數組。但緩沖區是僅僅讀的
UnsupportedOperationException - 假設不存在某個可訪問的數組實現此緩沖區
18、public final int arrayOffset()

返回此緩沖區的第一個元素在緩沖區的底層實現數組中的偏移量（可選操作）。

假設存在實現此緩沖區的數組，則緩沖區位置 p 相應于數組索引 p?+?arrayOffset()。

調用此方法之前要調用 hasArray 方法，以確保此緩沖區具有可訪問的底層實現數組。

指定者：類 Buffer 中的
arrayOffset

返回：此緩沖區的第一個元素在緩沖區數組中的偏移量 拋出： ReadOnlyBufferException - 假設存在實現此緩沖區的數組。但緩沖區是僅僅讀的
UnsupportedOperationException - 假設不存在某個可訪問的數組實現此緩沖區
19、public abstract ShortBuffer
compact()

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

將緩沖區當前位置和界限之間的 short（假設有）拷貝到緩沖區的開始處。即將索引 p?=?position() 處的 short 拷貝到索引 0 處，將索引
p?+?1 處的 short 拷貝到索引 1 處，依此類推，直到將索引 limit()?-?1 處的 short 拷貝到索引
n?=?limit()?-?1?-?p 處。

然后將緩沖區的位置設置為 n+1，并將其界限設置為其容量。假設已定義了標記。則丟棄它。

將緩沖區的位置設置為復制的 short 的數量，而不是零，以便調用此方法后能夠緊接著調用還有一個相對 put 方法。

返回：此緩沖區 拋出： ReadOnlyBufferException - 假設此緩沖區是僅僅讀的
20、public abstract boolean
isDirect()

推斷此 short 緩沖區是否為直接的。

指定者：類 Buffer 中的
isDirect

返回：當且僅當此緩沖區為直接時。返回 true
21、public String
toString() ?返回總結了此緩沖區狀態的字符串。

返回：一個總結字符串

22、public int hashCode()

返回此緩沖區的當前哈希碼。

short 緩沖區的哈希碼僅僅取決于其剩余元素；即取決于從 position() 開始一直到（包含） limit()?-?1 處的元素。

由于緩沖區哈希碼與內容有關，因此建議不要在哈希映射或類似數據結構中將緩沖區用作鍵，除非知道它們的內容不會發生更改。

覆蓋：類 Object 中的
hashCode

返回：此緩沖區的當前哈希碼
23、public boolean equals(Object?ob)

推斷此緩沖區是否與還有一個對象同樣。

兩個 short 緩沖區是同樣的。當且僅當：

它們具有同樣的元素類型，

它們具有同樣數量的剩余元素，而且

兩個剩余元素序列（與它們的起始位置無關）逐點同樣。

short 緩沖區與不論什么其它類型的對象都不同。

覆蓋：類 Object 中的
equals

參數：ob - 此緩沖區要比較的對象 返回：當且僅當此緩沖區與給定對象同樣時，返回 true
24、public int compareTo(ShortBuffer?that)

將此緩沖區與還有一個緩沖區進行比較。

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

short 緩沖區不能與不論什么其它類型的對象進行比較。

指定者：接口 Comparable<ShortBuffer> 中的
compareTo

參數：that - 要比較的對象。 返回：假設此緩沖區小于、等于或大于給定緩沖區。則對應返回負整數、零或正整數
25、public abstract ByteOrder
order()

獲取此緩沖區的字節順序。

通過分配或通過包裝現有 short 數組而創建的 short 緩沖區的字節順序是底層硬件的本機順序。

作為字節緩沖區的視圖而創建的 short 緩沖區的字節順序是創建視圖時字節緩沖區的字節順序。

返回：此緩沖區的字節順序

總結

以上是生活随笔為你收集整理的java中的ShortBuffer的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。