一 核心要素
- 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;