学校营销型网站建设关键词推广seo

基本概念

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 buffersfinal int offset;boolean isReadOnly;                 // Valid only for heap buffersByteBuffer(int mark, int pos, int lim, int cap,   // package-privatebyte[] 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 <= capacityprivate 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-privateint p = position;if (p >= limit)throw new BufferUnderflowException();position = p + 1;return p;
}final int nextPutIndex() {                          // package-privateint 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-privateif ((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;
}