Java NIO 中Buffer 緩衝區解析

2022-02-09 13:00:02

一、Buffer 簡介

Java NIO 中的 Buffer 用於和 NIO 通道進行互動。資料是通道讀取到緩衝區

緩衝區本質上是一塊可以寫入資料，然後可以從中讀取資料的記憶體。這塊記憶體被包裝 NIO Buffer 物件，並且提供了一組方法，用來方便的存取這塊記憶體。緩衝區世紀上一個容器物件，更直接的說，其實就是一個陣列，在 NIO 庫中，所有資料都是用緩衝區處理的。在讀取資料時，它直接讀到緩衝區中；在寫資料時，它也是寫入到緩衝區中的；任何時候存取 NIO 中的資料，都是將它放到緩衝區中。而在面向流 I/O 系統中，所有資料都是直接寫入或者直接將資料讀取到 Stream 物件中。

在 NIO 中，所有的緩衝區型別都是繼承於抽象類 Buffer, 最常用的就是 ByteBuffer. 對於 Java 中國呢的基本型別，金額都有一個具體 Buffer 型別與之對應，他們之間的繼承關係如下圖所示：

二、Buffer 的基本方法

1、使用 Buffer 讀寫資料

使用 Buffer 讀寫資料，一般遵循以下四個步驟：

（1）寫資料到 Buffer

（2）呼叫flip() 方法

（3）從 Buffer 中讀取資料

（4）呼叫 clear() 方法或者 compact() 方法

當向 buffer 寫資料時，buffer 會記錄下寫了多少資料。一旦要讀資料，需要通過 flip() 方法將 buffer 從寫模式切換到讀模式。在讀模式下，可以讀取到之前寫入到 buffer 的所有資料。一旦讀完了所有的資料，就需要清空緩衝區，讓它可以再次被寫入。有兩種方式能清空緩衝區：呼叫 clear() 或者 compact() 方法。clear() 方法會清空整個緩衝區。compact() 方法只會清除已經度過的資料。任何未讀取的資料都被移動到了緩衝區的起始處，新寫的資料將放到緩衝區未讀資料的後面。

2、使用 Buffer 的例子

@Test
public void buffer01() throws IOException {
    // FileChannel
    String pathName = "/Users/zhengsh/sourcecode.io/zhengsh-vvip/nio/src/main/resources/01.txt";
    RandomAccessFile accessFile =
        new RandomAccessFile(pathName, "rw");
    FileChannel channel = accessFile.getChannel();

    // 建立 buffer , 大小
    ByteBuffer buffer = ByteBuffer.allocate(1024);

    // 讀
    int bytesRead = channel.read(buffer);
    while (bytesRead != -1) {
        // read 模式
        buffer.flip();

        while (buffer.hasRemaining()) {
            System.out.println((char) buffer.get());
        }
        buffer.clear();

        channel.read(buffer);
    }

    accessFile.close();
}


@Test
public void buffer02() {

    // 建立 buffer
    IntBuffer buffer = IntBuffer.allocate(8);
    for (int i = 0; i < buffer.capacity(); i++) {
        int j = 2 * (i + 1);
        buffer.put(j);
    }

    // 重置緩衝區
    buffer.flip();

    while (buffer.hasRemaining()) {
        int value = buffer.get();
        System.out.println(value + "  ");
    }
}

三、Buffer 的 capactity、posittion 和limit

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

capacity
ponstition
limit

position 和 limit 的含義取決於 Buffer 處在讀模式還是寫模式。不管 buffer 處於什麼模式，capactity 的含義總是一樣的。

這裡有一個關於 capacity, postition 和 limit 在讀模式中的說明:

(1) capactiy

作為一個記憶體塊，Buffer 有一個固定的大小值，也叫做 “capactiy” . 你只能往裡面寫 capacity 個 byte

long、 char等型別。一旦 buffer 滿了，需要將其清空（通過讀資料或者清除資料）才能繼續寫資料往裡寫資料。

(2) postition

1）寫資料到 Bufer 中時，position 表示寫入資料的當前位置，position 的初始值為 0 。當一個 byte,long,等資料寫入到 buffer 後，position 會向下移動到下一個可插入的元素的 buffer 但願。position 最大可為 capacity -1 （因為 position 的初始值為 0）

2）讀資料到 Buffer 中時，position 表示讀資料的當前位置，如 position = 2 時表示已經開始讀了 3 個 byte，或者從第三個 byte 開始讀取，通過 ByteBuffer.flip() 切換到讀模式 position 會被重置為 0，當 Buffer 從 position 讀入資料後，position 會下移到下一個可讀入的資料 Buffer 單元。

(3) limit

1）寫資料時， limit 表示可以對 Buffer 最多寫入多少個資料。寫模式下，limit 等於 Buffer 的 capactiy

2）讀資料時， limit 表示 Buffer 裡有多少可讀資料（not null 的資料），因此能讀取到之前寫入的所有資料（limit 被設定為已寫資料的數量，這個值在寫模式下就是 position）

四、Buffer 的型別

Java NIO 有一下 Buffer 的型別

ByteBuffer
MappedByteBuffer
CharBuffer
DoubleBuffer
FloatBuffer
LongBuffer
ShortBuffer

這些 buffer 型別都代表了不同的資料型別。換句話說，就是可以通過 char ，short, int, long , float 或者 double 型別來操作緩衝區的位元組。

五、Buffer 分配和寫資料

1、 Buffer 分配

想要獲取一個 Buffer 物件首先要進行分配。每一個 Buffer 類都有一個 allocate 方法。

下面是一個分配 48 位元組 capactiy 的 ByteBuffer 的例子。

ByteBuffer buf = ByteBuffer.alloacte(48);

這是分配一個可儲存 1024 個字元的 CharBuffer:

ByteBuffer buf = ByteBuffer.alloacte(1024);

2、向 buffer 中寫資料

寫資料到 Buffer 有兩種方式：

（1）從 channel 寫到 Buffer
（2）通過 Buffer 的 put 方法寫到 Buffer 裡。

從 Channel 寫到 Buffer 的例子

int byteRead = channel.read(buf); // read into buffer

通過 put 方法寫入 buffer 的例子：

buf.put(100);

put 的方法有很多版本，允許你不同的方式把資料寫入到 buffer 中，例如，寫到一個指定的位置，或者把位元組陣列寫入到 Buffer .

3、flip() 方法

flip 方法將 Buffer 從寫模式切換到讀模式。呼叫 flip() 方法將會 position 設定為 0 ，並且將 limt 設定為之前 position 的值。換句話說，position 現在用於標記讀的位置，limit 表示之前寫進了多少個 byte, char 等（現在能讀取多少個 byte, char 等）。

六、從 Buffer 中讀取資料

從 Buffer 中讀取資料到 Channel 中：

（1）從 Buffer 中讀取資料到 Channel

（2）使用 get 方法從 Buffer 中讀取資料

從 Buffer 中讀取資料到 Channnel 到例子：

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

使用 get() 方法從 Buffer 中讀取資料的例子：

byte aByte = buf.get();

get 方法中有很多版本，允許你以不同的方式 Buffer 中讀取資料。例如，從指定 position 讀取，或者從 Buffer 中讀取到位元組陣列。

七、Buffer 幾個方法

1、rewind() 方法

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

2、clear() 與 compact() 方法

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

如果呼叫的是 cleanr () 方法，position 兼備設定為 0 ， limit 被設定成 capactiy 的值。換句話說，Buffer 被清空了。 Buffer 中的資料並未清除，只是這些標記高數我們從哪裡開始往 Buffer 中寫資料。

如果 Buffer 中有些數未讀的資料，呼叫 clear() 方法，資料將 “被遺忘”，意味著不在有任何標記會告訴你那些資料被讀過，那些還沒有。

如果 Buffer 中依然有未讀的資料，且後續還需要這些資料，但是此時想要先寫這些資料，那麼使用 compact() 方法。

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

3、mark() 與 reset() 方法

通過呼叫 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

八、緩衝區操作

1、緩衝區分片

在 NIO 中除了可以分配或者包裝一個緩衝區物件外，還可以更具現有的緩衝區物件來建立一個子緩衝區，即現有緩衝區上切出一片來作為一個新的緩衝區，但現有的緩衝區與建立的子緩衝區在底層陣列層面上是資料共用的，也就是說，子緩衝區相當於是現有緩衝區的一個檢視視窗。呼叫 slice() 方法可以建立一個子緩衝區。

// 緩衝區分片
@Test
public void b01() {
    ByteBuffer buffer = ByteBuffer.allocate(10);
    // 放入資料
    for (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());
    }
}

輸出結果如下：

2、唯讀緩衝區

唯讀緩衝區非常簡單，可以讀取他們，但是不能向他們寫入資料。可以通過呼叫緩衝區的 asReadOnlyBufer() 方法，將任何常規緩衝區轉換為唯讀緩衝區，這個方法返回一個與原緩衝區完全相同的緩衝區，並與原緩衝區共用資料，只不過它是唯讀的。如果原緩衝區的內容發生了變化，唯讀緩衝區的內容隨之發生變化：

// 唯讀緩衝區
@Test
public void b02() {
    ByteBuffer buffer = ByteBuffer.allocate(10);

    // 放入資料
    for (int i = 0; i < buffer.capacity(); i++) {
        buffer.put((byte) i);
    }

    // 建立一個唯讀緩衝區
    ByteBuffer readOnlyBuf = buffer.asReadOnlyBuffer();
    for (int i = 0; i < buffer.capacity(); i++) {
        byte b = buffer.get(i);
        b *= 10;
        buffer.put(i, b);
    }

    readOnlyBuf.position(0);
    readOnlyBuf.limit(readOnlyBuf.capacity());

    while (readOnlyBuf.remaining() > 0) {
        System.out.println(readOnlyBuf.get());
    }
}

3、直接緩衝區

直接緩衝區為了加快 I/O 速度，使用一種特殊的方式為其分配記憶體的緩衝區， JDK 檔案的描述為：給定一個直接位元組緩衝區，Java 虛擬機器器將盡最大努力直接對它執行本機 I/O 操作之前（或之後），嘗試避免將緩衝區的內容拷貝到一箇中間緩衝區中或者從一箇中間緩衝區中拷貝資料。要分配直接緩衝區，需要調 allocatieDirect() 方法，而不是 alloacte() 方法，使用方式與普通緩衝區並無區別。

// 直接緩衝區，檔案拷貝
@Test
public void b03() throws IOException {
    String filePath = "/xx/01.txt";
    FileInputStream inputStream = new FileInputStream(filePath);
    FileChannel fileInChannel = inputStream.getChannel();

    String outPath = "/xx/02.txt";
    FileOutputStream outputStream = new FileOutputStream(outPath);
    FileChannel fileOutChannel1 = outputStream.getChannel();

    //  使用 allocateDirect , 而不是 allocate
    ByteBuffer buffer = ByteBuffer.allocateDirect(1024);

    while (true) {
        buffer.clear();
        int r = fileInChannel.read(buffer);
        if (r == -1) {
            break;
        }
        buffer.flip();
        fileOutChannel1.write(buffer);
    }
    fileInChannel.close();
    fileOutChannel1.close();
}

4、記憶體對映檔案 I/O

記憶體對映檔案 I/O 是一種讀和寫檔案資料的方法，它可以比常規的基於流或者通道的 I/O 快得多。記憶體對映 I/O 是通過使檔案中的資料出現為記憶體陣列的內容來完成的，這起初聽起來師傅不過就是為了將整個檔案讀取到內容中，但是事實上並不是這樣的。一般來說只有檔案實際讀取或者寫入的部分才會對映到記憶體中。

// 記憶體對映檔案 I/O 
@Test
public void b04() throws IOException {
    String filePath = "/xxx/01.txt";
    RandomAccessFile randomAccessFile = new RandomAccessFile(filePath, "rw");
    FileChannel fileChannel = randomAccessFile.getChannel();
    MappedByteBuffer mappedByteBuffer = fileChannel.map(FileChannel.MapMode.READ_WRITE, 0, 1024);
    mappedByteBuffer.put(0, (byte) 97);
    mappedByteBuffer.put(1023, (byte) 122);
    fileChannel.close();
}

到此這篇關於Java NIO 中Buffer 緩衝區解析的文章就介紹到這了,更多相關Java NIO 中Buffer 緩衝區內容請搜尋it145.com以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援it145.com！