Bytebuffer-基本使用

于 2024-12-12 17:37:06 发布
阅读量904 收藏 7
点赞数 4
文章标签： 开发语言 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_71017987/article/details/144397018
版权

1.第一步先创建一个项目添加一下依赖

1.1 利用bytebuffer写一下案列

package com.netty.demo;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class TestByteBuffer {
    public static void main(String[] args) {
        // FileChannel
        // 1 输入输出流  2 RandomAccessFile
        try {
            FileChannel channel = new FileInputStream("data.txt").getChannel();
            // 准备缓冲区,设置缓冲区大小
            ByteBuffer buffer = ByteBuffer.allocate(10);
            while (true){
                // 从channel读取数据，写入buffer
                int read = channel.read(buffer);
                if (read == -1){ // 没有内容了
                    break;
                }
                // 打印buffer内容
                buffer.flip(); // 切换只读模式
                // 然后判定buffer是否读取完毕
                while (buffer.hasRemaining()){
                    byte b = buffer.get();
                    System.out.println((char) b);
                }
                 buffer.clear();// 切换成写模式

            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

这句话的意思大概是如果是-1代表没有了。这种可能分批读取。

1.2 bytebuffer内部结构

ByteBuffer有以下重要属性

capacity

position

limit

写模式下 position是写入模式，limit等于容量，下图表示写入4个字节后的状态

flip动作发生后，position切换为读取位置，limit切换为读取限制

读取4个字节状态

‘

clear发生后

compact方法，是把未读玩的部分向前压缩，然后切换只写模式

1.3 bytebuffer演示方法1

这是一个工具类

package com.netty.demo;

import io.netty.util.internal.StringUtil;

import java.nio.ByteBuffer;

import static io.netty.util.internal.MathUtil.isOutOfBounds;
import static io.netty.util.internal.StringUtil.NEWLINE;


public class ByteBufferUtil {
    private static final char[] BYTE2CHAR = new char[256];
    private static final char[] HEXDUMP_TABLE = new char[256 * 4];
    private static final String[] HEXPADDING = new String[16];
    private static final String[] HEXDUMP_ROWPREFIXES = new String[65536 >>> 4];
    private static final String[] BYTE2HEX = new String[256];
    private static final String[] BYTEPADDING = new String[16];

    static {
        final char[] DIGITS = "0123456789abcdef".toCharArray();
        for (int i = 0; i < 256; i++) {
            HEXDUMP_TABLE[i << 1] = DIGITS[i >>> 4 & 0x0F];
            HEXDUMP_TABLE[(i << 1) + 1] = DIGITS[i & 0x0F];
        }

        int i;

        // Generate the lookup table for hex dump paddings
        for (i = 0; i < HEXPADDING.length; i++) {
            int padding = HEXPADDING.length - i;
            StringBuilder buf = new StringBuilder(padding * 3);
            for (int j = 0; j < padding; j++) {
                buf.append("   ");
            }
            HEXPADDING[i] = buf.toString();
        }

        // Generate the lookup table for the start-offset header in each row (up to 64KiB).
        for (i = 0; i < HEXDUMP_ROWPREFIXES.length; i++) {
            StringBuilder buf = new StringBuilder(12);
            buf.append(NEWLINE);
            buf.append(Long.toHexString(i << 4 & 0xFFFFFFFFL | 0x100000000L));
            buf.setCharAt(buf.length() - 9, '|');
            buf.append('|');
            HEXDUMP_ROWPREFIXES[i] = buf.toString();
        }

        // Generate the lookup table for byte-to-hex-dump conversion
        for (i = 0; i < BYTE2HEX.length; i++) {
            BYTE2HEX[i] = ' ' + StringUtil.byteToHexStringPadded(i);
        }

        // Generate the lookup table for byte dump paddings
        for (i = 0; i < BYTEPADDING.length; i++) {
            int padding = BYTEPADDING.length - i;
            StringBuilder buf = new StringBuilder(padding);
            for (int j = 0; j < padding; j++) {
                buf.append(' ');
            }
            BYTEPADDING[i] = buf.toString();
        }

        // Generate the lookup table for byte-to-char conversion
        for (i = 0; i < BYTE2CHAR.length; i++) {
            if (i <= 0x1f || i >= 0x7f) {
                BYTE2CHAR[i] = '.';
            } else {
                BYTE2CHAR[i] = (char) i;
            }
        }
    }

    /**
     * 打印所有内容
     * @param buffer
     */
    public static void debugAll(ByteBuffer buffer) {
        int oldlimit = buffer.limit();
        buffer.limit(buffer.capacity());
        StringBuilder origin = new StringBuilder(256);
        appendPrettyHexDump(origin, buffer, 0, buffer.capacity());
        System.out.println("+--------+-------------------- all ------------------------+----------------+");
        System.out.printf("position: [%d], limit: [%d]\n", buffer.position(), oldlimit);
        System.out.println(origin);
        buffer.limit(oldlimit);
    }

    /**
     * 打印可读取内容
     * @param buffer
     */
    public static void debugRead(ByteBuffer buffer) {
        StringBuilder builder = new StringBuilder(256);
        appendPrettyHexDump(builder, buffer, buffer.position(), buffer.limit() - buffer.position());
        System.out.println("+--------+-------------------- read -----------------------+----------------+");
        System.out.printf("position: [%d], limit: [%d]\n", buffer.position(), buffer.limit());
        System.out.println(builder);
    }

    private static void appendPrettyHexDump(StringBuilder dump, ByteBuffer buf, int offset, int length) {
        if (isOutOfBounds(offset, length, buf.capacity())) {
            throw new IndexOutOfBoundsException(
                    "expected: " + "0 <= offset(" + offset + ") <= offset + length(" + length
                            + ") <= " + "buf.capacity(" + buf.capacity() + ')');
        }
        if (length == 0) {
            return;
        }
        dump.append(
                "         +-------------------------------------------------+" +
                        NEWLINE + "         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |" +
                        NEWLINE + "+--------+-------------------------------------------------+----------------+");

        final int startIndex = offset;
        final int fullRows = length >>> 4;
        final int remainder = length & 0xF;

        // Dump the rows which have 16 bytes.
        for (int row = 0; row < fullRows; row++) {
            int rowStartIndex = (row << 4) + startIndex;

            // Per-row prefix.
            appendHexDumpRowPrefix(dump, row, rowStartIndex);

            // Hex dump
            int rowEndIndex = rowStartIndex + 16;
            for (int j = rowStartIndex; j < rowEndIndex; j++) {
                dump.append(BYTE2HEX[getUnsignedByte(buf, j)]);
            }
            dump.append(" |");

            // ASCII dump
            for (int j = rowStartIndex; j < rowEndIndex; j++) {
                dump.append(BYTE2CHAR[getUnsignedByte(buf, j)]);
            }
            dump.append('|');
        }

        // Dump the last row which has less than 16 bytes.
        if (remainder != 0) {
            int rowStartIndex = (fullRows << 4) + startIndex;
            appendHexDumpRowPrefix(dump, fullRows, rowStartIndex);

            // Hex dump
            int rowEndIndex = rowStartIndex + remainder;
            for (int j = rowStartIndex; j < rowEndIndex; j++) {
                dump.append(BYTE2HEX[getUnsignedByte(buf, j)]);
            }
            dump.append(HEXPADDING[remainder]);
            dump.append(" |");

            // Ascii dump
            for (int j = rowStartIndex; j < rowEndIndex; j++) {
                dump.append(BYTE2CHAR[getUnsignedByte(buf, j)]);
            }
            dump.append(BYTEPADDING[remainder]);
            dump.append('|');
        }

        dump.append(NEWLINE +
                "+--------+-------------------------------------------------+----------------+");
    }

    private static void appendHexDumpRowPrefix(StringBuilder dump, int row, int rowStartIndex) {
        if (row < HEXDUMP_ROWPREFIXES.length) {
            dump.append(HEXDUMP_ROWPREFIXES[row]);
        } else {
            dump.append(NEWLINE);
            dump.append(Long.toHexString(rowStartIndex & 0xFFFFFFFFL | 0x100000000L));
            dump.setCharAt(dump.length() - 9, '|');
            dump.append('|');
        }
    }

    public static short getUnsignedByte(ByteBuffer buffer, int index) {
        return (short) (buffer.get(index) & 0xFF);
    }
}

根据以下代码可以看出position的limit的指针，以及大小，这是写入

接下来是读，如果在读取之前未使用flip，position的指针是0所以读不到数据

直接切换这是最终的数据postion指针到1，然后limit最大是4

compact 压缩未读取的数据

然后切换到写模式

1.4 bytebuffer 演示方法2

1.5 bytebuffer演示方法3

package com.netty.demo;

import java.nio.ByteBuffer;

public class TestByteBufferRead {
    public static void main(String[] args) {
        ByteBuffer buffer = ByteBuffer.allocate(10);
        buffer.put(new byte[]{'a','b','c','d'});
        buffer.flip();
//        // rewind 从头开始读取
//        buffer.get(new byte[4]);
//        ByteBufferUtil.debugAll(buffer);
//        buffer.rewind();
//        System.out.println((char) buffer.get());
        // mark & reset
        // mark 做一个标记，记录position的位置，reset是将position重置到mark的位置
//        System.out.println((char) buffer.get());
//        System.out.println((char) buffer.get());
//        // mark 做一个标记
//        buffer.mark();
//        // 然后接着读
//        System.out.println((char) buffer.get());
//        System.out.println((char) buffer.get());
//        // 然后拿到那个标记
//        buffer.reset();
//        System.out.println((char) buffer.get());
//        System.out.println((char) buffer.get());

        // get(i) 类似循环里面的i下标
        System.out.println((char) buffer.get(3));
        ByteBufferUtil.debugAll(buffer);

    }
}

1.6 bytebuffer演示方法4

string类型转换为bytebuffer

1.7 bytebuffer分散度集中写

分散度

集中写

ByteBuffer的讲解和使用
weixin_59244784的博客
05-08 1337
ByteBuffer的讲解和使用
使用ByteBuffer
CherishL_的专栏
06-27 799
文章目录创建堆缓冲区和直接缓冲区直接缓冲区与非直接缓冲区运行效率比较包装wrap数据的处理put(byte[] b)和get()方法的使用put(byte[] src, int offset, int length)和get(byte[] dst, int offset, int length)put(ByteBuffer src)putType()和getType()slice()方法转换为CharBuffer字符缓冲区及中文的处理设置与获得字节顺序创建只读缓冲区压缩缓冲区比较缓冲区内容复制缓冲区对缓冲区
Java 中的 ByteBuffer 详解
最新发布
daweias的博客
12-04 571
Java 中的 ByteBuffer 详解
ByteBuffer常用方法详解
热门推荐
懒人的博客
08-04 7万+
缓冲区(Buffer)就是在内存中预留指定大小的存储空间用来对输入/输出(I/O)的数据作临时存储，这部分预留的内存空间就叫做缓冲区： 使用缓冲区有这么两个好处： 1、减少实际的物理读写次数 2、缓冲区在创建时就被分配内存，这块内存区域一直被重用，可以减少动态分配和回收内存的次数 举个简单的例子，比如A地有1w块砖要搬到B地 由于没有工具（缓冲区），我们一次只能搬一本，那么就要搬1w次（
ByteBuffer的使用
z318913的博客
10-14 2746
ByteBuffer的使用以及其中的方法
ByteBuffer 使用
prcyang的专栏
08-17 1346
ByteBuffer
ByteBuffer-scanner-Memor-Hex技术解析
但是基于给出的标题，我们可以推断该文件可能包含一个Java程序，演示如何使用ByteBuffer来读写数据，利用Scanner进行解析，并以十六进制的形式显示或处理这些数据。这可能是一种内存级别的数据处理或分析工具，用于...
通过视图修改 ByteBuffer --《JAVA编程思想》80
BaymaxCS的博客
12-12 536
ByteBuffer 只能操作字节，无法产生任何基本类型，但 ByteBuffer 提供 asCharBuffer()、asShortBuffer()、asIntBuffer() 返回对应基本类型的视图，我们对视图的任何修改对会映射成为对 ByteBuffer 数据中的修改。 视图允许我们单个或批量的往 ByteBuffer 中写入数据。 示例： asIntBuffer() 获取 int 类型的视图，通过 get() 方法读取数据，put() 方法写入数据。 public class IntBuffer
dena-bytebuffer:dena-bytebuffer
06-06
2. **多字节类型支持**：除了基本的字节操作外，`dena-bytebuffer`还支持读写16位、32位的整数和浮点数，以及固定长度的字符串。 3. **高效的数据定位**：通过`position`属性，可以快速地在缓冲区中定位数据，进行...
Android在JNI中使用ByteBuffer的方法
09-03
下面将详细介绍在Android JNI中使用ByteBuffer的方法及其相关知识点。 首先，了解ByteBuffer的基本概念。ByteBuffer是一个固定大小的列表，用于存储基本数据类型，如字节、短整型、整型、长整型等。它有四个核心...
Java NIO学习笔记——ByteBuffer用法
03-24
NULL 博文链接：https://zheng12tian.iteye.com/blog/1094811
Java ByteBuffer用法总结
chruan的专栏
12-06 1万+
Java ByteBuffer用法总结 http://www.whoslab.me/blog/?p=469 最近用SocketChannel进行网络编程比较多，中间也遇到了几个问题，出现的bug也主要来自于对于ByteBuffer的使用不当。现在终于调通了，对ByteBuffer及Socket网络编程也有了更深的认识，特此总结一下。 对于ByteBuffer主要需要注意的是几
Java ByteBuffer使用全解析
Shujie
12-20 9786
ByteBuffer是 Java NIO（New I/O）库中的一个类，用于处理字节数据。它提供了一种灵活且高效的方式来操作字节缓冲区，适用于处理大量的字节数据，例如文件 I/O、网络通信等。ByteBufferByteBuffer有一个固定的容量，一旦分配，就不能更改。可以通过allocate静态方法或wrap静态方法来创建一个ByteBuffer。// 分配 1024 字节的缓冲区ByteBuffer有一个位置和限制的概念，它们用于跟踪读写的位置。position表示下一个要读写的位置，而limit。
java nio ByteBuffer的使用
xiao_yu_gan的博客
04-24 3657
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
bytebuffer 使用demo
Java持续实践
07-31 424
通过控制台看到,第一次读取到了缓存的10个字节,1到0.挨个把1到0打印了出来.创建一个txt文件,放在项目最外层,内容如下,有13个字节.第二次读取了3个字节,a到c,挨个打印了出来.
Netty——ByteBuffer（ByteBuffer的基本使用）
小志的博客
07-18 931
Netty——ByteBuffer（ByteBuffer的基本使用）
ByteBuffer的基本用法
weixin_43887958的博客
03-18 256
属性:position,limit,capacity,意思分别是(读/写)位置,结束位置,容量. ByteBuffer bf = ByteBuffer.allocate(10) 上述代码分配了十个字节的ByteBuffer,此时position=0,limit=capacity=10 bf.put("nihao".getBytes()); 放入5个字节,此时position=5,limit=capacity=10 bf.flip(); 从写模式切换到读模式,此时position=0,limit=
ByteBuffer是怎么构成的，如何使用？
weixin_42374229的博客
10-26 340
ByteBuffer通常用于Java原生NIO操作中，对Channel进行读取或者写入，其中封装了一些操作byte数组的方法，还是很实用的。 ByteBuffer的几个基本属性： position：表示进行下一个读写操作的下标位置 limit：表示进行读写操作时的结束位置； capacity：表示存储的容量 mark： 对数据进行标记 初始化：对ByteBuffer进行初始化，可以使用静态方法wrap(byte[] data)封装数组，也可以通过另一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值