Buffer

1. Buffer 简介

Java NIO中的Buffer用于和NIO通道进行交互。数据是从通道读入缓冲区，从缓冲区写入到通道中的。 缓冲区本质上是一块可以读写数据的内存。这块内存被包装成NIO Buffer对象，并提供了一组方法，用来方便的访问该块内存。Buffer底层就是一个数组，在NIO库中，所有数据都是用缓冲区处理的。在读取数据时，它是直接读到缓冲区中的； 在写入数据时，它也是写入到缓冲区中的；任何时候访问NIO中的数据，都是将它放到缓冲区中。而在面向流 I/O系统中，所有数据都是直接写入或者直接将数据读取到 Stream 对象中。 在NIO中，所有的缓冲区类型都继承于抽象类 Buffer，最常用的就是ByteBuffer，对于Java中的基本类型，基本都有一个具体Buffer类型与之相对应，它们之间的继承关系如下图所示：

2. Buffer 的基本用法

2.1 使用 Buffer 读写数据

一般遵循以下四个步骤：

1. 写入数据到 Buffer
2. 调用 flip()方法
3. 从 Buffer 中读取数据
4. 调用clear()方法或者compact()方法
   当向buffer写入数据时，buffer会记录下写了多少数据。一旦要读取数据，需要通过flip()方法将Buffer从写模式切换到读模式。在读模式下，可以读取之前写入到buffer的所有数据。一旦读完了所有的数据，就需要清空缓冲区，让它可以再次被写入。有两种方式能清空缓冲区：调用clear()或compact()方法。clear()方法会清空整个缓冲区。compact()方法只会清除已经读过的数据。任何未读的数据都被移到缓冲区的起始处，新写入的数据将放到缓冲区未读数据的后面。

3. ByteBuffer

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 + " ");
    }
}

3. Buffer的重要属性

为了记录读写的状态和位置，Buffer类提供三个重要的属性：capacity(容量)、position(读写位置)和limit(读写的限制)。
position和limit的含义取决于Buffer处在读模式还是写模式。不管Buffer处在什么模式，capacity的含义总是一样的,表示buffer的大小容量。需要注意的是一旦 Buffer初始化，就不能再改变capacity。

3.1 Buffer写模式

• position表示写入数据的当前位置，position的初始值为0，position最大可为capacity–1。
• limit表示可对Buffer最多可以写入多少数据。limit最大等于capacity。

3.2 Buffer读模式

• position为0，最大值为limit。
• limit表示Buffer里有多少可读数据量。

3.3 Buffer写模式切换读模式

• position会被重置为0
• limit变成position值

提示

Buffer的读写模式具体如何切换
当新建了一个缓冲区实例时，缓冲区处于写模式，这时是可以写数据的。在数据写入完成后，如果要从缓冲区读取数据，就要进行模式的切换，可以调用flip()方法将缓冲区变成读模式，flip为翻转的意思。

4. Buffer分配和写数据

4.1 Buffer分配

要想获得一个Buffer对象首先要进行分配。 每一个Buffer类都有一个allocate()。

// 分配 48 字节 capacity 的 ByteBuffer
ByteBuffer buf = ByteBuffer.allocate(48);   
// 分配一个可存储 1024 个字符的 CharBuffer
CharBuffer buf = CharBuffer.allocate(1024);

4.2 向Buffer中写数据

写数据到Buffer有两种方式：

• 从Channel写到Buffer
• 通过Buffer的put()方法写到Buffer里

// 从通道里面读数据到Buffer里面
int bytesRead = inChannel.read(buf); 
// 通过 put 方法写 Buffer
buf.put(127);

4.3 从Buffer中读取数据

从Buffer中读取数据有两种方式：

• 从Buffer读取数据到Channel。
• 使用get()方法从Buffer中读取数据。

//从 Buffer 读取数据到 Channel
int bytesWritten = inChannel.write(buf);
// 使用 get()方法从 Buffer 中读取数据
byte aByte = buf.get();
// 读取位置1数据
buffer.get(1);
// 读取多个位置数据
int[] posArray = {3,6,7};
IntBuffer subBuffer = buffer.get(posArray);

5. Buffer的常见API

5.1 rewind()

Buffer.rewind()将position设回0，用来在读模式下重读Buffer中的所有数据。

5.2 flip()

flip方法将Buffer从写模式切换到读模式。调用flip()方法会将position设回0，limit值设置成之前position的值。

5.3 clear()

position将被设回0，limit被设置成capacity的值。换句话说，Buffer被清空了。Buffer中的数据并未清除，只是这些标记告诉我们可以从哪里开始往Buffer里写数据。

5.4 compact()

如果Buffer中仍有未读的数据，且后续还需要这些数据，但是此时想要先先写些数据，那么使用compact()方法。compact()方法将所有未读的数据拷贝到 Buffer 起始处。然后将position设到最后一个未读元素后面。limit 属性依然像 clear()方法一样，设置成capacity。

5.5 mark()

在缓冲区操作过程当中，可以将当前的position值临时存入mark属性中；需要的时候，再从mark中取出暂存的标记值，恢复到position属性中，重新从position位置开始处理。

5.6 reset()

配合mark()方法使用， 通过调用Buffer.reset()方法恢复到mark()标记的position。

6. 缓冲区操作

6.1 缓冲区分片

可以根据现有的缓冲区对象来创建一个子缓冲区，即在现有缓冲区上切出一片来作为一个新的缓冲区，但现有的缓冲区与创建的子缓冲区在底层数组层面上是数据共享的，也就是说，子缓冲区相当于是现有缓冲区的一个视图窗口。调用 slice()方法可以创建一个子缓冲区。

@Test
public void testSlice() throws IOException {
    ByteBuffer buffer = ByteBuffer.allocate(10);
    // 缓冲区中的数据 0-9
    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());
    }
}

运行结果：

6.2 只读缓冲区

只读缓冲区可以读取它们，但是不能向它们写入数据。通过调用缓冲区的asReadOnlyBuffer()方法，将任何常规缓冲区转 换为只读缓冲区，这个方法返回一个与原缓冲区完全相同的缓冲区，并与原缓冲区共享数据，只不过它是只读的。如果原缓冲区的内容发生了变化，只读缓冲区的内容也随之发生变化。

@Test
public void testReadOnly() {
    ByteBuffer buffer = ByteBuffer.allocate(10);
    // 缓冲区中的数据 0-9
    for (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());
    }
}

如果尝试修改只读缓冲区的内容，则会报ReadOnlyBufferException异常。

6.3 直接缓冲区

直接缓冲区是为加快I/O速度，给定一个直接字节缓冲区，Java虚拟机将尽最大努力直接对它执行本机I/O 操作。也就是说它会在每一次调用底层操作系统的本机I/O操作之前(或之后)，尝试避免将缓冲区的内容拷贝到一个中间缓冲区中 或者从一个中间缓冲区中拷贝数据。要分配直接缓冲区。 拷贝文件示例:

@Test
public void testFastBuffer() throws IOException {
    String infile = "d:\\jack\\01.txt";
    FileInputStream fin = new FileInputStream(infile);
    FileChannel fcin = fin.getChannel();
    String outfile = String.format("d:\\jack\\02.txt");
    FileOutputStream fout = new FileOutputStream(outfile);
    FileChannel fcout = fout.getChannel();
    // 使用 allocateDirect，而不是 allocate
    ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
    while (true) {
        buffer.clear();
        int r = fcin.read(buffer);
        if (r == -1) {
            break;
        }
        buffer.flip();
        fcout.write(buffer);
    }
}

6.4 内存映射文件I/O

内存映射文件I/O是一种读和写文件数据的方法，它可以比常规的基于流或者基于通道的I/O快的多。内存映射文件I/O是通过使文件中的数据出现为内存数组的内容来完成的，只有文件中实际读取或者写入的部分才会映射到内存中。

static private final int start = 0;
static private final int size = 1024;
static public void main(String args[]) throws Exception {
    RandomAccessFile raf = new RandomAccessFile("d:\\jack\\01.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();
}