Buffer 源码解读：

　　　A container for data of a specific primitive type.  Buffer 是一个具体的原始类型（除去boolean）的数据容器

　　　　

　　　A buffer is a linear, finite sequence of elements of a specific primitive type. Aside from its content, the essential properties of a  buffer are its capacity, limit, and position:

　　　buffer 是一个 线性的，限定的，序列元素的 具体原始类型，除了他的内容之外， 一个buffer 必不可少的特性就是 capacity（容量）。limit    .position这三部分

　　　A buffer's <i>capacity</i> is the number of elements it contains.
　　 The capacity of a buffer is never negative and never changes.

　　capacity 是 buffer 容器里元素的个数， 它从来不会是负数，也不会被改变，在我们初始化的时候就会被我们自己定义它的大小

　　

　　　　A buffer's <i>position</i> is the index of the next element to be
　　　　* read or written. A buffer's position is never negative and is never
　　　　* greater than its limit.

　　　　position（位置） 是 读写下一元素的索引，position 也是从来不会是负数，从来不会大于limit

　　　　<p> A buffer's <i>limit</i> is the index of the first element that should
　　　　* not be read or written. A buffer's limit is never negative and is never
　　　　* greater than its capacity. </p>

　　　　limit(限定) 是不应该被读到或者被写到的元素的首位置， 它不会是负数，不会超过 capacity

<p> There is one subclass of this class for each non-boolean primitive type.
　　每一个非布尔的原始类型在这个class 里都会有一个子类

<p> Transferring data

Each subclass of this class defines two categories of <i>get</i> and
* <i>put</i> operations: </p>

数据的传输 ，每一个子类都会定义 get 和put 两种方式操作

*<p> <i>Relative</i> operations read or write one or more elements starting
* at the current position and then increment the position by the number of
* elements transferred. If the requested transfer exceeds the limit then a
* relative <i>get</i> operation throws a {@link BufferUnderflowException}
* and a relative <i>put</i> operation throws a {@link
* BufferOverflowException}; in either case, no data is transferred. </p>

相对的 操作读和写一个或者多个元素在目前的position(位置坐标)通过传递元素的数量增加这个position 位置

如果请求超出了limit 的范围，相对的get 操作会抛出BufferUnderflowException 异常
put 方法操作会抛出BufferOverflowException 异常
无论发生何种情况，都没有数据传递

* <p> <i>Absolute</i> operations take an explicit element index and do not
* affect the position. Absolute <i>get</i> and <i>put</i> operations throw
* an {@link IndexOutOfBoundsException} if the index argument exceeds the
* limit. </p>

绝对的操作 进行明确一个元素的索引，不会影响postion 位置，如果索引参数超出了limit 就会抛出 IndexOutOfBoundsException 异常

* <h2> Marking and resetting </h2>

 *

 * <p> A buffer's <i>mark</i> is the index to which its position will be reset

 * when the {@link #reset reset} method is invoked.  The mark is not always

 * defined, but when it is defined it is never negative and is never greater

 * than the position.  If the mark is defined then it is discarded when the

 * position or the limit is adjusted to a value smaller than the mark.  If the

 * mark is not defined then invoking the {@link #reset reset} method causes an

 * {@link InvalidMarkException} to be thrown.

标记与重置

buffer 的 标记是position 将会被重置的索引，当reset 方法被调用的时候。这个标记不总是被

定义的，但是当他定义的时候，他的值不应该是负数以及它不会超出position 的值，

如果标记被定义，当position 或者limit 调整成了一个比标记还小的值，那么这个标记就会被丢弃（-1）

如果标记没有被定义，但是你调用了reset 方法，将会抛出 InvalidMarkException 异常

一句话，mark 是一个标记，当调用reset 方法时候，position 位置将会是mark 的标记的索引位置

 * <p> A newly-created buffer always has a position of zero and a mark that is

 * undefined.  The initial limit may be zero, or it may be some other value

 * that depends upon the type of the buffer and the manner in which it is

 * constructed.  Each element of a newly-allocated buffer is initialized

 * to zero.

一个新创建的buffer 总会有一个从0开始的position 以及 未被定义的mark(-1)

初始的limit可能是0 或者是其他的值主要取决于你buffer 的类型和构造函数的方式

新分配的缓冲区每一个元素初始化为零

-------------例子详解------------

我们以IntBuffer 为例，进行构造它的Buffer 对象

IntBuffer buffer =IntBuffer.allocate(10);//分配一个容量为10的IntBuffer

我们跟踪源码点进去，第一步，可以看出它去创建了HeapIntBuffer 对象，

public static IntBuffer allocate(int capacity) {
if (capacity < 0)
throw new IllegalArgumentException();
return new HeapIntBuffer(capacity, capacity);
}

点进去 HeapIntBuffer,可以差不多看到刚开始构造时候，capacity = limit 值

HeapIntBuffer(int cap, int lim) { // package-private

super(-1, 0, lim, cap, new int[cap], 0);

}

点进去super，看到会创建出一个容量为capacity的数组，所以说buffer 底层是数组，且初始化的position 为0 ，mark 为-1（即无效）

IntBuffer(int mark, int pos, int lim, int cap, // package-private
int[] hb, int offset)
{
super(mark, pos, lim, cap);
this.hb = hb;
this.offset = offset;
}

clear 方法

 *   <li><p> {@link #clear} makes a buffer ready for a new sequence of

 *   channel-read or relative <i>put</i> operations: It sets the limit to the

 *   capacity and the position to zero.  </p></li>

    clear 方法 使buffer 准备以一个全新的方式进行 channel -read 操作或者相对的buffer put 操作

    它会将limit 值设置成buffer capacity的值，以及position 从0 开始；

    如下源码方法：可以看出clear 方法执行的操作。position 置位0 limit 等于 capacity ,清除标记-1 

  public final Buffer clear() {

        position = 0;

        limit = capacity;

        mark = -1;

        return this;

    }

------例子详解------

public static void main(String[] args) {

//分配一个容量为10 IntBuffer 底层是数组
IntBuffer buffer =IntBuffer.allocate(10);
//在够着函数创建之后，就会有了capacity limit position 的 值了
System.err.println("起始capacity值==>"+buffer.capacity());
System.err.println("起始limit值==>"+buffer.limit());
System.err.println("起始position值==>"+buffer.position());

for(int i =0;i<buffer.capacity();i++) {
//遍历在每一个buffer 节点 插入随机数
buffer.put(new SecureRandom().nextInt(10));
//打印当前的 capacity limit position 的 值；
System.out.println("循环capacity值==>"+buffer.capacity());
System.out.println("循环limit值==>"+buffer.limit());
System.out.println("循环position值==>"+buffer.position());
}

//buffer clear 方法调用

buffer.clear();

System.err.println("clear 后capacity值==>"+buffer.capacity());
System.err.println("clear 后limit值==>"+buffer.limit());
System.err.println("clear 后position值==>"+buffer.position());

//......再进行自己的put 操作

}

flip 方法

 *   <li><p> {@link #flip} makes a buffer ready for a new sequence of

 *   channel-write or relative <i>get</i> operations: It sets the limit to the

 *   current position and then sets the position to zero.  </p></li>

    clear 方法 使buffer 准备以一个全新的方式进行 channel -write操作或者相对的buffer get操作

    他会将limit 值设置为当前position 值，将position 设置为0

    如下源码方法：可以看出flip 方法执行的操作。

 public final Buffer flip() {

        limit = position;

        position = 0;

        mark = -1;

        return this;

    }

-------例子详解

public static void main(String[] args) {

//分配一个容量为10 IntBuffer 底层是数组
IntBuffer buffer =IntBuffer.allocate(10);
//在够着函数创建之后，就会有了capacity limit position 的 值了
System.err.println("起始capacity值==>"+buffer.capacity());
System.err.println("起始limit值==>"+buffer.limit());
System.err.println("起始position值==>"+buffer.position());

//为了看到limit 效果，这里设置循环5次
for(int i =0;i<5;i++) {
//遍历在每一个buffer 节点 插入随机数
buffer.put(new SecureRandom().nextInt(10));
//打印当前的 capacity limit position 的 值；
System.out.println("循环capacity值==>"+buffer.capacity());
System.out.println("循环limit值==>"+buffer.limit());
System.out.println("循环position值==>"+buffer.position());
}

//buffer flip 方法调用

buffer.flip();

System.err.println("flip 后capacity值==>"+buffer.capacity());
System.err.println("flip 后limit值==>"+buffer.limit());
System.err.println("flip 后position值==>"+buffer.position());

while(buffer.hasRemaining()) {//=position < limit的时候循环;

System.out.println("buffer的值===>"+buffer.get());
}

}

rewind(倒回) 方法;

 *   <li><p> {@link #rewind} makes a buffer ready for re-reading the data that

 *   it already contains: It leaves the limit unchanged and sets the position

 *   to zero.  </p></li>

 *

 * </ul>

    rewind 方法是在已经存在的容器里重新读取数据做好准备，他会保持limit 不改变并且使position 为0

    如下源码方法：可以看出rewind方法执行的操作。

public final Buffer rewind() {

        position = 0;

        mark = -1;

        return this;

    }

    public static void main(String[] args) throws Exception {

        FileInputStream file = new FileInputStream("c:\\demo.txt");

        //获取channel 对象

        FileChannel fileChannel=file.getChannel();

        //读写操作都会用到buffer

        ByteBuffer byteBuffer = ByteBuffer.allocate(5112);

        //channel 读取数据到buffer

        fileChannel.read(byteBuffer);

        //状态翻转，切换为读

        byteBuffer.flip();

        while(byteBuffer.hasRemaining()) {

            byte b =byteBuffer.get();

            System.out.println((char)b);

        }

        file.close();

    }