Java NIO缓存区基本操作【源码笔记】
目录
一、基本概念一、基本概念
缓冲区(Buffer)：包在一个对象内的基本数据元素数组
容量(Capacity)：缓冲区能够容纳的数据元素的最大数量
上界(Limit)：缓冲区的第一个不能被读或写的元素
位置(Position)：下一个要被读或写的元素的索引
标记(Mark)：一个备忘位置。调用mark()来设定mark=postion。调用reset()设定position= mark
概念关系：
0 <= mark <= position <= limit <= capacity
二、缓存区
1.Buffer类图
备注：从Buffer类图中体现的一系列操作方法，下文中将对其重要的方法源码逐一分析。
2.创建Buffer缓存区
以一个例子来分析Buffer缓存区的创建。
CharBuffer buffer = CharBuffer.allocate(10); //@1
public static CharBuffer allocate(int capacity) {
if (capacity < 0)
throw new IllegalArgumentException();
return new HeapCharBuffer(capacity, capacity); //@2
}
HeapCharBuffer(int cap, int lim) {
super(-1, 0, lim, cap, new char[cap], 0); //@3
}@1 通过CharBuffer.allocate创建缓存区，例子中缓存区的容量为10个字符
@2 通过new char[cap]字符数组构造缓存区容器,数组大小即缓存区容量
@3 默认 Mark为-1即没有标记；Position为0；Limit与容量Capacity相同；offset默认为0
三、基本操作
1.填充与读取
1.1 填充示例
CharBuffer buffer = CharBuffer.allocate(10);
String mystr = "ABCDEFGHIG";
for (int i = 0; i < mystr.length( ); i++) {
buffer.put(mystr.charAt(i)); // @1
}
buffer.position(0); // @2
System.out.println(buffer.get()); // @3@1 填充缓冲区
@2 重置位置到开始位置
@3 从缓存区读取
1.2 填充源码
public CharBuffer put(char x) {
hb[ix(nextPutIndex())] = x; // @1
return this;
}
final int nextPutIndex() {
if (position >= limit)
throw new BufferOverflowException();
return position++; // @2
}
protected int ix(int i) {
return i + offset; // @3
}@1 给数组赋值，hb即char[]hb，在缓存区构造时创建
@2 position需要小于等于limit；返回position后自增向后移位
@3 offset默认为0，可以在构造缓存区时对其赋值；每次填充时position需要加上offset
1.3 读取源码
public char get() {
return hb[ix(nextGetIndex())]; // @1
}@1 从缓存区读取，即从数组中获取position下标对应的值；返回值后下标向后移动（position自增）
小结：缓存区的填充即填充数组，每个元素填充后，位置会向后移位；当缓存区满时，possion也移动到了数组的最后位置；possion不能超过limit，否则抛出BufferOverflowException。读取即从数组中取出，读取不能超过limit限制；每次读取后位置会向后移位。
2.翻转
2.1 Flip示例
CharBuffer buffer = CharBuffer.allocate(10);
String mystr = "ABCDEFGHIG";
for (int i = 0; i < (mystr.length()-2); i++) {
buffer.put(mystr.charAt(i));
}
buffer.flip();
System.out.println(buffer.get());2.1.1 Flip前内存截图
备注：Flip前position=8; limit=10; capacity=10
2.1.2 Flip后内存截图
备注：Flip后position=0; limit=8; capacity=10
2.1.3 Flip源码
public final Buffer flip() {
limit = position;
position = 0;
mark = -1;
return this;
}备注：由Flip源码可以看出，将limit设置为当前的position; position重置为0；mark重置为-1.
2.2 Rewind示例
CharBuffer buffer = CharBuffer.allocate(10);
String mystr = "ABCDEFGHIG";
for (int i = 0; i < (mystr.length()-2); i++) {
buffer.put(mystr.charAt(i));
}
buffer.rewind();
System.out.println(buffer.get());2.2.1 Rewind前内存截
备注：Rewind前position=8; limit=10; capacity=10
2.2.2 Rewind后内存截图
备注：Rewind后position=0; limit=10; capacity=10
小结：Flip和Rewind都会将position设置为0，即转换成准备读出元素的释放状态；两者的区别在于Rewind不会改变limit的值，而Flip会改变limit的值，变更为原position。
3.释放
3.1 释放示例
CharBuffer buffer = CharBuffer.allocate(10);
String mystr = "ABCDEFGHIG";
for (int i = 0; i < mystr.length(); i++) {
buffer.put(mystr.charAt(i));
}
buffer.flip();
while(buffer.hasRemaining()){ // @1
System.out.print(buffer.get());
}3.2 HasRemaining源码
public final boolean hasRemaining() {
return position < limit; // @2
}@1 通过buffer.hasRemaining()判断是否还有剩余元素；可以通过此方式将Buffer数据释放
@2 剩余元素即当前位置是否已经达到上界
3.3 Clear源码
public final Buffer clear() {
position = 0;
limit = capacity;
mark = -1;
return this;
}备注：clear将缓存区恢复，即：当前位置设置为0；limit与容量相等；mark设置为-1；clear并不会改变buffer中的值。
4.压缩
4.1 压缩示例
CharBuffer buffer = CharBuffer.allocate(10);
String mystr = "ABCDEFGHIG";
for (int i = 0; i < mystr.length(); i++) {
buffer.put(mystr.charAt(i));
}
buffer.position(2).limit(7); // @1
buffer.compact(); // @2
System.out.println(buffer.get());@1 将缓存区位置设置为2, limit设置为7
@2 执行压缩
4.2 压缩前内存截图
备注：压缩前position=2; limit=7; capacity=10
4.3 压缩后内存截图
备注：压缩后position=5; limit=10; capacity=10此处观察position与limit的变化，具体原因见下面源码
4.4 压缩源码
public CharBuffer compact() {
System.arraycopy(hb, ix(position()), hb, ix(0), remaining()); // @1
position(remaining()); // @2
limit(capacity()); // @3
discardMark(); // @4
return this;
}
public final int remaining() {
return limit - position;
}
final void discardMark() {
mark = -1;
}@1 通过数组拷贝的方式将剩余的元素拷贝到数组头部，即从下标0开始填充；
已释放的（position前面的）将被丢弃
@2 将position重置为剩余元素的末端（limit-position）
@3 将limit重置为Buffer容量
@4 丢弃mark即设置为-1
小结：调用compact()的作用是丢弃已经释放的数据，保留未释放的数据，并使缓冲区对重新填充容量准备就绪。
5.标记
5.1 标记示例
CharBuffer buffer = CharBuffer.allocate(10);
String mystr = "ABCDEFGHIG";
for (int i = 0; i < mystr.length(); i++) {
buffer.put(mystr.charAt(i));
}
buffer.position(2).limit(7);
buffer.mark();
System.out.println(buffer.position()); // @1
buffer.position(5);
System.out.println(buffer.position()); // @2
buffer.reset();
System.out.println(buffer.position()); // @3@1 设置标记后打印位置，此时输出为2
@2 将位置重置到5后打印，此时输出为5
@3 执行reset后打印，此时输出为2
5.2 标记源码
public final Buffer mark() {
mark = position; // @1
return this;
}
public final Buffer reset() {
int m = mark;
if (m < 0)
throw new InvalidMarkException();
position = m; // @2
return this;
}@1 mark()将position赋值给变量mark
@2 reset()重新将mark赋给position
小结：mark作用将当前position记下来，在执行reset后还原position
6.比较
6.1 Equals示例
CharBuffer buffer = CharBuffer.allocate(10);
String mystr = "ABCDEFGHIG";
for (int i = 0; i < mystr.length(); i++) {
buffer.put(mystr.charAt(i));
}
buffer.position(0).limit(5); // @1
CharBuffer buffer2 = CharBuffer.allocate(10);
String mystr2 = "FGHIGABCDE";
for (int i = 0; i < mystr2.length(); i++) {
buffer2.put(mystr2.charAt(i));
}
buffer2.position(5).limit(10); // @2
boolean isEquals = buffer.equals(buffer2);
System.out.println(isEquals); // @3Equals内存截图
@1 buffer剩余元素（limit-position）为ABCDE
@2 buffer2剩余元素（limit-position）为ABCDE
@3 buffer与buffer2相等
6.3 Equals源码
public boolean equals(Object ob) {
if (this == ob)
return true;
if (!(ob instanceof CharBuffer)) // @1
return false;
CharBuffer that = (CharBuffer)ob;
if (this.remaining() != that.remaining()) // @2
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))) // @3
return false;
return true;
}@1 equals比较两个buffer须类型相同
@2 equals比较两个buffer须剩余元素个数相等（limit-position）
@3 equals比较两个buffer须在剩余元素中下标对应的每个元素都相同
小结：两个buffer的equals比较须：类型相同、剩余元素个数相同、对应下标的每个元素相同。
7.批量移动
7.1 批量获取示例
CharBuffer buffer = CharBuffer.allocate(10);
String mystr = "ABCDEFGHIG";
for (int i = 0; i < mystr.length(); i++) {
buffer.put(mystr.charAt(i));
}
buffer.flip();
char[] chars = new char[3];
buffer.get(chars,0,3); // @1
System.out.println(chars); // @2@1 buffer.get中传入字符数组chars，给该数组填充3个元素
@2 输出结果：ABC
7.2 批量获取源码
public CharBuffer get(char[] dst, int offset, int length) {
checkBounds(offset, length, dst.length);
if (length > remaining()) // @1
throw new BufferUnderflowException();
int end = offset + length;
for (int i = offset; i < end; i++)
dst[i] = get(); // @2
return this;
}@1 要填充数组的长度需要小于剩余元素，否则抛出异常
@2 填充数组
备注：批量获取，即将buffer的当前position到limit的剩余元素，填充指定的长度到传入的数组中。
7.3 批量写入示例
CharBuffer buffer = CharBuffer.allocate(10);
char[] chars = {'a','c','c'};
buffer.put(chars,0,3); // @1
buffer.flip();
System.out.println(buffer.get()); // @2@1 将字符数组chars写入到buffer
@2 输出为a
7.4 批量源码
public CharBuffer put(char[] src, int offset, int length) {
checkBounds(offset, length, src.length);
if (length > remaining()) // @1
throw new BufferOverflowException();
int end = offset + length;
for (int i = offset; i < end; i++)
this.put(src[i]); // @2
return this;
}@1 批量写入的长度不能大于剩余元素
@2 将数组元素写入到buffer
四、参考资料
《Java NIO》第二章