ByteBuffer的allocate和allocateDirect

最新推荐文章于 2025-04-02 17:41:45 发布
最新推荐文章于 2025-04-02 17:41:45 发布
阅读量190 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/younglibin/article/details/88348523
本文介绍了Java中ByteBuffer的两种实例化方式及其应用场景。一种是在JVM内部分配内存，另一种是在JVM外分配系统级内存，后者在处理大数据量时效率更高。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

在Java中当我们要对数据进行更底层的操作时，通常是操作数据的字节（byte）形式，这时常常会用到ByteBuffer这样一个类。ByteBuffer提供了两种静态实例方式： 

Java代码   收藏代码
  1. public static ByteBuffer allocate(int capacity)  
  2. public static ByteBuffer allocateDirect(int capacity)  


为什么要提供两种方式呢？这与Java的内存使用机制有关。第一种分配方式产生的内存开销是在JVM中的，而第二种的分配方式产生的开销在JVM之外，以就是系统级的内存分配。当Java程序接收到外部传来的数据时，首先是被系统内存所获取，然后在由系统内存复制拷贝到JVM内存中供Java程序使用。所以在第二种分配方式中，可以省去复制这一步操作，效率上会有所提高。但是系统级内存的分配比起JVM内存的分配要耗时得多，所以并不是任何时候allocateDirect的操作效率都是最高的。下面是一个不同容量情况下两种分配方式的操作时间对比： 

 
由图可以看出，当操作数据量很小时，两种分配方式操作使用时间基本是相同的，第一种方式有时可能会更快，但是当数据量很大时，第二种方式会远远大于第一种的分配方式。

ByteBuffer的内存分配
优快云_G_Y的博客
02-26 1283
ByteBuffer内存分配方式
ByteBuffer.allocateDirect函数分析
dlx_handsome的博客
08-07 1654
在NIO中,有两种分配字节的方法: 在堆中初始缓冲区 public static ByteBuffer allocate(int capacity) { if (capacity < 0) throw createCapacityException(capacity); return new HeapByteBuffer(capacity, capacity); } 以及 在堆外创建缓冲区 public static ByteBuffer al
ByteBuffer中的allocate和allocateDirect
qq_49810363的博客
01-18 1267
1、区别 allocate方法创建的内存在jvm的管理范围，而allocateDirect方法创建的内存不由jvm管理，意思就是allocateDirect创建的内存由系统直接管理 2、释放 allocateDirect创建的内存不归jvm管理，那如何释放呢？虽然这块内存不属于jvm管理，但它属于该对象，当对象销毁时就是这块内存销毁的时候 3、为什么要有两种内存分配方式 由于java的内存不由系统直接管理，所以当网路数据过来时，需要先复制到系统所能操作的内存后再复制到java内存中，如果是用allocate
ByteBuffer 用法详解
Shrimp_millet
04-02 978
ByteBuffer 是 Java NIO 中用于处理字节数据的关键类，提供了比传统 byte[] 更灵活和高效的字节操作方式。
Android中的ByteBuffer解析
07-13
1. **分配缓冲区**：可以通过`ByteBuffer.allocate(int capacity)`来创建一个新的ByteBuffer，其中capacity参数指定缓冲区的大小。 2. **直接缓冲区**：对于性能敏感的应用，可以使用`ByteBuffer.allocateDirect...
ByteBuffer 直接缓冲区和非直接缓冲区
qq_36789243的博客
08-03 430
ByteBuffer 直接缓冲区和非直接缓冲区 ByteBuffer 在平时工作中可能用到的不多，但是面试中经常会被问到。本文总结了一些关于 ByteBuffer 的用法和相关 API 介绍。 下面是创建ByteBuffer对象的几种方式： static ByteBuffer allocate(int capacity) static ByteBuffer allocateDirect(int capacity) static ByteBuffer wrap(byte[] array)
ByteBuffer的三种实现与进程间通信
凤瓦力
02-21 552
ByteBuffer的三种实现为： HeapByteBuffer 堆内存 DirectByteBuffer 堆外/直接内存 MappedByteBuffer 堆外/文件映射 一、ByteBuffer ByteBuffer是java nio中的一种数据结构。主要用来保存从Socket中读写字节流，可以循环使用，有效降低GC压力。 内部有一个固定长度的byte[]。用三个数字来控制读写：capac...
Java中ByteBuffer的allocate方法 和allocateDirect方法的区别和选用原则
Shujie
12-19 896
选择使用哪种方式取决于应用的需求和性能特征：适用于较小的缓冲区，对内存占用不太敏感的情况。由于是在Java堆上分配，垃圾回收器能够管理这部分内存，但可能会有一些性能开销。适用于需要较大缓冲区或对性能要求较高的情况。由于是在本地内存上分配，可能减少了一些垃圾回收器的开销，但在分配和释放直接缓冲区时可能涉及到一些本地资源的操作。在使用时需要谨慎，因为它可能占用较多的本地内存，过度使用可能导致本地内存耗尽。在选用这两种技术方案中哪一种的时候需要根据具体的应用场景和需求权衡两者之间的取舍。
ByteBuffer.allocate()和ByteBuffer.allocateDirect
passtome的专栏
08-21 7391
allocateDirectpublic static ByteBuffer allocateDirect(int capacity)分配新的直接字节缓冲区。 新缓冲区的位置将为零，其界限将为其容量，其标记是不确定的。无论它是否具有底层实现数组，其标记都是不确定的。 参数：capacity - 新缓冲区的容量，以字节为单位allocatepublic static ByteBuffer alloc
ByteBuffer中allocateDirect与allocate的区别
09-19 3705
Java的NIO（New IO）中的ByteBuffer的allocateDirect()与allocate()的区别 allocateDirect public static ByteBuffer allocateDirect(int capacity) 分配新的直接字节
NIO ByteBuffer 的 allocate 和 allocateDirect 的区别（HeapByteBuffer 和 DirectByteBuffer 的区别）
程序猿小郝的博客，关住技术圈，分享原创技术文章和踩坑记录。
03-18 1005
ByteBuffer 中NIO里用得最多的Buffer ，有两种实现方式：HeapByteBuffer基于Java堆的实现，而DirectByteBuffer 使用了 unsafed 的API 进行了对外的实现。
ByteBuffer的原理和使用详解
10-31 657
ByteBuffer是字节缓冲区，主要用户读取和缓存字节数据，多用于网络编程，原生的类，存在不好用，Netty采用自己的ByteBuff，对其进行了改进。
Java ByteBuffer使用全解析
热门推荐
Shujie
12-20 1万+
ByteBuffer是 Java NIO（New I/O）库中的一个类，用于处理字节数据。它提供了一种灵活且高效的方式来操作字节缓冲区，适用于处理大量的字节数据，例如文件 I/O、网络通信等。ByteBufferByteBuffer有一个固定的容量，一旦分配，就不能更改。可以通过allocate静态方法或wrap静态方法来创建一个ByteBuffer。// 分配 1024 字节的缓冲区ByteBuffer有一个位置和限制的概念，它们用于跟踪读写的位置。position表示下一个要读写的位置，而limit。
ByteBuffer缓冲区的三种创建方式与解读
你学废了吗？
03-23 4808
1、allocate()创建堆缓冲区2、allocateDirect()创建直接缓冲区3、wrap()创建堆缓冲区4、直接缓冲区和非直接缓冲区的比较： 字节缓冲区分为直接字节缓冲区与非直接字节缓冲区。 1、allocate()创建堆缓冲区 ByteBuffer buffer1 = ByteBuffer.allocate(10); allocate()方法的作用： 分配一个新的非直接...
Java IO学习笔记二：DirectByteBuffer与HeapByteBuffer
Practitioner
11-10 575
allocate分配方式产生的内存开销是在JVM中的，allocateDirect分配方式产生的开销在JVM之外，也就是系统级的内存分配。3、经常复用DirectByteBuffer对象，即经常写入数据到DirectByteBuffer中，然后flip，再读取出来，最后clear，反复使用该DirectByteBuffer对象。所以在创建一个对象的情况下，HeapByteBuffer并没有什么优势，所以，开发中要使用ByteBuffer时，直接用DirectByteBuffer就行了）
NIO ByteBuffer的allocate与allocateDirect区别（HeapByteBuffer与DirectByteBuffer的区别）
祁东握力的博客
02-13 7129
其中allocateDirect分配的字节缓冲区用中文叫做直接缓冲区（DirectByteBuffer），用allocate分配的ByteBuffer叫做堆字节缓冲区(HeapByteBuffer).. 其实根据类名就可以看出，HeapByteBuffer所创建的字节缓冲区就是在jvm堆中的，即内部所维护的java字节数组。而DirectByteBuffer是直接操作操作系统本地代码创建的内存缓...
ByteBuffer中关于allocate和directAllocate的区别
上善若水，浮生如茶
07-29 1654
allocate和directAllocate 区别在于内存分配的方式，allocate分配的内存在jvm管理范围内，directAllocate分配的内存则不是由jvm管理，可以理解成是类似C++那种分配的内存，大家一定会说那由directAllocate分配的内存即然不由jvm管理，那么他是如何释放的，虽然directAllocate分配的内存不由jvm管理但他...
byteBuffer 如何重置 position 和 cap
最新发布
07-02
<think>我们正在讨论Java NIO中的ByteBuffer。用户的问题是如何重置ByteBuffer的position和设置capacity。首先，我们需要明确：ByteBuffer的capacity在创建后通常是固定的（除了通过slice()、duplicate()等方法创建视图，或者使用asReadOnlyBuffer()等，但这些方法不会改变底层数组的capacity）。如果要改变容量，通常需要创建一个新的ByteBuffer。但是，我们可以重置position（即设置position为0）以及调整limit等。另外，compact()方法可以压缩缓冲区，将position到limit之间的数据移动到缓冲区的开头，然后将position设置为剩余数据的末尾，limit设置为capacity。这样，我们就可以继续向缓冲区写入数据，而不会覆盖未读的数据。根据引用[3]：在HeapByteBuffer中的compact实现，它通过System.arraycopy将position到limit的数据复制到缓冲区的开头，然后设置position为剩余数据的数量（remaining()），设置limit为capacity。用户的问题包含两个部分：1.重置position：我们可以使用position(intnewPosition)方法设置position，或者使用rewind()方法将position设置为0（同时清除mark）。2.设置capacity：实际上，ByteBuffer的capacity在创建后不能改变。但是，我们可以通过创建一个新的ByteBuffer并复制数据来改变容量。因此，我们可以这样操作：重置position：-使用`buffer.position(0);`将position设置为0。-或者使用`buffer.rewind();`将position设置为0，同时limit不变（通常用于重新读取数据）。改变capacity：-如果我们需要更大的容量，可以创建一个新的ByteBuffer（可以是HeapByteBuffer或DirectByteBuffer），然后将原缓冲区中的数据复制到新缓冲区中。-复制数据时，我们可以使用`put`方法，但要注意先重置原缓冲区的位置（使用rewind()），然后读取原缓冲区的数据（从0到limit）写入新缓冲区。另外，引用[1]提到：mark()方法可以标记当前位置，然后通过reset()方法可以回到标记的位置。但是，重置position和设置capacity并不直接依赖于mark。步骤：1.重置position（不改变capacity）：-使用`buffer.rewind();`：将position设置为0，limit保持不变，mark被丢弃。这适用于重新读取缓冲区。-使用`buffer.clear();`：将position设置为0，limit设置为capacity，mark被丢弃。这适用于重新写入缓冲区。2.改变capacity（需要创建新缓冲区）：-创建一个新的ByteBuffer，指定新的容量。-将原缓冲区中的数据复制到新缓冲区。复制前，需要调整原缓冲区的position和limit（例如，使用`flip()`或`rewind()`）以便读取全部或部分数据。示例代码：重置position： ```javaByteBufferbuffer =...;buffer.rewind();//将position设置为0，limit不变//或者buffer.clear();//将position设置为0，limit设置为capacity```改变capacity（扩大或缩小）： ```java//假设我们需要将容量扩大到newCapacityintnewCapacity= ...; ByteBuffer newBuffer =ByteBuffer.allocate(newCapacity); //或者allocateDirect//将原缓冲区切换到读模式buffer.flip();//设置limit为当前position，position为0（这样读取的数据就是之前写入的数据） //或者如果原缓冲区已经处于读模式，我们可以使用rewind()，但要注意不要读取超过limit//将原缓冲区的数据复制到新缓冲区newBuffer.put(buffer);//现在newBuffer包含了原缓冲区的数据，并且position指向最后写入的位置，limit为capacity//如果我们需要读取新缓冲区的数据，需要调用flip()newBuffer.flip(); ```注意：如果原缓冲区是直接缓冲区，新缓冲区可以是直接缓冲区或堆缓冲区，反之亦然。另外，如果原缓冲区中的数据量大于新容量，那么复制时会抛出BufferOverflowException。因此，在复制前需要确保新容量足够。另外，引用[5]提到：getByte(intindex)方法可以从指定位置读取，而不改变position。但是，我们这里不涉及。总结：重置position：使用`rewind()`或`clear()`，或者使用`position(0)`。改变capacity：需要创建新的ByteBuffer并复制数据。因此，回答用户的问题：如何在JavaNIO中重置ByteBuffer的position和capacity？重置position：直接调用`rewind()`或`clear()`或`position(0)`。改变capacity：不能直接改变，需要创建新的ByteBuffer并复制数据。下面给出完整代码示例。</think>### Java NIO ByteBuffer 的 position 重置与 capacity 设置 在 Java NIO 中，`ByteBuffer` 的 **position** 和 **capacity** 是两个核心属性： - **position**：当前读写位置指针 - **capacity**：缓冲区的最大容量（创建后固定不变） #### 1. 重置 position 的三种方法 ```java ByteBuffer buffer = ByteBuffer.allocate(1024); // 方法1：rewind() - 重置position到0，limit保持不变 buffer.rewind(); // position=0, limit不变 // 方法2：clear() - 重置position到0，limit=capacity buffer.clear(); // position=0, limit=capacity // 方法3：position() - 精确设置position值 buffer.position(0); // 手动设置position=0 ``` #### 2. "改变 capacity" 的实际操作 由于 `capacity` 在创建后不可修改，要实现类似效果需创建新缓冲区并复制数据： ```java // 原始缓冲区 ByteBuffer original = ByteBuffer.allocate(256); original.put("Hello".getBytes()); original.flip(); // 准备读取 position=0, limit=5 // 创建更大容量的新缓冲区 int newCapacity = 512; ByteBuffer newBuffer = ByteBuffer.allocate(newCapacity); // 复制数据（使用绝对位置操作避免改变position） for (int i = 0; i < original.limit(); i++) { newBuffer.put(i, original.get(i)); // get(i)不改变position[^5] } // 设置新缓冲区的读写位置 newBuffer.position(original.position()); newBuffer.limit(original.limit()); ``` #### 3. 高效数据迁移方法 使用 `compact()` 压缩数据并重置位置（适合重用缓冲区）： ```java ByteBuffer buffer = ByteBuffer.allocate(100); buffer.put("Data".getBytes()); buffer.flip(); // 压缩缓冲区：将未读数据移到头部 buffer.compact(); // position=剩余空间起始位, limit=capacity[^3] // 继续写入新数据 buffer.put("Append".getBytes()); buffer.flip(); // 准备读取 ``` #### 4. 关键概念说明 | 方法 | 作用 | position变化 | limit变化 | |------------|-------------------------------|-------------|----------| | `rewind()` | 重置position到0 | 0 | 不变 | | `clear()` | 重置position到0，limit=capacity | 0 | capacity | | `flip()` | limit=position, position=0 | 0 | 原position | | `compact()`| 压缩未读数据到缓冲区头部 | 剩余数据长度 | capacity | #### 5. 最佳实践建议 1. **读取后重置**： ```java buffer.mark(); // 标记当前位置[^1] buffer.get(); // 读取1字节（position自增） buffer.reset(); // 回到标记位置 ``` 2. **批量复制**： ```java ByteBuffer[] buffers = new ByteBuffer[3]; // ...初始化buffers... channel.read(buffers); // 分散读取[^4] ``` 3. **直接缓冲区**（高性能场景）： ```java ByteBuffer directBuffer = ByteBuffer.allocateDirect(1024); ``` 4. **容量检查**： ```java if (buffer.remaining() < requiredSize) { // 创建新缓冲区并迁移数据 } ``` > **重要限制**：`capacity` 在 `ByteBuffer` 实例创建后不可修改，这是由底层数组的固定性决定的[^2]。需要"改变容量"时，必须创建新实例并复制数据。 ### 应用场景示例 **网络数据包重组**： ```java ByteBuffer packetBuffer = ByteBuffer.allocate(2048); // 接收数据片段 while (channel.read(packetBuffer) > 0) { packetBuffer.flip(); // 处理完整数据包 while (packetBuffer.remaining() >= PACKET_SIZE) { processPacket(packetBuffer); } // 压缩剩余数据 packetBuffer.compact(); // 未读数据移到头部 } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值