Buffer (抽象類)
├── ByteBuffer          // 最常用的，處理字節(jié)數(shù)據(jù)
│   └── MappedByteBuffer    // 內(nèi)存映射文件專用
│       ├── DirectByteBuffer    // 直接內(nèi)存實現(xiàn)
│       └── FileChannelImpl.MappedByteBufferAdapter
├── CharBuffer          // 處理字符
├── DoubleBuffer        // 處理雙精度浮點數(shù)
├── FloatBuffer         // 處理單精度浮點數(shù)
├── IntBuffer           // 處理整數(shù)
├── LongBuffer          // 處理長整數(shù)
└── ShortBuffer         // 處理短整數(shù)

// 創(chuàng)建一個能裝1024個字節(jié)的Buffer
ByteBuffer buffer = ByteBuffer.allocate(1024);
int capacity = buffer.capacity(); // 返回1024，永遠不變

ByteBuffer buffer = ByteBuffer.allocate(10);
buffer.put((byte) 'A'); // position從0跳到1
buffer.put((byte) 'B'); // position從1跳到2
int currentPosition = buffer.position(); // 現(xiàn)在是2

ByteBuffer buffer = ByteBuffer.allocate(10);
// 寫模式：limit = capacity = 10，可以寫滿
int limitInWriteMode = buffer.limit(); // 返回10
// 寫入3個字節(jié)后切換到讀模式
buffer.put((byte) 'A').put((byte) 'B').put((byte) 'C');
buffer.flip(); // 切換到讀模式
// 讀模式：limit = 3，只能讀這3個字節(jié)
int limitInReadMode = buffer.limit(); // 返回3

// 創(chuàng)建一個能裝8個字節(jié)的Buffer
ByteBuffer buffer = ByteBuffer.allocate(8);
System.out.println("剛創(chuàng)建時：");
System.out.println("capacity: " + buffer.capacity()); // 8，總?cè)萘?
System.out.println("limit: " + buffer.limit());       // 8，能寫到哪
System.out.println("position: " + buffer.position()); // 0，當前位置
// 寫入數(shù)據(jù)
buffer.put("ABCD".getBytes());
System.out.println("\n寫入ABCD后：");
System.out.println("capacity: " + buffer.capacity()); // 8，總?cè)萘坎蛔?
System.out.println("limit: " + buffer.limit());       // 8，還能繼續(xù)寫
System.out.println("position: " + buffer.position()); // 4，指針移到第4位
// 切換到讀模式
buffer.flip();
System.out.println("\nflip()切換讀模式后：");
System.out.println("capacity: " + buffer.capacity()); // 8，總?cè)萘坎蛔?
System.out.println("limit: " + buffer.limit());       // 4，只能讀4個字節(jié)
System.out.println("position: " + buffer.position()); // 0，從頭開始讀

剛創(chuàng)建（寫模式）：
[0][1][2][3][4][5][6][7]
 ^                       ^
position              limit/capacity
寫入ABCD后：
[A][B][C][D][ ][ ][ ][ ]
             ^           ^
          position   limit/capacity
flip()后（讀模式）：
[A][B][C][D][ ][ ][ ][ ]
 ^           ^           ^
position   limit      capacity

ByteBuffer buffer = ByteBuffer.allocate(10);
buffer.put((byte) 'A');
buffer.put((byte) 'B');
buffer.mark(); // 在position=2的地方做個書簽
buffer.put((byte) 'C');
buffer.reset(); // 跳回書簽位置(position=2)

public final Buffer flip() {
    limit = position;     // 設置讀取邊界
    position = 0;         // 從頭開始讀
    mark = -1;           // 清除書簽
    return this;
}

public final Buffer clear() {
    position = 0;         // 從頭開始寫
    limit = capacity;     // 可以寫滿整個Buffer
    mark = -1;           // 清除書簽
    return this;
}

public ByteBuffer compact() {
    // 把沒讀完的數(shù)據(jù)移到前面
    System.arraycopy(hb, ix(position()), hb, ix(0), remaining());
    position(remaining());  // position指向未讀數(shù)據(jù)后面
    limit(capacity());      // 可以寫滿整個Buffer
    discardMark();         // 清除書簽
    return this;
}

// 在JVM堆內(nèi)存里創(chuàng)建，速度快
ByteBuffer heapBuffer = ByteBuffer.allocate(1024);
// 在系統(tǒng)內(nèi)存里創(chuàng)建，I/O效率高
ByteBuffer directBuffer = ByteBuffer.allocateDirect(1024);
// 把現(xiàn)有數(shù)組包裝成Buffer
byte[] array = new byte[1024];
ByteBuffer wrappedBuffer = ByteBuffer.wrap(array);

// 寫一個字節(jié)，position自動+1
buffer.put((byte) 127);
// 寫一串字節(jié)
byte[] data = "Hello".getBytes();
buffer.put(data);
// 在指定位置寫入，不影響position
buffer.put(3, (byte) 65); // 在第3個位置寫入'A'
// 從數(shù)組的某個位置開始，寫入指定長度
buffer.put(data, 1, 3); // 從data[1]開始寫3個字節(jié)

// 讀一個字節(jié)，position自動+1
byte b = buffer.get();
// 讀一串字節(jié)到數(shù)組里
byte[] data = new byte[10];
buffer.get(data);
// 從指定位置讀取，不影響position
byte b = buffer.get(3); // 讀取第3個位置的字節(jié)
// 讀指定長度到數(shù)組的某個位置
buffer.get(data, 1, 3); // 讀3個字節(jié)到data[1]開始的位置

// 做書簽和跳回書簽
buffer.mark();  // 在當前position做個書簽
buffer.reset(); // 跳回書簽位置
// 倒帶，position回到0
buffer.rewind();
// 檢查還能讀多少
boolean hasRemaining = buffer.hasRemaining(); // 還有數(shù)據(jù)嗎？
int remaining = buffer.remaining(); // 還剩多少個（limit - position）
// 手動移動position
buffer.position(buffer.position() + 3); // 跳過3個位置
// 復制Buffer，共享數(shù)據(jù)但各自有獨立的指針
ByteBuffer duplicate = buffer.duplicate();
// 創(chuàng)建只讀版本，不能修改數(shù)據(jù)
ByteBuffer readOnlyBuffer = buffer.asReadOnlyBuffer();
// 切片，共享一部分數(shù)據(jù)
ByteBuffer slicedBuffer = buffer.slice(2, 5); // 從位置2開始，長度5的片段

ByteBuffer heapBuffer = ByteBuffer.allocate(1024); // 在堆內(nèi)存里創(chuàng)建

// HeapByteBuffer的底層實現(xiàn)（簡化版）
final byte[] hb;  // 就是個普通數(shù)組
final int offset; // 數(shù)組里的起始位置
// 讀取操作
public byte get() {
    return hb[ix(nextGetIndex())];
}
// 寫入操作
public ByteBuffer put(byte b) {
    hb[ix(nextPutIndex())] = b;
    return this;
}

ByteBuffer directBuffer = ByteBuffer.allocateDirect(1024); // 在系統(tǒng)內(nèi)存里創(chuàng)建

// DirectByteBuffer的底層實現(xiàn)（簡化版）
private long address; // 系統(tǒng)內(nèi)存地址
// 讀取操作
public byte get() {
    return Unsafe.getByte(ix(nextGetIndex())); // 直接從系統(tǒng)內(nèi)存讀
}
// 寫入操作
public ByteBuffer put(byte b) {
    Unsafe.putByte(ix(nextPutIndex()), b); // 直接寫到系統(tǒng)內(nèi)存
    return this;
}

public class BufferPerformanceTest {
    private static final int BUFFER_SIZE = 1024 * 1024; // 1MB大小
    private static final int ITERATIONS = 1000; // 測試1000次
    public static void main(String[] args) throws Exception {
        // 測試創(chuàng)建速度
        testAllocation();
        // 測試I/O速度
        testIO();
        // 測試讀寫速度
        testMemoryAccess();
    }
    private static void testAllocation() {
        long start, end;
        // 測試堆內(nèi)存Buffer創(chuàng)建速度
        start = System.nanoTime();
        for (int i = 0; i < ITERATIONS; i++) {
            ByteBuffer buffer = ByteBuffer.allocate(BUFFER_SIZE); // 在堆里創(chuàng)建
            buffer.put((byte) 1); // 寫點數(shù)據(jù)
        }
        end = System.nanoTime();
        System.out.println("堆Buffer創(chuàng)建: " + (end - start) / 1000000 + "ms");
        // 測試直接Buffer創(chuàng)建速度
        start = System.nanoTime();
        for (int i = 0; i < ITERATIONS; i++) {
            ByteBuffer buffer = ByteBuffer.allocateDirect(BUFFER_SIZE); // 在系統(tǒng)內(nèi)存創(chuàng)建
            buffer.put((byte) 1); // 寫點數(shù)據(jù)
        }
        end = System.nanoTime();
        System.out.println("直接Buffer創(chuàng)建: " + (end - start) / 1000000 + "ms");
    }
    private static void testIO() throws Exception {
        File tempFile = File.createTempFile("buffer-test", ".tmp"); // 創(chuàng)建臨時文件
        tempFile.deleteOnExit(); // 程序結(jié)束時刪除
        // 準備測試數(shù)據(jù)
        ByteBuffer data = ByteBuffer.allocate(BUFFER_SIZE);
        while (data.hasRemaining()) {
            data.put((byte) 'A'); // 填充數(shù)據(jù)
        }
        data.flip(); // 切換到讀模式
        // 測試堆Buffer的I/O速度
        ByteBuffer heapBuffer = ByteBuffer.allocate(BUFFER_SIZE);
        testFileIO(heapBuffer, tempFile, "堆Buffer I/O");
        // 測試直接Buffer的I/O速度
        ByteBuffer directBuffer = ByteBuffer.allocateDirect(BUFFER_SIZE);
        testFileIO(directBuffer, tempFile, "直接Buffer I/O");
    }
    private static void testFileIO(ByteBuffer buffer, File file, String label) throws Exception {
        FileChannel channel = new FileOutputStream(file).getChannel(); // 獲取文件通道
        long start = System.nanoTime(); // 開始計時
        for (int i = 0; i < ITERATIONS; i++) {
            buffer.clear(); // 清空Buffer，準備寫入
            buffer.put(new byte[BUFFER_SIZE]); // 寫入數(shù)據(jù)
            buffer.flip(); // 切換到讀模式
            while (buffer.hasRemaining()) {
                channel.write(buffer); // 寫到文件
            }
        }
        channel.close(); // 關閉通道
        long end = System.nanoTime(); // 結(jié)束計時
        System.out.println(label + ": " + (end - start) / 1000000 + "ms");
    }
    private static void testMemoryAccess() {
        ByteBuffer heapBuffer = ByteBuffer.allocate(BUFFER_SIZE); // 堆Buffer
        ByteBuffer directBuffer = ByteBuffer.allocateDirect(BUFFER_SIZE); // 直接Buffer
        // 測試堆Buffer讀寫速度
        long start = System.nanoTime();
        for (int i = 0; i < ITERATIONS; i++) {
            for (int j = 0; j < 1024; j++) {
                heapBuffer.put(j, (byte) j); // 在指定位置寫入
            }
            for (int j = 0; j < 1024; j++) {
                byte b = heapBuffer.get(j); // 從指定位置讀取
            }
        }
        long end = System.nanoTime();
        System.out.println("堆Buffer讀寫: " + (end - start) / 1000000 + "ms");
        // 測試直接Buffer讀寫速度
        start = System.nanoTime();
        for (int i = 0; i < ITERATIONS; i++) {
            for (int j = 0; j < 1024; j++) {
                directBuffer.put(j, (byte) j); // 在指定位置寫入
            }
            for (int j = 0; j < 1024; j++) {
                byte b = directBuffer.get(j); // 從指定位置讀取
            }
        }
        end = System.nanoTime();
        System.out.println("直接Buffer讀寫: " + (end - start) / 1000000 + "ms");
    }
}