Java NIO-Buffer

原创文章：Java NIO-Buffer – 编程屋

1 概述

Java NIO中的Buffer用于和NIO通道进行交互。数据是从通道进入缓冲区，从缓冲区写入通道中的。缓冲区本质上是一块可以写入数据，然后可以从中读取数据的内存。这块内存被包装成了NIO Buffer对象。在NIO中所有的数据都是用缓冲区处理的。

2 Buffer

2.1 Buffer的使用

使用Buffer一般步骤：

第一步：写入数据到Buffer

第二步：调用flip()

第三步：从Buffer中读取数据

第四步：调用clear()或者compact方法

注意：读取数据时，需要调用flip()方法将Buffer从写模式切换到读模式，可以读取之前写入到buffer中的所有数据。数据读取完成后，需要清空缓冲区，让他再次被写入。清空缓冲区的方法有两种,clear()会清空整个缓冲区。compact()只会清空已经读过的数据。任何位读的数据都会放在缓存区的起始处，新写入的数据将放到缓冲区未读数据的后面。

测试代码:

 public static void main(String[] args) throws Exception {
        //创建FileChannel
        RandomAccessFile accessFile = new RandomAccessFile("C:\\Users\\LiuBuJun\\Desktop\\liubujun\\01.txt","rw");
        FileChannel channel = accessFile.getChannel();

        //创建buffer
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        //读取数据到buffer中
        int bytesRead = channel.read(buffer);
        // bytesRead = -1 表示到达文件末尾
        while (bytesRead != -1 ) {
            //将数据从buffer取出来 .flip()反转读写模式
            buffer.flip();

            while (buffer.hasRemaining()) {
                System.out.println((char)buffer.get());
            }
            //清除缓存区内容
            buffer.clear();
            bytesRead =  channel.read(buffer);
        }
        accessFile.close();
        System.out.println("over");
    }

测试结果:

2.2 Buffer的三个属性

1）capacity: 作为一个内存块，Buffer有一个固定大小的值。你只能向里面写capacity个byte、long、char等类型。一旦Buffer满了，需要将其清空(需要读数据或者清楚数据)才能继续写数据。

2）position：

        写数据到buffer时，position表示写入数据的当前位置，position的初始值为0。当一个byte、long等数据写到buffer后，position会向下移动到下一个可插入数据的Buffer。

        读数据到buffer时，position表示读入数据的当前位置，如position = 2时表示已经开始读入了3个byte，或从第3个byte开始读取。通过ByteBuffer.flip()切换到读模式时会被重置为0，当Buffer从position读入数据后，position会下移到下一个可读入数据的Buffer单元。

3）limit: 

        写数据时，表示可对Buffer最多写入多少数据。写模式下，limit等于Buffer的capacity。

        读数据时，limit表示Buffer里有多少可读数据，因此能读到之前写入的所有数据

2.3 Buffer分配和写数据

1）Buffer分配

要想或得一个Buffer对象首先要进行分配。每一个Buffer类都有一个allocate方法

//分配1024字节capacity的ByteBuffer的例子
ByteBuffer buffer = ByteBuffer.allocate(1024);

2）向Buffer中写数据

从Channel写到Buffer：

int bytesRead = channel.read(buffer);

通过put方法写入方法：

buffer.put(124)

3）从Buffer中读取数据

从buffer读取数据到channel：

int bytesRead = channel.write(buffer);

使用get()方法从Buffer中读取数据

byte aByte = buffer.get();

2.4 Buffer的几个方法

1）flip()方法

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

2）rewind()

Buffer.rewind()将position设为0，所以可以重读Buffer中所有数据。limit保持不变，依然表示能从buffer中读取多少个元素

3）clear()与compact()方法

一旦读完buffer中的所有数据，需要让Buffer准备好再次被写入，可以通过clear()或compact方法来完成

如果调用的是clear方法，position将被设为0，limit被设为capacity的值，换句话说，Buffer被清空了。Buffer中的数据并为清除，只是标记我们可以从哪里开始往Buffer里写数据。

如果调用clear()方法 ，此时Buffer中还有一些未读的数据时，数据将会遗忘，不会有任何标记告诉你哪些数据被读过，哪些还没有

如果Buffer中还有未读的数据，且后续还需要这些数据，但是此时还要写数据，那么使用compact()方法

compact（）方法会将所有未读的数据拷贝到Buffer起始处。然后将position设到最后一个未读元素后面。limit属性依然会像clear()方法一样，设置成capacity。现在buffer准备写数据但不会覆盖未读的数据。

4）mark（）与reset（）方法

通过调用Buffer.mark()方法，可以标记方法中一个特定的position。之后可以调用Buffer.reset()方法恢复到position

3 缓冲区操作

3.1 缓冲区分片

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

代码演示：

@Test
    public void test1(){
        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());
        }


    }

测试结果：

 3.2 只读缓冲区

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

    @Test
    public void test2(){
        ByteBuffer buffer = ByteBuffer.allocate(10);
        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());
        }
    }

 3.3 直接缓冲区

直接缓冲区是为了加快I/O速度，使用一种特殊的方式为其分配内存的缓冲区。jdk文档描述为：给定一个直接的字符缓冲区，Java虚拟机将尽自己最大努力直接对他执行本机的IO操作。要分配直接缓冲区，需要调用allocateDirect方法，而不是allocate()方法

    @Test
    public void test3() throws Exception {
        String infile = "C:\\Users\\LiuBuJun\\Desktop\\liubujun\\01.txt";
        FileInputStream fin = new FileInputStream(infile);
        FileChannel fileChannel = fin.getChannel();

        String outfile = "C:\\Users\\LiuBuJun\\Desktop\\liubujun\\02.txt";
        FileOutputStream out = new FileOutputStream(outfile);
        FileChannel foutChannel = out.getChannel();

        //创建直接缓冲区
        ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
        while (true) {
            buffer.clear();
            int r = fileChannel.read(buffer);
            if (r == -1 ) {
                break;
            }
            buffer.flip();
            foutChannel.write(buffer);
        }
    }

此时已经将01文件中的内容复制到了02中。

3.4 内存映射文件I/O

内存映射文件I/O是一种读和写文件数据的方法，它可以比常规的基于流或者基于通道的I/O快的多。内存映射I/O是通过使文件中的数据出现为内存数组的内容来完成的，这其初听起来似乎不过就是将整个文件读到内存中，但事实并不是这样。一般来说，只有文件中实际读取或者写入的部分才会映射到内存中。

    @Test
    public void test4() throws Exception {
        //创建FileChannel
        RandomAccessFile accessFile = new RandomAccessFile("C:\\Users\\LiuBuJun\\Desktop\\liubujun\\01.txt","rw");
        FileChannel channel = accessFile.getChannel();

        MappedByteBuffer map = channel.map(FileChannel.MapMode.READ_WRITE, start, size);
        map.put(0,(byte) 97);
        map.put(1023,(byte) 122);
        accessFile.close();
    }

以上只是部分内容，为了维护方便，本文已迁移到新地址：Java NIO-Buffer – 编程屋