@Slf4j
public class TestByteBuffer {

    public static void main(String[] args) {

        try (FileChannel channel = new FileInputStream("data.txt").getChannel()) {
            // 準備緩沖區(qū)
            ByteBuffer buffer = ByteBuffer.allocate(10);
            while (true) {
                // 從 channel 讀取數(shù)據(jù)寫入到 buffer
                int len = channel.read(buffer);
                log.debug("讀取到的字節(jié)數(shù) {}", len);
                if (len == -1) break;

                // 打印 buffer 內容
                buffer.flip();  // 切換至讀模式
                while(buffer.hasRemaining()) {  // 是否還有剩余未讀數(shù)據(jù)
                    byte b = buffer.get();
                    log.debug("實際字節(jié) {}", (char)b);
                }
                buffer.clear();
            }
        } catch (IOException e) {

        }

    }

}

<?xml version="1.0" encoding="utf-8" ?>
<configuration
        xmlns="http://ch.qos.logback/xml/ns/logback"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://ch.qos.logback/xml/ns/logback logback.xsd">

    <!-- 輸出控制，格式控制 -->
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%date{HH:mm:ss} [%-5level] [%thread] %logger{17} - %m%n </pattern>
        </encoder>
    </appender>
    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 日志文件名稱 -->
        <file>logFile.log</file>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!-- 每天產生一個新的日志文件 -->
            <fileNamePattern>logFile.%d{yyyy-MM-dd}.log</fileNamePattern>
            <!-- 保留 15 天的日志 -->
            <maxHistory>15</maxHistory>
        </rollingPolicy>
        <encoder>
            <pattern>%date{HH:mm:ss} [%-5level] [%thread] %logger{17} - %m%n </pattern>
        </encoder>
    </appender>

    <!-- 用來控制查看哪個類的日志內容（對 mybatis name 代表命名空間）-->
    <logger name="com.sidiot.netty" level="DEBUG" additivity="false">
        <appender-ref ref="STDOUT" />
    </logger>

    <root level="ERROR">
        <appender-ref ref="STDOUT" />
    </root>
</configuration>

<dependency>  
    <groupId>org.projectlombok</groupId>  
    <artifactId>lombok</artifactId>  
    <version>1.18.26</version>  
</dependency>

// Invariants: mark <= position <= limit <= capacity  
private int mark = -1;  
private int position = 0;  
private int limit;  
private int capacity;

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

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

public class TestByteBufferReadWrite {
    public static void main(String[] args) {
        ByteBuffer buffer = ByteBuffer.allocate(10);

        // 寫入一個字節(jié)的數(shù)據(jù)
        buffer.put((byte) 0x73);
        debugAll(buffer);

        // 寫入一組五個字節(jié)的數(shù)據(jù)
        buffer.put(new byte[]{0x69, 0x64, 0x69, 0x6f, 0x74});
        debugAll(buffer);

        // 獲取數(shù)據(jù)
        buffer.flip();
        ByteBufferUtil.debugAll(buffer);
        System.out.println((char) buffer.get());
        System.out.println((char) buffer.get());
        ByteBufferUtil.debugAll(buffer);

        // 使用 compact 切換寫模式
        buffer.compact();
        ByteBufferUtil.debugAll(buffer);

        // 再次寫入
        buffer.put((byte) 102);
        buffer.put((byte) 103);
        ByteBufferUtil.debugAll(buffer);
    }
}

// 向緩沖區(qū)寫入了一個字節(jié)的數(shù)據(jù)，此時 postition 為 1；
+--------+-------------------- all ------------------------+----------------+
position: [1], limit: [10]
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 73 00 00 00 00 00 00 00 00 00                   |s.........      |
+--------+-------------------------------------------------+----------------+

// 向緩沖區(qū)寫入了五個字節(jié)的數(shù)據(jù)，此時 postition 為 6；
+--------+-------------------- all ------------------------+----------------+
position: [6], limit: [10]
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 73 69 64 69 6f 74 00 00 00 00                   |sidiot....      |
+--------+-------------------------------------------------+----------------+

// 調用 flip() 切換至讀模式，此時 position 為 0，表示從第 0 個數(shù)據(jù)開始讀取；
// 同時要注意，此時的 limit 為 6，表示 position=6 時內容就讀完了；
+--------+-------------------- all ------------------------+----------------+
position: [0], limit: [6]
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 73 69 64 69 6f 74 00 00 00 00                   |sidiot....      |
+--------+-------------------------------------------------+----------------+

// 讀取兩個字節(jié)的數(shù)據(jù)；
s
i

// 此時 position 變?yōu)?2； 
+--------+-------------------- all ------------------------+----------------+
position: [2], limit: [6]
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 73 69 64 69 6f 74 00 00 00 00                   |sidiot....      |
+--------+-------------------------------------------------+----------------+

// 調用 compact() 切換至寫模式，此時 position 及其后面的數(shù)據(jù)被壓縮到 ByteBuffer 的前面；
// 此時 position 為 4，會覆蓋之前的數(shù)據(jù)； 
+--------+-------------------- all ------------------------+----------------+
position: [4], limit: [10]
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 64 69 6f 74 6f 74 00 00 00 00                   |diotot....      |
+--------+-------------------------------------------------+----------------+

// 再次寫入兩個字節(jié)的數(shù)據(jù)，之前的 0x6f 0x74 被覆蓋；  
+--------+-------------------- all ------------------------+----------------+
position: [6], limit: [10]
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 64 69 6f 74 66 67 00 00 00 00                   |diotfg....      |
+--------+-------------------------------------------------+----------------+

Process finished with exit code 0

public class TestByteBufferAllocate {
    public static void main(String[] args) {

        System.out.println(ByteBuffer.allocate(16).getClass());
        System.out.println(ByteBuffer.allocateDirect(16).getClass());
        /*
            class java.nio.HeapByteBuffer    - java 堆內存， 讀寫效率低， 受垃圾回收 GC 的影響；
            class java.nio.DirectByteBuffer  - 直接內存，讀寫效率高(少一次拷貝)，不會受 GC 的影響；
                                             - 使用完后 需要徹底的釋放，以免內存泄露；
         */

    }
}

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

@Test
public void testRewind() {
    // rewind 從頭開始讀
    ByteBuffer buffer = ByteBuffer.allocate(16);
    buffer.put(new byte[]{'s', 'i', 'd', 'i', 'o', 't'});
    buffer.flip();
    buffer.get(new byte[6]);
    debugAll(buffer);
    buffer.rewind();
    System.out.println((char) buffer.get());
}

public Buffer mark() {
    mark = position;
    return this;
}

public Buffer reset() {
    int m = mark;
    if (m < 0)
        throw new InvalidMarkException();
    position = m;
    return this;
}

@Test
public void testMarkAndReset() {
    // mark 做一個標記，用于記錄 position 的位置；reset 是將 position 重置到 mark 的位置；
    ByteBuffer buffer = ByteBuffer.allocate(16);
    buffer.put(new byte[]{'s', 'i', 'd', 'i', 'o', 't'});
    buffer.flip();
    System.out.println((char) buffer.get());
    System.out.println((char) buffer.get());
    buffer.mark();      // 添加標記為索引2的位置;
    System.out.println((char) buffer.get());
    System.out.println((char) buffer.get());
    debugAll(buffer);
    buffer.reset();     // 將 position 重置到索引2;
    debugAll(buffer);
    System.out.println((char) buffer.get());
    System.out.println((char) buffer.get());
}

@Test
public void testGet_i() {
    // get(i) 不會改變讀索引的位置；
    ByteBuffer buffer = ByteBuffer.allocate(16);
    buffer.put(new byte[]{'s', 'i', 'd', 'i', 'o', 't'});
    buffer.flip();
    System.out.println((char) buffer.get(2));
    debugAll(buffer);
}

public byte[] getBytes() {
    return StringCoding.encode(coder(), value);
}

@Test
public void testGetBytes() {
    ByteBuffer buffer = ByteBuffer.allocate(16);
    buffer.put("sidiot".getBytes());
    debugAll(buffer);
}

public final ByteBuffer encode(String str) {
    return encode(CharBuffer.wrap(str));
}

@Test
public void testCharset() {
    ByteBuffer buffer = StandardCharsets.UTF_8.encode("sidiot");
    debugAll(buffer);

    System.out.println(StandardCharsets.UTF_8.decode(buffer));
}

public static ByteBuffer wrap(byte[] array,
                                int offset, int length)
{
    try {
        return new HeapByteBuffer(array, offset, length, null);
    } catch (IllegalArgumentException x) {
        throw new IndexOutOfBoundsException();
    }
}

@Test
public void testWrap() {
    ByteBuffer buffer = ByteBuffer.wrap("sidiot".getBytes());
    debugAll(buffer);
}