Java NIO ByteBuffer 使用方法

最新推荐文章于 2024-08-16 23:08:28 发布
最新推荐文章于 2024-08-16 23:08:28 发布
阅读量858 收藏 15
点赞数 13
分类专栏： Java 文章标签： java nio python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010454030/article/details/139634975
版权
前言

最近在使用spring boot + websocket + xterm.js 给 k8s pod做了个在线的 web 终端，发现websocket的类核心方法，用的都是ByteBuffer传递数据，如下：

    @OnMessage
    public void onMessage(Session session, ByteBuffer byteBuffer) {
     //xxxxx
    }

以前只知道 NIO 里面大量用到了 ByteBuffer ，并没有仔细了解过，这次特意学习了一下，因为JDK自带的ByteBuffer 可以切换读写两种模式加上内置很多方法组合使用，有很多约定俗成的用法，稍不注意就有可能踩坑，这也是为什么Netty里面又基于 ByteBuffer 重新封装了ByteBuf类，就是因为 JDK 自带的太难用了

UML 图概览

解释：

Buffer 抽象类是所有 ByteBuffer 类的父类，其子类还有8种基本类型的IntBuffer，LongBuffer等，这不是我们这次的重点，我们这次主要关注 ByteBuffer 子类，如上图所示。

Buffer抽象类几个字段：

  • capacity：这个很好理解，它规定了整个 Buffer 的容量，具体可以容纳多少个元素。capacity 指针之前的元素均是 Buffer 可操作的空间。
  • position：用于指向 Buffer 中下一个可操作性的元素，初始值为 0。在 Buffer 的写模式下，position 指针用于指向下一个可写位置。在读模式下，position 指针指向下一个可读位置。
  • limit：表示 Buffer 可操作元素的上限。什么意思呢？比如在 Buffer 的写模式下，可写元素的上限就是 Buffer 的整体容量也就是 capacity ，capacity - 1 即为 Buffer 最后一个可写位置。在读模式下，Buffer 中可读元素的上限即为上一次 Buffer 在写模式下最后一个写入元素的位置。也就是上一次写模式中的 position。
  • mark：用于标记 Buffer 当前 position 的位置
    // Invariants: mark <= position <= limit <= capacity
    private int mark = -1; // 搭配 reset 使用
    private int position = 0; // 写模式下指向下一次写的位置，读模式下是当前要读数据的位置
    private int limit; 
    private int capacity;
    // Used only by direct buffers
    // NOTE: hoisted here for speed in JNI GetDirectBufferAddress
    long address;

MappedByteBuffer : 映射 JVM 堆外内存，也就是这部分内存由 linux 内核管理，其中可映射文件，也可也直接在操作堆上分配空间。最常用的是：DirectByteBuffer ，DirectByteBufferR 代表只读视图

HeapByteBuffer ： 在 JVM 堆内分配内存，HeapByteBufferR 代表只读视图

常用方法
put

这个比较简单，就是向 ByteBuffer 里面放入数据，例子如下：

    public static  void putData(){

        //默认声明出来的是写模式
        ByteBuffer buffer = ByteBuffer.allocate(16);
        buffer.put(new byte[]{'s','h'});
        System.out.println(buffer);
        //java.nio.HeapByteBuffer[pos=2 lim=16 cap=16]
    }
get

这个就要注意了，在没有切换成读模式下直接get是有问题的，除非指定 index 读

    public static  void getData(){

        ByteBuffer buffer = ByteBuffer.allocate(16);
        buffer.put(new byte[]{'s','h'});
        System.out.println(buffer);
        System.out.println(buffer.position());
        System.out.println(buffer.get()); // 输出 0
        //在没有切换读模式下，get方法获取的是写 pos的值，也就是pos=2，所以读取不正确
        System.out.println(buffer.get(0)); // 输出 s
    }

此外，get方法也会使得 pos ++，所以几次get之后，在写数据就会出现空间空了几次：

    public static  void getData2(){

        ByteBuffer buffer = ByteBuffer.allocate(16);
        buffer.put(new byte[]{'s','h'});
        System.out.println(buffer);
        System.out.println(buffer.get()); // 输出 0
        System.out.println(buffer); // get 方法会导致pos指针++
        System.out.println(buffer.get()); // 输出 0
        System.out.println(buffer); // get 方法会导致pos指针++
        System.out.println(buffer.get()); // 输出 0
        System.out.println(buffer); // get 方法会导致pos指针++
        //在没有切换读模式下，get方法获取的是写 pos的值，也就是pos=2，所以读取不真确
        //java.nio.HeapByteBuffer[pos=2 lim=16 cap=16]
        //0
        //java.nio.HeapByteBuffer[pos=3 lim=16 cap=16]
        //0
        //java.nio.HeapByteBuffer[pos=4 lim=16 cap=16]
        //0
        //java.nio.HeapByteBuffer[pos=5 lim=16 cap=16]

        //
        buffer.put(new byte[]{'e'});
        System.out.println(buffer);
        //最终内存结果
        //[115, 104, 0, 0, 0, 101, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
    }

获取最后一位数据：

    public static  void getData3(){

        ByteBuffer buffer = ByteBuffer.allocate(16);
        buffer.put(new byte[]{'s','h'});
        System.out.println(buffer);
        System.out.println(buffer.get()); // 输出 0
        System.out.println(buffer); // get 方法会导致pos指针++
        System.out.println(buffer.get()); // 输出 0
        System.out.println(buffer); // get 方法会导致pos指针++
        System.out.println(buffer.get()); // 输出 0
        System.out.println(buffer); // get 方法会导致pos指针++
        //在没有切换读模式下，get方法获取的是写 pos的值，也就是pos=2，所以读取不真确
        //java.nio.HeapByteBuffer[pos=2 lim=16 cap=16]
        //0
        //java.nio.HeapByteBuffer[pos=3 lim=16 cap=16]
        //0
        //java.nio.HeapByteBuffer[pos=4 lim=16 cap=16]
        //0
        //java.nio.HeapByteBuffer[pos=5 lim=16 cap=16]

        //
        buffer.put(new byte[]{'e'});
        System.out.println(buffer);
        buffer.put(new byte[]{'\n'});
        //最终内存结果
        //[115, 104, 0, 0, 0, 101, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

        // 使用getIndex获取最后一位数据, 并且不会导致pos++


//        回车，ASCII码13
//        换行，ASCII码10
//        空格，ASCII码32

        // 输出10
        System.out.println(buffer.get(buffer.position()-1));


    }
flip

切换成读模式：limit和pos的值会自动适配变化，需要注意的是即使切换到读模式，你仍然可以写因为这不是强制的，但如果你切换成读模式后立马写数据，会覆盖掉第一位数据

    public static  void flip(){

        ByteBuffer buffer = ByteBuffer.allocate(16);
        buffer.put(new byte[]{'t', 'o','m'});
        System.out.println(buffer);// java.nio.HeapByteBuffer[pos=3 lim=16 cap=16]
        buffer.flip();
        System.out.println(buffer); // java.nio.HeapByteBuffer[pos=0 lim=3 cap=16]

        System.out.println((char)buffer.get());
        System.out.println((char)buffer.get());
        System.out.println(buffer);// java.nio.HeapByteBuffer[pos=2 lim=3 cap=16]

        buffer.put(new byte[]{'e'});

        System.out.println(buffer);
        //


    }

覆盖写例子：

    // 切换读模式
    public static  void flip2(){

        ByteBuffer buffer = ByteBuffer.allocate(16);
        buffer.put(new byte[]{'t', 'o','m'});
        System.out.println(buffer);// java.nio.HeapByteBuffer[pos=3 lim=16 cap=16]
        buffer.flip();
        System.out.println(buffer); // java.nio.HeapByteBuffer[pos=0 lim=3 cap=16]

        buffer.put(new byte[]{'e'});
        System.out.println(buffer); // java.nio.HeapByteBuffer[pos=1 lim=3 cap=16]
        System.out.println((char)buffer.get(0)); //写的数据覆盖了第一个t



    }
rewind

读模式下重置数据，从头开始读：

    public static void  rewind(){
        ByteBuffer buffer = ByteBuffer.allocate(16);
        buffer.put(new byte[]{'t', 'o'});
        buffer.flip();
        System.out.println((char)buffer.get()); // t
        System.out.println((char)buffer.get()); // o

        // 从头开始读
        buffer.rewind();

        System.out.println((char)buffer.get()); // t
        System.out.println((char)buffer.get()); // o
    }
mark & reset

mark标记当前位置，继续读写后，然后reset可以重置到mark的位置，实现原理很简单就是用mark字段备份了原来pos的值：

    public static void markResetRead(){

        ByteBuffer buffer = ByteBuffer.allocate(16);
        buffer.put(new byte[]{'t', 'o', 'm', 'c','a','t'});
        System.out.println(buffer);
        buffer.flip();
        System.out.println((char) buffer.get()); // t
        System.out.println((char) buffer.get()); // o
        // 控记住当前的 position
        buffer.mark();
        System.out.println((char) buffer.get()); // m
        System.out.println((char) buffer.get()); // c

        buffer.reset();
        System.out.println((char) buffer.get()); // m
        System.out.println((char) buffer.get()); // c
    }

写模式也可以：

    public static void markResetWrite(){

        ByteBuffer buffer = ByteBuffer.allocate(16);
        buffer.mark();
        buffer.put(new byte[]{'a'});
        buffer.put(new byte[]{'b'});
        // 控记住当前的 position

        System.out.println((char) buffer.get(0)); // a
        System.out.println((char) buffer.get(1)); // b

        buffer.reset();
        buffer.put(new byte[]{'c'});
        buffer.put(new byte[]{'d'});

        System.out.println((char) buffer.get(0)); // c
        System.out.println((char) buffer.get(1)); // d

    }
clear

重置写模式，注意这个并没有删除旧数据，只是把pos位置置0:

   // 从头开始写覆盖数据
    public static void clear(){
        ByteBuffer buffer = ByteBuffer.allocate(16);
        buffer.put(new byte[]{'a', 'b', 'c', 'd'});
        System.out.println(buffer);//java.nio.HeapByteBuffer[pos=4 lim=16 cap=16]
        buffer.clear();
        System.out.println(buffer);//java.nio.HeapByteBuffer[pos=0 lim=16 cap=16]

    }
compact

compact方法，主要是用来解决clear方法切换写模式后，总是从头开始的问题，因为切换为读的时候，大部分情况下可能只读一部分数据，然后就要切写模式，直接掉clear方法会覆盖掉一部分未读的数据，所以这个时候需要使用compact方法，将没读的部分移动到前面，然后将pos重置到下一个可覆盖写的地方

    public static void compact(){
        ByteBuffer buffer = ByteBuffer.allocate(16);
        buffer.put("hadoop".getBytes(StandardCharsets.UTF_8));
        System.out.println(buffer);//java.nio.HeapByteBuffer[pos=6 lim=16 cap=16]
        // 切换到读模式
        buffer.flip();
        String v=StandardCharsets.UTF_8.decode(buffer).toString();
        System.out.println(v);//hadoop
        buffer.rewind(); //重置读
        System.out.println((char) buffer.get()); // h
        System.out.println(buffer);//java.nio.HeapByteBuffer[pos=1 lim=6 cap=16]
        // 数据读了一部分，这个时候使用clear切换写模式，会覆盖掉没读部分，所以得使用 compat 将没读过的数据, 移到 buffer 的首部
        buffer.compact(); // 此时 buffer 的数据就会变成 adoopp
        System.out.println(buffer);// java.nio.HeapByteBuffer[pos=5 lim=16 cap=16]
        buffer.rewind();
        String v1=StandardCharsets.UTF_8.decode(buffer).toString();
        System.out.println(v1);//adoopp
    }
hasRemaining

判断 pos 位置是否小于 limit，也就是是否达到buffer的上限

    public static  void remaining(){

        ByteBuffer buffer = ByteBuffer.allocate(2);
        buffer.put(new byte[]{'b'});
        System.out.println(buffer.hasRemaining()); //true
        buffer.put(new byte[]{'c'}); 
        System.out.println(buffer.hasRemaining()); //false // check position < limit;
    }
remaining

写模式下，判断剩余容量还有多少：

    public static void remaining(){
        ByteBuffer buffer = ByteBuffer.allocate(10);
        buffer.put(new byte[]{'b'});
        buffer.put(new byte[]{'c'});

        System.out.println(buffer.remaining()); // 8
    }
其他方法：

isReadOnly： 判断是否是只读Buffer

isDirect： 是否从对外分配的内存空间

duplicate：

clone 原生 ByteBuffer。它们的 offset，mark，position，limit，capacity 变量的值全部是一样的，这里需要注意虽然值是一样的，但是它们各自之间是相互独立的。用于对同一字节数组做不同的逻辑时候需要

slice：

调用 slice() 方法创建出来的 ByteBuffer 视图内容是从原生 ByteBufer 的当前位置 position 开始一直到 limit 之间的数据。也就是说通过 slice() 方法创建出来的视图里边的数据是原生 ByteBuffer 中还未处理的数据部分，共享原生的数据，访问时需要带上 offset

总结

Java 中的 ByteBuffer 是 java.nio 包中的核心类之一，属于 New I/O (NIO) 框架。它提供了用于操作字节数据的丰富方法，ByteBuffer 在需要高效 I/O 操作的应用程序中非常有用，特别是在网络编程、文件 I/O、内存映射文件、以及其他需要直接操作字节数据的场景中。使用 ByteBuffer 可以带来更好的性能和灵活性。

三劫散仙
关注
  • 13
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java NIO.zip
06-16
Java NIO提供了诸如ByteBuffer、CharBuffer、IntBuffer等类型，对应于不同的数据类型。缓冲区具有读写位置，可以通过flip()、clear()和rewind()等方法来管理缓冲区的状态，从而高效地进行数据读写。 3. **选择器...
深入理解Apache Mina （6）---- Java Nio ByteBuffer与Mina ByteBuffer的区别
05-25
本篇将深入探讨Java NIO（非阻塞I/O）中的ByteBuffer和Mina库自定义的ByteBuffer之间的区别。 Java NIO的ByteBuffer是Java标准库提供的一个核心类，它是通道(Channel)和缓冲区(Buffer)之间数据传输的主要媒介。它...
JAVA NIO缓冲区(Buffer)------ByteBuffer常用方法详解
沧海龙腾LV的博客
07-14 6万+
缓冲区(Buffer)缓冲区(Buffer)就是在内存中预留指定大小的存储空间用来对输入/输出(I/O)的数据作临时存储，这部分预留的内存空间就叫做缓冲区：使用缓冲区有这么两个好处：1、减少实际的物理读写次数2、缓冲区在创建时就被分配内存，这块内存区域一直被重用，可以减少动态分配和回收内存的次数举个简单的例子，比如A地有1w块砖要搬到B地由于没有工具（缓冲区），我们一次只能搬一本，那么就要搬1w次...
java.nio.ByteBuffer用法小结
热门推荐
水蓝城
04-22 7万+
文章目录简介初始化向ByteBuffer写数据手动写入数据从SocketChannel中读入数据至ByteBuffer从ByteBuffer中读数据复位position读取数据字节序处理 简介 在Java的Socket编程中，若使用阻塞式（BIO），则往往通过ServerSocket的accept()方法获取到客户端Socket之后，再使用客户端Socket的InputStream和OutputS...
android----在JNI中如何使用ByteBuffer？
Trent1985的专栏
09-05 1万+
1,ByteBuffer 定义 在NIO中,数据的读写操作始终是与缓冲区相关联的（读取时信道(SocketChannel)将数据读入缓冲区,写入时首先要将发送的数据按顺序填入缓冲区） 缓冲区是定长的,基本上它只是一个列表,它的所有元素都是基本数据类型（String并未包含其中，但是String. getBytes就可以了）.   Nio缓冲区的7种形式 ByteBuffer  Sh
Android开发之二：在JNI中如何使用ByteBuffer
随意的风的专栏
02-06 2849
1，ByteBuffer 定义 在NIO中,数据的读写操作始终是与缓冲区相关联的（读取时信道(SocketChannel)将数据读入缓冲区,写入时首先要将发送的数据按顺序填入缓冲区） 缓冲区是定长的,基本上它只是一个列表,它的所有元素都是基本数据类型。ByteBuffer是最常用的缓冲区,它提供了读写其他数据类型的方法,且信道的读写方法只接收ByteBuffer。 ByteBuffer有以下几种...
Android开发实践：Java层与Jni层的数组传递
weixin_34050519的博客
02-18 1419
Android开发中，经常会在Java代码与Jni层之间传递数组（byte[]），一个典型的应用是Java层把需要发送给客户端的数据流传递到Jni层，由Jni层的Socket代码发送出去，当然，Jni层也需要把从Socket接收到的数据流返回给Java层。我简单地总结了一下，从Java层到Jni层，从Jni层到JAVA层，各有3种传递方式，下面用代码示例简单地介绍一下。示例代码的主要文件有两个，一...
java nio ByteBuffer的使用
xiao_yu_gan的博客
04-24 3578
1、介绍 Buffer是nio包的一个抽象类，作为java nio的三大组件（Buffer、Channel，Selector）之一，在java nio网络编程中尤为重要。 Buffer提供了一个字节缓冲区，配合Channel使用，可以从Channel中读取或写入数据。 2、结构 属性介绍 以ByteBuffer为例，其包括5个主要的属性：hb、position、limit、capacity、mark。 hb：ByteBuffer类有一个byte数组变量hb，此数组里面存放的就是实际的字节数据。 capaci
Java中nio的bytebuffer常用方法解读
tousdi的博客
04-30 850
在Java中，ByteBuffer是Java NIO（New Input/Output）库中的一个重要类，主要用于高效地处理原始字节数据。它是 java.nio.Buffer 抽象类的一个子类，专门设计用来读写字节流，尤其是在进行文件I/O操作、网络通信、数据打包与解包等场景中非常有用。
Java NIO 总结: ByteBuffer类介绍
码到三十五
07-15 1330
ByteBuffer是Java NIO包中的一个类，它实现了Buffer接口，是处理字节数据的基础类。ByteBuffer类提供了多种方法，用于读取和写入字节数据，以及管理缓冲区的状态。ByteBuffer类支持多种数据类型，包括字节、字符、短整型、整型、长整型、浮点型和双精度浮点型等。ByteBuffer内部使用一个字节数组（byte[]）来存储数据，通过操作数组中的索引位置来实现数据的读写。ByteBuffer类提供了多种方法，用于读取和写入字节数据，以及管理缓冲区的状态。
JAVA NIO ByteBuffer详解
aliuguangjin的博客
02-15 691
ByteBuffer 是 Java NIO 中常常使用的一个字节缓冲区类。合理的使用它可以进行高效的IO操作。 创建ByteBuffer 1）使用allocate()静态方法 ByteBufferbuffer=ByteBuffer.allocate(256); 以上代码为创建一个256字节的缓冲区。缓冲区创建后不可更改，如果想改变大小唯一的方法只有重新创建一...
Android在JNI中使用ByteBuffer的方法
09-03
下面将详细介绍在Android JNI中使用ByteBuffer的方法及其相关知识点。 首先，了解ByteBuffer的基本概念。ByteBuffer是一个固定大小的列表，用于存储基本数据类型，如字节、短整型、整型、长整型等。它有四个核心...
Java NIO实战之聊天室功能详解
08-25
Java NIO实战之聊天室功能详解主要介绍了Java NIO实战之聊天室功能，结合实例形式详细分析了Java NIO聊天室具体的服务端、客户端相关实现方法与操作注意事项。 Java NIO概述 Java NIO（New I/O）是一种Java API，...
JavaNIO.zip_java nio_nio java
09-24
Java NIO提供了多种类型的缓冲区，如ByteBuffer、CharBuffer、IntBuffer等，它们都继承自抽象类Buffer。 3. **选择器（Selectors）**：选择器用于监控多个通道的事件，比如连接就绪、数据可读或可写等。通过一个...
JAVA进阶补充
2301_80150315的博客
08-15 873
概念：把已经有的方法拿过来用，当作函数式接口中抽象方法的方法体条件：引用处必须是函数式接口被引用的方法需要已经存在被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致被引用方法的功能需要满足当前需求：方法引用符意义：就是为让控制台的报错信息更加的见名知意自定义异常的步骤：定义异常类写继承关系空参构造带参构造​file对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径；这个路径可以是存在的，也允许是不存在的构造方法描述根据文件路径创建对象。
手撕快排——三种实现方法（附动图及源码）
最新发布
jsjs1346的博客
08-16 558
🤖💻👨‍💻👩‍💻🌟🚀🤖🌟👨‍💻👩‍💻👨‍💻👩‍💻🚀是一种高效的排序算法，广泛应用于各种场景。它采用策略，将一个数组分成两个子数组，然后递归地对这两个子数组进行排序。本文将介绍三种快速排序的实现方法，并附上相应的源码。⚙️一、快速排序的基本原理一个基准元素（pivot）分成两个子数组递归合并O(n log n)O(n log n)O(n^2)后文我们将给出优化方案O(log n)📚三、实现霍尔方法是快速排序原始版本中使用的分区方法。
进程间通信 ---共享内存
BUG制造机的博客
08-14 1039
在这篇文章中向大家介绍了共享内存的原理以及常用的指令函数，希望大家有所收获！😁。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值