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

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

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個(gè)字節(jié)后切換到讀模式
buffer.put((byte) 'A').put((byte) 'B').put((byte) 'C');
buffer.flip(); // 切換到讀模式
// 讀模式：limit = 3，只能讀這3個(gè)字節(jié)
int limitInReadMode = buffer.limit(); // 返回3

// 創(chuàng)建一個(gè)能裝8個(gè)字節(jié)的Buffer
ByteBuffer buffer = ByteBuffer.allocate(8);
System.out.println("剛創(chuàng)建時(shí)：");
System.out.println("capacity: " + buffer.capacity()); // 8，總?cè)萘?
System.out.println("limit: " + buffer.limit());       // 8，能寫到哪
System.out.println("position: " + buffer.position()); // 0，當(dāng)前位置
// 寫入數(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個(gè)字節(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的地方做個(gè)書簽
buffer.put((byte) 'C');
buffer.reset(); // 跳回書簽位置(position=2)

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

public final Buffer clear() {
    position = 0;         // 從頭開始寫
    limit = capacity;     // 可以寫滿整個(gè)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());      // 可以寫滿整個(gè)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);

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

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

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

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

// HeapByteBuffer的底層實(shí)現(xiàn)（簡(jiǎn)化版）
final byte[] hb;  // 就是個(gè)普通數(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的底層實(shí)現(xiàn)（簡(jiǎ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; // 測(cè)試1000次
    public static void main(String[] args) throws Exception {
        // 測(cè)試創(chuàng)建速度
        testAllocation();
        // 測(cè)試I/O速度
        testIO();
        // 測(cè)試讀寫速度
        testMemoryAccess();
    }
    private static void testAllocation() {
        long start, end;
        // 測(cè)試堆內(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); // 寫點(diǎn)數(shù)據(jù)
        }
        end = System.nanoTime();
        System.out.println("堆Buffer創(chuàng)建: " + (end - start) / 1000000 + "ms");
        // 測(cè)試直接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); // 寫點(diǎn)數(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)建臨時(shí)文件
        tempFile.deleteOnExit(); // 程序結(jié)束時(shí)刪除
        // 準(zhǔn)備測(cè)試數(shù)據(jù)
        ByteBuffer data = ByteBuffer.allocate(BUFFER_SIZE);
        while (data.hasRemaining()) {
            data.put((byte) 'A'); // 填充數(shù)據(jù)
        }
        data.flip(); // 切換到讀模式
        // 測(cè)試堆Buffer的I/O速度
        ByteBuffer heapBuffer = ByteBuffer.allocate(BUFFER_SIZE);
        testFileIO(heapBuffer, tempFile, "堆Buffer I/O");
        // 測(cè)試直接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(); // 開始計(jì)時(shí)
        for (int i = 0; i < ITERATIONS; i++) {
            buffer.clear(); // 清空Buffer，準(zhǔn)備寫入
            buffer.put(new byte[BUFFER_SIZE]); // 寫入數(shù)據(jù)
            buffer.flip(); // 切換到讀模式
            while (buffer.hasRemaining()) {
                channel.write(buffer); // 寫到文件
            }
        }
        channel.close(); // 關(guān)閉通道
        long end = System.nanoTime(); // 結(jié)束計(jì)時(shí)
        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
        // 測(cè)試堆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");
        // 測(cè)試直接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");
    }
}