JAVA NIO緩衝區(Buffer)------ByteBuffer常用方法詳解

JAVA NIO緩衝區(Buffer)------ByteBuffer常用方法詳解
原創滄海龍騰LV 最後發佈於2018-07-14 16:27:11 閱讀數 24330 收藏
展開

緩衝區(Buffer)

緩衝區(Buffer)就是在內存中預留指定大小的存儲空間用來對輸入/輸出(I/O)的數據作臨時存儲，這部分預留的內存空間就叫做緩衝區：

使用緩衝區有這麼兩個好處：

1、減少實際的物理讀寫次數

2、緩衝區在創建時就被分配內存，這塊內存區域一直被重用，可以減少動態分配和回收內存的次數

舉個簡單的例子，比如A地有1w塊磚要搬到B地

由於沒有工具（緩衝區），我們一次只能搬一本，那麼就要搬1w次（實際讀寫次數）

如果A，B兩地距離很遠的話（IO性能消耗），那麼性能消耗將會很大

但是要是此時我們有輛大卡車（緩衝區），一次可運5000本，那麼2次就夠了

相比之前，性能肯定是大大提高了。

而且一般在實際過程中，我們一般是先將文件讀入內存，再從內存寫出到別的地方

這樣在輸入輸出過程中我們都可以用緩存來提升IO性能。

所以，buffer在IO中很重要。在舊I/O類庫中（相對java.nio包）中的BufferedInputStream、BufferedOutputStream、BufferedReader和BufferedWriter在其實現中都運用了緩衝區。java.nio包公開了Buffer API，使得Java程序可以直接控制和運用緩衝區。

在Java NIO中，緩衝區的作用也是用來臨時存儲數據，可以理解爲是I/O操作中數據的中轉站。緩衝區直接爲通道(Channel)服務，寫入數據到通道或從通道讀取數據，這樣的操利用緩衝區數據來傳遞就可以達到對數據高效處理的目的。在NIO中主要有八種緩衝區類(其中MappedByteBuffer是專門用於內存映射的一種ByteBuffer)：

Fields

所有緩衝區都有4個屬性：capacity、limit、position、mark，並遵循：mark <= position <= limit <= capacity，下表格是對着4個屬性的解釋：
屬性描述
Capacity 容量，即可以容納的最大數據量；在緩衝區創建時被設定並且不能改變
Limit 表示緩衝區的當前終點，不能對緩衝區超過極限的位置進行讀寫操作。且極限是可以修改的
Position 位置，下一個要被讀或寫的元素的索引，每次讀寫緩衝區數據時都會改變改值，爲下次讀寫作準備
Mark 標記，調用mark()來設置mark=position，再調用reset()可以讓position恢復到標記的位置
Methods
1、實例化

java.nio.Buffer類是一個抽象類，不能被實例化。Buffer類的直接子類，如ByteBuffer等也是抽象類，所以也不能被實例化。

但是ByteBuffer類提供了4個靜態工廠方法來獲得ByteBuffer的實例：
方法描述
allocate(int capacity) 從堆空間中分配一個容量大小爲capacity的byte數組作爲緩衝區的byte數據存儲器
allocateDirect(int capacity) 是不使用JVM堆棧而是通過操作系統來創建內存塊用作緩衝區，它與當前操作系統能夠更好的耦合，因此能進一步提高I/O操作速度。但是分配直接緩衝區的系統開銷很大，因此只有在緩衝區較大並長期存在，或者需要經常重用時，才使用這種緩衝區
wrap(byte[] array) 這個緩衝區的數據會存放在byte數組中，bytes數組或buff緩衝區任何一方中數據的改動都會影響另一方。其實ByteBuffer底層本來就有一個bytes數組負責來保存buffer緩衝區中的數據，通過allocate方法系統會幫你構造一個byte數組
wrap(byte[] array,
int offset, int length)

在上一個方法的基礎上可以指定偏移量和長度，這個offset也就是包裝後byteBuffer的position，而length呢就是limit-position的大小，從而我們可以得到limit的位置爲length+position(offset)

我寫了這幾個方法的測試方法，大家可以運行起來更容易理解

public static void main(String args[]) throws FileNotFoundException {  
  
    System.out.println("----------Test allocate--------");  
    System.out.println("before alocate:"  
            + Runtime.getRuntime().freeMemory());  
      
    // 如果分配的內存過小，調用Runtime.getRuntime().freeMemory()大小不會變化？  
    // 要超過多少內存大小JVM才能感覺到？  
    ByteBuffer buffer = ByteBuffer.allocate(102400);  
    System.out.println("buffer = " + buffer);  
      
    System.out.println("after alocate:"  
            + Runtime.getRuntime().freeMemory());  
      
    // 這部分直接用的系統內存，所以對JVM的內存沒有影響  
    ByteBuffer directBuffer = ByteBuffer.allocateDirect(102400);  
    System.out.println("directBuffer = " + directBuffer);  
    System.out.println("after direct alocate:"  
            + Runtime.getRuntime().freeMemory());  
      
    System.out.println("----------Test wrap--------");  
    byte[] bytes = new byte[32];  
    buffer = ByteBuffer.wrap(bytes);  
    System.out.println(buffer);  
      
    buffer = ByteBuffer.wrap(bytes, 10, 10);  
    System.out.println(buffer);   
}

2、另外一些常用的方法
方法描述
limit(), limit(10)等其中讀取和設置這4個屬性的方法的命名和jQuery中的val(),val(10)類似，一個負責get，一個負責set
reset() 把position設置成mark的值，相當於之前做過一個標記，現在要退回到之前標記的地方
clear() position = 0;limit = capacity;mark = -1; 有點初始化的味道，但是並不影響底層byte數組的內容
flip() limit = position;position = 0;mark = -1; 翻轉，也就是讓flip之後的position到limit這塊區域變成之前的0到position這塊，翻轉就是將一個處於存數據狀態的緩衝區變爲一個處於準備取數據的狀態
rewind() 把position設爲0，mark設爲-1，不改變limit的值
remaining() return limit - position;返回limit和position之間相對位置差
hasRemaining() return position < limit返回是否還有未讀內容
compact() 把從position到limit中的內容移到0到limit-position的區域內，position和limit的取值也分別變成limit-position、capacity。如果先將positon設置到limit，再compact，那麼相當於clear()
get() 相對讀，從position位置讀取一個byte，並將position+1，爲下次讀寫作準備
get(int index) 絕對讀，讀取byteBuffer底層的bytes中下標爲index的byte，不改變position
get(byte[] dst, int offset, int length) 從position位置開始相對讀，讀length個byte，並寫入dst下標從offset到offset+length的區域
put(byte b) 相對寫，向position的位置寫入一個byte，並將postion+1，爲下次讀寫作準備
put(int index, byte b) 絕對寫，向byteBuffer底層的bytes中下標爲index的位置插入byte b，不改變position
put(ByteBuffer src) 用相對寫，把src中可讀的部分（也就是position到limit）寫入此byteBuffer
put(byte[] src, int offset, int length) 從src數組中的offset到offset+length區域讀取數據並使用相對寫寫入此byteBuffer

以下爲一些測試方法：

public static void main(String args[]){  
  
    System.out.println("--------Test reset----------");  
    buffer.clear();  
    buffer.position(5);  
    buffer.mark();  
    buffer.position(10);  
    System.out.println("before reset:" + buffer);  
    buffer.reset();  
    System.out.println("after reset:" + buffer);  
  
    System.out.println("--------Test rewind--------");  
    buffer.clear();  
    buffer.position(10);  
    buffer.limit(15);  
    System.out.println("before rewind:" + buffer);  
    buffer.rewind();  
    System.out.println("before rewind:" + buffer);  
  
    System.out.println("--------Test compact--------");  
    buffer.clear();  
    buffer.put("abcd".getBytes());  
    System.out.println("before compact:" + buffer);  
    System.out.println(new String(buffer.array()));  
    buffer.flip();  
    System.out.println("after flip:" + buffer);  
    System.out.println((char) buffer.get());  
    System.out.println((char) buffer.get());  
    System.out.println((char) buffer.get());  
    System.out.println("after three gets:" + buffer);  
    System.out.println("\t" + new String(buffer.array()));  
    buffer.compact();  
    System.out.println("after compact:" + buffer);  
    System.out.println("\t" + new String(buffer.array()));  
  
    System.out.println("------Test get-------------");  
    buffer = ByteBuffer.allocate(32);  
    buffer.put((byte) 'a').put((byte) 'b').put((byte) 'c').put((byte) 'd')  
            .put((byte) 'e').put((byte) 'f');  
    System.out.println("before flip()" + buffer);  
    // 轉換爲讀取模式  
    buffer.flip();  
    System.out.println("before get():" + buffer);  
    System.out.println((char) buffer.get());  
    System.out.println("after get():" + buffer);  
    // get(index)不影響position的值  
    System.out.println((char) buffer.get(2));  
    System.out.println("after get(index):" + buffer);  
    byte[] dst = new byte[10];  
    buffer.get(dst, 0, 2);  
    System.out.println("after get(dst, 0, 2):" + buffer);  
    System.out.println("\t dst:" + new String(dst));  
    System.out.println("buffer now is:" + buffer);  
    System.out.println("\t" + new String(buffer.array()));  
  
    System.out.println("--------Test put-------");  
    ByteBuffer bb = ByteBuffer.allocate(32);  
    System.out.println("before put(byte):" + bb);  
    System.out.println("after put(byte):" + bb.put((byte) 'z'));  
    System.out.println("\t" + bb.put(2, (byte) 'c'));  
    // put(2,(byte) 'c')不改變position的位置  
    System.out.println("after put(2,(byte) 'c'):" + bb);  
    System.out.println("\t" + new String(bb.array()));  
    // 這裏的buffer是 abcdef[pos=3 lim=6 cap=32]  
    bb.put(buffer);  
    System.out.println("after put(buffer):" + bb);  
    System.out.println("\t" + new String(bb.array()));  
}

buffer order（大端模式，小端模式，中端模式）

在一個32位的CPU中“字長”爲32個bit，也就是4個byte。在這樣的CPU中，總是以4字節對齊的方式來讀取或寫入內存，那麼同樣這4個字節的數據是以什麼順序保存在內存中的呢？例如，

現在我們要向內存地址爲a的地方寫入數據0x0A0B0C0D，那麼這4個字節分別落在哪個地址的內存上呢？這就涉及到字節序的問題了。

每個數據都有所謂的“有效位（significant byte）”，它的意思是“表示這個數據所用的字節”。例如一個32位整數，它的有效位就是4個字節。而對於0x0A0B0C0D來說，它的有效位從高到低便是0A、0B、0C及0D——這裏您可以把它作爲一個256進制的數來看（相對於我們平時所用的10進制數）。

而所謂大字節序（big endian），便是指其“最高有效位（most significant byte）”落在低地址上的存儲方式。例如像地址a寫入0x0A0B0C0D之後，在內存中的數據便是：
Big Endian

而對於小字節序（little endian）來說就正好相反了，它把“最低有效位（least significant byte）”放在低地址上。例如：
Little Endian

對於我們常用的CPU架構，如Intel，AMD的CPU使用的都是小字節序，而例如Mac OS以前所使用的Power PC使用的便是大字節序（不過現在Mac OS也使用Intel的CPU了）。此外，除了大字節序和小字節序之外，還有一種很少見的中字節序（middle endian），它會以2143的方式來保存數據（相對於大字節序的1234及小字節序的4321）。
在java.nio中，字節順序由ByteOrder類封裝。

package java.nio; 
public final class ByteOrder 
{ 
	public static final ByteOrder BIG_ENDIAN 
	public static final ByteOrder LITTLE_ENDIAN 
	public static ByteOrder nativeOrder( ) 
	public String toString( ) 
}

ByteOrder類定義了決定從緩衝區中存儲或檢索多字節數值時使用哪一字節順序的常量。這個類的作用就像一個類型安全的枚舉。它定

義了以其本身實例預初始化的兩個public區域。只有這兩個ByteOrder實例總是存在於JVM中，因此它們可以通過使用–操作符進行比

較。如果您需要知道JVM運行的硬件平臺的固有字節順序，請調用靜態類函數nativeOrder()。它將返回兩個已確定常量中的一個。調用

toString()將返回一個包含兩個文字字符串BIG_ENDIAN或者LITTLE_ENDIAN之一的String。
假設一個叫buffer的ByteBuffer對象處於下圖的狀態：

這段代碼：
int value = buffer.getInt( );
會返回一個由緩衝區中位置1-4的byte數據值組成的int型變量的值。實際的返回值取決於緩衝區的當前的比特排序（byte-order）設置。
更具體的寫法是：
int value = buffer.order (ByteOrder.BIG_ENDIAN).getInt( );
這將會返回值0x3BC5315E，
同時：
int value = buffer.order (ByteOrder.LITTLE_ENDIAN).getInt( );
返回值0x5E31C53B。

方法詳細

1、public static ByteBuffer allocateDirect(int capacity) 分配新的直接字節緩衝區。新緩衝區的位置將爲零，其界限將爲其容量，其標記是不確定的。無論它是否具有底層實現數組，其標記都是不確定的。

參數：capacity - 新緩衝區的容量，以字節爲單位

返回：新的字節緩衝區

拋出： IllegalArgumentException - 如果capacity 爲負整數

2、public static ByteBuffer allocate(int capacity) 分配一個新的字節緩衝區。新緩衝區的位置將爲零，其界限將爲其容量，其標記是不確定的。它將具有一個底層實現數組，且其數組偏移量將爲零。

參數：capacity - 新緩衝區的容量，以字節爲單位

返回：新的字節緩衝區

拋出： IllegalArgumentException - 如果capacity 爲負整數

3、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 參數的前提不成立

4、public static ByteBuffer wrap(byte[] array) 將 byte 數組包裝到緩衝區中。

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

參數：array - 實現此緩衝區的數組返回：新的字節緩衝區
5、public abstract ByteBuffer slice() 創建新的字節緩衝區，其內容是此緩衝區內容的共享子序列。

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

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

6、public abstract ByteBuffer duplicate() 創建共享此緩衝區內容的新的字節緩衝區。

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

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

7、public abstract ByteBuffer asReadOnlyBuffer() 創建共享此緩衝區內容的新的只讀字節緩衝區。

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

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

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

8、public abstract byte get() 相對get 方法。讀取此緩衝區當前位置的字節，然後該位置遞增。返回：緩衝區當前位置的字節拋出： BufferUnderflowException - 如果該緩衝區的當前位置不小於其界限
9、public abstract ByteBuffer put(byte b) 相對 put 方法（可選操作）。將給定的字節寫入此緩衝區的當前位置，然後該位置遞增。參數：b - 要寫入的字節返回：此緩衝區拋出： BufferOverflowException - 如果此緩衝區的當前位置不小於其界限 ReadOnlyBufferException - 如果此緩衝區是隻讀緩衝區
10、public abstract byte get(int index) 絕對get 方法。讀取指定索引處的字節。

參數：index - 將從中讀取該字節的索引
返回：給定索引處的字節
拋出： IndexOutOfBoundsException - 如果index 爲負或不小於緩衝區界限

11、public abstract ByteBuffer put(int index,byte b) 絕對 put 方法（可選操作）。將給定字節寫入此緩衝區的給定索引處。
參數：index - 將在該位置寫入字節的索引
b - 要寫入的字節值
返回：此緩衝區
拋出：IndexOutOfBoundsException - 如果index 爲負或不小於緩衝區界限
ReadOnlyBufferException - 如果此緩衝區是隻讀緩衝區

12、publicByteBufferget(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 參數的前提不成立

13、public ByteBufferget(byte[] dst)

相對批量 get 方法。

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

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

返回：
    此緩衝區
拋出：
    BufferUnderflowException - 如果此緩衝區中的剩餘字節少於length

14、public ByteBufferput(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 - 如果此緩衝區是隻讀緩衝區

15、public ByteBufferput(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 - 如果此緩衝區是隻讀緩衝區

16、public final ByteBuffer put(byte[] src)相對批量 put 方法（可選操作）。

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

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

返回：
此緩衝區
拋出：
BufferOverflowException - 如果此緩衝區沒有足夠空間
ReadOnlyBufferException - 如果此緩衝區是隻讀緩衝區

17、public final boolean hasArray()

判斷是否可通過一個可訪問的 byte 數組實現此緩衝區。

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

指定者：
    類 Buffer 中的hasArray

返回：
    當且僅當存在實現此緩衝區的數組，並且此緩衝區不是隻讀緩衝區時，返回 true

18、public final byte[] array()

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

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

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

指定者：
    類 Buffer 中的array

返回：
    實現此緩衝區的數組
拋出：
    ReadOnlyBufferException - 如果存在實現此緩衝區的數組，但緩衝區是隻讀的
    UnsupportedOperationException - 如果不存在某個可訪問的數組實現此緩衝區

19、public final int arrayOffset()

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

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

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

指定者：
    類 Buffer 中的arrayOffset

返回：
    此緩衝區的第一個元素在緩衝區數組中的偏移量
拋出：
    ReadOnlyBufferException - 如果存在實現此緩衝區的數組，但緩衝區是隻讀的
    UnsupportedOperationException - 如果不存在某個可訪問的數組實現此緩衝區

20、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 - 如果此緩衝區是隻讀緩衝區

21、public abstract boolean isDirect()

判斷此字節緩衝區是否爲直接的。

指定者：
    類 Buffer 中的isDirect

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

22、public String toString()

返回彙總了此緩衝區狀態的字符串。

覆蓋：
    類 Object 中的toString

返回：
    一個彙總字符串

23、public int hashCode()返回此緩衝區的當前哈希碼。

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

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

覆蓋：
類 Object 中的hashCode

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

24、public boolean equals(Object ob)判斷此緩衝區是否與另一個對象相同。

當且僅當滿足以下條件時兩個字節緩衝區相同：

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

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

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

字節緩衝區與任何其他類型的對象都不同。

覆蓋：
類 Object 中的equals

參數：
ob - 此緩衝區要比較的對象
返回：
當且僅當此緩衝區與給定對象相同時，返回 true

25、public int compareTo(ByteBuffer that)

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

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

字節緩衝區不能與任何其他類型的對象進行比較。

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

參數：
    that - 要比較的對象。
返回：
    當此緩衝區小於、等於或大於給定緩衝區時，返回負整數、零或正整數

26、public final ByteOrder order() 獲取此緩衝區的字節順序。在讀寫多字節值以及爲此字節緩衝區創建視圖時使用該字節順序。新創建的字節緩衝區的順序始終爲BIG_ENDIAN。

27、public final ByteBuffer order(ByteOrder bo) 修改此緩衝區的字節順序。參數：bo - 新的字節順序，要麼是 BIG_ENDIAN，要麼是LITTLE_ENDIAN返回：此緩衝區
28、public abstract char getChar() 用於讀取 char 值的相對 get 方法。

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

返回：
緩衝區當前位置的 char 值
拋出：
BufferUnderflowException - 如果此緩衝區中的剩餘字節數少於 2

29、public abstract ByteBuffer putChar(char value)

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

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

參數：
    value - 要寫入的 char 值
返回：
    此緩衝區
拋出：
    BufferOverflowException - 如果此緩衝區中的剩餘字節數少於 2
    ReadOnlyBufferException - 如果此緩衝區是隻讀緩衝區

30、public abstract char getChar(int index) 用於讀取 char 值的絕對 get 方法。讀取給定索引處的兩個字節，並根據當前的字節順序將它們組成 char 值。

參數：
index - 將從該位置讀取字節的索引
返回：
給定索引處的 char 值
拋出：
IndexOutOfBoundsException - 如果index 爲負數，或者不小於該緩衝區的界限 - 1 所得的值

31、public abstract ByteBuffer putChar(int index, char value)

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

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

參數：
    index - 將在該位置寫入字節的索引
    value - 要寫入的 char 值
返回：
    此緩衝區
拋出：
    IndexOutOfBoundsException - 如果index 爲負數，或者不小於該緩衝區的界限 - 1 所得的值
    ReadOnlyBufferException - 如果此緩衝區是隻讀緩衝區

32、public abstract CharBuffer asCharBuffer() 創建此字節緩衝區的視圖，作爲 char 緩衝區。

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

返回：
新的 char 緩衝區

33、public abstract short getShort()

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

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

返回：
    緩衝區當前位置的 short 值
拋出：
    BufferUnderflowException - 如果此緩衝區中的剩餘字節數少於 2

34、public abstract ByteBuffer putShort(short value) 用於寫入 short 值的相對 put 方法（可選操作）。

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

參數：
value - 要寫入的 short 值
返回：
此緩衝區
拋出：
BufferOverflowException - 如果此緩衝區中的剩餘字節數少於 2
ReadOnlyBufferException - 如果此緩衝區是隻讀緩衝區

35、public abstract short getShort(int index)

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

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

參數：
    index - 將從該位置讀取字節的索引
返回：
    給定索引處的 short 值
拋出：
    IndexOutOfBoundsException - 如果index 爲負數，或者不小於該緩衝區的界限 - 1 所得的值

36、public abstract ByteBuffer putShort(int index,short value) 用於寫入 short 值的絕對 put 方法（可選操作）。

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

參數：
index - 將在該位置寫入字節的索引
value - 要寫入的 short 值
返回：
此緩衝區
拋出：
IndexOutOfBoundsException - 如果index 爲負數，或者不小於該緩衝區的界限 - 1 所得的值
ReadOnlyBufferException - 如果此緩衝區是隻讀緩衝區

37、public abstract ShortBuffer asShortBuffer()

創建此字節緩衝區的視圖，作爲 short 緩衝區。

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

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

返回：
    新的 short 緩衝區

38、public abstract int getInt()

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

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

返回：
    緩衝區當前位置的 int 值
拋出：
    BufferUnderflowException - 如果此緩衝區中的剩餘字節數少於 4

39、public abstract ByteBuffer putInt(int value) 用於寫入 int 值的相對 put 方法（可選操作）。

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

參數：
value - 要寫入的 int 值
返回：
此緩衝區
拋出：
BufferOverflowException - 如果此緩衝區中的剩餘字節數少於 4
ReadOnlyBufferException - 如果此緩衝區是隻讀緩衝區

40、public abstract int getInt(int index) 用於讀取 int 值的絕對 get 方法。

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

參數：
index - 將從該位置讀取字節的索引
返回：
給定索引處的 int 值
拋出：
IndexOutOfBoundsException - 如果index 爲負數，或者不小於該緩衝區的界限 - 3 所得的值

41、public abstract ByteBuffer putInt(int index, int value)

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

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

參數：
    index - 將在該位置寫入字節的索引
    value - 要寫入的 int 值
返回：
    此緩衝區
拋出：
    IndexOutOfBoundsException - 如果index 爲負數，或者不小於該緩衝區的界限 - 3 所得的值
    ReadOnlyBufferException - 如果此緩衝區是隻讀緩衝區

42、public abstract IntBuffer asIntBuffer()

創建此字節緩衝區的視圖，作爲 int 緩衝區。

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

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

返回：
    新的 int 緩衝區

43、public abstract long getLong()

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

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

返回：
    緩衝區當前位置的 long 值
拋出：
    BufferUnderflowException - 如果此緩衝區中的剩餘字節數少於 8

44、public abstract ByteBuffer putLong(long value)

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

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

參數：
    value - 要寫入的 long 值
返回：
    此緩衝區
拋出：
    BufferOverflowException - 如果此緩衝區中的剩餘字節數少於 8
    ReadOnlyBufferException - 如果此緩衝區是隻讀緩衝區

45、public abstract long getLong(int index)

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

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

參數：
    index - 將從該位置讀取字節的索引
返回：
    給定索引處的 long 值
拋出：
    IndexOutOfBoundsException - 如果index 爲負數，或者不小於該緩衝區的界限 - 7 所得的值

46、public abstract ByteBuffer putLong(int index,long value)

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

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

參數：
    index - 將在該位置寫入字節的索引
    value - 要寫入的 long 值
返回：
    此緩衝區
拋出：
    IndexOutOfBoundsException - 如果index 爲負數，或者不小於該緩衝區的界限 - 7 所得的值
    ReadOnlyBufferException - 如果此緩衝區是隻讀緩衝區

47、public abstract LongBuffer asLongBuffer() 創建此字節緩衝區的視圖，作爲 long 緩衝區。

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

返回：
新的 long 緩衝區

48、public abstract float getFloat() 用於讀取 float 值的相對 get 方法。

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

返回：
緩衝區當前位置的 float 值
拋出：
BufferUnderflowException - 如果此緩衝區中的剩餘字節數少於 4

49、public abstract ByteBuffer putFloat(float value)

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

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

參數：
    value - 要寫入的 float 值
返回：
    此緩衝區
拋出：
    BufferOverflowException - 如果此緩衝區中的剩餘字節數少於 4
    ReadOnlyBufferException - 如果此緩衝區是隻讀緩衝區

50、public abstract float getFloat(int index) 用於讀取 float 值的絕對 get 方法。

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

參數：
index - 將從該位置讀取字節的索引
返回：
給定索引處的 float 值
拋出：
IndexOutOfBoundsException - 如果index 爲負數，或者不小於該緩衝區的界限 - 3 所得的值

51、public abstract ByteBuffer putFloat(int index, float value) 用於寫入 float 值的絕對 put 方法（可選操作）。

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

參數：
index - 將在該位置寫入字節的索引
value - 要寫入的 float 值
返回：
此緩衝區
拋出：
IndexOutOfBoundsException - 如果index 爲負數，或者不小於該緩衝區的界限 - 3 所得的值
ReadOnlyBufferException - 如果此緩衝區是隻讀緩衝區

52、public abstract FloatBuffer asFloatBuffer() 創建此字節緩衝區的視圖，作爲 float 緩衝區。

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

返回：
新的 float 緩衝區

53、public abstract double getDouble()

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

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

返回：
    緩衝區當前位置的 double 值
拋出：
    BufferUnderflowException - 如果此緩衝區中的剩餘字節數少於 8

54、public abstract ByteBuffer putDouble(double value) 用於寫入 double 值的相對 put 方法（可選操作）。

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

參數：
value - 要寫入的 double 值
返回：
此緩衝區
拋出：
BufferOverflowException - 如果此緩衝區中的剩餘字節數少於 8
ReadOnlyBufferException - 如果此緩衝區是隻讀緩衝區

55、public abstract double getDouble(int index)用於讀取 double 值的絕對 get 方法。

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

參數：
index - 將從該位置讀取字節的索引
返回：
給定索引處的 double 值
拋出：
IndexOutOfBoundsException - 如果index 爲負數，或者不小於該緩衝區的界限 - 7 所得的值

56、public abstract ByteBuffer putDouble(int index, double value)用於寫入 double 值的絕對 put 方法（可選操作）。

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

參數：
index - 將在該位置寫入字節的索引
value - 要寫入的 double 值
返回：
此緩衝區
拋出：
IndexOutOfBoundsException - 如果index 爲負數，或者不小於該緩衝區的界限 - 7 所得的值
ReadOnlyBufferException - 如果此緩衝區是隻讀緩衝區

57、public abstract DoubleBuffer asDoubleBuffer()

創建此字節緩衝區的視圖，作爲 double 緩衝區。

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

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

返回：
    新的 double 緩衝區

————————————————
版權聲明：本文爲CSDN博主「滄海龍騰LV」的原創文章，遵循 CC 4.0 BY-SA 版權協議，轉載請附上原文出處鏈接及本聲明。
原文鏈接：https://blog.csdn.net/xialong_927/article/details/81044759

JAVA NIO緩衝區(Buffer)------ByteBuffer常用方法詳解

java等待喚醒機制的使用（wait/notify）

Android之AES對文件進行加密解密

個人理解--代理模式和命令模式區別

JAVA NIO緩衝區(Buffer)------ByteBuffer常用方法詳解

Android使用okhttp進行自制證書的雙向SSL驗證

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結