Java NIO系列教程（三） Buffer

Java NIO系列教程（三） Buffer

Java NIO 中的 Buffer 用於和 NIO 通道進行交互。如你所知，數據是從通道讀入緩衝區，從緩衝區寫入到通道中的。

緩衝區本質上是一塊能夠寫入數據，而後能夠從中讀取數據的內存。這塊內存被包裝成 NIO Buffer 對象，並提供了一組方法，用來方便的訪問該塊內存。

1. Buffer 的基本用法

使用 Buffer 讀寫數據通常遵循如下四個步驟：

1. 寫入數據到 Buffer
2. 調用 flip() 方法
3. 從 Buffer 中讀取數據
4. 調用 clear() 方法或者 compact() 方法

當向 buffer 寫入數據時，buffer 會記錄下寫了多少數據。一旦要讀取數據，須要經過 flip() 方法將 Buffer 從寫模式切換到讀模式。在讀模式下，能夠讀取以前寫入到 buffer 的全部數據。

一旦讀完了全部的數據，就須要清空緩衝區，讓它能夠再次被寫入。有兩種方式能清空緩衝區：調用 clear() 或 compact() 方法。clear() 方法會清空整個緩衝區。compact() 方法只會清除已經讀過的數據。任何未讀的數據都被移到緩衝區的起始處，新寫入的數據將放到緩衝區未讀數據的後面。

//1. 分配一個指定大小的緩衝區
ByteBuffer buf1= ByteBuffer.allocate(1024);
System.out.println(buf1); // [pos=0 lim=1024 cap=1024]

//2. 利用 put() 存放數據到緩衝區
buf1.put("abc".getBytes());
System.out.println(new String(buf1.array())); // abc
System.out.println(buf1); // [pos=3 lim=1024 cap=1024]

//3. buf1.put(0, (byte)'z')時position不變
buf1.put(0, (byte)'z');
System.out.println(new String(buf1.array())); // zbc
System.out.println(buf1); // [pos=3 lim=1024 cap=1024]

//4. 切換到讀模式
buf1.flip();
System.out.println(buf1); // [pos=0 lim=3 cap=1024]

//5. get() 讀數據，position + 1
for (int i = 0; i < buf1.limit(); i++) {
    System.out.println(buf1.get());
}
System.out.println(buf1); // [pos=3 lim=3 cap=1024]

//6. get(0) 讀數據，position 不變
buf1.get(1);
System.out.println(buf1); // [pos=3 lim=3 cap=1024]

//7. rewind() 重讀模式，postion = 0，limit 不變
buf1.rewind();
System.out.println(buf1); // [pos=0 lim=3 cap=1024]

//8. buf.get(bytes)讀一個字節數組
byte[] bytes = new byte[buf.limit()];
buf.get(bytes);
System.out.println(new String(bytes));  //[pos=3 lim=3 cap=1024]

//9. buf.hasRemaining()
if (buf.hasRemaining()) {
   System.out.println(buf.remaining());
}

//10. buf.duplicate()
ByteBuffer buf2 = buf.duplicate();

//11. mark() 和 reset()
buf1.mark();
buf1.reset();

//12. compact() 保留未讀的部分切換到時寫模式
buf1.position(1).limit(3);
System.out.println(buf1); // [pos=1 lim=3 cap=1024]
buf1.compact();
System.out.println(buf1); // [pos=2 lim=1024 cap=1024]

//13. clear() 切換到時寫模式
buf1.clear();
System.out.println(buf1); // [pos=0 lim=1024 cap=1024]

2. Buffer 的 capacity, position 和 limit

緩衝區本質上是一塊能夠寫入數據，而後能夠從中讀取數據的內存。這塊內存被包裝成 NIO Buffer 對象，並提供了一組方法，用來方便的訪問該塊內存。

爲了理解 Buffer 的工做原理，須要熟悉它的三個屬性：

• capacity
• position
• limit

position 和 limit 的含義取決於 Buffer 處在讀模式仍是寫模式。無論 Buffer 處在什麼模式，capacity 的含義老是同樣的。

這裏有一個關於 capacity，position 和 limit 在讀寫模式中的說明，詳細的解釋在插圖後面。

Java源代碼： java.nio.Buffer

// Invariants: mark <= position <= limit <= capacity
private int mark = -1;
private int position = 0;
private int limit;
private int capacity;

(1) capacity

做爲一個內存塊，Buffer 有一個固定的大小值，也叫 「capacity」。你只能往裏寫 capacity 個 byte、long，char 等類型。一旦 Buffer 滿了，須要將其清空（經過讀數據或者清除數據）才能繼續寫數據往裏寫數據。

(2) position

當你寫數據到 Buffer 中時，position 表示當前的位置。初始的 position 值爲 0。當一個 byte、long 等數據寫到 Buffer 後， position 會向前移動到下一個可插入數據的 Buffer 單元。position 最大可爲 capacity – 1。

當讀取數據時，也是從某個特定位置讀。當將 Buffer 從寫模式切換到讀模式，position 會被重置爲 0。 當從 Buffer 的 position 處讀取數據時，position 向前移動到下一個可讀的位置。

(3) limit

在寫模式下，Buffer 的 limit 表示你最多能往 Buffer 裏寫多少數據。 寫模式下，limit 等於 Buffer 的 capacity。

當切換 Buffer 到讀模式時， limit 表示你最多能讀到多少數據。所以，當切換 Buffer 到讀模式時，limit 會被設置成寫模式下的 position 值。換句話說，你能讀到以前寫入的全部數據（limit 被設置成已寫數據的數量，這個值在寫模式下就是 position）。

(4) mark

標記，表示記錄當前 postion 的位置。能夠經過 reset 恢復到時 mark 的位置。

注：mark <= postion <= limit <= capacity

3. Buffer 的類型

Java NIO 有如下 Buffer 類型

• ByteBuffer
• MappedByteBuffer
• CharBuffer
• DoubleBuffer
• FloatBuffer
• IntBuffer
• LongBuffer
• ShortBuffer

如你所見，這些 Buffer 類型表明了不一樣的數據類型。換句話說，就是能夠經過 char，short，int，long，float 或 double 類型來操做緩衝區中的字節。

MappedByteBuffer 有些特別，在涉及它的專門章節中再講。

4. Buffer 的分配

要想得到一個 Buffer 對象首先要進行分配。 每個 Buffer 類都有一個 allocate 方法。下面是一個分配 48 字節 capacity 的 ByteBuffer 的例子。

ByteBuffer buf = ByteBuffer.allocate(48);

這是分配一個可存儲 1024 個字符的 CharBuffer：

CharBuffer buf = CharBuffer.allocate(1024);

5. 向 Buffer 中 寫數據

寫數據到 Buffer 有兩種方式：

1. 從 Channel 寫到 Buffer。
2. 經過 Buffer 的 put() 方法寫到 Buffer 裏。

從 Channel 寫到 Buffer 的例子

int bytesRead = inChannel.read(buf); //read into buffer.

經過 put 方法寫 Buffer 的例子：

buf.put(127);

注意： buf.put(127) 和 buf.put(0， 127) 區別，前者 postion 會 +1，後者不變，buf.get() 和 buf.get(0) 相似。

put 方法有不少版本，容許你以不一樣的方式把數據寫入到 Buffer 中。例如， 寫到一個指定的位置，或者把一個字節數組寫入到 Buffer。

6. flip() 方法

public final Buffer flip() {
    limit = position;
    position = 0;
    mark = -1;
    return this;
}

flip 方法將 Buffer 從寫模式切換到讀模式。調用 flip() 方法會將 position 設回 0，並將 limit 設置成以前 position 的值。

換句話說，position 如今用於標記讀的位置，limit 表示以前寫進了多少個 byte、char 等，如今能讀取多少個 byte、char 等。

7. 從 Buffer 中讀取數據

從 Buffer 中讀取數據有兩種方式：

1. 從 Buffer 讀取數據到Channel。
2. 使用 get() 方法從 Buffer 中讀取數據。

從 Buffer 讀取數據到 Channel 的例子：

//read from buffer into channel.
int bytesWritten = inChannel.write(buf);

使用 get() 方法從 Buffer 中讀取數據的例子

byte aByte = buf.get();

get 方法有不少版本，容許你以不一樣的方式從 Buffer 中讀取數據。例如，從指定 position 讀取，或者從 Buffer 中讀取數據到字節數組。

8. rewind() 方法

public final Buffer rewind() {
    position = 0;
    mark = -1;
    return this;
}

Buffer.rewind() 將 position 設回 0，因此你能夠重讀 Buffer 中的全部數據。limit 保持不變，仍然表示能從 Buffer 中讀取多少個元素（byte、char等）。

9. clear() 與 compact() 方法

一旦讀完 Buffer 中的數據，須要讓 Buffer 準備好再次被寫入。能夠經過 clear() 或 compact() 方法來完成。

public final Buffer clear() {
    position = 0;
    limit = capacity;
    mark = -1;
    return this;
}

若是調用的是 clear() 方法，position 將被設回 0，limit 被設置成 capacity 的值。換句話說，Buffer 被清空了。Buffer 中的數據並未清除，只是這些標記告訴咱們能夠從哪裏開始往 Buffer 裏寫數據。

若是 Buffer 中有一些未讀的數據，調用 clear() 方法，數據將「被遺忘」，意味着再也不有任何標記會告訴你哪些數據被讀過，哪些尚未。

public ByteBuffer compact() {
    System.arraycopy(hb, ix(position()), hb, ix(0), remaining());
    position(remaining());
    limit(capacity());
    discardMark();
    return this;
}

若是 Buffer 中仍有未讀的數據，且後續還須要這些數據，可是此時想要先先寫些數據，那麼使用 compact() 方法。

compact() 方法將全部未讀的數據拷貝到 Buffer 起始處。而後將 position 設到最後一個未讀元素正後面。limit 屬性依然像 clear() 方法同樣，設置成 capacity。如今 Buffer 準備好寫數據了，可是不會覆蓋未讀的數據。

10. mark() 與 reset() 方法

public final Buffer mark() {
    mark = position;
    return this;
}

public final Buffer reset() {
    int m = mark;
    if (m < 0)
        throw new InvalidMarkException();
    position = m;
    return this;
}

經過調用Buffer.mark()方法，能夠標記Buffer中的一個特定position。以後能夠經過調用Buffer.reset()方法恢復到這個position。例如：

buffer.mark();
//call buffer.get() a couple of times, e.g. during parsing.
buffer.reset();  //set position back to mark.

11. equals() 與 compareTo() 方法

可使用 equals() 和 compareTo() 方法兩個 Buffer。

equals

當知足下列條件時，表示兩個 Buffer 相等：

1. 有相同的類型（byte、char、int等）。
2. Buffer 中剩餘的 byte、char 等的個數相等。
3. Buffer 中全部剩餘的 byte、char 等都相同。

如你所見，equals 只是比較 Buffer 的一部分，不是每個在它裏面的元素都比較。實際上，它只比較 Buffer 中的剩餘元素。

compareTo

compareTo() 方法比較兩個 Buffer 的剩餘元素(byte、char等)， 若是知足下列條件，則認爲一個 Buffer 「小於」另外一個 Buffer：

1. 第一個不相等的元素小於另外一個 Buffer 中對應的元素 。
2. 全部元素都相等，但第一個 Buffer 比另外一個先耗盡(第一個Buffer的元素個數比另外一個少)。

（譯註：剩餘元素是從 position 到 limit 之間的元素）

轉載自併發編程網 – ifeve.com，本文連接地址: Java NIO系列教程（三） Buffer