Java NIO中的Buffer 详解

Java NIO中的Buffer用于和NIO通道进行交互。如你所知，数据是从通道读入缓冲区，从缓冲区写入到通道中的。缓冲区本质上是一块可以写入数据，然后可以从中读取数据的内存。这块内存被包装成NIO Buffer对象，并提供了一组方法，用来方便的访问该块内存。

Buffer的基本用法
使用Buffer读写数据一般遵循以下四个步骤：

写入数据到Buffer
    调用flip()方法
    从Buffer中读取数据
    调用clear()方法或者compact()方法

当向buffer写入数据时，buffer会记录下写了多少数据。一旦要读取数据，需要通过flip()方法将Buffer从写模式切换到读模式。在读模式下，可以读取之前写入到buffer的所有数据。

一旦读完了所有的数据，就需要清空缓冲区，让它可以再次被写入。有两种方式能清空缓冲区：调用clear()或compact()方法。clear()方法会清空整个缓冲区。compact()方法只会清除已经读过的数据。任何未读的数据都被移到缓冲区的起始处，新写入的数据将放到缓冲区未读数据的后面。

下面是一个使用Buffer的例子：
Java代码  收藏代码

RandomAccessFile aFile = new RandomAccessFile("data/nio-data.txt", "rw");
    FileChannel inChannel = aFile.getChannel();  

    //create buffer with capacity of 48 bytes
    ByteBuffer buf = ByteBuffer.allocate(48);  

    int bytesRead = inChannel.read(buf); //read into buffer.
    while (bytesRead != -1) {  

      buf.flip();  //make buffer ready for read  

      while(buf.hasRemaining()){
          System.out.print((char) buf.get()); // read 1 byte at a time
      }  

      buf.clear(); //make buffer ready for writing
      bytesRead = inChannel.read(buf);
    }
    aFile.close();

Buffer的capacity,position和limit
缓冲区本质上是一块可以写入数据，然后可以从中读取数据的内存。这块内存被包装成NIO Buffer对象，并提供了一组方法，用来方便的访问该块内存。

为了理解Buffer的工作原理，需要熟悉它的三个属性：

capacity
    position
    limit

position和limit的含义取决于Buffer处在读模式还是写模式。不管Buffer处在什么模式，capacity的含义总是一样的。

这里有一个关于capacity，position和limit在读写模式中的说明，详细的解释在插图后面。
aaarticlea/png;base64,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" alt="" />

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

如你所见，这些Buffer类型代表了不同的数据类型。换句话说，就是可以通过char，short，int，long，float 或 double类型来操作缓冲区中的字节。MappedByteBuffer 有些特别。

Buffer的分配
要想获得一个Buffer对象首先要进行分配。 每一个Buffer类都有一个allocate方法。下面是一个分配48字节capacity的ByteBuffer的例子。
ByteBuffer buf = ByteBuffer.allocate(48);
这是分配一个可存储1024个字符的CharBuffer：
CharBuffer buf = CharBuffer.allocate(1024);

向Buffer中写数据
写数据到Buffer有两种方式：
从Channel写到Buffer。
通过Buffer的put()方法写到Buffer里。
从Channel写到Buffer的例子
int bytesRead = inChannel.read(buf); //read into buffer.
通过put方法写Buffer的例子：
buf.put(127);
put方法有很多版本，允许你以不同的方式把数据写入到Buffer中。例如， 写到一个指定的位置，或者把一个字节数组写入到Buffer。 更多Buffer实现的细节参考JavaDoc。

flip()方法
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。例如：

Java代码  收藏代码

buffer.mark();  
    //call buffer.get() a couple of times, e.g. during parsing.  
    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的元素个数比另一个少)。
（译注：剩余元素是从 position到limit之间的元素）