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

【NIO番外篇】之组件 Buffer

news 来源：原创 2025/9/2 4:52:59

在这里插入图片描述

- 一、Buffer：数据界的“快递小哥”/“临时仓库管理员” 😉
- - 什么是 Buffer？
  - 它的作用是什么？
- 二、Buffer 的“三围”和“书签”📌：核心属性
- - 1. Capacity (容量)：
  - 2. Position (位置)：
  - 3. Limit (限制)：
  - 4. Mark (标记)：
- 三、Buffer 的“七十二变”🎭：核心方法
- 四、常用的 Buffer 种类
- - 上代码！边看边乐 🎬
- 五、总结一下 Buffer 的人生哲学

🌟我的其他文章也讲解的比较有趣😁，如果喜欢博主的讲解方式，可以多多支持一下，感谢🤗！

🌟了解 Redis主从复制请看： Redis主从复制：告别单身Redis！

其他优质专栏：【🎇SpringBoot】【🎉多线程】【🎨Redis】【✨设计模式专栏（已完结）】…等

如果喜欢作者的讲解方式，可以点赞收藏加关注，你的支持就是我的动力
✨更多文章请看个人主页：码熔burning

客官！ Java NIO Buffer 豪华幽默详解套餐来了！坐稳了，咱们这就发车 🚀，去看看这个在 NIO 世界里搬砖（搬数据）的劳模 —— Buffer！

一、Buffer：数据界的“快递小哥”/“临时仓库管理员” 😉

了解Java NIO的 Channel 组件请看：【NIO番外篇】之组件 Channel

想象一下，你（Java 应用程序）要和外面的世界（比如文件、网络连接，也就是 NIO 里的 Channel）进行大量的数据交换。直接一个字节一个字节地吼，效率太低，嗓子也受不了（系统开销大 😫）。这时候，Buffer 这位“快递小哥”就闪亮登场了！✨

什么是 Buffer？

简单说，Buffer 就是内存里的一块 固定大小 的区域，专门用来 临时存储 数据。它就像一个容量有限的 快递车厢 🚚 或者 仓库里的托盘 📦。数据要么从 Channel “装货”到 Buffer，要么从 Buffer “卸货”到 Channel。你也可以直接往 Buffer 里放东西 (put) 或者从里面取东西 (get)。

它的作用是什么？

提高效率：老式的 IO 是流式（Stream-based）的，一次可能只处理一个字节，慢吞吞🐢。NIO 和 Buffer 允许我们一次性处理一块数据（一个 Buffer 的量），减少了系统调用次数，就像快递小哥一次送一车货，而不是一件一件跑腿，效率大大滴提高了！👍
数据中转站：它是 Channel 和你的应用程序之间数据传输的 必经之路。数据必须先读入 Buffer，然后你才能处理；或者你先把数据写入 Buffer，然后才能通过 Channel 发送出去。Buffer 在中间扮演了“接驳员”的角色 🤝。
方便数据操作：Buffer 提供了一套精密的 API 来操作这块内存，让你能精确地控制读写位置、数据范围等。

二、Buffer 的“三围”和“书签”📌：核心属性

每个 Buffer 都像一个有严格规矩的仓库管理员，时刻关注着这四个核心指标：

1. Capacity (容量)：

含义：Buffer 能容纳的最大数据量（元素的数量）。一旦创建，容量就固定不变了。
理解：快递车厢的总容积，或者仓库托盘的最大承重。定了多大就是多大，不能超载 🚫，也不能临时扩容（除非你换个更大的车/托盘）。
方法：capacity()

2. Position (位置)：

含义：下一个要被读取或写入的元素的索引。初始值为 0。
理解：快递小哥当前正在操作（装货/卸货）的那个包裹的位置 👇。写数据 (put) 时，它指向下一个空位；读数据 (get) 时，它指向下一个要取的包裹。put 或 get 一次，position 就自动往后挪一个位置。➡️
方法：position() / position(int newPosition)

3. Limit (限制)：

含义：表示 Buffer 中有效内容的界限。
- 写模式下：Limit 等于 Capacity，表示你最多能写到哪里。
- 读模式下：Limit 等于之前写模式下的 position，表示你最多能读到哪里（也就是实际有多少数据可读）。
理解：
- 写模式：仓库管理员划定的“货物堆放区”的最大边界（不能超过这个边界放货 ✋）。
- 读模式：仓库管理员告诉你：“嘿，这批货实际上只装到了这里（Limit），后面的区域是空的或者还没整理好，你别过去取了！” 🤔
方法：limit() / limit(int newLimit)

4. Mark (标记)：

含义：一个备忘录位置。你可以通过 mark() 方法在当前 position 做个标记，之后可以通过 reset() 方法将 position 恢复到这个标记的位置。初始时 Mark 是未定义的（通常是 -1）。
理解：快递小哥在某个包裹上贴了个“稍后回来处理”的便利贴 (mark())📝。后来他忙完别的事，看到便利贴，就立刻回到那个包裹的位置 (reset())。↩️

记住这个重要的关系：0 <= mark <= position <= limit <= capacity （就像套娃一样，一层套一层 🧸）。

三、Buffer 的“七十二变”🎭：核心方法

Buffer 的操作就像一套组合拳，最常用的有：

allocate(int capacity) / allocateDirect(int capacity) (ByteBuffer 专属)：
- 作用：创建 Buffer。“喂！给我来个能装 capacity 个货的空车/托盘！” 🙋‍♂️
- allocate: 在 JVM 堆内存中分配，受 GC 管理。普通青年。
- allocateDirect: 在堆外（本地内存）分配，不受 GC 管理（但关联对象被回收时会释放），可能更快，因为操作系统可以直接操作这块内存，减少拷贝。文艺青年 😎，有点小资，分配和销毁成本高点。
- 初始状态：position = 0, limit = capacity, mark = -1。
put(...)：
- 作用：往 Buffer 里放数据。“装货！装货！” 📥
- 有多种重载形式，可以放单个元素，也可以放一个数组。
- 每放一个元素，position 就加 1。如果 position 追上 limit 了，再 put 就会抛出 BufferOverflowException（车厢满了！装不下了！🈵）。
get(...)：
- 作用：从 Buffer 里取数据。“卸货！卸货！” 📤
- 也有多种重载形式。
- 每取一个元素，position 就加 1。如果 position 追上 limit 了，再 get 就会抛出 BufferUnderflowException（货都卸完了！没货了！🤷‍♀️）。
flip() (翻转，核心！核心！核心！🤯)：
- 作用：从写模式切换到读模式。“装满货（或者写到一定程度）了，准备开始卸货！”
- 内部操作：
  - limit = position; （把当前写到的位置设为读取的上限）
  - position = 0; （把读取的起始位置拨回 0）
  - mark = -1; （标记作废）
- 理解：快递小哥装完货，大手一挥：“搞定！总共装了 position 件货。现在把装货清单（Limit）更新为 position，然后把卸货点（Position）挪回第一件货，准备开卸！” 这是最容易让人懵圈的操作，但也是 Buffer 的精髓所在！💡
rewind() (倒带)：
- 作用：重新读取 Buffer 中的数据。“刚才卸的货没看清，倒回去再看一遍！” ⏪
- 内部操作：
  - position = 0; （把读取位置拨回 0）
  - mark = -1; （标记作废）
- limit 保持不变。通常在 flip() 之后，读了一部分或全部数据后使用，可以让你从头再读一遍。
clear() (清空…但只是看起来像 🧹)：
- 作用：从读模式切换回写模式，准备重新写入。“这车货卸完了（或者不关心剩下的了），把车厢打扫干净（指针归位），准备装下一批！”
- 内部操作：
  - position = 0;
  - limit = capacity;
  - mark = -1;
- 注意：clear() 并不会真的清除 Buffer 中的数据！它只是把 position 和 limit 指针恢复到初始状态，表示这个 Buffer 现在可以从头开始写了。之前的数据还在那里，但除非你读它们，否则它们会被后续写入的数据覆盖。就像快递小哥只是把计数器归零，车厢里可能还有上次剩下的包装纸 🤫。
compact() (压缩)：
- 作用：把未读的数据（从 position 到 limit 之间的数据）挪到 Buffer 的开头，然后把 position 设置到最后一个未读元素的后面，limit 设置为 capacity。这样就可以在后面继续写入新的数据了。“把车厢里剩下的几件货往前挪挪，腾出后面的空间继续装新货！” 💪
- 场景：当你读取了 Buffer 中的一部分数据，但又想继续往 Buffer 里写，而不是完全 clear() 时使用。
mark() & reset()：
- mark(): 在当前的 position 打个标记。“在这做个记号！” 📍
- reset(): 把 position 恢复到之前 mark() 的位置。“回到刚才做记号的地方！” ↪️ 如果之前没调用过 mark() 或者 mark 因为 flip() 或 rewind() 被清除了，调用 reset() 会抛 InvalidMarkException。

四、常用的 Buffer 种类

主要是针对 Java 的基本数据类型：

ByteBuffer: 最常用！劳模中的劳模 🏆。处理字节数据，网络和文件 IO 的主力军。它可以是直接的（Direct）或非直接的（Heap）。
CharBuffer: 处理字符数据。
ShortBuffer: 处理短整型数据。
IntBuffer: 处理整型数据。
LongBuffer: 处理长整型数据。
FloatBuffer: 处理单精度浮点数。
DoubleBuffer: 处理双精度浮点数。

除了 ByteBuffer 有 allocateDirect，其他类型的 Buffer 通常通过 ByteBuffer 的 asCharBuffer(), asIntBuffer() 等方法创建，它们共享 ByteBuffer 底层的字节数据，只是提供了不同类型的“视图”（View Buffer）👀。

上代码！边看边乐 🎬

import java.nio.ByteBuffer;
import java.nio.charset.StandardCharsets;public class BufferFunTime {public static void main(String[] args) {System.out.println("Buffer 喜剧小剧场开演！🎉");// === 第一幕：申请个新“车厢” ===// 申请一个容量为 10 字节的 ByteBuffer (堆内)ByteBuffer buffer = ByteBuffer.allocate(10);printBufferState("1. 新车厢已就位 (allocate) 🚚", buffer); // pos=0, lim=10, cap=10// === 第二幕：往车厢里装货 (put) ===String message = "Hi!";buffer.put(message.getBytes(StandardCharsets.UTF_8));printBufferState("2. 装入 'Hi!' (put) 📥", buffer); // pos=3, lim=10, cap=10// === 第三幕：准备卸货！翻转！(flip) ===// 从写模式切换到读模式buffer.flip();printBufferState("3. 翻转！准备卸货 (flip) ✨", buffer); // pos=0, lim=3, cap=10// === 第四幕：开始卸货 (get) ===System.out.print("4. 卸货中 (get) 📤: ");while (buffer.hasRemaining()) { // hasRemaining() 检查 position < limitSystem.out.print((char) buffer.get()); // 读一个字节，position++}System.out.println();printBufferState("   卸货完毕 👍", buffer); // pos=3, lim=3, cap=10// === 第五幕：想再看一遍？倒带！(rewind) ===buffer.rewind();printBufferState("5. 倒带，准备重读 (rewind) ⏪", buffer); // pos=0, lim=3, cap=10System.out.print("   重新读取: ");while (buffer.hasRemaining()) {System.out.print((char) buffer.get());}System.out.println();printBufferState("   重读完毕 ✅", buffer); // pos=3, lim=3, cap=10// === 第六幕：打扫车厢，准备装新货 (clear) ===// 注意：数据其实还在，只是指针重置了buffer.clear();printBufferState("6. 打扫车厢 (clear) 🧹", buffer); // pos=0, lim=10, cap=10// 验证 clear 只是重置指针，数据可能还在System.out.println("   偷偷看一眼第一个字节 (它还在! 👀): " + (char)buffer.get(0)); // 使用绝对位置get，不改变position// === 第七幕：装新货，但这次车厢有点特殊 (compact 演示) ===buffer.clear(); // 先清空buffer.put("Hello".getBytes(StandardCharsets.UTF_8)); // 写入 "Hello" (5 字节)printBufferState("7a. 写入 'Hello'", buffer); // pos=5, lim=10, cap=10buffer.flip(); // 准备读printBufferState("7b. 翻转准备读 'Hello'", buffer); // pos=0, lim=5, cap=10// 只读前两个字节 'He'System.out.print("   只读 'He': ");System.out.print((char) buffer.get());System.out.print((char) buffer.get());System.out.println();printBufferState("   读完 'He'", buffer); // pos=2, lim=5, cap=10// 现在想继续往 Buffer 写，但又不想丢掉 'llo'// 使用 compact 把 'llo' 挪到前面buffer.compact();printBufferState("7c. 压缩 (compact) 💪", buffer); // pos=3, lim=10, cap=10// 解释: 'llo' (3字节)被移到 0,1,2 位置。position 设为 3，limit 设为 10.// 验证 'llo' 在前面System.out.println("   压缩后第一个字节 (是 'l'): " + (char)buffer.get(0));// 现在可以继续写入了，比如写入 " World" (6 字节)buffer.put(" World".getBytes(StandardCharsets.UTF_8));printBufferState("7d. 在压缩后写入 ' World'", buffer); // pos=9, lim=10, cap=10// 最后读出完整结果 "llo World"buffer.flip();printBufferState("7e. 翻转准备读 'llo World'", buffer); // pos=0, lim=9, cap=10System.out.print("   最终结果: ");while(buffer.hasRemaining()) {System.out.print((char)buffer.get());}System.out.println();printBufferState("   最终读取完毕🏁", buffer); // pos=9, lim=9, cap=10System.out.println("\nBuffer 喜剧小剧场落幕！鼓掌！👏👏");}// 辅助方法，打印 Buffer 的状态，方便观察private static void printBufferState(String action, ByteBuffer buffer) {System.out.printf("   Action: %-30s | pos=%-2d lim=%-2d cap=%-2d%n", // 稍微加宽 action 字段action, buffer.position(), buffer.limit(), buffer.capacity());}
}

运行这段代码，仔细观察每一步操作后 position, limit, capacity 的变化，就能深刻理解 Buffer 的工作机制了！🧐

五、总结一下 Buffer 的人生哲学

容量天注定（Capacity 固定）。
读写靠指针（Position 移动）。
边界要看清（Limit 控制范围）。
模式切换靠翻转（flip() 是关键 ✨）。
想重来可倒带（rewind() ⏪）。
要复用得“清场”（clear() 重置指针 🧹）。
腾空间有妙招（compact() 移动未读数据 💪）。

希望这个充满“槽点”、比喻和表情包😂的讲解，能让你彻底搞懂 Java NIO Buffer 这个有点绕但非常重要的家伙！下次再遇到它，就可以拍拍它的“肩膀”说：“Buffer 老兄，你的套路我懂了！😎”

目录