一 核心要素
- capacity （容量）；不能为负，不可更改；就是buffer的长度（buffer.length）
- limit （限制）；指第一个不可被读入缓冲区元素的位置；不可为负，若position大于limit，那么limit就是position；
- position （位置）；指下一个被读入缓冲区元素的位置；不可为负，小于limit，默认索引由0开始；
- mark （标记）；指在缓冲区设置标记；若调用reset()方法会回到position的位置；如果未设置mark调用reset()方法会报异常；如果positon或者limt小于mark时，mark被丢弃，其指为 -1；
各要素之间的关系：
0 <= mark <= position <= limit <= capacity
二 Buffer 架构体系
Buffer 是在多线程环境下是非安全操作，如果要在多线程情况下使用通常要加锁；Buffer 和其子类都是抽象类，其不能被实例化，需通过wrap(byte[] byte)方法来构建不同的缓冲区，具体的架构体系如下：
Object (java.lang)
-->Buffer (java.nio)
---->IntBuffer (java.nio)
---->FloatBuffer (java.nio)
---->CharBuffer (java.nio)
---->DoubleBuffer (java.nio)
---->ShortBuffer (java.nio)
---->LongBuffer (java.nio)
---->ByteBuffer (java.nio)
三 Buffer 方法介绍
Buffer 的子类完全实现了其父类的方法，所以本文示例都是使用其子类举例分析；
3.1 position()
int position() 方法是返回缓冲区的位置；
@Test
public void testPosition(){
byte[] bytes = {15,17,25,13,46,18};
ByteBuffer wrap = ByteBuffer.wrap(bytes);
// 获得位置
int position = wrap.position();
System.out.println(position);//0
// 设置位置
Buffer position1 = wrap.position(5);
//[pos=5 lim=6 cap=6]
System.out.println(position1);
}
3.2 limit()
int limit() 返回缓冲区的限制；如果 position > limit ，position就是limit，自行验证；
@Test
public void testLimit(){
byte[] bytes = {15,17,25,13,46,18};
ByteBuffer wrap = ByteBuffer.wrap(bytes);
// 获得限制
int limit = wrap.limit();
System.out.println(limit);//6
// 设置限制
Buffer limit1 = wrap.limit(3);
//[pos=0 lim=3 cap=6]
System.out.println(limit1);
// 输出缓冲区元素
for (int i=0; i<bytes.length; i++){
// 只输出 15 17 25 继续get会报 BufferUnderflowException
System.out.println(wrap.get());
}
}
3.3 mark()
Buffer mark() 设置缓冲区标记；如果未设置mark调用reset()会报 InvalidMarkException 异常，自行验证；
@Test
public void testMark() {
byte[] bytes = {15, 17, 25, 13, 46, 18};
ByteBuffer wrap = ByteBuffer.wrap(bytes);
// 设置位置
wrap.position(1);
// 设置标记
wrap.mark();
// [pos=1 lim=6 cap=6]
System.out.println(wrap);
// 改变位置
wrap.position(4);
// 调用reset
wrap.reset();
// [pos=1 lim=6 cap=6]
System.out.println(wrap);
}
3.4 capacity()
int capacity() 返回缓冲区的容量，不可改变；
@Test
public void test(){
byte[] bytes = new byte[25];
ByteBuffer wrap = ByteBuffer.wrap(bytes);
// 获得缓冲区容量
int capacity = wrap.capacity();
// 25
System.out.println(capacity);
}
3.5 remaining()
int remaining() 返回当前位置和限制之间的大小；即 remaining = limit - position;
@Test
public void testRemaining() {
byte[] bytes = {15, 17, 25, 13, 46, 18};
ByteBuffer wrap = ByteBuffer.wrap(bytes);
// 获得缓冲区的元素个数
int remaining = wrap.remaining();
// 6
System.out.println(remaining);
// 设置位置
wrap.position(1);
// 设置limit
wrap.limit(5);
// 重新获得缓冲区的元素个数
int remaining1 = wrap.remaining();
//4
System.out.println(remaining1);
}
3.6 isDirect()
abstract boolean isDirect() 判断该缓冲区是否是直接缓冲区；平常的缓冲区都是非直接缓冲区，即在jvm内部创建的缓冲区，我们调用Buffer相关的方法都会走jvm内部缓冲区，其性能不如直接缓存区快；直接缓冲区是指无需创建jvm内部缓冲区，直接跟计算级的内存空间交互，其速度较快；
@Test
public void testIsDirect() {
byte[] bytes = {15, 17, 25, 13, 46, 18};
ByteBuffer wrap = ByteBuffer.wrap(bytes);
// 判断是否是直接缓冲区
boolean direct = wrap.isDirect();
// false
System.out.println(direct);
// 分配直接缓冲区
ByteBuffer byteBuffer = ByteBuffer.allocateDirect(8);
boolean direct1 = byteBuffer.isDirect();
// true
System.out.println(direct1);
}
3.7 isReadOnly()
abstract boolean isReadOnly() 判断是否是只读缓冲区；
@Test
public void testIsDeadOnly() {
byte[] bytes = {15, 17, 25, 13, 46, 18};
ByteBuffer wrap = ByteBuffer.wrap(bytes);
// 判断是否是只读缓冲区
boolean readOnly = wrap.isReadOnly();
// false
System.out.println(readOnly);
}
3.8 clean()
Buffer clear() 是还原缓冲区的初始状态，记住不是字面的意思清除缓冲区数据；
@Test
public void testClean() {
byte[] bytes = {15, 17, 25, 13, 46, 18};
ByteBuffer wrap = ByteBuffer.wrap(bytes);
wrap.position(2);
wrap.limit(5);
// [pos=2 lim=5 cap=6]
System.out.println(wrap);
// 还原缓冲区状态
wrap.clear();
// [pos=0 lim=6 cap=6]
System.out.println(wrap);
}
其主要使用于重新写入数据至缓冲区；通常在通道read，put 操作之前调用为了填充缓冲区；
示例：
@Test
public void testClean2() {
CharBuffer wrap = CharBuffer.allocate(24);
wrap.put("youku1327");
wrap.clear();
wrap.put("知识追寻者");
wrap.rewind();
for (int i=0; i<wrap.limit();i++){
//知识追寻者1327
System.out.print(wrap.get());
}
}
源码：
public final Buffer clear() {
// 位置清0
position = 0;
// 调整限制等于容量
limit = capacity;
// 标记调整为默认值
mark = -1;
return this;
}
3.9 flip()
Buffer flip() 翻转缓冲区；不是字面意思上的将缓冲区的数据倒转，是指截取的意思；将限制设置为位置所在的当前值，将位置清0，如果有定义标记，则抛弃标记；
源码：
public final Buffer flip() {
// 将限制设置当前位置的值
limit = position;
// 位置清 0
position = 0;
// 抛弃标记
mark = -1;
return this;
}
示例：
@Test
public void testFilp() {
byte[] bytes = {15, 17, 25, 13, 46, 18};
ByteBuffer wrap = ByteBuffer.wrap(bytes);
wrap.position(2);
wrap.mark();
// 翻转前 [pos=2 lim=6 cap=6]
System.out.println(wrap);
// 翻转
wrap.flip();
// 反正后 [pos=0 lim=2 cap=6]
System.out.println(wrap);
// 输出缓冲区元素
for (int i=0; i<wrap.limit(); i++){
// 15 17
System.out.println(wrap.get());
}
}
其通常在一系列 通道 put 或者 read 操作之后调用此方法为通道的write或者 get操作做准备；
示例：
@Test
public void testFilp2() {
CharBuffer wrap = CharBuffer.allocate(15);
wrap.put("公众号:知识追寻者");
// 翻转
wrap.flip();
for (int i=0; i<wrap.limit(); i++){
// 公众号:知识追寻着
System.out.print(wrap.get());
}
}
3.10 hasArray()
abstract boolean hasArray() 判断底层是否支持数组的实现；
@Test
public void testHasArray(){
// 间接缓存
ByteBuffer allocate = ByteBuffer.allocate(10);
boolean hasArray = allocate.hasArray();
// true
System.out.println(hasArray);
// 直接缓存
ByteBuffer byteBuffer = ByteBuffer.allocateDirect(10);
boolean hasArray1 = byteBuffer.hasArray();
// false
System.out.println(hasArray1);
}
3.11 hasRemaining()
boolean hasRemaining() 判断 limit 和 position直接是否有元素；经常使用于缓冲区读取数据；
@Test
public void testHasRemaining(){
byte[] bytes = {15, 17, 25, 13, 46, 18};
ByteBuffer wrap = ByteBuffer.wrap(bytes);
while (wrap.hasRemaining()){
// 15 17 25 13 46 18
System.out.println(wrap.get());
}
}
3.12 rewind()
Buffer rewind() 重绕缓冲区；其通常在通道write 或者 get 操作之前调用，为了重新读取数据；注意其限制不变；
源码：
public final Buffer rewind() {
// 位置设置为0
position = 0;
// 抛弃标记
mark = -1;
return this;
}
示例：
@Test
public void testRewind(){
byte[] bytes = {15, 17, 25, 13, 46, 18};
ByteBuffer wrap = ByteBuffer.wrap(bytes);
while (wrap.hasRemaining()){
// 15 17 25 13 46 18
System.out.println(wrap.get());
}
// 重绕缓冲区
wrap.rewind();
while (wrap.hasRemaining()){
// 15 17 25 13 46 18
System.out.println(wrap.get());
}
}
3.13 arrayOffset()
abstract int arrayOffset() 返回写入缓冲区第一个元素的偏移，可选操作；
@Test
public void testOffset(){
byte[] bytes = {15, 17, 25, 13, 46, 18};
ByteBuffer wrap = ByteBuffer.wrap(bytes);
// 获得偏移
int arrayOffset = wrap.arrayOffset();
// 0
System.out.println(arrayOffset);
}
源码：
public final int arrayOffset() {
if (hb == null)
throw new UnsupportedOperationException();
if (isReadOnly)
throw new ReadOnlyBufferException();
return offset;
}
final int offset;