Java NIO 关键概念之 Buffer

一、前言

Java NIO 的三大关键概念之一是 Buffer，在一些文章/源代码中，我们也经常会看到 Buffer 相关的信息。Buffer 到底是什么，Buffer 的基本使用方法是什么，这是本文主要要说的。

二、Buffer 的基本概念

Buffer自 JDK1.4 引入，是一个抽象类，在java.nio包下，定义了一些通用的方法，并不能直接创建对象，在使用时，需要通过其具体的基础数据类型子类来创建对象。Java 的基础数据类型中，除了boolean外，都有一个对应数据类型的子类，如 ByteBuffer、IntBuffer 等。

通俗点说，Buffer 是 Java 基础数据类型的数据容器，本质上其实就是一个相应基础数据类型的数组封装，并扩展了相关的属性、操作方法等以方便使用。(实现缓存数据、方便高效地操作数据，后面会有示例/源码说明)

Buffer 中，有几个重要的属性/概念，简单说明如下：

简单来说，capacity 是 Buffer 对应的数组的容量值，limit 是读/写的限制值，position 是数组中相关元素位置的索引值，这三个值都不会为负数，且这几个值的大小关系如下：

mark <= position <= limit <= capacity

复制代码

Buffer 作为一个数据容器，操作一个 Buffer 的一般过程如下：

java.nio.Buffer类作为一个抽象基类，提供了一些基本方法，如capacity()、limit()等，可以返回其私有属性值，也提供了flip()（读/写模式切换）、clear()（清空数据）等设置属性值的操作方法，且这些方法都是用final关键字修饰的，不可被重写。

而要创建一个 Buffer 对象，则只能通过对应基础数据类型的子类中的allocate()方法来实现，同样，写数据、读数据，也需要调用相应子类中的相关put()、get()方法来实现。

三、Buffer 的基本使用 &源码分析

基本使用

首先，通过一个例子演示下 Buffer 的基本使用：

import java.nio.ByteBuffer;/** * Java Buffer demo *  * 输出的byteBuffer对象中，可以看到读/写等相关方法操作后，position、limit、capacity值的的变化。 * * @author : laonong */public class ByteBufferMain {    public static void main(String[] args) {        //创建总容量为10的Buffer对象        ByteBuffer byteBuffer = ByteBuffer.allocate(10);        System.out.println("创建Buffer后：" + byteBuffer);        //写入4个节点元素数据        byteBuffer.put((byte) 'a');        byteBuffer.put((byte) 'b');        byteBuffer.put((byte) 'c');        byteBuffer.put((byte) 'd');        System.out.println("写入数据后：" + byteBuffer);        //读写转换        byteBuffer.flip();        System.out.println("flip()方法读写转换后：" + byteBuffer);        //读取Buffer中的所有元素数据        System.out.print("读取Buffer中的数据：");        while (byteBuffer.hasRemaining()) {            System.out.print((char)byteBuffer.get());            if (byteBuffer.hasRemaining()) {                System.out.print("，");            }        }        System.out.println();        System.out.println("读取数据后：" + byteBuffer);        //重置Buffer        byteBuffer.clear();        System.out.println("clear()方法重置后：" + byteBuffer);    }}

复制代码

执行代码输出：

创建Buffer后：java.nio.HeapByteBuffer[pos=0 lim=10 cap=10]写入数据后：java.nio.HeapByteBuffer[pos=4 lim=10 cap=10]flip()方法读写转换后：java.nio.HeapByteBuffer[pos=0 lim=4 cap=10]读取Buffer中的数据：a，b，c，d读取数据后：java.nio.HeapByteBuffer[pos=4 lim=4 cap=10]clear()方法重置后：java.nio.HeapByteBuffer[pos=0 lim=10 cap=10]

复制代码

从输出结果可以看出，随着对 Buffer 进行各种读/写操作，Buffer 中的三个关键属性中，position、limit 的值在不断变化，capacity 的值固定不变，如下图所示：

源码分析

接下来，我们通过源码，看一下 Buffer 到底是如何实现示例中的相关功能的。

示例代码中，几个关键类的关系如下图所示：

1、java.nio.Buffer部分源码：

package java.nio;import java.util.Spliterator;/** * A container for data of a specific primitive type. */public abstract class Buffer {      //标记当前的position    private int mark = -1;    //读/写位置游标    private int position = 0;    //buffer读/写的上限边界值    private int limit;    //buffer的最大容量值    private int capacity;      //构造函数    Buffer(int mark, int pos, int lim, int cap) {       // package-private        if (cap < 0)            throw new IllegalArgumentException("Negative capacity: " + cap);        this.capacity = cap;        limit(lim);        position(pos);        if (mark >= 0) {            if (mark > pos)                throw new IllegalArgumentException("mark > position: ("                                                   + mark + " > " + pos + ")");            this.mark = mark;        }    }     /**    * 清除数据     *（可以看出，并不是真正意义上的删除buffer中的元素，而是重置属性的值[数据的索引值]）    */    public final Buffer clear() {        position = 0;        limit = capacity;        mark = -1;        return this;    }    /**     * 翻转buffer       * (通过重置属性值的方式，实现切换buffer读/写模式的目的。【注意：只能一次从写模式翻转到读模式，不能反复翻转】)     */    public final Buffer flip() {        limit = position;        position = 0;        mark = -1;        return this;    }    /**     * 倒带buffer     *  (用于当buffer已经读过一遍了，但还需要从头读一次，则需要调用一次该方法)     */    public final Buffer rewind() {        position = 0;        mark = -1;        return this;    }      /**     * 判断position、limit之间是否还有元素 （）     */    public final boolean hasRemaining() {        return position < limit;    }      /**     * position值自增 （用于子类中写数据时调用）     */   final int nextPutIndex() {                          // package-private        if (position >= limit)            throw new BufferOverflowException();        return position++;    }     /**     * position值自增 （用于子类中读数据时调用）     */   final int nextGetIndex() {                          // package-private        if (position >= limit)            throw new BufferUnderflowException();        return position++;    }}

复制代码

2、java.nio.ByteBuffer 部分源码：（其它 IntBuffer、CharBuffer 等 Buffer 子类源码相似）

package java.nio;/** * A byte buffer. */public abstract class ByteBuffer extends Buffer implements Comparable<ByteBuffer> {    /**     * 内部属性     *（这几个属性主要是在ByteBuffer的子类中使用，如HeapByteBuffer）     */    final byte[] hb;                  // Non-null only for heap buffers    final int offset;    boolean isReadOnly;                 // Valid only for heap buffers      /**     * 分配（创建）一个新的指定容量的 ByteBuffer     */    public static ByteBuffer allocate(int capacity) {        if (capacity < 0)            throw new IllegalArgumentException();        return new HeapByteBuffer(capacity, capacity);    }      /**     * 读数据      * （读取的是数组当前索引值为position的数据，读取后，position的值加1）     *     */    public abstract byte get();    /**     * 写数据      * （写数据的位置当前索引值为position，写数据后，position的值加1）     */    public abstract ByteBuffer put(byte b);      /**     * 压缩buffer     */    public abstract ByteBuffer compact();}

复制代码

java.nio.ByteBuffer 类中的get()、put(byte b)、 compact()这几个方法都只有抽象定义，具体实现在子类中，接下来看下HeapByteBuffer中的具体实现代码。

3、java.nio.ByteBuffer 部分源码：

package java.nio;/** * A read/write HeapByteBuffer. */class HeapByteBuffer extends ByteBuffer {     /**  * 添加偏移的索引值  */  protected int ix(int i) {    return i + offset;  }   /**  * 写数据   */  public ByteBuffer put(byte x) {        hb[ix(nextPutIndex())] = x;        return this;  }   /**  * 读数据   */  public byte get() {    return hb[ix(nextGetIndex())];  }    /**  * 压缩buffer  * (复制数组中未读的元素，然后通过设置position、limit的值，将数据移动到buffer的头部，  *  这样的话，buffer继续写数据就不会覆盖未读的数据)  */  public IntBuffer compact() {        System.arraycopy(hb, ix(position()), hb, ix(0), remaining());        position(remaining());        limit(capacity());        discardMark();        return this;    }}

复制代码

以上，笔者只贴了部分关键代码，代码中已添加简单说明。更多详细代码可以去看源码，源码中有非常详细的相关注释。

源码补充说明：

1、对 Buffer 的清除、压缩、翻转等操作，在某种意义上来说，其实就是对数据索引值 position、limit 的操作。

2、Buffer 中的清除数据（clear()方法），并不会真正删除 Buffer 中数组中的元素，而是通过设置 position、limit 属性值的方式，修改 Buffer 的读/写位置与边界值。

3、如果 Buffer 中的数据没有全部读完，就调用clear()方法的话，则可能会造成未读数据被覆盖掉，此时，如果想只清除已读数据，保留未读数据的话，可调用compact()方法。

4、Buffer 通过优秀的设计实现了可以方便灵活、简单高效地缓存/操作数据。

Buffer 的常用方法简单说明如下：

当然，buffer 的子类中还有许多其它方法，用于更灵活地操作 buffer，如put(int index, byte b);方法可指定索引值写数据，get(int index);方法可指定索引值读取数据等等，此处笔者就不一一列举了。

Buffer 的大小比较：

另外，需要说明的是，Buffer 的具体基础数据类型子类都实现了Comparable接口，并重写了equals()、compareTo()方法，也就是说，Buffer 是可以比较大小的，只是需满足特定条件：

ByteBuffer 关键源码如下：

  public boolean equals(Object ob) {       if (this == ob)         return true;       if (!(ob instanceof ByteBuffer))         return false;       ByteBuffer that = (ByteBuffer)ob;       if (this.remaining() != that.remaining())         return false;       int p = this.position();       for (int i = this.limit() - 1, j = that.limit() - 1; i >= p; i--, j--)         if (!equals(this.get(i), that.get(j)))           return false;       return true;  }  private static boolean equals(byte x, byte y) {       return x == y;  }  public int compareTo(ByteBuffer that) {      int n = this.position() + Math.min(this.remaining(), that.remaining());      for (int i = this.position(), j = that.position(); i < n; i++, j++) {        int cmp = compare(this.get(i), that.get(j));        if (cmp != 0)          return cmp;      }      return this.remaining() - that.remaining();  }  private static int compare(byte x, byte y) {      return Byte.compare(x, y);  }