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

緩沖區本質上是一塊可以寫入數據，然后可以從中讀取數據的內存。這塊內存被包裝成NIO Buffer對象，并提供了一組方法，用來方便的訪問該塊內存。緩沖區實際上是一個容器對象，更直接的說，其實就是一個數組，在NIO庫中，所有數據都是用緩沖區處理的。在讀取數據時，它是直接讀到緩沖區中的； 在寫入數據時，它也是寫入到緩沖區中的；任何時候訪問 NIO 中的數據，都是將它放到緩沖區中。而在面向流I/O系統中，所有數據都是直接寫入或者直接將數據讀取到Stream對象中。

在NIO中，所有的緩沖區類型都繼承于抽象類Buffer，最常用的就是ByteBuffer，對于Java中的基本類型，基本都有一個具體Buffer類型與之相對應，它們之間的繼承關系如下圖所示：

?

下面是NIO Buffer相關的話題列表：

Buffer的基本用法

Buffer的capacity,position和limit

Buffer的類型

Buffer的分配

向Buffer中寫數據

flip()方法

從Buffer中讀取數據

clear()與compact()方法

mark()與reset()方法

equals()與compareTo()方法

?

Buffer的基本用法

使用Buffer讀寫數據一般遵循以下四個步驟：

寫入數據到Buffer

調用flip()方法

從Buffer中讀取數據

調用clear()方法或者compact()方法

當向buffer寫入數據時，buffer會記錄下寫了多少數據。一旦要讀取數據，需要通過flip()方法將Buffer從寫模式切換到讀模式。在讀模式下，可以讀取之前寫入到buffer的所有數據。

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

下面是一個使用Buffer的例子：

RandomAccessFile aFile = new RandomAccessFile("data/nio-data.txt", "rw");FileChannel inChannel = aFile.getChannel();//create buffer with capacity of 48 bytesByteBuffer buf = ByteBuffer.allocate(48);int bytesRead = inChannel.read(buf); //read into buffer.while (bytesRead != -1) {buf.flip(); //make buffer ready for readwhile(buf.hasRemaining()){System.out.print((char) buf.get()); // read 1 byte at a time }buf.clear(); //make buffer ready for writingbytesRead = inChannel.read(buf);}aFile.close();

示例2：

下面是一個簡單的使用IntBuffer的例子：

package com.dxz.nio;import java.nio.IntBuffer;public class TestIntBuffer { public static void main(String[] args) { // 分配新的int緩沖區，參數為緩沖區容量 // 新緩沖區的當前位置將為零，其界限(限制位置)將為其容量。它將具有一個底層實現數組，其數組偏移量將為零。 IntBuffer buffer = IntBuffer.allocate(8); for (int i = 0; i < buffer.capacity(); ++i) { int j = 2 * (i + 1); // 將給定整數寫入此緩沖區的當前位置，當前位置遞增 buffer.put(j); } // 重設此緩沖區，將限制設置為當前位置，然后將當前位置設置為0 buffer.flip(); // 查看在當前位置和限制位置之間是否有元素 while (buffer.hasRemaining()) { // 讀取此緩沖區當前位置的整數，然后當前位置遞增 int j = buffer.get(); System.out.print(j + " "); } } }

結果：

2 4 6 8 10 12 14 16

?

Buffer的capacity,position和limit

緩沖區本質上是一塊可以寫入數據，然后可以從中讀取數據的內存。這塊內存被包裝成NIO Buffer對象，并提供了一組方法，用來方便的訪問該塊內存。

為了理解Buffer的工作原理，需要熟悉它的三個屬性：

• capacity
• position
• limit

position和limit的含義取決于Buffer處在讀模式還是寫模式。不管Buffer處在什么模式，capacity的含義總是一樣的。

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

capacity

作為一個內存塊，Buffer有一個固定的大小值，也叫“capacity”.你只能往里寫capacity個byte、long，char等類型。一旦Buffer滿了，需要將其清空（通過讀數據或者清除數據）才能繼續寫數據往里寫數據。

position

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

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

limit

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

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

Buffer的類型

Java NIO 有以下Buffer類型

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

p<>
如你所見，這些Buffer類型代表了不同的數據類型。換句話說，就是可以通過char，short，int，long，float 或 double類型來操作緩沖區中的字節。

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

Buffer的分配

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

1	ByteBuffer buf = ByteBuffer.allocate(48);

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

1	CharBuffer buf = CharBuffer.allocate(1024);

向Buffer中寫數據

寫數據到Buffer有兩種方式：

• 從Channel寫到Buffer。
• 通過Buffer的put()方法寫到Buffer里。

從Channel寫到Buffer的例子

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

通過put方法寫Buffer的例子：

1	buf.put(127);

put方法有很多版本，允許你以不同的方式把數據寫入到Buffer中。例如， 寫到一個指定的位置，或者把一個字節數組寫入到Buffer。 更多Buffer實現的細節參考JavaDoc。

flip()方法

flip英?[fl?p]　美?[fl?p]?及物動詞 輕彈，輕擊; 按（開關）; 快速翻轉; 急揮

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

換句話說，position現在用于標記讀的位置，limit表示之前寫進了多少個byte、char等 —— 現在能讀取多少個byte、char等。

從Buffer中讀取數據

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

從Buffer讀取數據到Channel。

使用get()方法從Buffer中讀取數據。

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

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

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

byte aByte = buf.get();

get方法有很多版本，允許你以不同的方式從Buffer中讀取數據。例如，從指定position讀取，或者從Buffer中讀取數據到字節數組。更多Buffer實現的細節參考JavaDoc。

rewind()方法

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

clear()與compact()方法

一旦讀完Buffer中的數據，需要讓Buffer準備好再次被寫入。可以通過clear()或compact()方法來完成。

如果調用的是clear()方法，position將被設回0，limit被設置成 capacity的值。換句話說，Buffer 被清空了。Buffer中的數據并未清除，只是這些標記告訴我們可以從哪里開始往Buffer里寫數據。

如果Buffer中有一些未讀的數據，調用clear()方法，數據將“被遺忘”，意味著不再有任何標記會告訴你哪些數據被讀過，哪些還沒有。

如果Buffer中仍有未讀的數據，且后續還需要這些數據，但是此時想要先先寫些數據，那么使用compact()方法。

compact()方法將所有未讀的數據拷貝到Buffer起始處。然后將position設到最后一個未讀元素正后面。limit屬性依然像clear()方法一樣，設置成capacity。現在Buffer準備好寫數據了，但是不會覆蓋未讀的數據。

mark()與reset()方法

通過調用Buffer.mark()方法，可以標記Buffer中的一個特定position。之后可以通過調用Buffer.reset()方法恢復到這個position。例如：

1	buffer.mark();

2

?

3	//call buffer.get() a couple of times, e.g. during parsing.

4

?

5	buffer.reset();??//set position back to mark.

equals()與compareTo()方法

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

equals()

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

有相同的類型（byte、char、int等）。

Buffer中剩余的byte、char等的個數相等。

Buffer中所有剩余的byte、char等都相同。

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

compareTo()方法

compareTo()方法比較兩個Buffer的剩余元素(byte、char等)， 如果滿足下列條件，則認為一個Buffer“小于”另一個Buffer：

第一個不相等的元素小于另一個Buffer中對應的元素 。

所有元素都相等，但第一個Buffer比另一個先耗盡(第一個Buffer的元素個數比另一個少)。

?

緩沖區分片

　　在NIO中，除了可以分配或者包裝一個緩沖區對象外，還可以根據現有的緩沖區對象來創建一個子緩沖區，即在現有緩沖區上切出一片來作為一個新的緩沖區，但現有的緩沖區與創建的子緩沖區在底層數組層面上是數據共享的，也就是說，子緩沖區相當于是現有緩沖區的一個視圖窗口。調用slice()方法可以創建一個子緩沖區，讓我們通過例子來看一下：

package com.dxz.nio;import java.nio.ByteBuffer;public class BufferDemo1 {static public void main(String args[]) throws Exception {ByteBuffer buffer = ByteBuffer.allocate(10);// 緩沖區中的數據0-9for (int i = 0; i < buffer.capacity(); ++i) {buffer.put((byte) i);}// 創建子緩沖區buffer.position(3);buffer.limit(7);ByteBuffer slice = buffer.slice();// 改變子緩沖區的內容for (int i = 0; i < slice.capacity(); ++i) {byte b = slice.get(i);b *= 10;slice.put(i, b);}buffer.position(0);buffer.limit(buffer.capacity());while (buffer.remaining() > 0) {System.out.println(buffer.get());}} }

結果：

0 1 2 30 40 50 60 7 8 9

只讀緩沖區

只讀緩沖區非常簡單，可以讀取它們，但是不能向它們寫入數據。可以通過調用緩沖區的asReadOnlyBuffer()方法，將任何常規緩沖區轉 換為只讀緩沖區，這個方法返回一個與原緩沖區完全相同的緩沖區，并與原緩沖區共享數據，只不過它是只讀的。如果原緩沖區的內容發生了變化，只讀緩沖區的內容也隨之發生變化：

package com.dxz.nio;import java.nio.ByteBuffer;public class BufferDemo2 {static public void main(String args[]) throws Exception {ByteBuffer buffer = ByteBuffer.allocate(10);// 緩沖區中的數據0-9for (int i = 0; i < buffer.capacity(); ++i) {buffer.put((byte) i);}// 創建只讀緩沖區ByteBuffer readonly = buffer.asReadOnlyBuffer();// 改變原緩沖區的內容for (int i = 0; i < buffer.capacity(); ++i) {byte b = buffer.get(i);b *= 10;buffer.put(i, b);}readonly.position(0);readonly.limit(buffer.capacity());// 只讀緩沖區的內容也隨之改變while (readonly.remaining() > 0) {System.out.println(readonly.get());}} }

結果：

0 10 20 30 40 50 60 70 80 90

　　如果嘗試修改只讀緩沖區的內容，則會報ReadOnlyBufferException異常。只讀緩沖區對于保護數據很有用。在將緩沖區傳遞給某個 對象的方法時，無法知道這個方法是否會修改緩沖區中的數據。創建一個只讀的緩沖區可以保證該緩沖區不會被修改。只可以把常規緩沖區轉換為只讀緩沖區，而不能將只讀的緩沖區轉換為可寫的緩沖區。

直接緩沖區（DirectByteBuffer堆外緩存）

　　直接緩沖區是為加快I/O速度，使用一種特殊方式為其分配內存的緩沖區，JDK文檔中的描述為：給定一個直接字節緩沖區，Java虛擬機將盡最大努 力直接對它執行本機I/O操作。也就是說，它會在每一次調用底層操作系統的本機I/O操作之前(或之后)，嘗試避免將緩沖區的內容拷貝到一個中間緩沖區中 或者從一個中間緩沖區中拷貝數據。要分配直接緩沖區，需要調用allocateDirect()方法，而不是allocate()方法，使用方式與普通緩沖區并無區別，如下面的拷貝文件示例：

package com.dxz.nio;import java.io.FileInputStream; import java.io.FileOutputStream; import java.nio.ByteBuffer; import java.nio.channels.*;public class BufferDemo3 {static public void main(String args[]) throws Exception {String infile = "e:\\logs\\test.txt";FileInputStream fin = new FileInputStream(infile);FileChannel fcin = fin.getChannel();String outfile = String.format("e:\\logs\\testcopy.txt");FileOutputStream fout = new FileOutputStream(outfile);FileChannel fcout = fout.getChannel();// 使用allocateDirect，而不是allocateByteBuffer buffer = ByteBuffer.allocateDirect(1024);while (true) {buffer.clear();int r = fcin.read(buffer);if (r == -1) {break;}buffer.flip();fcout.write(buffer);}} }

內存映射文件I/O

　　內存映射文件I/O是一種讀和寫文件數據的方法，它可以比常規的基于流或者基于通道的I/O快的多。內存映射文件I/O是通過使文件中的數據出現為 內存數組的內容來完成的，這其初聽起來似乎不過就是將整個文件讀到內存中，但是事實上并不是這樣。一般來說，只有文件中實際讀取或者寫入的部分才會映射到內存中。如下面的示例代碼：

package com.dxz.nio;import java.io.RandomAccessFile; import java.nio.MappedByteBuffer; import java.nio.channels.*;public class BufferDemo4 {static private final int start = 0;static private final int size = 1024;static public void main(String args[]) throws Exception {RandomAccessFile raf = new RandomAccessFile("e:\\logs\\test.txt", "rw");FileChannel fc = raf.getChannel();MappedByteBuffer mbb = fc.map(FileChannel.MapMode.READ_WRITE, start, size);mbb.put(0, (byte) 97);mbb.put(1023, (byte) 122);raf.close();} }

?參考：http://blog.csdn.net/wuxianglong/article/details/6612263

轉載于:https://www.cnblogs.com/duanxz/p/6759833.html

總結

以上是生活随笔為你收集整理的Java NIO系列教程（五）Buffer的全部內容，希望文章能夠幫你解決所遇到的問題。

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