当前位置：首页 > news >正文

NIO ByteBuffer 总结

news 来源：原创 2025/5/8 21:05:55

基本概念

java.nio.ByteBuffer 是 Java NIO 中一个核心类， 用于高效处理二进制数据的读写操作。应用于通道（Channel）的I/O操作。作用：

数据缓冲：作为内存中的临时存储区，用于在通道Channel（如文件或网络通道）之间传输数据。
简化数据处理：支持对基本数据类型（如int、char）的直接读写。
高效操作：提供直接内存访问（Direct Buffer），减少数据在JVM堆和本地内存之间的复制开销。

创建 ByteBuffer

（1）堆缓冲区（Heap Buffer）

ByteBuffer buffer = ByteBuffer.allocate(1024); // 在JVM堆上分配

源码：

// java.nio.ByteBuffer
public static ByteBuffer allocate(int capacity) {
    if (capacity < 0)
        throw new IllegalArgumentException();
    return new HeapByteBuffer(capacity, capacity); // 堆分配
}

class HeapByteBuffer extends ByteBuffer
{
    HeapByteBuffer(int cap, int lim) {
        super(-1, 0, lim, cap, new byte[cap], 0);
        /*
        hb = new byte[cap]; -- 底层是字节数组
        offset = 0;         -- 偏移量初始 0
        */
}

（2）直接缓冲区（Direct Buffer）

ByteBuffer directBuffer = ByteBuffer.allocateDirect(1024); // 直接在本地内存分配

源码：

// java.nio.ByteBuffer
public static ByteBuffer allocateDirect(int capacity) {
    return new DirectByteBuffer(capacity); // 本地内存分配
}

// ...

（3）包装数组（wrap）

byte[] bytes = new byte[1024];
ByteBuffer wrappedBuffer = ByteBuffer.wrap(bytes); // 包装现有数组

核心属性

ByteBuffer通过四个属性控制读写操作：

Capacity：缓冲区容量（不可变）。
Position：当前读写位置，下一个操作的起始索引。
Limit：可操作数据的最大位置（写模式时等于Capacity，读模式时等于有效数据量）。
Mark：标记位置，后续可通过reset()返回到此位置;

// 继承了 java.nio.Buffer
public abstract class ByteBuffer extends Buffer 
    implements Comparable<ByteBuffer>{
    
    ...
    
    final byte[] hb;                  // Non-null only for heap buffers
    final int offset;
    boolean isReadOnly;                 // Valid only for heap buffers
    
    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;
    }
    
    ...
    
}

// 父类 java.nio.Buffer
public abstract class Buffer {

    ...

    // Invariants: mark <= position <= limit <= capacity
    private int mark = -1;
    private int position = 0;
    private int limit;
    private int capacity;
    
    // 返回 mark 标记位置
    public final Buffer reset() {
        int m = mark;
        if (m < 0)
            throw new InvalidMarkException();
        position = m;
        return this;
    }
    
    ... 
    
}

关键方法

切换模式

（1）flip()：写模式 → 读模式（limit=position，position=0）。

/** 
 * java.nio.Buffer 父类中实现, 
 
 * 使用示例 :
 * buf.put(magic);    // Prepend header
 * in.read(buf);      // Read data into rest of buffer
 * buf.flip();        // Flip buffer
 * out.write(buf);    // Write header + data to channel</pre></blockquote>
 */
public final Buffer flip() {
    limit = position;
    position = 0;
    mark = -1;
    return this;
}

（2）clear()：读模式 → 写模式（position=0，limit=capacity，数据未删除）。

/**
 * Clears this buffer.  The position is set to zero, the limit is set to
 * the capacity, and the mark is discarded.
 *
 * <p> Invoke this method before using a sequence of channel-read or
 * <i>put</i> operations to fill this buffer.  For example:
 *
 * <blockquote><pre>
 * buf.clear();     // Prepare buffer for reading
 * in.read(buf);    // Read data</pre></blockquote>
 *
 * <p> This method does not actually erase the data in the buffer, but it
 * is named as if it did because it will most often be used in situations
 * in which that might as well be the case. </p>
 */
public final Buffer clear() {
    position = 0;
    limit = capacity;
    mark = -1;
    return this;
}

（3）rewind()：重置position为0，用于重新读取数据。

/**
 * Rewinds this buffer.  The position is set to zero and the mark is
 * discarded.
 *
 * <p> Invoke this method before a sequence of channel-write or <i>get</i>
 * operations, assuming that the limit has already been set
 * appropriately.  For example:
 *
 * <blockquote><pre>
 * out.write(buf);    // Write remaining data
 * buf.rewind();      // Rewind buffer
 * buf.get(array);    // Copy data into array</pre></blockquote>
 *
 * @return  This buffer
 */
public final Buffer rewind() {
    position = 0;
    mark = -1;
    return this;
}

读写操作

（1）put(byte b) 和 get()：相对位置操作（自动移动position）。

java.nio.ByteBuffer 抽象方法：

public abstract class ByteBuffer extends Buffer 
    implements Comparable<ByteBuffer>{
    ...
    
    public abstract byte get(); // 抽象方法
    
    public abstract ByteBuffer put(byte b); // 抽象方法
    
    ...
}

具体实现类：java.nio.HeapByteBuffer / java.nio.DirectByteBuffer

// java.nio.HeapByteBuffer
public byte get() {
    return hb[ix(nextGetIndex())];
}

public ByteBuffer put(byte x) {
    hb[ix(nextPutIndex())] = x;
    return this;
}

final int nextGetIndex() {                          // package-private
    int p = position;
    if (p >= limit)
        throw new BufferUnderflowException();
    position = p + 1;
    return p;
}

final int nextPutIndex() {                          // package-private
    int p = position;
    if (p >= limit)
        throw new BufferOverflowException();
    position = p + 1;
    return p;
}

（2）put(int index, byte b) 和 get(int index)：绝对位置操作（不移动position）。

// java.nio.HeapByteBuffer
public byte get(int i) {
    return hb[ix(checkIndex(i))];
}

public ByteBuffer put(int i, byte x) {
    hb[ix(checkIndex(i))] = x;
    return this;
}

// java.nio.Buffer
final int checkIndex(int i) {                       // package-private
    if ((i < 0) || (i >= limit))
        throw new IndexOutOfBoundsException();
    return i;
}

压缩数据

compact()：将未读数据复制到缓冲区头部，position设置为剩余数据末尾，继续写入。

java.nio.ByteBuffer 抽象方法：

public abstract ByteBuffer compact();

具体实现类：java.nio.HeapByteBuffer / java.nio.DirectByteBuffer

// java.nio.HeapByteBuffer
public ByteBuffer compact() {
    // 未读数据复制到缓冲区头部
    System.arraycopy(hb, ix(position()), hb, ix(0), remaining()); 
    // position设置为剩余数据末尾
    position(remaining());
    // limit设置为容量，支持继续写入
    limit(capacity());
    discardMark();
    return this;
}