什么是 ByteBuffer？
ByteBuffer 是一个用于存储字节数据的缓冲区，你可以把它想象成一个固定大小的容器，专门用来存放 byte 类型的数据，它不仅仅是一个简单的字节数组，更重要的是，它提供了三个关键特性，使其在 I/O 操作中远比传统的字节数组高效：
（图片来源网络，侵删）
- 视图:
ByteBuffer可以被“包装”成其他基本数据类型（如IntBuffer,LongBuffer,ShortBuffer等）的缓冲区，这意味着你可以用ByteBuffer来存放int或long数据,而无需手动处理字节序和转换。 - 字节序:
ByteBuffer可以明确指定数据在网络传输或跨平台存储时的字节顺序（大端序 Big-Endian 或小端序 Little-Endian），这对于网络协议的实现至关重要，可以确保不同架构的计算机（如 x86 的小端序和 PowerPC 的大端序）能正确解析数据。 - 通道:
ByteBuffer是Channel（通道）进行 I/O 操作的唯一数据载体，无论是文件读写还是网络通信，数据都必须通过ByteBuffer在Channel和Channel的另一端（如文件或套接字）之间进行传输。
ByteBuffer 的核心概念：position, limit, capacity
ByteBuffer 内部有三个重要的指针，它们共同定义了缓冲区中可以进行读写的范围，理解这三个指针是掌握 ByteBuffer 的关键。
-
capacity(容量):- 含义: 缓冲区可以容纳的最大数据量，它在缓冲区创建时被设定，之后永远不会改变。
- 好比: 一个 10 升的水桶，它的
capacity10。
-
limit(限制):- 含义: 缓冲区中当前不可读写的位置的索引,它标记了读写的边界。
- 写模式:
limit通常等于capacity,表示你可以写满整个缓冲区。 - 读模式: 当你从
Channel读取数据到缓冲区后，limit会被设置为实际读取到的数据量之后的位置，你读取了 5 个字节，limit就会被设置为 5，这样你就只能读取前 5 个字节,防止读到未初始化的数据。 - 好比: 水桶里装了 5 升水，
limit5，你最多只能喝到 5 升,再多喝就超出范围了。
-
position(位置):
（图片来源网络，侵删）- 含义: 下一个要被读或写的元素的索引，每次读写操作后，
position都会自动增加。 - 好比: 水龙头当前的水位位置，每次喝水（读）或加水（写），水位线（
position）就会上升。
- 含义: 下一个要被读或写的元素的索引，每次读写操作后，
总结关系：
0 <= position <= limit <= capacity
ByteBuffer 的两种模式：读/写模式
ByteBuffer 在任何时刻都处于两种模式之一：写模式 或 读模式。
- 初始状态: 新创建的
ByteBuffer处于写模式。position = 0limit = capacity
- 从写模式切换到读模式: 调用
flip()方法，这是ByteBuffer最核心的操作之一。flip()的作用是：将limit设置为当前的position（即已写入的数据长度），然后将position重置为 0。- 这就为后续的读取操作做好了准备,让你可以从缓冲区的开头读取刚刚写入的数据。
- 从读模式切换到写模式: 调用
clear()或compact()方法。clear(): 快速清空，准备写入新数据，它只是重置position=0和limit=capacity，但不会清除数据,这些数据会被后续的写入覆盖。compact(): 更智能的清空，它会将未读取的数据复制到缓冲区的开头，然后设置position为未读数据的长度，limit为capacity，这允许你继续在缓冲区的剩余空间写入新数据,而不会丢失未读的数据。
常用方法详解
1 创建 ByteBuffer
// 1. 分配一个指定大小的直接缓冲区（Direct Buffer） // 直接缓冲区在 JVM 之外分配内存，减少了 JVM 和操作系统之间数据拷贝的次数，适合网络和文件 I/O。 ByteBuffer directBuffer = ByteBuffer.allocateDirect(1024); // 2. 分配一个堆缓冲区（Heap Buffer） // 最常用，在 JVM 堆上分配内存，受 GC 管理，创建和销毁更快。 ByteBuffer heapBuffer = ByteBuffer.allocate(1024); // 3. 包装一个现有的字节数组 // 这个缓冲区和数组共享底层数据，修改一个会影响另一个。 byte[] array = new byte[100]; ByteBuffer wrapBuffer = ByteBuffer.wrap(array);
2 写入数据
ByteBuffer buffer = ByteBuffer.allocate(50); // 写入单个字节 buffer.put((byte) 10); // 写入一个字节数组 byte[] data = "Hello, NIO!".getBytes(); buffer.put(data); // 写入一个 int (4个字节)，使用小端序 buffer.putInt(2025); // 内部会调用 put(byte[4])，并考虑字节序 // 写入一个 long (8个字节) buffer.putLong(987654321L);
3 切换模式与读取数据
// 假设 buffer 已经写入了数据 buffer.flip(); // 切换到读模式 // 读取单个字节 byte b = buffer.get(); // 读取一个字节数组到另一个数组中 byte[] dest = new byte[buffer.remaining()]; buffer.get(dest); // 读取剩余所有数据到 dest // 读取一个 int (4个字节) int i = buffer.getInt(); // 读取一个 long (8个字节) long l = buffer.getLong();
4 其他重要方法
remaining(): 返回limit - position，即还剩下多少数据可读/可写。hasRemaining():remaining() > 0的简写。rewind(): 将position设置为 0，但不改变limit,用于重新读取缓冲区中的数据。mark()和reset():mark()记录当前的position，reset()将position恢复到mark的位置。clear(): 清空缓冲区，准备写入新数据。position=0,limit=capacity。compact(): 压缩缓冲区，将未读数据移到开头,准备在剩余空间写入新数据。duplicate(),slice(),asReadOnlyBuffer(): 创建缓冲区的“视图”，共享底层数据，但拥有独立的position,limit,mark。
字节序
字节序决定了多字节数据（如 int, long）在内存中存储的顺序。
- 大端序: 高位字节在内存的低地址，低位字节在高地址。网络协议（如 TCP/IP）默认使用大端序。
- 小端序: 低位字节在内存的低地址，高位字节在高地址。x86/x64 架构的 CPU 使用小端序。
ByteBuffer 默认使用大端序。
（图片来源网络，侵删）
ByteBuffer buffer = ByteBuffer.allocate(4);
buffer.putInt(0x01020304); // 写入一个整数
// 默认是大端序，内存中存储为: 01 02 03 04
System.out.println("默认字节序 (大端): " + buffer.get(0)); // 输出 1
// 切换为小端序
buffer.order(ByteOrder.LITTLE_ENDIAN);
buffer.putInt(0x01020304); // 再次写入
// 现在是小端序，内存中存储为: 04 03 02 01
System.out.println("小端序: " + buffer.get(0)); // 输出 4
最佳实践: 在进行网络编程时，始终在 ByteBuffer 上设置一个统一的字节序（通常是 ByteOrder.BIG_ENDIAN）,以确保通信双方数据一致。
直接缓冲区 vs. 堆缓冲区
| 特性 | 堆缓冲区 (allocate()) |
直接缓冲区 (allocateDirect()) |
|---|---|---|
| 内存位置 | JVM 堆内存 | JVM 堆外内存（由操作系统直接管理） |
| 创建/销毁 | 快速，受 GC 管理 | 较慢，不受 GC 管理，需要手动释放 |
| I/O 性能 | 较慢，数据从 JVM 堆拷贝到内核空间，再拷贝到网卡/磁盘（两次拷贝）。 | 更快，减少了 JVM 和操作系统之间的数据拷贝次数（一次拷贝）。 |
| 适用场景 | 大多数常规应用，内存占用不大，对性能要求不高的场景。 | 网络 I/O、文件 I/O，特别是数据量大的场景。 |
| 缺点 | I/O 性能是瓶颈。 | 占用本地内存，如果创建过多可能导致本地内存溢出（OutOfMemoryError）。 |
简单记： 需要和操作系统（网络、文件）打交道，用 Direct Buffer，只在 JVM 内部处理数据，用 Heap Buffer。
完整代码示例：Echo Server
这个示例展示了 ByteBuffer 如何与 ServerSocketChannel 和 SocketChannel 配合工作,实现一个简单的回显服务器。
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
public class NioEchoServer {
public static void main(String[] args) throws IOException {
// 1. 打开一个服务器通道
try (ServerSocketChannel serverChannel = ServerSocketChannel.open()) {
// 2. 绑定端口并设置为非阻塞模式
serverChannel.bind(new InetSocketAddress(8080));
serverChannel.configureBlocking(false);
System.out.println("Echo Server started on port 8080...");
// 3. 创建一个直接缓冲区用于接收数据
ByteBuffer readBuffer = ByteBuffer.allocateDirect(1024);
while (true) {
// 4. 接受新的客户端连接
SocketChannel clientChannel = serverChannel.accept();
if (clientChannel != null) {
System.out.println("Accepted connection from: " + clientChannel.getRemoteAddress());
clientChannel.configureBlocking(false);
// 5. 循环处理客户端数据
while (clientChannel.isConnected()) {
try {
// 6. 从通道读取数据到缓冲区
int bytesRead = clientChannel.read(readBuffer);
if (bytesRead == -1) {
// 客户端关闭连接
System.out.println("Client disconnected: " + clientChannel.getRemoteAddress());
clientChannel.close();
break;
}
if (bytesRead > 0) {
// 7. 切换缓冲区为读模式
readBuffer.flip();
// 8. 将缓冲区中的数据写回客户端（回显）
while (readBuffer.hasRemaining()) {
clientChannel.write(readBuffer);
}
// 9. 清空缓冲区，准备下一次读取
readBuffer.clear();
}
} catch (IOException e) {
System.err.println("Error with client: " + clientChannel.getRemoteAddress());
clientChannel.close();
break;
}
}
}
}
}
}
}
ByteBuffer 是 Java NIO 的基石，它通过缓冲区、通道和选择器模型，解决了传统 BIO（阻塞 I/O）模型在高并发场景下的性能瓶颈。
掌握 ByteBuffer 的关键在于：
- 理解
position,limit,capacity三个指针。 - 熟练使用
flip(),clear(),compact()来切换读写模式。 - 区分
Direct Buffer和Heap Buffer的使用场景。 - 明确字节序在网络编程中的重要性。
通过 ByteBuffer，Java 程序可以更高效地管理内存，并与操作系统进行更直接、更快速的 I/O 交互。
