NIO笔记02-ByteBuffer

最新推荐文章于 2024-09-03 23:00:00 发布
最新推荐文章于 2024-09-03 23:00:00 发布
阅读量208 收藏 4
点赞数 4
文章标签： nio 笔记 java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46425661/article/details/141791918
版权

文章目录

前言

创建data.txt文件，内容为

0123456789123asd

使用 FileChannel 来读取文件内容
代码中的position指针后面会详细讲解

@Slf4j
public class Test01ByteBuffer {

    public static void main(String[] args) {
        // FileChannel
        // 1. 输入输出流， 2. RandomAccessFile
        try (FileChannel channel = new FileInputStream("data.txt").getChannel()) {
            // 准备缓冲区
            ByteBuffer buffer = ByteBuffer.allocate(10);//缓冲区设为10字节
            while(true) {
                // 从 channel 读取数据，向 buffer 写入
                int len = channel.read(buffer);
                log.debug("读取到的字节数 {}", len);
                if(len == -1) { // 没有内容了
                    break;
                }
                // 打印 buffer 的内容
                buffer.flip(); // 切换至读模式(将position = 0)
                while(buffer.hasRemaining()) { // 是否还有剩余未读数据
                    byte b = buffer.get();
                    log.debug("实际字节 {}", (char) b);
                }
                buffer.clear(); // 切换为写模式
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

输出：

22:22:59 [DEBUG] [main] c.i.n.c.Test01ByteBuffer - 读取到的字节数 10
22:22:59 [DEBUG] [main] c.i.n.c.Test01ByteBuffer - 实际字节 0
22:22:59 [DEBUG] [main] c.i.n.c.Test01ByteBuffer - 实际字节 1
22:22:59 [DEBUG] [main] c.i.n.c.Test01ByteBuffer - 实际字节 2
22:22:59 [DEBUG] [main] c.i.n.c.Test01ByteBuffer - 实际字节 3
22:22:59 [DEBUG] [main] c.i.n.c.Test01ByteBuffer - 实际字节 4
22:22:59 [DEBUG] [main] c.i.n.c.Test01ByteBuffer - 实际字节 5
22:22:59 [DEBUG] [main] c.i.n.c.Test01ByteBuffer - 实际字节 6
22:22:59 [DEBUG] [main] c.i.n.c.Test01ByteBuffer - 实际字节 7
22:22:59 [DEBUG] [main] c.i.n.c.Test01ByteBuffer - 实际字节 8
22:22:59 [DEBUG] [main] c.i.n.c.Test01ByteBuffer - 实际字节 9
22:22:59 [DEBUG] [main] c.i.n.c.Test01ByteBuffer - 读取到的字节数 6
22:22:59 [DEBUG] [main] c.i.n.c.Test01ByteBuffer - 实际字节 1
22:22:59 [DEBUG] [main] c.i.n.c.Test01ByteBuffer - 实际字节 2
22:22:59 [DEBUG] [main] c.i.n.c.Test01ByteBuffer - 实际字节 3
22:22:59 [DEBUG] [main] c.i.n.c.Test01ByteBuffer - 实际字节 a
22:22:59 [DEBUG] [main] c.i.n.c.Test01ByteBuffer - 实际字节 s
22:22:59 [DEBUG] [main] c.i.n.c.Test01ByteBuffer - 实际字节 d
22:22:59 [DEBUG] [main] c.i.n.c.Test01ByteBuffer - 读取到的字节数 -1

1. ByteBuffer 正确使用姿势

  1. 向 buffer 写入数据，例如前面代码中调用 channel.read(buffer)
  2. 调用 flip() 切换至读模式
  3. 从 buffer 读取数据，例如调用 buffer.get()
  4. 调用 clear() 或 compact() 切换至写模式
  5. 重复 1~4 步骤

2. ByteBuffer 结构

ByteBuffer 有以下重要属性

  • capacity
  • position
  • limit

一开始创建ByteBuffer时为：position = 0

在这里插入图片描述

写模式下，position 是写入位置，limit 等于容量，下图表示写入了 4 个字节后的状态
position = 4
在这里插入图片描述

调用flip()后，position 切换为读取位置，limit 切换为读取限制
position = 0
limit = 4
在这里插入图片描述

读取 4 个字节后，状态：
position = 4
limit = 4
在这里插入图片描述

调用clear()方法后，状态：position = 0
在这里插入图片描述

compact 方法，是把未读完的部分向前压缩，然后切换至写模式
在这里插入图片描述

💡 调试工具类 ★

使用该类查看ByteBuffer中的可读取内容

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);
    }

    public static void main(String[] args) {
        ByteBuffer buffer = ByteBuffer.allocate(10);
        buffer.put(new byte[]{97, 98, 99, 100});
        debugAll(buffer);
    }

    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);
    }
}

3. ByteBuffer 常见方法

分配空间allocate

1.可以使用 allocate 方法为 ByteBuffer 分配空间，其它 buffer 类也有该方法

Bytebuffer buf = ByteBuffer.allocate(16);//底层是返回了new HeapByteBuffer(capacity, capacity)对象
//或
ByteBuffer byteBuffer = ByteBuffer.allocateDirect(16)//底层使用了DirectByteBuffer
  • class java.nio.HeapByteBuffer - 使用 java 堆内存，读写效率较低，受到 GC 的影响
  • class java.nio.DirectByteBuffer - 使用直接内存，读写效率高（少一次拷贝），不会受 GC 影响，分配的效率低

DirectByteBuffer缺点：

  1. 因为是直接内存(系统内存)，所以分配的速度比较慢，因为要调用操作系统的函数
  2. 使用不当会导致内存泄漏，DirectByteBuffer使用后必须要合理的释放。

netty对DirectByteBuffer进行了封装，读写和分配效率进行了优化。
netty采用了对象池进行分配，尽可能减少了DirectByteBuffer的分配频率，进而提高分配效率。同时对象池会对DirectByteBuffer进行回收，减少内存泄漏问题。

向 buffer 写入数据

有两种办法

  • 调用 channel 的 read 方法
int readBytes = channel.read(buf);
  • 调用 buffer 自己的 put 方法
buf.put((byte)127);

从 buffer 读取数据

同样有两种办法

  • 调用 channel 的 write 方法
int writeBytes = channel.write(buf);
  • 调用 buffer 自己的 get 方法
byte b = buf.get();

注意
get 方法会让 position 读指针向后走，如果想重复读取数据
1.可以调用 rewind 方法将 position 重新置为 0
2.或者调用 get(int i) 方法获取索引 i 的内容，它不会移动读指针

mark 和 reset

mark 是在读取时，做一个标记，即使 position 改变后，只要调用 reset 就能回到 mark 的位置
注意： rewind 和 flip 都会清除 mark 位置

代码实现

import java.nio.ByteBuffer;
import static cn.qf.nio.ByteBufferUtil.debugAll;
public class ByteBufferRead {
    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]);//读取4字节的数据
//        debugAll(buffer);
//        buffer.rewind();//底层源码是将position赋值为0
//        System.out.println((char)buffer.get());

        // mark() & reset()
        // mark() 做一个标记，记录 position 位置， reset() 是将 position 重置到 mark 的位置
        //mark()和reset()结合使用实现标记跳转功能
        //position从0开始
//        System.out.println((char) buffer.get());//a
//        System.out.println((char) buffer.get());//b
//        buffer.mark(); // 加标记，索引2 的位置。但position值不变
//        System.out.println((char) buffer.get());//c
//        System.out.println((char) buffer.get());//d
//        buffer.reset(); // 将 position 重置到索引 2
//        System.out.println((char) buffer.get());//c
//        System.out.println((char) buffer.get());//d

        // get(i) 不会改变读索引的位置
        //position从0开始
        System.out.println((char) buffer.get(3));
        debugAll(buffer);//position依然等于0
    }
}

字符串与 ByteBuffer 互转

import java.nio.ByteBuffer;
import java.nio.charset.StandardCharsets;
import static cn.qf.nio.c2.ByteBufferUtil.debugAll;

public class ByteBufferString {
    public static void main(String[] args) {
        // 1. 字符串转为 ByteBuffer
        ByteBuffer buffer1 = ByteBuffer.allocate(16);
        buffer1.put("hello".getBytes());
        debugAll(buffer1);

        // 2. Charset
        ByteBuffer buffer2 = StandardCharsets.UTF_8.encode("hello");
        debugAll(buffer2);//会自动切换到读模式 position = 0

        // 3. wrap
        ByteBuffer buffer3 = ByteBuffer.wrap("hello".getBytes());
        debugAll(buffer3);//会自动切换到读模式 position = 0

        // 4. 转为字符串
        String str1 = StandardCharsets.UTF_8.decode(buffer2).toString();
        System.out.println(str1);//hello

        buffer1.flip();
        String str2 = StandardCharsets.UTF_8.decode(buffer1).toString();
        System.out.println(str2);//hello
        
        String str3 = new String(buffer3.array());
        System.out.println(str3);//hello
    }
}

输出:

+--------+-------------------- all ------------------------+----------------+
position: [5], limit: [16]
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 68 65 6c 6c 6f 00 00 00 00 00 00 00 00 00 00 00 |hello...........|
+--------+-------------------------------------------------+----------------+
+--------+-------------------- all ------------------------+----------------+
position: [0], limit: [5]
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 68 65 6c 6c 6f                                  |hello           |
+--------+-------------------------------------------------+----------------+
+--------+-------------------- all ------------------------+----------------+
position: [0], limit: [5]
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 68 65 6c 6c 6f                                  |hello           |
+--------+-------------------------------------------------+----------------+
hello
hello
hello

注意：Buffer 是非线程安全的

4. Scattering Reads(分散读取ByteBuffer )

分散读取，创建一个文本文件 words.txt

onetwothree

使用如下方式读取，可以将数据填充至多个 buffer

import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import static cn.qf.nio.c2.ByteBufferUtil.debugAll;
public class Test06ScatteringReads {
    public static void main(String[] args) {
        try (FileChannel channel = new RandomAccessFile("words.txt", "r").getChannel()) {
            ByteBuffer b1 = ByteBuffer.allocate(3);
            ByteBuffer b2 = ByteBuffer.allocate(3);
            ByteBuffer b3 = ByteBuffer.allocate(5);
            channel.read(new ByteBuffer[]{b1, b2, b3});
            b1.flip();
            b2.flip();
            b3.flip();
            debugAll(b1);
            debugAll(b2);
            debugAll(b3);
        } catch (IOException e) {
        }
    }
}

输出

+--------+-------------------- all ------------------------+----------------+
position: [0], limit: [3]
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 6f 6e 65                                        |one             |
+--------+-------------------------------------------------+----------------+
+--------+-------------------- all ------------------------+----------------+
position: [0], limit: [3]
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 74 77 6f                                        |two             |
+--------+-------------------------------------------------+----------------+
+--------+-------------------- all ------------------------+----------------+
position: [0], limit: [5]
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 74 68 72 65 65                                  |three           |
+--------+-------------------------------------------------+----------------+

5. Gathering Writes(批量ByteBuffer写入)

使用如下方式写入，可以将多个 buffer 的数据填充至 channel

import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.charset.StandardCharsets;
public class Test07GatheringWrites {
    public static void main(String[] args) {
        ByteBuffer b1 = StandardCharsets.UTF_8.encode("hello");
        ByteBuffer b2 = StandardCharsets.UTF_8.encode("world");
        ByteBuffer b3 = StandardCharsets.UTF_8.encode("你好呀");

        try (FileChannel channel = new RandomAccessFile("words2.txt", "rw").getChannel()) {
            channel.write(new ByteBuffer[]{b1, b2, b3});
        } catch (IOException e) {
        }
    }
}

运行代码输出到words2.txt文件中。

6. 练习(黏包和半包问题) ★

网络上有多条数据发送给服务端，数据之间使用 \n 进行分隔
但由于某种原因这些数据在接收时，被进行了重新组合，例如原始数据有3条为

  • Hello,world\n
  • I’m zhangsan\n
  • How are you?\n

变成了下面的两个 byteBuffer (黏包，半包)

  • Hello,world\nI’m zhangsan\nHo
  • w are you?\n

现在要求你编写程序，将错乱的数据恢复成原始的按 \n 分隔的数据

import java.nio.ByteBuffer;
import static cn.itcast.nio.c2.ByteBufferUtil.debugAll;
public class Test08ByteBufferExam {
    public static void main(String[] args) {
         /*
         网络上有多条数据发送给服务端，数据之间使用 \n 进行分隔
         但由于某种原因这些数据在接收时，被进行了重新组合，例如原始数据有3条为
             Hello,world\n
             I'm zhangsan\n
             How are you?\n
         变成了下面的两个 byteBuffer (黏包，半包)
             Hello,world\nI'm zhangsan\nHo
             w are you?\n
         现在要求你编写程序，将错乱的数据恢复成原始的按 \n 分隔的数据
         */
        ByteBuffer source = ByteBuffer.allocate(32);
        source.put("Hello,world\nI'm zhangsan\nHo".getBytes());
        split(source);
        source.put("w are you?\n".getBytes());
        split(source);
    }

    private static void split(ByteBuffer source) {
        source.flip();
        for (int i = 0; i < source.limit(); i++) {
            // 找到一条完整消息
            if (source.get(i) == '\n') {
                int length = i + 1 - source.position();
                // 把这条完整消息存入新的 ByteBuffer
                ByteBuffer target = ByteBuffer.allocate(length);
                // 从 source 读，向 target 写
                for (int j = 0; j < length; j++) {
                    target.put(source.get());
                }
                System.out.println("---------------↓输出的数据内容↓-----------");
                ByteBufferUtil.debugAll(result);
                System.out.println("---------------↓传递的数据内容↓-----------");
                ByteBufferUtil.debugAll(buffer);
                System.out.println("----------------------------------------------------");
            }
        }
        source.compact();
    }
}

输出

---------------↓输出的数据内容↓-----------

+--------+-------------------- all ------------------------+----------------+
position: [12], limit: [12]
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 48 65 6c 6c 6f 2c 77 6f 72 6c 64 0a             |Hello,world.    |
+--------+-------------------------------------------------+----------------+
---------------↓传递的数据内容↓-----------
+--------+-------------------- all ------------------------+----------------+
position: [12], limit: [27]
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 48 65 6c 6c 6f 2c 77 6f 72 6c 64 0a 49 27 6d 20 |Hello,world.I'm |
|00000010| 7a 68 61 6e 67 73 61 6e 0a 48 6f 00 00 00 00 00 |zhangsan.Ho.....|
+--------+-------------------------------------------------+----------------+
----------------------------------------------------
---------------↓输出的数据内容↓-----------
+--------+-------------------- all ------------------------+----------------+
position: [13], limit: [13]
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 49 27 6d 20 7a 68 61 6e 67 73 61 6e 0a          |I'm zhangsan.   |
+--------+-------------------------------------------------+----------------+
---------------↓传递的数据内容↓-----------
+--------+-------------------- all ------------------------+----------------+
position: [25], limit: [27]
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 48 65 6c 6c 6f 2c 77 6f 72 6c 64 0a 49 27 6d 20 |Hello,world.I'm |
|00000010| 7a 68 61 6e 67 73 61 6e 0a 48 6f 00 00 00 00 00 |zhangsan.Ho.....|
+--------+-------------------------------------------------+----------------+
----------------------------------------------------
---------------↓输出的数据内容↓-----------
+--------+-------------------- all ------------------------+----------------+
position: [13], limit: [13]
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 48 6f 77 20 61 72 65 20 79 6f 75 3f 0a          |How are you?.   |
+--------+-------------------------------------------------+----------------+
---------------↓传递的数据内容↓-----------
+--------+-------------------- all ------------------------+----------------+
position: [13], limit: [13]
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 48 6f 77 20 61 72 65 20 79 6f 75 3f 0a 27 6d 20 |How are you?.'m |
|00000010| 7a 68 61 6e 67 73 61 6e 0a 48 6f 00 00 00 00 00 |zhangsan.Ho.....|
+--------+-------------------------------------------------+----------------+
----------------------------------------------------
齐 飞
关注
  • 4
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
从零开始学习Netty - 学习笔记 - NIO基础 - ByteBuffer: 简介和基本操作
q1372302825的博客
02-19 1179
NIO基础中的ByteBuffer是Java NIO中重要的组件之一，用于处理字节数据。通过ByteBuffer，可以实现灵活的数据读取、写入、修改等操作。它的特点包括容量和位置的管理、读写操作的灵活性、字节顺序的配置、直接和非直接缓冲区的选择等。ByteBuffer常见方法包括分配空间、包装现有数组、读写数据、翻转缓冲区等。在实际应用中，ByteBuffer在网络编程、文件I/O等领域有着广泛的应用。与传统的I/O相比，使用ByteBuffer可以提高系统的并发处理能力和性能表现，是Java NIO中不可
NIO笔记01-NIO 基础三大组件
weixin_46425661的博客
09-01 250
主要介绍NIO的基础三大组件(Channel & Buffer & Selector)
Java NIO 学习笔记 - ByteBuffer
idhuanghao的专栏
12-26 669
在 NIO 库中，所有数据都是用缓冲区处理的。在读取数据时，它是直接读到缓冲区中的。在写入数据时，它是写入到缓冲区中的。任何时候访问 NIO 中的数据，都是将它放到缓冲区中。缓冲区实质上是一个数组。通常它是一个字节数组，但是也可以使用其他种类的数组。但是一个缓冲区不仅仅是一个数组。缓冲区提供了对数据的结构化访问，而且还可以跟踪系统的读/写进程。 buffer其实只是一个美化了的数组。 状态
【JAVA 网络编程系列】NIO -- ByteBuffer 堆内与堆外内存
CopperSun 技术博客
10-02 672
【JAVA 网络编程系列】NIO -- ByteBuffer堆内与堆外内存 【1】Unsafe 与堆外内存分配 Unsafe 操作直接内存的方法 // 分配内存 public native long allocateMemory(long var1); // 释放内存 public native void freeMemory(long var1); // 设置内存值 public native void setMemory(Object var1, long var2, long var4, b.
转载：Java NIO 学习笔记 - ByteBuffer
javazhuanzai的专栏
01-10 363
在 nio 库中,所有数据都是用缓冲区处理的。在读取数据时,它是直接读到缓冲区中的。在写入数据时,它是写入到缓冲区中的。任何时候访问 nio 中的数据,都是将它放到缓冲区中。缓冲区实质上是一个数组。通常它是一个字节数组,但是也可以使用其他种类的数组。但是一个缓冲区不仅仅是一个数组。缓冲区提供了对数据的结构化访问,而且还可以跟踪系统的读/写进程。 buffer其实只是一个美化了的数组。 状态变量
NIO笔记03-文件编程
最新发布
weixin_46425661的博客
09-03 825
本文主要讲解文件编程相关api
NIO笔记---上
weixin_30892987的博客
02-04 55
小弟前端时间由于开发个管理系统导致断更了近20天！！马上就要春招了，学习了一下NIO，将笔记记录下，希望和我一样的18届毕业生都能找到满意的公司！！ 本文记录了NIO与IO的区别，缓冲区的数据存取，直接缓冲区与非直接缓冲区，通道的原理与获取，通道之间的数据传输 一.简介 1.NIO简介： 与原来的IO有同样的作用与目的，但是使用的方式完全不同，NIO支持面向缓冲区的，基于通道的...
Java NIO 学习笔记 - ByteBuffer (转）
k3huihui的专栏
11-29 112
在 NIO 库中，所有数据都是用缓冲区处理的。在读取数据时，它是直接读到缓冲区中的。在写入数据时，它是写入到缓冲区中的。任何时候访问 NIO 中的数据，都是将它放到缓冲区中。缓冲区实质上是一个数组。通常它是一个字节数组，但是也可以使用其他种类的数组。但是一个缓冲区不仅仅是一个数组。缓冲区提供了对数据的结构化访问，而且还可以跟踪系统的读/写进程。 buffer其实只是一个美化了的数组。 状态变量...
Java NIO学习笔记--02
逍遥绝情的博客
01-29 210
SocketChannel Java NIO中的SocketChannel是一个连接到TCP网络套接字的通道。可以通过以下2种方式创建SocketChannel： 1.打开一个SocketChannel并连接到互联网上的某台服务器。 2.一个新连接到达ServerSocketChannel时，会创建一个SocketChannel。 1.打开 SocketChannel 下面是SocketC
Java NIO学习笔记——ByteBuffer用法
03-24
本文主要关注的是Java NIO中的ByteBuffer，一个关键的数据容器，用于在通道(Channel)和缓冲区(Buffer)之间传输数据。ByteBuffer的用法是Java NIO学习中的核心内容。 首先，我们了解下ByteBuffer的基本概念。...
JAVA NIO学习笔记.docx
09-02
import java.nio.ByteBuffer; import java.nio.channels.FileChannel; public class CopyFile { public static void main(String[] args) throws Exception { String infile = "C:\\copy.sql"; String ...
NIO笔记.doc
01-17
- Java NIO有多种类型的缓冲区，如ByteBuffer、CharBuffer、ShortBuffer等，对应不同数据类型。缓冲区的操作包括allocate、put、get、flip、clear和rewind等。 5. **选择器（Selector）**： - 选择器允许单线程...
java-nio-缓冲区ByteBuffer、Netty的ByteBuf和MappedByteBuffer的使用
2010yhh
03-18 1183
java-nio-缓冲区ByteBuffer、Netty的ByteBuf和MappedByteBuffer的使用 文章目录java-nio-缓冲区ByteBuffer、Netty的ByteBuf和MappedByteBuffer的使用1.ByteBuffer2.MappedByteBuffer3 Netty的ByteBuf4.测试 环境 idea2018，jdk1.8 记录一下缓冲区ByteB...
Java 输入与输出之 NIO.2【AIO】【内存映射文件】【自动资源管理】探索之【四】
weixin_42369079的博客
08-30 1280
Java NIO（New IO）的另外特性：内存映射文件和try语句的自动资源管理 JDK 1.4引入的缓冲区Buffer和通道Channel，以及MappedByteBuffer，为内存映射文件提供了基础。 NIO Java 7 增加了一个新特性 自动资源管理的“带资源的try语句”。
Java 输入与输出之 NIO.2【AIO】【Path、Paths、Files】【walkFileTree接口】探索之【三】
weixin_42369079的博客
08-30 1267
详细介绍了Java NIO.2 中Path 、Paths和 Files等两个核心类，演示了使用Path和Files一起访问文件系统，对文件和目录进行管理和操作。详细介绍了Files.newDirectoryStream方法和Files.walkFileTree方法对目录进行遍历操作。
Java 入门指南：Java NIO —— Buffer（缓冲区）
Zachyy的博客
08-30 1052
在 NIO（New Input/Output）模型中，Buffer 是一个重要的概念，与数据打交道，用于在内存中存储数据。通过 Channel 将数据传输到 Buffer 缓冲区中，并在缓冲区内进行数据的读写操作。 Buffer 本质上是一个数组，可以存储多个相同类型的基本数据类型，如 byte、short、int、long、float、double 等。Buffer 封装了内部的数组，并提供了一些操作该数组的方法。
Java 入门指南：Java NIO —— Selector（选择器）
Zachyy的博客
08-30 1312
Selector 是 Java NIO（New I/O）库中的一个重要组件，它用于实现非阻塞 I/O 操作。它可以用于管理多个通道（如网络套接字或文件通道）的事件，从而使单个线程能够有效地处理多个通道的 I/O 操作。
Java 入门指南：初识 Java NIO
Zachyy的博客
08-29 991
Java1.4 版本引入了 NIO（New I/O or Non-Blocking I/O）java.nio。提供了一种基于缓冲区、选择器和非阻塞 IO 模型的 IO 处理方式。相比于之前的 `BIO` 模型，NIO 可以实现更高的并发、更低的延迟以及更少的资源消耗。
http-nio-8080-exec-1
06-06
http-nio-808-exec-1是Tomcat服务器中的一个线程，用于处理来自客户端的HTTP请求。它是通过NIO（非阻塞IO）方式处理请求的，可以提高服务器的性能和吞吐量。当客户端发送一个HTTP请求时，Tomcat服务器会为该请求分配一个http-nio-808-exec-1线程来处理请求，并在处理完请求后将响应返回给客户端。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值