Java ByteBuffer使用全解析

已于 2024-02-02 16:24:13 修改
阅读量2k 收藏 17
点赞数 28
分类专栏： Java 文章标签： java 开发语言
于 2023-12-20 21:21:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Shujie_L/article/details/135109223
版权

文章目录

ByteBuffer 总体介绍

ByteBuffer 是 Java NIO（New I/O）库中的一个类，用于处理字节数据。它提供了一种灵活且高效的方式来操作字节缓冲区，适用于处理大量的字节数据，例如文件 I/O、网络通信等。

ByteBuffer 的一些重要特性和用法：

  1. 容量（Capacity）： ByteBuffer 有一个固定的容量，一旦分配，就不能更改。可以通过 allocate 静态方法或 wrap 静态方法来创建一个 ByteBuffer。

    ByteBuffer buffer = ByteBuffer.allocate(1024);  // 分配 1024 字节的缓冲区

  2. 位置（Position）和限制（Limit）： ByteBuffer 有一个位置和限制的概念，它们用于跟踪读写的位置。position 表示下一个要读写的位置，而 limit 表示当前位置可读写的最大位置。

  3. 读写操作： ByteBuffer 提供了一系列读写方法，包括 get、put、read、write 等。这些方法允许你从缓冲区读取数据或将数据写入缓冲区。

    // 写入数据到缓冲区
buffer.put((byte) 10);

// 从缓冲区读取数据
byte value = buffer.get();

  4. 翻转（Flip）： 为了从写模式切换到读模式，或者从读模式切换到写模式，可以使用 flip 方法。这个方法将 limit 设置为当前位置，然后将 position 设置为 0，准备读取数据或写入数据。

    buffer.flip();  // 切换到读模式

  5. 清空（Clear）： clear 方法用于清空缓冲区，将 position 设置为 0，limit 设置为容量，准备写入数据。

    buffer.clear();  // 清空缓冲区，准备写入数据

  6. Compact： compact 方法用于在读写模式之间移动数据。它将缓冲区中未读取的数据复制到缓冲区的开始位置，然后将 position 设置为未读取数据的末尾。

    buffer.compact();  // 在读写模式之间移动数据

ByteBuffer 的灵活性和高效性使其成为处理字节数据的强大工具，特别适用于网络编程、文件 I/O 和其他需要高性能的场景。

使用示例

put

    @Test
    public void put() {
        ByteBuffer buffer = ByteBuffer.allocate(10);
        System.out.println("buffer = " + buffer);
        buffer.put((byte) 0x01);
        System.out.println("buffer.toString() = " + Arrays.toString(buffer.array()));
        System.out.println("buffer = " + buffer);
        buffer.put(5, (byte) 42);
        System.out.println("buffer.toString() = " + Arrays.toString(buffer.array()));
        System.out.println("buffer = " + buffer);
    }
输出：
buffer = java.nio.HeapByteBuffer[pos=0 lim=10 cap=10]
buffer.toString() = [1, 0, 0, 0, 0, 0, 0, 0, 0, 0]
buffer = java.nio.HeapByteBuffer[pos=1 lim=10 cap=10]
buffer.toString() = [1, 0, 0, 0, 0, 42, 0, 0, 0, 0]
buffer = java.nio.HeapByteBuffer[pos=1 lim=10 cap=10]

  @Test
    public void put2() {
        ByteBuffer buffer = ByteBuffer.allocate(10);
        System.out.println("buffer = " + buffer);

        buffer.put(new byte[] { 0X01, 0X02 });
        System.out.println("buffer = " + buffer);
        System.out.println("buffer.toString() = " + Arrays.toString(buffer.array()));
    }
buffer = java.nio.HeapByteBuffer[pos=0 lim=10 cap=10]
buffer = java.nio.HeapByteBuffer[pos=2 lim=10 cap=10]
buffer.toString() = [1, 2, 0, 0, 0, 0, 0, 0, 0, 0]

    @Test
    public void put3() {
        ByteBuffer buffer = ByteBuffer.allocate(10);
        System.out.println("buffer = " + buffer);

        buffer.put(new byte[] { 0X01, 0X02 }, 1, 1);
        System.out.println("buffer = " + buffer);
        System.out.println("buffer.toString() = " + Arrays.toString(buffer.array()));
    }
buffer = java.nio.HeapByteBuffer[pos=0 lim=10 cap=10]
buffer = java.nio.HeapByteBuffer[pos=1 lim=10 cap=10]
buffer.toString() = [2, 0, 0, 0, 0, 0, 0, 0, 0, 0]

get

   @Test
    public void get() {
        ByteBuffer buffer = ByteBuffer.allocate(10);
        System.out.println("buffer = " + buffer);

        for (int i = 0; i < buffer.limit(); i++) {
            buffer.put((byte) i);
        }
        System.out.println("buffer = " + buffer);
        System.out.println("buffer.toString() = " + Arrays.toString(buffer.array()));

        //获取第3到第5的数据
        byte[] bytes = new byte[3];
        buffer.position(3);
        buffer.get(bytes);
        System.out.println("bytes.toString() = " + Arrays.toString(bytes));
    }

buffer = java.nio.HeapByteBuffer[pos=0 lim=10 cap=10]
buffer = java.nio.HeapByteBuffer[pos=10 lim=10 cap=10]
buffer.toString() = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
bytes.toString() = [3, 4, 5]

position

    @Test
    public void test() {
        ByteBuffer buffer = ByteBuffer.allocate(10);
        System.out.println("buffer = " + buffer);

        buffer.put((byte) 0x01);
        buffer.put(new byte[] { 0x00, 0x00 });
        buffer.put((byte) 0x01);
        System.out.println("buffer.toString() = " + Arrays.toString(buffer.array()));
        System.out.println("buffer = " + buffer);

        buffer.position(1);
        buffer.put(new byte[] { 0x0A, 0x0A });
        System.out.println("buffer.toString() = " + Arrays.toString(buffer.array()));
        System.out.println("buffer = " + buffer);
    }
buffer = java.nio.HeapByteBuffer[pos=0 lim=10 cap=10]
buffer.toString() = [1, 0, 0, 1, 0, 0, 0, 0, 0, 0]
buffer = java.nio.HeapByteBuffer[pos=4 lim=10 cap=10]
buffer.toString() = [1, 10, 10, 1, 0, 0, 0, 0, 0, 0]
buffer = java.nio.HeapByteBuffer[pos=3 lim=10 cap=10]

  @Test
    public void test2() {
        ByteBuffer buffer = ByteBuffer.allocate(10);
        System.out.println("buffer = " + buffer);

        for (int i = 0; i < 7; i++) {
            buffer.put((byte) i);
        }
        System.out.println("buffer = " + buffer);
        System.out.println("buffer.toString() = " + Arrays.toString(buffer.array()));

        buffer.position(3);
        System.out.println("buffer = " + buffer);
        buffer.put((byte) 0xff);
        System.out.println("buffer = " + buffer);
        System.out.println("buffer.toString() = " + Arrays.toString(buffer.array()));

        //回到最后一个有元素的position
        buffer.position(buffer.limit() - 1);
        System.out.println("buffer = " + buffer);
    }
buffer = java.nio.HeapByteBuffer[pos=0 lim=10 cap=10]
buffer = java.nio.HeapByteBuffer[pos=7 lim=10 cap=10]
buffer.toString() = [0, 1, 2, 3, 4, 5, 6, 0, 0, 0]
buffer = java.nio.HeapByteBuffer[pos=3 lim=10 cap=10]
buffer = java.nio.HeapByteBuffer[pos=4 lim=10 cap=10]
buffer.toString() = [0, 1, 2, -1, 4, 5, 6, 0, 0, 0]
buffer = java.nio.HeapByteBuffer[pos=9 lim=10 cap=10]

flip

ByteBuffer的flip()方法用于将缓冲区切换为读模式，即将limit设置为当前position的值，并将position重置为0，以准备读取缓冲区中的数据。

flip方法源码

    public Buffer flip() {
        limit = position;
        position = 0;
        mark = -1;
        return this;
    }

可以看到调用flip之后limit会对齐到position，然后吧position置零。

下面是一个使用flip方法的示例：

 @Test
    public void flip() {
        ByteBuffer buffer = ByteBuffer.allocate(10);

        buffer.put((byte) 1);
        buffer.put((byte) 2);
        buffer.put((byte) 3);
        buffer.put((byte) 4);
        buffer.put((byte) 5);

        buffer.flip();

        while (buffer.hasRemaining()) {
            System.out.println(buffer.get());
        }

        System.out.println("切换到读模式后的position: " + buffer.position()); // 输出5
        System.out.println("切换到读模式后的limit: " + buffer.limit()); // 输出5

        buffer.clear();

        System.out.println("切换到写模式后的position: " + buffer.position()); // 输出0
        System.out.println("切换到写模式后的limit: " + buffer.limit()); // 输出10
    }
输出：
1
2
3
4
5
切换到读模式后的position: 5
切换到读模式后的limit: 5
切换到写模式后的position: 0
切换到写模式后的limit: 10

在上面的例子中，我们创建了一个大小为10的ByteBuffer。然后依次向缓冲区中写入了5个字节。

接着调用flip方法将缓冲区切换为读模式。在读模式下，我们可以通过get方法逐个获取缓冲区中的字节。

在打印输出数据后，我们可以看到当前的position和limit都被重新设置为5。

最后，我们调用clear方法将缓冲区切换为写模式。在写模式下，position被重置为0，limit被设置为缓冲区的容量（10）。

limit

ByteBuffer的limit()方法用于设置或获取缓冲区的限制，即缓冲区中可操作数据的大小。它定义了缓冲区中第一个不能读写的元素的索引。

下面是一个使用limit方法的例子：

  @Test
    public void limit2() {
        ByteBuffer buffer = ByteBuffer.allocate(10);

        System.out.println("初始limit: " + buffer.limit() + " position : " + buffer.position()); //
        // 输出10

        buffer.limit(5);
        System.out.println("设置limit为5后: " + buffer.limit() + " position : " + buffer.position()); // 输出5

        buffer.put((byte) 1);
        buffer.put((byte) 2);
        buffer.put((byte) 3);
        buffer.put((byte) 4);
        buffer.put((byte) 5);

		//buffer.put((byte) 6); // 超过limit，抛出异常

        System.out.println("buffer = " + buffer);
        System.out.println("buffer.array() = " + Arrays.toString(buffer.array()));
    }
输出：
初始limit: 10 position : 0
设置limit为5后: 5 position : 0
buffer = java.nio.HeapByteBuffer[pos=5 lim=5 cap=10]
buffer.array() = [1, 2, 3, 4, 5, 0, 0, 0, 0, 0]

假如再put一个字节就会抛出异常。

QA

allocate 静态方法或 wrap 静态方法有什么区别？

ByteBuffer 类提供了两种主要方法用于创建新的 ByteBuffer 实例：allocate 和 wrap。它们有一些关键区别：

  1. allocate 方法：

    • allocate 方法是静态方法，通过该方法可以分配新的字节缓冲区。
    • 该方法会在堆上分配一块新的字节数组，作为底层的缓冲区。
    • 这个方法总是创建一个新的缓冲区，不管传递给它的参数是什么。
    ByteBuffer buffer = ByteBuffer.allocate(1024);

  2. wrap 方法：

    • wrap 方法也是一个静态方法，用于包装一个已有的字节数组，创建一个新的 ByteBuffer。
    • 通过 wrap 方法创建的缓冲区与传递给它的字节数组共享相同的底层数据。
    • wrap 方法不会为传递的字节数组创建新的副本，而是直接使用它。
    byte[] byteArray = new byte[1024];
ByteBuffer buffer = ByteBuffer.wrap(byteArray);

选择使用哪个方法取决于需求和情境：

  • 如果需要一个新的缓冲区，并且不想与现有的字节数组共享数据，那么使用 allocate 方法是合适的。

  • 如果你已经有一个字节数组，并且想要使用它来创建一个 ByteBuffer，并且希望对 ByteBuffer 的修改会反映在原始数组中，那么使用 wrap 方法是更合适的选择。

allocate 适用于创建新的、独立的缓冲区，而 wrap 适用于共享已有字节数组的缓冲区。

怎么理解limit？

ByteBuffer的limit是一个标记，表示缓冲区中可以读取或写入的最后一个元素的位置的下一个位置。换句话说，limit是第一个不应该读取或写入的元素的索引。在写模式下，limit通常设置为缓冲区的容量（即，你可以写入数据的最大数量）。在切换到读模式时，limit通常设置为写模式下的position值（即，你写入的数据的数量），这样你就可以读取所有写入的数据。

例如，如果你在一个容量为10的ByteBuffer中写入了5个字节的数据，那么在写模式下，limit将是10，position将是5。当你切换到读模式时，limit将设置为5，这意味着你可以读取5个字节的数据，这正是你之前写入的数据量。

林树杰
关注
  • 28
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Android在JNI中使用ByteBuffer的方法
09-03
主要介绍了Android在JNI中使用ByteBuffer的方法,涉及Android中缓冲区的相关使用技巧,需要的朋友可以参考下
Java NIO ByteBuffer原理使用图文详解
知识分享官
09-19 740
ByteBuffer总体使用起来和Netty的ByteBuf对比没有Netty ByteBuf好用。但是对于使用原生的Java NIO的开发来说也是可以的。主要是需要用户自己对读写进行转换等操作，使用起来比较繁琐。但是整个ByteBuffer的实现还是比较简单的。
Java使用ByteBuffer处理大小端踩坑
ZyManTou的博客
09-19 5073
Java使用ByteBuffer处理大小端踩坑1. 什么是大小端2 踩坑 1. 什么是大小端 大端模式，是指数据的高字节保存在内存的低地址中，而数据的低字节保存在内存的高地址中，这样的存储模式有点儿类似于把数据当作字符串顺序处理：地址由小向大增加，而数据从高位往低位放； 小端模式，是指数据的高字节保存在内存的高地址中，而数据的低字节保存在内存的低地址中，这种存储模式将地址的高低和数据位权有效地结合起来，高地址部分权值高，低地址部分权值低，和我们的逻辑方法一致。 JVM默认为大端模式 ByteOr
Java-ByteBuffer使用（Nio）
架构师之路。。
01-27 344
Java的ByteBuffer是一种用于高效处理二进制数据的类，它是Java NIO（New Input/Output）库的一部分。它提供了一种有效的方式来读取、写入和操作二进制数据。
Java ByteBuffer用法总结
热门推荐
chruan的专栏
12-06 1万+
Java ByteBuffer用法总结 http://www.whoslab.me/blog/?p=469 最近用SocketChannel进行网络编程比较多，中间也遇到了几个问题，出现的bug也主要来自于对于ByteBuffer的使用不当。现在终于调通了，对ByteBuffer及Socket网络编程也有了更深的认识，特此总结一下。 对于ByteBuffer主要需要注意的是几
Java的NIO之ByteBuffer底层分析
kakajw的专栏
02-06 503
类ByteBuffer是Java nio程序经常会用到的类，也是重要类 ，我们通过源码分析该类的实现原理。 一.ByteBuffer类的继承结构 public abstract class ByteBufferextends Bufferimplements Comparable&lt;ByteBuffer&gt;   ByteBuffer的核心特性来自Buffer 二. ByteB...
ByteBuffer的原理和使用详解
TheWayForDream
04-24 2360
ByteBuffer的原理和使用详解1.ByteBuffer的2种创建方式2.字符串转成ByteBuffer的3三种方式3.Bytebuffer的读写底层原理 ByteBuffer是字节缓冲区，主要用户读取和缓存字节数据，多用于网络编程，Netty框架的重要知识点 1.ByteBuffer的2种创建方式 1.ByteBuffer buf = ByteBuffer.allocate(int size); 方式1的buf缓冲区存储在堆内存中，内存开销在JVM中，受GC影响，会多拷贝一次，因为java程序收到的数
一文搞懂ByteBuffer使用与原理
m0_71777195的博客
04-05 3560
已知NIOChannelBuffer和Selector。那么Buffer的作用就是提供一个缓冲区，用于用户程序和Channel之间进行数据读写，也就是用户程序中可以使用Buffer向Channel写入数据，也可以使用Buffer从Channel读取数据。ByteBuffer是Buffer子类，是字节缓冲区，特点如下所示。大小不可变。一旦创建，无法改变其容量大小，无法扩容或者缩容；读写灵活。内部通过指针移动来实现灵活读写；支持堆上内存分配和直接内存分配。本文将对ByteBuffer的相关概念，常用。
JAVA基础 - BYTEBUFFER是什么？
记录并分享
06-10 2851
Buffer 类是 java.nio 的构造基础。一个 Buffer 对象是固定数量的、数据的容器，其作用是一个存储器或者分段运输区。在这里，数据可被存储并在之后用于检索。缓冲区可以被写满或释放。对于每个非布尔类型的、原始数据类型都有一个缓冲区类，即 Buffer 的子类有：ByteBuffer、CharBuffer、DoubleBuffer、FloatBuffer、IntBuffer、LongBuffer 和 ShortBuffer，是没有 BooleanBuffer 之说的。......
ByteBuffer详解
一场人生，一场梦
01-10 1万+
一、前言 前一篇文章我们介绍了Android中直播视频技术的基础大纲知识，这里就开始一一讲解各个知识点，首先主要来看一下视频直播中的一个重要的基础核心类：ByteBuffer，这个类看上去都知道了，是字节缓冲区处理字节的，这个类的功能非常强大，也在各个场景都有用到，比如网络数据底层处理，特别是结合网络通道信息处理的时候，还有就是后面要说到的OpenGL技术也要用到，当然在视频处理中也是很重要
java.nio.ByteBuffer常用方法详解
long_hai_d的博客
04-26 1320
在Java nio中，主要有三大组件：Buffer，Channel和Selector。Buffer提供了一个字节缓冲区，其可以不断的从Channel中读取接收到的数据。Buffer的优点主要在于其提供了一系列的Api，能够让用户更方便的对数据进行读取和写入；Channel简单来说就是一个信道，也就是客户端与服务器的一个连接，而且每个客户端都会对应一个Channel对象；
Android中的ByteBuffer解析
07-13
Android
java api之ByteBuffer基础、应用场景、实战讲解
01-04
java api之ByteBuffer基础、应用场景、实战讲解 文档中有丰富的例子代码实现
java 与C语言传递结构体数据
05-23
描述：为了解决java与C结构通信过程中结构体解析问题。 主要功能：能友好的用java处理任何发送的C结构体对象，并且能发送java对象转换成C结构体接收的二进制。 功能说明 1、基于spring框架开发 2、对于结构体定义...
string模拟实现
m0_73969414的博客
04-23 1384
c++中string的模拟实现，面试必会知识点
【1524】java投票管理系统Myeclipse开发mysql数据库web结构java编程计算机网页项目
qq_251836457的博客
04-18 996
2、开发环境为TOMCAT7.0,Myeclipse8.5开发，数据库为Mysql5.0，使用java语言开发。(5)投票选项管理：对投票选项信息进行添加、删除、修改和查看。(6)投票记录管理：对投票记录信息进行添加、删除、修改和查看。(1)管理员管理：对管理员信息进行添加、删除、修改和查看。(2)用户管理：对用户信息进行添加、删除、修改和查看。(3)公告管理：对公告信息进行添加、删除、修改和查看。(4)投票管理：对投票信息进行添加、删除、修改和查看。4）投票浏览查看、查看投票、投票记录。
PageHelper实现分页查询
m0_63849044的博客
04-24 948
这行代码是在使用 MyBatis Generator (MBG) 或类似的 MyBatis 工具生成的代码来构建查询条件。（可能是MyBatis的Mapper接口）来执行基于前面定义的查询条件的查询，并获取结果列表。实例之后会被用来设置各种查询条件，如字段的等于、不等于、大于、小于、模糊查询等。实体类生成的辅助类，它通常包含了一些静态内部类和方法，用于构建查询条件。在MyBatis中，这样的对象通常用于构建查询条件。对象，可能用于作为查询条件）。的一个内部类，用于定义查询的具体条件。
Lambda表达式特点
最新发布
weixin_57763462的博客
04-24 556
**API 设计**：Lambda 表达式鼓励使用函数式接口的设计模式，这改变了 Java 库的设计，例如 `java.util.function` 包下的一系列函数式接口。- **函数式编程**：Lambda 表达式引入了函数式编程的理念，使得 Java 更接近于函数式编程语言，如 Scala 和 Clojure。- **并发编程**：Lambda 表达式与 Java 8 新增的 Stream API 结合使用，可以简化并发编程，特别是与集合的操作相关。
javaweb-SpringBoot基础
kussm_的博客
04-20 1285
Spring的官网(Spring的简介：Spring makes Java simple。Spring Boot 可以帮助我们非常快速的构建应用程序、简化开发、提高效率。创建一个子包controller。
java解析lorawan协议
05-14
Java作为一种面向对象、健壮性强的编程语言，通过其丰富的类库和开发工具可以解析Lorawan协议。 要解析Lorawan协议，首先需要了解Lorawan协议的结构和通信流程。Lorawan协议采用了较为复杂的通信协议，具有类似于TCP/IP协议的4层架构，包括物理层、数据链路层、网络层和应用层。其中每一层都有对应的协议数据单元（PDU）和控制数据单元（CDU），且具有包头和包尾的格式。 针对Lorawan协议的特点，Java可以利用其强大的网络通信类库，如Socket、DatagramSocket、DatagramPacket等，进行数据收发、解析和封装。在应用层中，Java提供了丰富的数据类型和操作类库，如Byte、ByteBuffer、ByteOrder等，可以方便地处理Lorawan协议中的二进制数据。 为了更高效地解析Lorawan协议，Java还提供了多种解析工具和框架，如Jackson、GSON、Protocol Buffers等，可以将协议数据转换成Java对象、JSON或二进制格式，以方便数据的处理和操作。 总之，通过Java的强大语言特性、类库和工具，可以非常方便地解析Lorawan协议，为Lorawan应用的开发和运行提供了良好的支持。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

林树杰

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值