1.概念
A buffer's capacity is the number of elements it contains. The capacity of a buffer is never negative and never changes.
A buffer's limit 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.
A buffer's position 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.
2.代码示例
public static void main(String[] args) throws IOException {
IntBuffer buffer = IntBuffer.allocate(10);
System.out.println("init: " + buffer);
System.out.println("enter for loop(put): ");
for (int i = 0; i < 5; i++) {
System.out.println(buffer);
//SecureRandom是java.util.Random的子类，这个类更健壮一些，推荐使用
int random = new SecureRandom().nextInt(20);
buffer.put(random);
}
System.out.println("before flip(): " + buffer);
//实现读写的切换
buffer.flip();
System.out.println("after flip(): " + buffer);
System.out.println("enter while loop(get): ");
while (buffer.hasRemaining()) {
System.out.println(buffer);
buffer.get();
}
System.out.println("finally: " + buffer);
}
控制台：
init: java.nio.HeapIntBuffer[pos=0 lim=10 cap=10]
enter for loop(put):
java.nio.HeapIntBuffer[pos=0 lim=10 cap=10]
java.nio.HeapIntBuffer[pos=1 lim=10 cap=10]
java.nio.HeapIntBuffer[pos=2 lim=10 cap=10]
java.nio.HeapIntBuffer[pos=3 lim=10 cap=10]
java.nio.HeapIntBuffer[pos=4 lim=10 cap=10]
before flip(): java.nio.HeapIntBuffer[pos=5 lim=10 cap=10]
after flip(): java.nio.HeapIntBuffer[pos=0 lim=5 cap=10]
enter while loop(get):
java.nio.HeapIntBuffer[pos=0 lim=5 cap=10]
java.nio.HeapIntBuffer[pos=1 lim=5 cap=10]
java.nio.HeapIntBuffer[pos=2 lim=5 cap=10]
java.nio.HeapIntBuffer[pos=3 lim=5 cap=10]
java.nio.HeapIntBuffer[pos=4 lim=5 cap=10]
finally: java.nio.HeapIntBuffer[pos=5 lim=5 cap=10]
3.源码分析
1.初始化：(并不存在索引为10的元素，为了描述而虚拟的)
源代码：
1.IntBuffer buffer = IntBuffer.allocate(10);//查看allocate(int capacity)的源码
2.
public static IntBuffer allocate(int capacity) {
if (capacity < 0)
throw new IllegalArgumentException();
return new HeapIntBuffer(capacity, capacity);
}
3.继续跟进new HeapIntBuffer(capacity, capacity);
4.
HeapIntBuffer(int cap, int lim) {
super(-1, 0, lim, cap, new int[cap], 0);
}
5.跟进super构造方法
IntBuffer(int mark, int pos, int lim, int cap,int[] hb, int offset)
通过源码我们就发现了初始化pos,lim,cap时，分别是0，capacity,capacity
2.每写一个元素，pos就向右移一个元素，当写完5个元素后，索引指向5
源码:
1.查看HeapIntBuffer的源码
public IntBuffer put(int x) {
hb[ix(nextPutIndex())] = x;
return this;
}
2.查看nextPutIndex()
final int nextPutIndex() { // package-private
if (position >= limit)
throw new BufferOverflowException();
return position++;//position就是在这里自增的
}
3.查看ix()
protected int ix(int i) {
return i + offset;//当初始化时，offset为0，所以还是i，也就是当前position所指的地方
}
图解：
3.在调用flip()后，
源码：
/**
* Flips this buffer. The limit is set to the current position and then
* the position is set to zero. If the mark is defined then it is discarded.
*/
public final Buffer flip() {
limit = position;
position = 0;
mark = -1;
return this;
}
4.同样，每读一个元素，pos就后移一位，直到pos大于或等于lim
源码：
1.查看HeapIntBuffer的源码
public int get() {
return hb[ix(nextGetIndex())];
}
2.查看nextGetIndex()
final int nextGetIndex() { // package-private
if (position >= limit)
throw new BufferUnderflowException();
return position++;//先返回当前position，然后自增
}
3.查看ix()
protected int ix(int i) {
return i + offset;//初始化时，offset为0
}
思考：此时如果再次调用flip()会怎样？
limit = position;// 原地不动
position = 0;// 回到第一个元素
即重新读一遍
总结：其实不管怎样，玩的其实就是position和limit两个指针，其它都是为了这两个指针位置服务的。
4.其它方法
1.mark和reset
/**
* Sets this buffer's mark at its position.
*
* @return This buffer
*/
public final Buffer mark() {
mark = position;
return this;
}
public final Buffer reset() {
int m = mark;
if (m < 0)
throw new InvalidMarkException();
position = m;
return this;
}
2.clear()
/*
*这个方法实际上并没有擦除缓冲区中的数据，只不过是利用变量来把将来我们新放入的数据覆盖掉旧的数据
*/
public final Buffer clear() {
position = 0;
limit = capacity;
mark = -1;
return this;
}
3.rewind()
/**
* Rewinds this buffer. The position is set to zero and the mark is
* discarded.
*/
public final Buffer rewind() {
position = 0;
mark = -1;
return this;
}
