前言
一直想把NIO系列的文章更新下去，只不过发现在入职支付宝后工作实在是忙，所以一直拖到现在。直接从一个学生过狗成为一名加班狗，好吧，这就是互联网公司的现状吧，但是每天都是充实的，而且发现其他的员工也基本非常乐意加班，难道这就是阿里的文化熏陶？！
废话不多说，还是进入今天的正题，在前面的文章中，我们已经对Java的NIO有了一个粗浅的认识——主要之为了非阻塞I/O的操作，之前的BIO则是阻塞的。因为异步性的引入，大大提高了Java在处理异步任务的效率。下面认识下NIO中的缓冲区：
认识缓冲区
缓冲区可以理解为存储固定数量的容器，这些数据可以在存储后被检索，缓冲区的数据可以被写满或者被释放，而这些操作的实现需要认识缓冲区的属性：容量（capacity）、上界（limit）、位置（position）和标记（mark）。这四个属性的关系可以用下图来表示：
理解好这张图，缓冲区的精髓就掌握的四五分了，还有四五分从哪里来呢？当然是实践中来了。这张图传达了如下的信息：
0 <= mark <= position <= limit <= capacity
容量
容量是指缓冲区可以容纳的最大元素个数，这一容量在缓冲区被创建的时候就被指定了。
上界
就是缓冲区现存元素的计数
位置
下一个要被读取的元素的索引
标记
由于在读取过程中position的值是动态变化，如果在读到某一个位置的时候需要做一个标记以便下次继续读，就可以做一个“书签”，让mark的值等于当前读到的position的值。
在java.nio包中Buffer类是缓冲区的顶层类，其他的缓冲区类都是基于这个类展开的。一个缓冲区类的主要方法如下：
public abstract class Buffer {
// 获取缓冲区的容量
public final int capacity( );
// 获取下一个将要被读取的元素的索引
public final int position( );
// 设置缓冲区的位置为新位置
public final Buffer position (int newPositio);
// 返回上界
public final int limit( );
// 设置新的上界
public final Buffer limit (int newLimit);
// 返回标记的值
public final Buffer mark( );
// 将position重置为mark的值
public final Buffer reset( );
// 清空对上界和位置的操作
public final Buffer clear( );
// 重置position为0并将上界设为远position的值
public final Buffer flip( );
// 将position设置0
public final Buffer rewind( );
// 返回剩余未读的元素个数
public final int remaining( );
// 判断是否还有未读的元素
public final boolean hasRemaining( );
// 判断是否是只读
public abstract boolean isReadOnly( );
}
作为一个缓冲区，肯定是需要存取数据的，但是在Buffer类中并没有get和put类似的方法，实际上Java 设计者将get和put方法放到子类实现了。这样设计主要是考虑到在只需要关心缓冲区钟部分数据的情况，因为在这种情况可能有不同的存取策略。
缓冲区实战
现在已经对缓冲区有了一个基本认识，缓冲区的操作主要涉及以下几个部分：
存取
翻转
释放
压缩
标记
比较
批量移动
存取、翻转和释放
在缓冲区存取元素，需要创建缓冲区，存取操作的两个核心方法是：get和put方法，完成翻转只需要调用flip方法。下面是一个简单示例：
package com.rhwayfun.patchwork.nio.buffer;
import java.nio.CharBuffer;
/**
* @description: Buffer缓冲区演示
* @author: rhwayfun
* @since: 2022-05-21
*/
public class BufferFillDrain {
// 位置
private static int index = 0;
// 需要填充入缓冲区字符串数组
private static String[] strings = new String[]{
"Hello, this is a buffer",
"I am learning buffer",
"It is a wonderful world"
};
public static void main(String[] args) {
// 申请100字节的缓冲区
CharBuffer buffer = CharBuffer.allocate(100);
// 如果缓存区没有达到上界则可以继续填充
while (fillBuffer(buffer)){
// 缓冲区翻转
// flip可以将上界设为当前position的位置
// 并将position重置为0
buffer.flip();
// 从缓冲区释放数据
drainBuffer(buffer);
// 清空缓冲区
// 调用clear方法可本质上干了两件事
// 一：将上界limit设为容量大小的位置
// 二：将position重置为0
buffer.clear();
}
}
private static void drainBuffer(CharBuffer buffer) {
// 得到剩余的元素个数
int count = buffer.remaining();
for (int i = 0; i < count; i++){
System.out.println(i + "--->" + buffer.get());
}
}
private static boolean fillBuffer(CharBuffer buffer) {
if (index >= strings.length) {
return false;
}
// 依次放入每个字符串数组
String s = strings[index++];
for (int i = 0; i < s.length(); i++){
buffer.put(s.charAt(i));
}
return true;
}
}
压缩
压缩使用在需要释放缓冲区的空间的场景，执行压缩需要调用compact方法。该方法的会首先将position位置之后的元素（如果没有调用flip方法的话）复制从0开始的位置上，而position位置及之后的元素保持不变，在进行元素复制的过程中position的值也会发生改变。压缩的过程可以用如下的图表示：
下面的代码有演示了这个过程：
package com.rhwayfun.patchwork.nio.buffer;
import java.nio.CharBuffer;
/**
* @description: 使用compact方法释放一部分数据
* @author: rhwayfun
* @since: 2022-05-21
*/
public class BufferCompact {
public static void main(String[] args) {
String s = "hello";
CharBuffer buffer = CharBuffer.allocate(10);
for (int i = 0; i < s.length(); i++){
buffer.put(s.charAt(i));
}
// 将第一个位置的字符h换为M，并填入一个新的字符w
buffer.put(0,M).put(w);
// 现在缓冲区的元素是Mellow，position的位置是6，limit和capacity都是10
// 调用flip方法得到有效元素的位置，其实也就是position的位置
buffer.flip();
// 将M和e两个个字符释放掉
System.out.println("release char " + buffer.get());
System.out.println("release char " + buffer.get());
// 调用compact方法可以回收M和e字符占用的空间
// 调用compact后position位置是4，
// 0-3位置的字符依次是llow，4-5位置的字符依次是ow
// 虽然4-5位置有字符，但是调用put方法后会被重写
// 并且调用compact方法后limit又回到了capacity的位置，也就是10
buffer.compact();
// 将4-5位置的字符修改为ab
buffer.put(a).put(b);
// 输出缓冲区的元素，根据上面的分析，最后输出的字符应该是llowab
// 需要先调用flip方法将position设为0，这样才能读到完整的字符
buffer.flip();
while (buffer.hasRemaining()){
System.out.println("print output " + buffer.get());
}
}
}
比较
缓冲区的比较可以使用equals方法，进行缓冲区的比较的意义在于检测缓冲区包含的数据是否相同。当然，缓冲区的比较也使用compareTo方法进行比较。如果buffer1.equals(buffer2)要返回true，那么需要满足以下条件才可以：
两个对象类型相同。包含不同数据类型的 buffer 永远不会相等,而且 buffer绝不会等于非 buffer 对象。
两个对象都剩余同样数量的元素。Buffer 的容量不需要相同,而且缓冲区中剩余数据的索引也不必相同。但每个缓冲区中剩余元素的数目(从位置到上界)必须相同。
在每个缓冲区中应被 Get()函数返回的剩余数据元素序列必须一致。
下面的代码演示了进行缓冲区比较的过程：
package com.rhwayfun.patchwork.nio.buffer;
import java.nio.CharBuffer;
/**
* @description: 使用equals方法比较两个缓冲区是否相等
* @author: rhwayfun
* @since: 2022-05-21
*/
public class BufferCompareWithEquals {
public static void main(String[] args) {
String s1 = "two com";
String s2 = "com";
CharBuffer buffer1 = CharBuffer.allocate(10);
CharBuffer buffer2 = CharBuffer.allocate(10);
for (int i = 0; i < s1.length(); i++){
buffer1.put(s1.charAt(i));
}
// 调用flip方法后limit为7
buffer1.flip();
// 继续往缓冲区放入一个字符，当前position的位置是1
buffer1.put(A);
// 将当前位置设为4，也就是字符c开始的位置
buffer1.position(4);
/*System.out.print("buffer1: ");
while (buffer1.hasRemaining()){
System.out.print(buffer1.get() + " ");
}*/
for (int i = 0; i < s2.length();i++){
buffer2.put(s2.charAt(i));
}
// limit的位置是3，position的位置是0
buffer2.flip();
// 现在执行put方法会把位置0的字符c替换为B
buffer2.limit(4);
buffer2.put(3,B);
buffer2.position(0);
buffer2.limit(3);
/*System.out.print("buffer2: ");
while (buffer2.hasRemaining()){
System.out.print(buffer2.get() + " ");
}*/
// 使用equals方法比较两个缓冲区是否相等
// 必须满足三个条件才能返回true
// 1）两个缓冲区的对象的类型必须相同
// 2）缓冲区的元素不必完全相同，但是如果position到limit之间的元素不相同，也返回false
// 3）每个缓冲区get方法得到元素序列必须一致
System.out.println(buffer1.equals(buffer2));
// 还可以使用compareTo方法比较两个缓冲区，但是如果两个缓冲区的元素的类型不一致，equals方法返回false
// 而compareTo方法则直接抛出ClassCastException的异常
}
}
批量操作
在之前的get和put方法，一次只能操作一个元素，从效率的角度讲还是很低的，那么有没有批量操作的方法呢？在Buffer API中可以使用重载的get和put方法进行批量的操作。下面的代码演示了如何进行缓冲区的批量操作：
package com.rhwayfun.patchwork.nio.buffer;
import java.nio.CharBuffer;
/**
* @description: 批量操作缓冲区
* @author: rhwayfun
* @since: 2022-05-21
*/
public class BufferBatchOperation {
public static void main(String[] args) {
copyToBigArray();
copyToSmallArray();
System.out.println();
putStringToBuffer();
}
private static void copyToBigArray() {
// 将一个缓冲区释放到一个大数组中
String s = "hello,rhwayfun";
CharBuffer buffer = CharBuffer.allocate(20);
for (int i = 0; i < s.length(); i++){
buffer.put(s.charAt(i));
}
buffer.flip();
// 创建一个大数组
char[] array = new char[100];
// 如果直接使用get方法将元素释放到array数组中
// 则实际上将数组的0位置到最后一个位置，这里是
// 99,依次将缓冲区的元素释放到数组中。由于缓冲
// 区的元素根本不够，所以会抛出BufferUnderflowException异常
// buffer.get(array);
int remaining = buffer.remaining();
buffer.get(array,0,remaining);
// 测试array数组
for (char c : array){
System.out.print(c + " ");
}
}
private static void copyToSmallArray(){
// 将一个缓冲区释放到一个大数组中
String s = "hello,rhwayfun";
CharBuffer buffer = CharBuffer.allocate(20);
for (int i = 0; i < s.length(); i++){
buffer.put(s.charAt(i));
}
buffer.flip();
char[] array = new char[10];
while (buffer.hasRemaining()){
int length = Math.min(array.length,buffer.remaining());
buffer.get(array,0,length);
}
}
private static void putStringToBuffer(){
String s = "Good morning";
CharBuffer buffer = CharBuffer.allocate(20);
buffer.put(s);
buffer.flip();
while (buffer.hasRemaining()) {
System.out.print(buffer.get() + " ");
}
}
}
小结
通过以上的叙述以及针对缓冲区的也也演示操作，我们对缓冲区的掌握也更加深入了，其实对缓冲区的理解最关键的还是缓冲区的模型图。这个图理解了，掌握Buffer类的API也就驾轻就熟了。
