Buffer其实就是是一个容器对象，它包含一些要写入或者刚读出的数据。在NIO中加入Buffer对象，体现了新库与原I/O的一个重要区别。在面向流的I/O中，您将数据直接写入或者将数据直接读到Stream对象中。

在NIO库中，所有数据都是用缓冲区处理的。在读取数据时，它是直接读到缓冲区中的。在写入数据时，它是写入到缓冲区中的。任何时候访问NIO中的数据，您都是将它放到缓冲区中。

缓冲区实质上是一个数组。通常它是一个字节数组，但是也可以使用其他种类的数组。但是一个缓冲区不仅仅是一个数组。缓冲区提供了对数据的结构化访问，而且还可以跟踪系统的读/写进程。

最常用的缓冲区类型是ByteBuffer。 一个ByteBuffer可以在其底层字节数组上进行get/set操作(即字节的获取和设置)。

ByteBuffer不是NIO中唯一的缓冲区类型。事实上，对于每一种基本Java类型都有一种缓冲区类型(只有boolean类型没有其对应的缓冲区类)：

ByteBuffer

CharBuffer

ShortBuffer

IntBuffer

LongBuffer

FloatBuffer

DoubleBuffer

每一个Buffer类都是Buffer接口的一个实例。 除了ByteBuffer， 每一个Buffer类都有完全一样的操作，只是它们所处理的数据类型不一样。因为大多数标准I/O操作都使用ByteBuffer，所以它具有所有共享的 缓冲区操作以及一些特有的操作。我们来看一下Buffer的类层次图吧：

每个 Buffer 都有以下的属性：

capacity

这个 Buffer 最多能放多少数据。 capacity 一般在 buffer 被创建的时候指定。

limit

在 Buffer 上进行的读写操作都不能越过这个下标。当写数据到 buffer 中时， limit 一般和 capacity 相等，当读数据时， limit 代表 buffer 中有效数据的长度。

position

position变量跟踪了向缓冲区中写入了多少数据或者从缓冲区中读取了多少数据。

更确切的说，当您从通道中读取数据到缓冲区中时，它指示了下一个数据将放到数组的哪一个元素中。比如，如果您从通道中读三个字节到缓冲区中，那么缓冲区的 position将会设置为3，指向数组中第4个元素。反之，当您从缓冲区中获取数据进行写通道时，它指示了下一个数据来自数组的哪一个元素。比如，当您 从缓冲区写了5个字节到通道中，那么缓冲区的 position 将被设置为5，指向数组的第六个元素。

mark

一个临时存放的位置下标。调用 mark() 会将 mark 设为当前的 position 的值，以后调用 reset() 会将 position 属性设置为 mark 的值。 mark 的值总是小于等于 position 的值，如果将 position 的值设的比 mark 小，当前的 mark 值会被抛弃掉。

这些属性总是满足以下条件：

0 <= mark <= position <= limit <= capacity

缓冲区的内部实现机制：

下面我们就以数据从一个输入通道拷贝到一个输出通道为例，来详细分析每一个变量，并说明它们是如何协同工作的：

初始变量：

我们首先观察一个新创建的缓冲区，以ByteBuffer为例，假设缓冲区的大小为8个字节，ByteBuffer初始状态如下：

回想一下 ，limit决不能大于capacity，此例中这两个值都被设置为8。我们通过将它们指向数组的尾部之后(第8个槽位)来说明这点。

我们再将position设置为0。表示如果我们读一些数据到缓冲区中，那么下一个读取的数据就进入 slot 0。如果我们从缓冲区写一些数据，从缓冲区读取的下一个字节就来自slot 0。position设置如下所示：

由于缓冲区的最大数据容量capacity不会改变，所以我们在下面的讨论中可以忽略它。

第一次读取：

现在我们可以开始在新创建的缓冲区上进行读/写操作了。首先从输入通道中读一些数据到缓冲区中。第一次读取得到三个字节。它们被放到数组中从 position开始的位置，这时position被设置为0。读完之后，position就增加到了3，如下所示，limit没有改变。

第二次读取：

在第二次读取时，我们从输入通道读取另外两个字节到缓冲区中。这两个字节储存在由position所指定的位置上， position因而增加2，limit没有改变。

flip：

现在我们要将数据写到输出通道中。在这之前，我们必须调用flip()方法。 其源代码如下：

    public final Buffer flip()
    {
        limit = position;
        position = 0;
        mark = -1;
        return this;
    }

这个方法做两件非常重要的事：

i  它将limit设置为当前position。

ii 它将position设置为0。

上一个图显示了在flip之前缓冲区的情况。下面是在flip之后的缓冲区：

我们现在可以将数据从缓冲区写入通道了。position被设置为0，这意味着我们得到的下一个字节是第一个字节。limit已被设置为原来的position，这意味着它包括以前读到的所有字节，并且一个字节也不多。

第一次写入：

在第一次写入时，我们从缓冲区中取四个字节并将它们 写入输出通道。这使得position增加到4，而limit不变，如下所示：

第二次写入：

我们只剩下一个字节可写了。limit在我们调用flip()时被设置为5，并且position不能超过limit。 所以最后一次写入操作从缓冲区取出一个字节并将它写入输出通道。这使得position增加到5，并保持limit不变，如下所示：

clear：

最后一步是调用缓冲区的clear()方法。这个方法重设缓冲区以便接收更多的字节。其源代码如下：

    public final Buffer clear()
    {
        osition = 0;
        limit = capacity;
        mark = -1;
        return this;
    }

clear做两种非常重要的事情：

i 它将limit设置为与capacity相同。

ii 它设置position为0。

下图显示了在调用clear()后缓冲区的状态， 此时缓冲区现在可以接收新的数据了。

至此，我们只是使用缓冲区将数据从一个通道转移到另一个通道，然而，程序经常需要直接处理数据。例如，您可能需要将用户数据保存到磁盘。在这种情况下，您必须将这些数据直接放入缓冲区，然后用通道将缓冲区写入磁盘。 或者，您可能想要从磁盘读取用户数据。在这种情况下，您要将数据从通道读到缓冲区中，然后检查缓冲区中的数据。实际上，每一个基本类型的缓冲区都为我们提供了直接访问缓冲区中数据的方法，我们以ByteBuffer为例，分析如何使用其提供的get()和put()方法直接访问缓冲区中的数据。

a)    get()

ByteBuffer类中有四个get()方法：

byte get();
ByteBuffer get( byte dst[] );
ByteBuffer get( byte dst[], int offset, int length );
byte get( int index );

第一个方法获取单个字节。第二和第三个方法将一组字节读到一个数组中。第四个方法从缓冲区中的特定位置获取字节。那些返回ByteBuffer的方法只是返回调用它们的缓冲区的this值。 此外，我们认为前三个get()方法是相对的，而最后一个方法是绝对的。“相对”意味着get()操作服从limit和position值，更明确地说， 字节是从当前position读取的，而position在get之后会增加。另一方面，一个“绝对”方法会忽略limit和position值，也不会 影响它们。事实上，它完全绕过了缓冲区的统计方法。
上面列出的方法对应于ByteBuffer类。其他类有等价的get()方法，这些方法除了不是处理字节外，其它方面是是完全一样的，它们处理的是与该缓冲区类相适应的类型。

注：这里我们着重看一下第二和第三这两个方法

ByteBuffer get( byte dst[] );
ByteBuffer get( byte dst[], int offset, int length );

这两个get()主要用来进行批量的移动数据，可供从缓冲区到数组进行的数据复制使用。第一种形式只将一个数组 作为参数，将一个缓冲区释放到给定的数组。第二种形式使用 offset 和 length 参数来指 定目标数组的子区间。这些批量移动的合成效果与前文所讨论的循环是相同的，但是这些方法 可能高效得多，因为这种缓冲区实现能够利用本地代码或其他的优化来移动数据。

buffer.get(myArray)    等价于：

buffer.get(myArray,0,myArray.length);

注：如果您所要求的数量的数据不能被传送，那么不会有数据被传递，缓冲区的状态保持不 变，同时抛出 BufferUnderflowException 异常。因此当您传入一个数组并且没有指定长度，您就相当于要求整个数组被填充。如果缓冲区中的数据不够完全填满数组，您会得到一个 异常。这意味着如果您想将一个小型缓冲区传入一个大数组，您需要明确地指定缓冲区中剩
余的数据长度。上面的第一个例子不会如您第一眼所推出的结论那样，将缓冲区内剩余的数据 元素复制到数组的底部。例如下面的代码：

        String str = "com.xiaoluo.nio.MultipartTransfer";

        ByteBuffer buffer = ByteBuffer.allocate(50);

        for(int i = 0; i < str.length(); i++)
        {
            buffer.put(str.getBytes()[i]);
        }

        buffer.flip();byte[] buffer2 = new byte[100];

        buffer.get(buffer2);

        buffer.get(buffer2, 0, length);

        System.out.println(new String(buffer2));

这里就会抛出java.nio.BufferUnderflowException异常，因为数组希望缓存区的数据能将其填满，如果填不满，就会抛出异常，所以代码应该改成下面这样：

　　  //得到缓冲区未读数据的长度
        int length = buffer.remaining();

        byte[] buffer2 = new byte[100];

        buffer.get(buffer2, 0, length);

b)    put()

ByteBuffer类中有五个put()方法：

    ByteBuffer put( byte b );
    ByteBuffer put( byte src[] );
    ByteBuffer put( byte src[], int offset, int length );
    ByteBuffer put( ByteBuffer src );
    ByteBuffer put( int index, byte b );

第一个方法 写入（put）单个字节。第二和第三个方法写入来自一个数组的一组字节。第四个方法将数据从一个给定的源ByteBuffer写入这个 ByteBuffer。第五个方法将字节写入缓冲区中特定的 位置 。那些返回ByteBuffer的方法只是返回调用它们的缓冲区的this值。 与get()方法一样，我们将把put()方法划分为“相对”或者“绝对”的。前四个方法是相对的，而第五个方法是绝对的。上面显示的方法对应于ByteBuffer类。其他类有等价的put()方法，这些方法除了不是处理字节之外，其它方面是完全一样的。它们处理的是与该缓冲区类相适应的类型。

c)    类型化的 get() 和 put() 方法

除了前些小节中描述的get()和put()方法， ByteBuffer还有用于读写不同类型的值的其他方法，如下所示：

getByte()

getChar()

getShort()

getInt()

getLong()

getFloat()

getDouble()

putByte()

putChar()

putShort()

putInt()

putLong()

putFloat()

putDouble()

事实上，这其中的每个方法都有两种类型：一种是相对的，另一种是绝对的。它们对于读取格式化的二进制数据（如图像文件的头部）很有用。

下面的内部循环概括了使用缓冲区将数据从输入通道拷贝到输出通道的过程。

        while(true)
        {
            //clear方法重设缓冲区，可以读新内容到buffer里
            buffer.clear();

            int val = inChannel.read(buffer);

            if(val == -1)
            {
                break;
            }

            //flip方法让缓冲区的数据输出到新的通道里面
            buffer.flip();

            outChannel.write(buffer);
        }

read()和write()调用得到了极大的简化，因为许多工作细节都由缓冲区完成了。clear()和flip()方法用于让缓冲区在读和写之间切换。