ByteBuffer正确使用步骤
- 向 buffer 写入数据，如调用
int n = channel.read(buffer);如果返回值n = -1，则代表读取完毕。 - 调用
flip()切换至读模式 - 从 buffer 读取数据，例如调用
buffer.get(); - 调用
clear()或compact()切换至写模式 - 循环重复 1 ~ 4 步骤
// Invariants: mark <= position <= limit <= capacity
private int mark = -1;
// 当调用 mark() 方法后，会把 position 赋值给 mark
private int position = 0;
// 表示下一个被读取或者写入的位置
private int limit;
// 表示第一个不可以被读取或者写入的元素的位置
private int capacity;
// ByteBuffer，表示可以容纳的元素数量ByteBuffer 一共有两个构造器，且都是 protected 的，因此我们不可以使用 new 的方法构造对象
// Creates a new buffer with the given mark, position, limit, capacity,
// backing array, and array offset
//
ByteBuffer(int mark, int pos, int lim, int cap,// package-private
byte[] hb, int offset)
{
super(mark, pos, lim, cap);
this.hb = hb;
this.offset = offset;
}// Creates a new buffer with the given mark, position, limit, and capacity
//
ByteBuffer(int mark, int pos, int lim, int cap) { // package-private
this(mark, pos, lim, cap, null, 0);
}我们可以使用
allocate() 和 allocateDirect() 构造 ByteBuffer。public static ByteBuffer allocateDirect(int capacity) {
return new DirectByteBuffer(capacity);
}public static ByteBuffer allocate(int capacity) {
if (capacity < 0)
throw createCapacityException(capacity);
return new HeapByteBuffer(capacity, capacity);
}内部原理
当通过
allocate() 或 allocateDirect() 构造一个新的 ByteBuffer后positon = 0;
mark = -1;
limit = capacity;
文章图片
当前模式是写模式时：
position 即下一个要写入的位置切换读写模式
当使用
flip() 切换至读模式时候：limit 设置为下一个写入字节的位置position 为下一个要读取字节的位置，每次读取完后 position++；读取的时候如果
position 超过 limit 则抛出 BufferUnderflowExceptionpublic Buffer flip() {
limit = position;
position = 0;
mark = -1;
return this;
}当使用
clear() 切换至读模式时：即恢复到初始状态，下一个写入字节的位置为 0
该方法相当于清除
ByteBuffer 所有状态public Buffer clear() {
position = 0;
limit = capacity;
mark = -1;
return this;
}还可以使用
compact() 方法切换至读模式，相对于 clear() 方法，该方法会保留上次未读取完的字节，拷贝到内部字节数组前部，然后使得 position 为未读完字节长度。重要方法
get()
get() 方法会让 position 读指针向后走，如果想重复读取数据- 调用
rewind()方法将position重新置为 0 - 调用
get(int i)方法获取索引 i 的内容，它不会移动读指针
position 设为 0 ，相当于从头开始读public Buffer rewind() {
position = 0;
mark = -1;
return this;
}mark() & reset()
注意：rewind() 和 flip() 都会清除 mark 位置把当前读写位置
position 赋值给 mark 做一个标记，后续可以通过 reset() 方法恢复至标记的位置public Buffer mark() {
mark = position;
return this;
}转变当前
position 为上次保留的读写位置，设置 position 为 markpublic Buffer reset() {
int m = mark;
if (m < 0)
throw new InvalidMarkException();
position = m;
return this;
}字符字节互转 字符串转为字节：
// 字符串直接转为字节数组
ByteBuffer buffer1 = ByteBuffer.allocate(16);
buffer1.put("hello".getBytes());
// Charset
ByteBuffer buffer2 = StandardCharsets.UTF_8.encode("hello");
// warp
ByteBuffer buffer3 = ByteBuffer.wrap("hello".getBytes());
字节转化为字符：
// ByteBuffer 转 String
String s = StandardCharsets.UTF_8.decode(buffer2).toString();
System.out.println(s);
分散读集中写 当文本文件中为 onetwothree 时，我们可以一次性读取到大的
ByteBuffer 然后进行分割，这样会造成效率不高我们可以采取分散读，分别读到对应长度的
ByteBuffer 中去，然后再进行后续处理try (FileChannel channel = new RandomAccessFile("ScatteringReads.txt", "r").getChannel();
) {
ByteBuffer b1 = ByteBuffer.allocate(3);
ByteBuffer b2 = ByteBuffer.allocate(3);
ByteBuffer b3 = ByteBuffer.allocate(5);
// 分开读取到对应长度 ByteBuffer 中
channel.read(new ByteBuffer[]{b1, b2, b3});
b1.flip();
b2.flip();
b3.flip();
System.out.println(b1);
// one
System.out.println(b2);
// two
System.out.println(b3);
// three
} catch (IOException e) {
e.printStackTrace();
}【Netty之ByteBuffer】当我们需要把一批数据写入到文件中去，可以分别写，这样会造成 IO 效率低下，可以采用集中写，聚集到一起，一次性写入到文件中
ByteBuffer b1 = StandardCharsets.UTF_8.encode("hello");
// 5个字节
ByteBuffer b2 = StandardCharsets.UTF_8.encode("world");
// 5个字节
ByteBuffer b3 = StandardCharsets.UTF_8.encode("你好");
// 6个字节try (FileChannel channel = new RandomAccessFile("GatheringWrites.txt", "rw").getChannel();
) {
channel.write(new ByteBuffer[]{b1, b2, b3});
} catch (IOException e) {
e.printStackTrace();
}
