一文搞懂ByteBuffer使用与原理-六虎

学妹觉得我之前写的Reactor模型还不错，

问我是不是能够再总结一下ByteBuffer，

其实平时不怎么会运用ByteBuffer的，

可是架不住学妹一杯奶茶，

那就简略的总结一下吧。

前言

已知NIO中有三大组件：Channel，Buffer和Selector。那么Buffer的效果便是供给一个缓冲区，用于用户程序和Channel之间进行数据读写，也便是用户程序中能够运用Buffer向Channel写入数据，也能够运用Buffer从Channel读取数据。

ByteBuffer是Buffer子类，是字节缓冲区，特色如下所示。

巨细不行变。一旦创立，无法改动其容量巨细，无法扩容或许缩容；
读写灵活。内部经过指针移动来完结灵活读写；
支撑堆上内存分配和直接内存分配。

本文将对ByteBuffer的相关概念，常用API以及运用事例进行分析。全文约1万字，知识点脑图如下。

ByteBuffer-知识点脑图

正文

一. Buffer

在NIO中，八大根底数据类型中除了boolean外，都有相应的Buffer的完结，类图如下所示。

Buffer类图

Buffer类对各种根底数据类型的缓冲区做了顶层笼统，所以要了解ByteBuffer，首先应该学习Buffer类。

1. Buffer的特点

一切缓冲区结构都有如下特点。

特点	阐明
int position	方位索引。代表下一次即将操作的元素的方位，默许初始为0，方位索引最小为0，最大为limit
int limit	约束索引。约束索引及之后的索引方位上的元素都不能操作，约束索引最小为0，最大为capacity
int capacity	容量。缓冲区的最大元素个数，创立缓冲区时指定，最小为0，不能改动

三者之间的巨细联系应该是：0 <= position <= limit <= capacity，图示如下。

网络编程-Buffer特点示意图

除此之外，还有一个特点叫做mark，如下所示。

特点	阐明
int mark	符号索引。mark会符号一个索引，在Buffer#reset调用时，将position重置为mark。mark不是有必要的，可是当界说mark后，其最小为0，最大为position

关于mark还有如下两点阐明。

position或limit一旦小于mark则mark会被丢弃；
没有界说mark时假如调用了Buffer#reset则会抛出InvalidMarkException。

2. Buffer的读形式

Buffer有两种形式，读形式和写形式，在读形式下，能够读取缓冲区中的数据。那么关于一个缓冲区，要读取数据时，分为两步。

拿到position方位索引；
取position方位的数据。

那么Buffer供给了nextGetIndex() 办法和nextGetIndex(int nb) 办法来获取position，先看一下nextGetIndex() 办法的完结。

final int nextGetIndex() {
    // limit方位是不行操作的
    if (position >= limit) {
        throw new BufferUnderflowException();
    }
    // 回来当时position
    // 然后position后移一个方位
    return position++;
}

nextGetIndex() 办法首先校验一下position是否大于等于limit，由于limit及之后的方位都是不行操作的，所以只需满足position大于等于limit则抛出反常，然后回来当时的position（也便是当时可操作的方位），终究position后移一位。

而nextGetIndex(int nb) 办法，则是用于Buffer的子类ByteBuffer运用，由于ByteBuffer的一个元素便是一个字节，而假如想要经过ByteBuffer获取一个整形数据，那么此刻就需求连续读取四个字节。nextGetIndex(int nb) 办法如下所示。

final int nextGetIndex(int nb) {
    // 判别一下剩下可操作元素是否够本次获取
    if (limit - position < nb) {
        throw new BufferUnderflowException();
    }
    // 暂存当时position
    int p = position;
    // 然后position后移nb个方位
    position += nb;
    // 回来暂存的position
    return p;
}

拿到position后，实践的读取数据，由Buffer的子类来完结。

3. Buffer的写形式

有读就有写，在Buffer的写形式下，写入数据也是分为两步。

拿到position方位索引；
写入数据到position方位。

写形式下，Buffer相同为获取position供给了两个办法，如下所示。

final int nextPutIndex() {
    // limit方位是不行操作的
    if (position >= limit) {
        throw new BufferOverflowException();
    }
    // 回来当时position
    // 然后position后移一个方位
    return position++;
}
final int nextPutIndex(int nb) {
    // 判别一下剩下可操作元素是否够本次写入
    if (limit - position < nb) {
        throw new BufferOverflowException();
    }
    // 暂存当时position
    int p = position;
    // 然后position后移nb个方位
    position += nb;
    // 回来暂存的position
    return p;
}

相同，拿到position后，实践的写入数据，由Buffer的子类来完结。

4. Buffer读写形式切换

Buffer供给了读形式和写形式，同一时间Buffer只能在同一形式下作业，相应的，Buffer供给了对应的办法来做读写形式切换。

首先是读形式切换到写形式，先看如下示意图。

网络编程-Buffer读且读完切换写示意图

上图中的状况是缓冲区中的数据现已悉数被读完，那么此刻假如要切换到写形式，对应的办法是clear() 办法，如下所示。

public final Buffer clear() {
    // 重置position为0
    position = 0;
    // 设置limit为capacity
    limit = capacity;
    // 重置mark为-1
    mark = -1;
    return this;
}

注意，尽管办法名叫做clear()，可是实践缓冲区中的数据并没有被铲除，而只是将方位索引position，约束索引limit进行了重置，一起铲除了符号状态（也便是将mark设置为-1）。切换到写形式后，缓冲区示意图如下所示。

网络编程-Buffer读且读完切换写后示意图

然后是写形式切换到读形式，先看如下示意图。

网络编程-Buffer写切换读前示意图

数据现已写入结束了，此刻假如要切换到读形式，对应的办法是flip()，如下所示。

public final Buffer flip() {
    // 由于position方位还没写入数据
    // 所以将position方位设置为limit
    limit = position;
    // 重置position为0
    position = 0;
    // 重置mark为-1
    mark = -1;
    return this;
}

由于position永远代表下一个可操作的方位，那么在写形式下，position代表下一个写入的方位，那么其实就还没有数据写入，所以调用flip() 办法后，首先将position方位设置为limit，表明数据最多读取到limit的上一个方位，然后重置position和mark。切换到读形式后，缓冲区示意图如下所示。

网络编程-Buffer写切换读后示意图

5. Buffer的rewind操作

在运用Buffer时，能够针对现已操作的区域进行重操作，假定缓冲区示意图如下。

网络编程-Buffer的rewind前示意图

再看一下rewind() 办法的完结，如下所示。

public final Buffer rewind() {
    // 重置position为0
    position = 0;
    // 铲除mark
    mark = -1;
    return this;
}

主要便是将方位索引position重置为0，这样就能从头操作现已操作过的方位了，一起假如启用了mark，那么还会铲除mark，也便是重置mark为-1。rewind() 办法调用后的缓冲区示意图如下所示。

网络编程-Buffer的rewind后示意图

6. Buffer的reset操作

在运用Buffer时，能够启用mark来符号一个现已操作过的方位，假定缓冲区示意图如下。

网络编程-Buffer的reset前示意图

再看一下reset() 办法的完结，如下所示。

public final Buffer reset() {
    int m = mark;
    // 只需启用mark那么mark就不能为负数
    if (m < 0) {
        throw new InvalidMarkException();
    }
    // 将position重置为mark
    position = m;
    return this;
}

在没有启用mark时，mark为-1，只需启用了mark，那么mark就不能为负数。在reset() 中主要便是将方位索引position从头设置到mark符号的方位，以完结对mark符号的方位及之后的方位进行从头操作。reset() 办法调用后的缓冲区示意图如下所示。

网络编程-Buffer的reset后示意图

二. ByteBuffer

在上一节主要对Buffer进行了一个阐明，那么本节会在上一节的根底上，对ByteBuffer及其完结进行学习。

1. ByteBuffer的特点

ByteBuffer相较于Buffer，多了如下三个特点。

特点	阐明
byte[] hb	字节数组。仅HeapByteBuffer会运用到，HeapByteBuffer的数据存储在hb中
int offset	偏移量。仅HeapByteBuffer会运用到，后面会具体阐明
isReadOnly	是否只读。仅HeapByteBuffer会运用到，后面会具体阐明

NIO中为ByteBuffer分配内存时，能够有两种办法。

在堆上分配内存，此刻得到HeapByteBuffer；
在直接内存中分配内存，此刻得到DirectByteBuffer。

类图如下所示。

ByteBuffer类图

由于DirectByteBuffer是分配在直接内存中，必定无法像HeapByteBuffer相同将数据存储在字节数组，所以DirectByteBuffer会经过一个address字段来标识数据地点直接内存的开端地址。address字段界说在Buffer中，如下所示。

long address;

2. ByteBuffer的创立

ByteBuffer供给了如下四个办法用于创立ByteBuffer，如下所示。

办法	阐明
allocate(int capacity)	在堆上分配一个新的字节缓冲区。阐明如下： 1. 创立出来后，position为0，而且limit会取值为capacity； 2. 创立出来的实践为HeapByteBuffer，其内部运用一个字节数组hb存储元素； 3. 初始时hb中一切元素为0
allocateDirect(int capacity)	在直接内存中分配一个新的字节缓冲区。阐明如下： 1. 创立出来后，position为0，而且limit会取值为capacity； 2. 创立出来的实践为DirectByteBuffer，是根据操作系统创立的内存区域作为缓冲区； 3. 初始时一切元素为0
wrap(byte[] array)	将字节数组包装到字节缓冲区中。阐明如下： 1. 创立出来的是HeapByteBuffer，其内部的hb字节数组就会运用传入的array； 2. 改动HeapByteBuffer会影响array，改动array会影响HeapByteBuffer； 3. 得到的HeapByteBuffer的limit和capacity均取值为array.length； 4. position此刻都为0
wrap(byte[] array, int off, int length)	将字节数组包装到字节缓冲区，阐明如下。 1. 创立出来的是HeapByteBuffer，其内部的hb字节数组就会运用传入的array； 2. 改动HeapByteBuffer会影响array，改动array会影响HeapByteBuffer； 3. capacity取值为array.length； 4. limit取值为off + length； 5. position取值为off

下面结合源码，分析一下上述四种创立办法。

首先是allocate(int capacity)，如下所示。

public static ByteBuffer allocate(int capacity) {
    if (capacity < 0) {
        throw new IllegalArgumentException();
    }
    // 直接创立HeapByteBuffer
    // HeapByteBuffer(int cap, int lim)
    return new HeapByteBuffer(capacity, capacity);
}

然后是allocateDirect(int capacity)，如下所示。

public static ByteBuffer allocateDirect(int capacity) {
    return new DirectByteBuffer(capacity);
}
DirectByteBuffer(int cap) {
    // MappedByteBuffer(int mark, int pos, int lim, int cap)
    super(-1, 0, cap, cap);
    boolean pa = VM.isDirectMemoryPageAligned();
    int ps = Bits.pageSize();
    long size = Math.max(1L, (long)cap + (pa ? ps : 0));
    Bits.reserveMemory(size, cap);
    long base = 0;
    try {
        // 分配堆外内存
        base = unsafe.allocateMemory(size);
    } catch (OutOfMemoryError x) {
        Bits.unreserveMemory(size, cap);
        throw x;
    }
    unsafe.setMemory(base, size, (byte) 0);
    // 核算堆外内存开端地址
    if (pa && (base % ps != 0)) {
        address = base + ps - (base & (ps - 1));
    } else {
        address = base;
    }
    // 经过虚引证的手法来监督DirectByteBuffer是否被废物回收
    // 然后能够及时的开释堆外内存空间
    cleaner = Cleaner.create(this, new Deallocator(base, size, cap));
    att = null;
}

然后是wrap(byte[] array)，如下所示。

public static ByteBuffer wrap(byte[] array) {
    return wrap(array, 0, array.length);
}

其实wrap(byte[] array) 办法便是调用的wrap(byte[] array, int off, int length)，下面直接看wrap(byte[] array, int off, int length) 办法的完结。

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

这儿先简略阐明一下上述办法中的off和length这两个参数的含义。

off便是表明字节数组封装到字节缓冲区后，position的方位，所以有position = off；
length简略理解便是用于核算limit，即limit = position + length。其实length是理解为字节数组封装到字节缓冲区后，要运用的字节数组的长度。

下面给出一张wrap(byte[] array, int off, int length) 办法的效果示意图。

网络编程-ByteBuffer的wrap示意图

终究阐明一点，无论是wrap(byte[] array) 仍是wrap(byte[] array, int off, int length) 办法，均结构的是HeapByteBuffer。

3. ByteBuffer的slice操作

在ByteBuffer中界说了一个笼统办法叫做slice()，用于在已有的ByteBuffer上得到一个新的ByteBuffer，两个ByteBuffer的position，limit，capacity和mark都是独立的，可是底层存储数据的内存区域是相同的，那么相应的，对其间任何一个ByteBuffer做更改，会影响到另外一个ByteBuffer。

下面先看一下HeapByteBuffer对slice() 办法的完结。

public ByteBuffer slice() {
    return new HeapByteBuffer(hb, -1, 0, this.remaining(), this.remaining(), this.position() + offset);
}
public final int remaining() {
    return limit - position;
}
protected HeapByteBuffer(byte[] buf, int mark, int pos, int lim, int cap, int off) {
    super(mark, pos, lim, cap, buf, off);
}
ByteBuffer(int mark, int pos, int lim, int cap,
           byte[] hb, int offset) {
    super(mark, pos, lim, cap);
    this.hb = hb;
    this.offset = offset;
}

新的HeapByteBuffer的mark重置为了-1，position重置为了0，limit等于capacity等于老的HeapByteBuffer的未操作数据的长度（老的limit – posittion）。

此外，两个HeapByteBuffer存储数据的字节数组hb是同一个，且新的HeapByteBuffer的offset等于老的HeapByteBuffer的position，什么意思呢，先看下面这张图。

网络编程-HeapByteBuffer的slice示意图

意思便是，在新的HeapByteBuffer中，操作position方位的元素，实践是在操作hb[position + offset] 方位的元素，那么这儿也就解说了ByteBuffer中offset特点的效果，便是表明要操作字节数组时的索引偏移量。

有了上面临HeapByteBuffer的理解，那么现在再看DirectByteBuffer就显得很简略了，DirectByteBuffer对slice() 办法的完结如下所示。

public ByteBuffer slice() {
    int pos = this.position();
    int lim = this.limit();
    assert (pos <= lim);
    int rem = (pos <= lim ? lim - pos : 0);
    int off = (pos << 0);
    assert (off >= 0);
    return new DirectByteBuffer(this, -1, 0, rem, rem, off);
}
DirectByteBuffer(DirectBuffer db,
                 int mark, int pos, int lim, int cap,
                 int off) {
    super(mark, pos, lim, cap);
    address = db.address() + off;
    cleaner = null;
    att = db;
}

DirectByteBuffer对slice() 办法的完结和HeapByteBuffer差不多，只不过在HeapByteBuffer中是对字节数组索引有偏移，而在DirectByteBuffer中是对堆外内存地址有偏移，一起偏移量都是老的ByteBuffer的position的值。

终究针对slice() 办法，有一点小阐明，在DirectByteBuffer的att中有这么一段注释。

If this buffer is a view of another buffer then …

这儿提到了view，翻译过来叫做视图，其实调用ByteBuffer的slice() 办法，能够想象成便是为原字节缓冲区创立了一个视图，这个视图和原字节缓冲区同享同一片内存区域，可是有新的一套mark，position，limit和capacity。

4. ByteBuffer的asReadOnlyBuffer操作

ByteBuffer界说了一个笼统办法叫做asReadOnlyBuffer()，会在当时ByteBuffer根底上创立一个新的ByteBuffer，创立出来的ByteBuffer能看见老ByteBuffer的数据（同享同一块内存），但只能读不能写（只读的），一起两个ByteBuffer的position，limit，capacity和mark是独立的。

先看一下HeapByteBuffer对asReadOnlyBuffer() 办法的完结，如下所示。

public ByteBuffer asReadOnlyBuffer() {
    return new HeapByteBufferR(hb,
            this.markValue(),
            this.position(),
            this.limit(),
            this.capacity(),
            offset);
}
protected HeapByteBufferR(byte[] buf,
                          int mark, int pos, int lim, int cap,
                          int off) {
    super(buf, mark, pos, lim, cap, off);
    this.isReadOnly = true;
}

也便是会new一个HeapByteBufferR出来，而且会指定其isReadOnly字段为true，表明只读。HeapByteBufferR承继于HeapByteBuffer，表明只读HeapByteBuffer，HeapByteBufferR重写了HeapByteBuffer的一切写相关办法，而且在这些写相关办法中抛出ReadOnlyBufferException反常，下面是部分写办法的示例。

public ByteBuffer put(int i, byte x) {
    throw new ReadOnlyBufferException();
}
public ByteBuffer put(byte x) {
    throw new ReadOnlyBufferException();
}

再看一下DirectByteBuffer对asReadOnlyBuffer() 办法的完结，如下所示。

public ByteBuffer asReadOnlyBuffer() {
    return new DirectByteBufferR(this,
            this.markValue(),
            this.position(),
            this.limit(),
            this.capacity(),
            0);
}
DirectByteBufferR(DirectBuffer db,
                  int mark, int pos, int lim, int cap,
                  int off) {
    super(db, mark, pos, lim, cap, off);
}

也是会new一个只读的DirectByteBufferR，DirectByteBufferR承继于DirectByteBuffer偏重写了一切写相关办法，而且在这些写相关办法中抛出ReadOnlyBufferException反常。

5. ByteBuffer的写操作

ByteBuffer中界说了很多写操作相关的笼统办法，如下图所示。

ByteBuffer界说的写操作笼统办法图

总体能够进行如下归类。

ByteBuffer-写操作脑图

下面将对上述部分写办法结合源码进行阐明。

Ⅰ. put(byte)

首先是最简略的put(byte) 办法，效果是往字节缓冲区的position方位写入一个字节，先看一下HeapByteBuffer对其的完结，如下所示。

public ByteBuffer put(byte x) {
    hb[ix(nextPutIndex())] = x;
    return this;
}
protected int ix(int i) {
    return i + offset;
}
// Buffer#nextPutIndex()
final int nextPutIndex() {
    if (position >= limit) {
        throw new BufferOverflowException();
    }
    return position++;
}

再看一下DirectByteBuffer对put(byte) 办法的完结，如下所示。

public ByteBuffer put(byte x) {
    unsafe.putByte(ix(nextPutIndex()), ((x)));
    return this;
}
private long ix(int i) {
    return address + ((long)i << 0);
}
// Buffer#nextPutIndex()
final int nextPutIndex() {
    if (position >= limit) {
        throw new BufferOverflowException();
    }
    return position++;
}

都是会调用到Buffer#nextPutIndex() 办法来拿到当时的position，区别是HeapByteBuffer是将字节写入到堆上的数组，而DirectByteBuffer是写在直接内存中。

Ⅱ. put(int, byte)

put(int, byte) 办法能够在指定方位写入一个字节，注意该办法写入字节不会改动position。

HeapByteBuffer对其完结如下所示。

public ByteBuffer put(int i, byte x) {
    hb[ix(checkIndex(i))] = x;
    return this;
}
protected int ix(int i) {
    return i + offset;
}
// Buffer#checkIndex(int)
final int checkIndex(int i) {
    if ((i < 0) || (i >= limit)) {
        throw new IndexOutOfBoundsException();
    }
    return i;
}

DirectByteBuffer对put(int, byte) 办法的完结如下所示。

public ByteBuffer put(int i, byte x) {
    unsafe.putByte(ix(checkIndex(i)), ((x)));
    return this;
}
private long ix(int i) {
    return address + ((long) i << 0);
}
// Buffer#checkIndex(int)
final int checkIndex(int i) {
    if ((i < 0) || (i >= limit)) {
        throw new IndexOutOfBoundsException();
    }
    return i;
}

Ⅲ. put(byte[], int, int)

put(byte[], int, int) 办法是批量的将字节数组中指定的字节写到ByteBuffer。

put(byte[], int, int) 办法并不是笼统办法，在ByteBuffer中界说了其完结，但一起HeapByteBuffer和DirectByteBuffer也都对其进行了重写。下面别离看一下其完结。

ByteBuffer#put(byte[], int, int) 完结如下所示。

public ByteBuffer put(byte[] src, int offset, int length) {
    checkBounds(offset, length, src.length);
    if (length > remaining()) {
        throw new BufferOverflowException();
    }
    int end = offset + length;
    // 从src的offset索引开端顺次将后续的length个字节写到ByteBuffer中
    for (int i = offset; i < end; i++) {
        this.put(src[i]);
    }
    return this;
}

ByteBuffer对put(byte[], int, int) 办法的完结是循环遍历字节数组中每一个需求写入的字节，然后调用put(byte) 办法完结写入，其间offset表明从字节数组的哪一个字节开端写，length表明从offset开端往后的多少个字节需求写入。

由于ByteBuffer对put(byte[], int, int) 办法的完结的写入功率不高，所以HeapByteBuffer和DirectByteBuffer都有自己的完结，先看一下HeapByteBuffer对put(byte[], int, int) 办法的完结，如下所示。

public ByteBuffer put(byte[] src, int offset, int length) {
    checkBounds(offset, length, src.length);
    if (length > remaining()) {
        throw new BufferOverflowException();
    }
    // 运用了native的复制办法来完结更高效的写入
    System.arraycopy(src, offset, hb, ix(position()), length);
    position(position() + length);
    return this;
}

由于HeapByteBuffer存储字节是存储到字节数组中，所以直接运用native的arraycopy() 办法来完结字节数组的复制是更为高效的手法。

再看一下DirectByteBuffer对put(byte[], int, int) 办法的完结，如下所示。

public ByteBuffer put(byte[] src, int offset, int length) {
    // 写入字节数大于6时运用native办法来批量写入才更高效
    if (((long) length << 0) > Bits.JNI_COPY_FROM_ARRAY_THRESHOLD) {
        checkBounds(offset, length, src.length);
        int pos = position();
        int lim = limit();
        assert (pos <= lim);
        int rem = (pos <= lim ? lim - pos : 0);
        if (length > rem) {
            throw new BufferOverflowException();
        }
        // 这儿终究会调用到native办法Unsafe#copyMemory来批量写入
        Bits.copyFromArray(src, arrayBaseOffset,
                (long) offset << 0,
                ix(pos),
                (long) length << 0);
        // 更新position
        position(pos + length);
    } else {
        // 写入字节数小于等于6则遍历每个字节并顺次写入会更高效
        super.put(src, offset, length);
    }
    return this;
}

在DirectByteBuffer的完结中，并没有直接调用到native办法来批量操作直接内存，而是先做了判别：假如本次批量写入的字节数大于JNI_COPY_FROM_ARRAY_THRESHOLD（默许是6），才调用native办法Unsafe#copyMemory来完结字节在直接内存中的批量写入，否则就仍是一个字节一个字节的写入。DirectByteBuffer的做法主要仍是考虑到native办法的调用的一个开支，比方就写入一个字节，那必定是没有必要调用native办法的。

Ⅳ. put(byte[])

put(byte[]) 办法的效果是将一个字节数组的内容悉数写入到ByteBuffer，该办法是一个final办法，所以这儿看一下ByteBuffer中该办法的完结，如下所示。

public final ByteBuffer put(byte[] src) {
    return put(src, 0, src.length);
}

其实便是调用到put(byte[], int, int) 办法来完结批量写入。

Ⅴ. put(ByteBuffer)

put(ByteBuffer) 办法用于将一个ByteBuffer中一切未操作的字节批量写入当时ByteBuffer。ByteBuffer，HeapByteBuffer和DirectByteBuffer都有相应的完结，下面别离看一下。

ByteBuffer#put(ByteBuffer) 思路仍是一个字节一个字节的写入，完结如下。

public ByteBuffer put(ByteBuffer src) {
    if (src == this) {
        throw new IllegalArgumentException();
    }
    if (isReadOnly()) {
        throw new ReadOnlyBufferException();
    }
    // 核算limit - position
    int n = src.remaining();
    if (n > remaining()) {
        throw new BufferOverflowException();
    }
    // 一个字节一个字节的写入
    for (int i = 0; i < n; i++) {
        put(src.get());
    }
    return this;
}

HeapByteBuffer#put(ByteBuffer) 思路是先判别源ByteBuffer的类型，假如源ByteBuffer是HeapByteBuffer，则调用native办法System#arraycopy完结批量写入，假如源ByteBuffer是在直接内存中分配的，则再判别一下要写入的字节是否大于6，假如大于6就调用native办法Unsafe#copyMemory完结批量写入，否则就一个字节一个字节的写入。完结如下。

public ByteBuffer put(ByteBuffer src) {
    if (src instanceof HeapByteBuffer) {
        if (src == this) {
            throw new IllegalArgumentException();
        }
        HeapByteBuffer sb = (HeapByteBuffer) src;
        // 核算源ByteBuffer剩下的字节数
        int n = sb.remaining();
        if (n > remaining()) {
            throw new BufferOverflowException();
        }
        // 调用native办法批量写入
        System.arraycopy(sb.hb, sb.ix(sb.position()),
                hb, ix(position()), n);
        // 更新源ByteBuffer的position
        sb.position(sb.position() + n);
        // 更新当时ByteBuffer的position
        position(position() + n);
    } else if (src.isDirect()) {
        // 核算源ByteBuffer剩下的字节数
        int n = src.remaining();
        if (n > remaining()) {
            throw new BufferOverflowException();
        }
        // 批量写入字节到当时ByteBuffer的hb字节数组中
        src.get(hb, ix(position()), n);
        // 更新当时ByteBuffer的position
        position(position() + n);
    } else {
        super.put(src);
    }
    return this;
}
// DirectByteBuffer#get(byte[], int, int)
public ByteBuffer get(byte[] dst, int offset, int length) {
    if (((long) length << 0) > Bits.JNI_COPY_TO_ARRAY_THRESHOLD) {
        checkBounds(offset, length, dst.length);
        int pos = position();
        int lim = limit();
        assert (pos <= lim);
        int rem = (pos <= lim ? lim - pos : 0);
        if (length > rem) {
            throw new BufferUnderflowException();
        }
        Bits.copyToArray(ix(pos), dst, arrayBaseOffset,
                (long) offset << 0,
                (long) length << 0);
        // 更新源ByteBuffer的position
        position(pos + length);
    } else {
        super.get(dst, offset, length);
    }
    return this;
}

DirectByteBuffer#put(ByteBuffer) 的思路也是先判别源ByteBuffer的类型，假如源ByteBuffer是DirectByteBuffer，则直接运用native办法Unsafe#copyMemory完结批量写入，假如源ByteBuffer是在堆上分配的，则依照DirectByteBuffer的put(byte[], int, int) 办法的逻辑完结批量写入。完结如下所示。

public ByteBuffer put(ByteBuffer src) {
    if (src instanceof DirectByteBuffer) {
        if (src == this) {
            throw new IllegalArgumentException();
        }
        DirectByteBuffer sb = (DirectByteBuffer) src;
        int spos = sb.position();
        int slim = sb.limit();
        assert (spos <= slim);
        // 核算源ByteBuffer剩下的字节数
        int srem = (spos <= slim ? slim - spos : 0);
        int pos = position();
        int lim = limit();
        assert (pos <= lim);
        int rem = (pos <= lim ? lim - pos : 0);
        if (srem > rem) {
            throw new BufferOverflowException();
        }
        // 调用native办法完结批量写入
        unsafe.copyMemory(sb.ix(spos), ix(pos), (long) srem << 0);
        // 更新源ByteBuffer的position
        sb.position(spos + srem);
        // 更新当时ByteBuffer的position
        position(pos + srem);
    } else if (src.hb != null) {
        int spos = src.position();
        int slim = src.limit();
        assert (spos <= slim);
        // 核算源ByteBuffer剩下的字节数
        int srem = (spos <= slim ? slim - spos : 0);
        // 调用DirectByteBuffer#put(byte[], int, int)完结批量写入
        put(src.hb, src.offset + spos, srem);
        // 更新源ByteBuffer的position
        src.position(spos + srem);
    } else {
        super.put(src);
    }
    return this;
}
// DirectByteBuffer#put(byte[], int, int)
public ByteBuffer put(byte[] src, int offset, int length) {
    if (((long) length << 0) > Bits.JNI_COPY_FROM_ARRAY_THRESHOLD) {
        checkBounds(offset, length, src.length);
        int pos = position();
        int lim = limit();
        assert (pos <= lim);
        int rem = (pos <= lim ? lim - pos : 0);
        if (length > rem) {
            throw new BufferOverflowException();
        }
        Bits.copyFromArray(src, arrayBaseOffset,
                (long) offset << 0,
                ix(pos),
                (long) length << 0);
        // 更新当时ByteBuffer的position
        position(pos + length);
    } else {
        super.put(src, offset, length);
    }
    return this;
}

终究有一点需求阐明，调用put(ByteBuffer) 办法完结批量字节写入后，源ByteBuffer和当时ByteBuffer的position都会被更新。

Ⅵ. 字节序

上述的几种put() 办法都是向ByteBuffer写入字节，但其实也是能够直接将char，int等根底数据类型写入ByteBuffer，但在分析这些写入根底数据类型到ByteBuffer的put() 办法以前，有必要对字节序的相关概念进行演示和阐明。

已知在Java中一个int是四个字节，而一个字节是8位，那么就以数字23333为例，示意如下。

网络编程-int字节表明图

那么上述的一个int数据，存储在内存中时，假如高位字节存储在内存的低地址，低位字节存储在内存的高地址，这种就称为大端字节序（Big Endian），示意图如下所示。

网络编程-大端字节序示意图

反之假如低位字节存储在内存的低地址，高位字节存储在内存的高地址，这种就称为小端字节序（Little Endian），示意图如下所示。

网络编程-小端字节序示意图

上述其实是主机字节序，表明核算机内存中字节的存储次序。在Java中，数据的存储默许是依照大端字节序来存储的。

然后还有一种叫做网络字节序，表明网络传输中字节的传输次序，分类如下。

大端字节序（Big Endian）。从二进制数据的高位开端传输；
小端字节序（Little Endian）。从二进制数据的低位开端传输。

在网络传输中，默许依照大端字节序来传输。

Ⅶ. putInt(int)

putInt(int) 办法是ByteBuffer界说的用于直接写入一个int的笼统办法，先看HeapByteBuffer的完结，如下所示。

public ByteBuffer putInt(int x) {
    // 经过nextPutIndex(4)办法拿到当时position，并让position加4
    // 然后调用Bits#putInt完结写入，其间bigEndian默许是true
    Bits.putInt(this, ix(nextPutIndex(4)), x, bigEndian);
    return this;
}
// Bits#putInt
static void putInt(ByteBuffer bb, int bi, int x, boolean bigEndian) {
    if (bigEndian) {
        putIntB(bb, bi, x);
    } else {
        putIntL(bb, bi, x);
    }
}
// Bits#putIntB
static void putIntB(ByteBuffer bb, int bi, int x) {
    // 经过Bits#int3办法拿到x的第3字节（最高位字节）
    // 然后写入到hb字节数组的索引为bi的方位
    bb._put(bi    , int3(x));
    // 经过Bits#int2办法拿到x的第2字节（次高位字节）
    // 然后写入到hb字节数组的索引为bi+1的方位
    bb._put(bi + 1, int2(x));
    // 经过Bits#int1办法拿到x的第1字节（次低位字节）
    // 然后写入到hb字节数组的索引为bi+2的方位
    bb._put(bi + 2, int1(x));
    // 经过Bits#int0办法拿到x的第0字节（最低位字节）
    // 然后写入到hb字节数组的索引为bi+3的方位
    bb._put(bi + 3, int0(x));
}
// Bits#int3
private static byte int3(int x) {
    return (byte) (x >> 24);
}
// HeapByteBuffer#_put
void _put(int i, byte b) {
    hb[i] = b;
}

HeapByteBuffer完结的putInt(int) 办法中，会顺次将int的高位到低位写入到hb字节数组的低索引到高索引，而在堆中，内存地址是由低到高的，也便是跟着数组索引的添加，内存地址也会逐渐增高，所以上述的便是依照大端字节序的办法来直接写入一个int。

再看一下DirectByteBuffer对putInt(int) 办法的完结，如下所示。

public ByteBuffer putInt(int x) {
    // 经过nextPutIndex(4)办法拿到当时position，并让position加4
    // 经过ix()办法拿到实践要写入的内存地址
    putInt(ix(nextPutIndex((1 << 2))), x);
    return this;
}
// DirectByteBuffer#putInt(long, int)
private ByteBuffer putInt(long a, int x) {
    if (unaligned) {
        int y = (x);
        unsafe.putInt(a, (nativeByteOrder ? y : Bits.swap(y)));
    } else {
        // 调用Bits#putInt完结写入，其间bigEndian默许是true
        Bits.putInt(a, x, bigEndian);
    }
    return this;
}
// Bits#putInt
static void putInt(long a, int x, boolean bigEndian) {
    if (bigEndian) {
        putIntB(a, x);
    } else {
        putIntL(a, x);
    }
}
// Bits#putIntB
static void putIntB(long a, int x) {
    // 经过Bits#int3办法拿到x的第3字节（最高位字节）
    // 然后写入到直接内存地址为a的方位
    _put(a    , int3(x));
    // 经过Bits#int2办法拿到x的第2字节（次高位字节）
    // 然后写入到直接内存地址为a+1的方位
    _put(a + 1, int2(x));
    // 经过Bits#int1办法拿到x的第1字节（次低位字节）
    // 然后写入到直接内存地址为a+2的方位
    _put(a + 2, int1(x));
    // 经过Bits#int0办法拿到x的第0字节（最低位字节）
    // 然后写入到直接内存地址为a+3的方位
    _put(a + 3, int0(x));
}
// Bits#int3
private static byte int3(int x) {
    return (byte) (x >> 24);
}
// Bits#_put
private static void _put(long a, byte b) {
    unsafe.putByte(a, b);
}

在DirectByteBuffer的完结中，会顺次将int的高位到低位写入到直接内存的低地址到高地址，全体也是一个大端字节序的写入办法。

Ⅷ. putInt(int, int)

putInt(int, int) 办法能够在指定方位写入int，一起也不会更改position。putInt(int, int) 办法完结原理和putInt(int) 相同，故这儿不再赘述。

其它的写入非字节的办法，实质和写入int共同，故也不再赘述。

6. ByteBuffer的读操作

ByteBuffer中界说了很多读操作相关的笼统办法，如下图所示。

ByteBuffer界说的读操作笼统办法图

总体能够进行如下归类。

ByteBuffer-读操作脑图

下面将对上述部分读办法结合源码进行阐明。

Ⅰ. get()

get() 办法用于读取一个字节，HeapByteBuffer的完结如下所示。

public byte get() {
    return hb[ix(nextGetIndex())];
}

上述办法是读取字节数组中position索引方位的字节，然后position加1。再看一下DirectByteBuffer对get() 办法的完结，如下所示。

public byte get() {
    return ((unsafe.getByte(ix(nextGetIndex()))));
}

上述办法是根据native办法拿到address + position方位的字节然后position加1。

Ⅱ. get(int)

get(int) 办法用于读取指定方位的字节，HeapByteBuffer的完结如下所示。

public byte get(int i) {
    return hb[ix(checkIndex(i))];
}

上述办法会读取字节数组中指定索引方位的字节，注意position不会改动。再看一下DirectByteBuffer对get(int) 办法的完结，如下所示。

public byte get(int i) {
    return ((unsafe.getByte(ix(checkIndex(i)))));
}

上述办法是根据native办法拿到指定方位的字节，相同，position不会改动。

Ⅲ. get(byte[], int, int)

get(byte[], int, int) 办法用于将当时ByteBuffer从position方位开端往后的若干字节写入到方针字节数组的指定方位。ByteBuffer，HeapByteBuffer和DirectByteBuffer都有相应的完结，下面别离看一下。

ByteBuffer对get(byte[], int, int) 办法的完结中是一个字节一个字节的读取并写入，如下所示。

public ByteBuffer get(byte[] dst, int offset, int length) {
    checkBounds(offset, length, dst.length);
    if (length > remaining()) {
        throw new BufferUnderflowException();
    }
    int end = offset + length;
    // 写入方针数组的开端方位是offset
    // 共写入length个字节
    for (int i = offset; i < end; i++) {
        dst[i] = get();
    }
    return this;
}

HeapByteBuffer对get(byte[], int, int) 办法的完结中，是调用System#arraycopy本地办法来进行批量复制写入，功率比一个字节一个字节的读取并写入更高，且终究会更新当时HeapByteBuffer的position。

public ByteBuffer get(byte[] dst, int offset, int length) {
    checkBounds(offset, length, dst.length);
    if (length > remaining()) {
        throw new BufferUnderflowException();
    }
    // 调用native办法来批量写入字节到dst字节数组
    System.arraycopy(hb, ix(position()), dst, offset, length);
    // 更新当时HeapByteBuffer的position
    position(position() + length);
    return this;
}

DirectByteBuffer对get(byte[], int, int) 办法的完结中，会先判别需求读取并写入到方针字节数组中的字节数是否大于6，大于6时会调用native办法来批量写入，否则就一个字节一个字节的读取并写入，终究还会更新当时DirectByteBuffer的position。

public ByteBuffer get(byte[] dst, int offset, int length) {
    if (((long) length << 0) > Bits.JNI_COPY_TO_ARRAY_THRESHOLD) {
        // 批量写入的字节数大于6个
        checkBounds(offset, length, dst.length);
        int pos = position();
        int lim = limit();
        assert (pos <= lim);
        int rem = (pos <= lim ? lim - pos : 0);
        if (length > rem) {
            throw new BufferUnderflowException();
        }
        // 终究调用到Unsafe#copyMemory办法完结批量复制写入
        Bits.copyToArray(ix(pos), dst, arrayBaseOffset,
                (long) offset << 0,
                (long) length << 0);
        // 更新当时DirectByteBuffer的position
        position(pos + length);
    } else {
        // 批量写入的字节数小于等于6个
        // 则一个字节一个字节的读取并写入
        super.get(dst, offset, length);
    }
    return this;
}

Ⅳ. get(byte[])

get(byte[]) 办法会从当时ByteBuffer的position方位开端，读取方针字节数组长度个字节，然后顺次写入到方针字节数组。get(byte[]) 办法由ByteBuffer完结，如下所示。

public ByteBuffer get(byte[] dst) {
    return get(dst, 0, dst.length);
}

那么实质仍是依赖get(byte[], int, int) 办法，只不过将offset指定为了0（表明从dst字节数组的索引为0的方位开端写入），将length指定为了dst.length（表明要写满dst字节数组）。

Ⅴ. getInt()

getInt() 办法表明从ByteBuffer中读取一个int值，先看一下HeapByteBuffer的完结，如下所示。

public int getInt() {
    // 经过nextGetIndex(4)拿到当时position，然后position加4
    // 默许bigEndian为true，表明以大端字节序的办法读取int
    return Bits.getInt(this, ix(nextGetIndex(4)), bigEndian);
}
// Bits#getInt
static int getInt(ByteBuffer bb, int bi, boolean bigEndian) {
    return bigEndian ? getIntB(bb, bi) : getIntL(bb, bi) ;
}
// Bits#getIntB
static int getIntB(ByteBuffer bb, int bi) {
    // 顺次拿到低索引到高索引的字节
    // 这些字节顺次对应int值的高位到低位
    // 终究调用makeInt()办法拼接成int值
    return makeInt(bb._get(bi),
            bb._get(bi + 1),
            bb._get(bi + 2),
            bb._get(bi + 3));
}
// Bits#makeInt
static private int makeInt(byte b3, byte b2, byte b1, byte b0) {
    return (((b3) << 24) |
            ((b2 & 0xff) << 16) |
            ((b1 & 0xff) << 8) |
            ((b0 & 0xff)));
}
// HeapByteBuffer#_get
byte _get(int i) {
    return hb[i];
}

上述办法的完结中，首先获取到当时HeapByteBuffer的position，然后从position方位开端顺次读取四个字节，由于默许状况下是大端字节序（也便是写和读都是依照大端字节序的办法），所以读取到的字节应该顺次对应int值的高位到低位，所以终究会在Bits#makeInt办法中将四个字节经过错位或的办法得到int值。

再看一下DirectByteBuffer对getInt() 办法的完结，如下所示。

public int getInt() {
    // 经过nextGetIndex(4)拿到当时position，然后position加4
    // 经过ix()办法拿到操作的开端地址是address + position
    return getInt(ix(nextGetIndex((1 << 2))));
}
// DirectByteBuffer#getInt(long)
private int getInt(long a) {
    if (unaligned) {
        int x = unsafe.getInt(a);
        return (nativeByteOrder ? x : Bits.swap(x));
    }
    // 默许bigEndian为true，表明默许大端字节序
    return Bits.getInt(a, bigEndian);
}
// Bits#getInt
static int getInt(long a, boolean bigEndian) {
    return bigEndian ? getIntB(a) : getIntL(a) ;
}
// Bits#getIntB
static int getIntB(long a) {
    // 从低地址拿到int值的高位
    // 从高地址拿到int值的低位
    // 然后拼接得到终究的int值
    return makeInt(_get(a),
            _get(a + 1),
            _get(a + 2),
            _get(a + 3));
}
// Bits#_get
private static byte _get(long a) {
    return unsafe.getByte(a);
}
// Bits#makeInt
static private int makeInt(byte b3, byte b2, byte b1, byte b0) {
    return (((b3) << 24) |
            ((b2 & 0xff) << 16) |
            ((b1 & 0xff) << 8) |
            ((b0 & 0xff)));
}

DirectByteBuffer对getInt() 办法的全体完结思路和HeapByteBuffer是共同的，在默许大端字节序的状况下，从低地址拿到int值的高位字节，从高地址拿到int值的低位字节，终究经过错位或的办法得到终究的int值。请注意，操作完结后，position都会加4，这是由于一个int占四个字节，也便是相当于读取了4个字节。

Ⅵ. getInt(int)

getInt(int) 办法能够从指定方位读取一个int值，完结思路和getInt() 办法完全共同，故这儿不再赘述，但需求注意的是，getInt(int) 办法读取一个int值后，不会改动position。

其它的非字节的读取，实质和int值的读取相同，故也不再赘述。

7. ByteBuffer的运用示例

在Log4j2日志框架中，终究在将日志进行输出时，对日志内容的处理就有运用到ByteBuffer，下面一起来简略的看一下。（无需重视Log4j2的完结细节）

在将日志内容进行规范输出时，终究是经过OutputStreamManager完结将日志内容输出，它里边有一个字段便是HeapByteBuffer，用于存储日志内容的字节数据。下面先看一下org.apache.logging.log4j.core.layout.TextEncoderHelper#writeEncodedText办法，这儿面会有OutputStreamManager的ByteBuffer怎么被写入的相关逻辑。

private static void writeEncodedText(final CharsetEncoder charsetEncoder, final CharBuffer charBuf,
        final ByteBuffer byteBuf, final ByteBufferDestination destination, CoderResult result) {
    ......
    if (byteBuf != destination.getByteBuffer()) {
        // 这儿的byteBuf存储了处理后的日志内容
        // 调用flip()办法来进入读形式
        byteBuf.flip();
        // 这儿的destination便是OutputStreamManager
        // 这儿会将byteBuf的内容写到OutputStreamManager的ByteBuffer中
        destination.writeBytes(byteBuf);
        // 切换为写形式，也便是position置0，重置limit等于capacity等
        byteBuf.clear();
    }
}
// OutputStreamManager#writeBytes
public void writeBytes(final ByteBuffer data) {
    if (data.remaining() == 0) {
        return;
    }
    synchronized (this) {
        ByteBufferDestinationHelper.writeToUnsynchronized(data, this);
    }
}
// ByteBufferDestinationHelper#writeToUnsynchronized
public static void writeToUnsynchronized(final ByteBuffer source, final ByteBufferDestination destination) {
    // 拿到OutputStreamManager中的HeapByteBuffer
    // 这儿称OutputStreamManager中的HeapByteBuffer为方针ByteBuffer
    ByteBuffer destBuff = destination.getByteBuffer();
    // 假如源ByteBuffer剩下可读字节多于方针ByteBuffer剩下可写字节
    // 则循环的写满方针ByteBuffer再读取完方针ByteBuffer
    // 终究便是需求将源ByteBuffer的字节悉数由方针ByteBuffer消费掉
    while (source.remaining() > destBuff.remaining()) {
        final int originalLimit = source.limit();
        // 先将源ByteBuffer的limit设置为当时position + 方针ByetBuffer剩下可写字节数
        source.limit(Math.min(source.limit(), source.position() + destBuff.remaining()));
        // 将源ByteBuffer当时position到limit的字节写到方针ByteBuffer中
        destBuff.put(source);
        // 康复源ByteBuffer的limit
        source.limit(originalLimit);
        // 方针ByteBuffer先将已有的字节悉数规范输出
        // 然后回来一个写形式的方针ByteBuffer
        destBuff = destination.drain(destBuff);
    }
    // 到这儿阐明源ByteBuffer剩下可读字节小于等于方针ByteBuffer剩下可写字节
    // 则将源ByteBuffer剩下可读字节悉数写到方针ByteBuffer中
    // 后续会在其它地方将这部分内容悉数规范输出
    destBuff.put(source);
}
// OutputStreamManager#drain
public ByteBuffer drain(final ByteBuffer buf) {
    flushBuffer(buf);
    return buf;
}
// OutputStreamManager#flushBuffer
protected synchronized void flushBuffer(final ByteBuffer buf) {
    // 方针ByteBuffer切换为读形式
    ((Buffer) buf).flip();
    try {
        if (buf.remaining() > 0) {
            // 拿到HeapByteBuffer中的字节数组
            // 终究调用到PrintStream来规范输出字节数组中的字节内容
            writeToDestination(buf.array(), buf.arrayOffset() + buf.position(), buf.remaining());
        }
    } finally {
        // 方针ByteBuffer切换回写形式
        buf.clear();
    }
}

信任假如阅读完本文，那么上述Log4j2中关于ByteBuffer的运用，必定都是能看理解的，尽管Log4j2中有很多的根据ByteBuffer的运用，可是终究的规范输出仍是根据Java的传统IO来输出的，那么为什么中间还要用ByteBuffer来多处理一下呢，其实也便是由于ByteBuffer在读写字节时会考虑功能问题，会运用到功能更高的native办法来批量的操作字节数据，因此以快著称的Log4j2挑选了NIO中的ByteBuffer。

8. ByteBuffer的缺陷

假如要评论ByteBuffer的缺陷，其实能够结合第7末节的运用示例来一并评论。

首先便是读写形式的切换。在第7末节示例中，会发现存在多处调用flip() 办法来切换到读形式，调用clear() 办法来切换到写形式，这种形式的切换，既麻烦，还容易出错。

然后便是无法扩容。在第7末节示例中，有一个细节便是由于ByteBuffer容量太小了，无法一次写完一切字节数据，所以就只能循环的写满读取然后再写满这样子来操作，假如能扩容就不用这么麻烦了。

终究便是线程不安全。ByteBuffer自身并没有供给对线程安全的保护，要完结线程安全，需求运用者自己经过其它的并发语义来完结。

总结

本文对ByteBuffer的分析能够参照下图。

ByteBuffer-知识点脑图

为啥NIO中偏分析ByteBuffer呢，由于Netty中的缓存是ByteBuf，其对ByteBuffer做了改良，鄙人一篇文章中，将对Netty中的缓存ByteBuf进行具体分析。

假如觉得本篇文章对你有协助，求求你点个赞，加个收藏终究再点个重视吧。创作不易，感谢支撑！

本文正在参加「金石计划」

一文搞懂ByteBuffer使用与原理

前言

正文

一. Buffer

1. Buffer的特点

2. Buffer的读形式

3. Buffer的写形式

4. Buffer读写形式切换

5. Buffer的rewind操作

6. Buffer的reset操作

二. ByteBuffer

1. ByteBuffer的特点

2. ByteBuffer的创立

3. ByteBuffer的slice操作

4. ByteBuffer的asReadOnlyBuffer操作

5. ByteBuffer的写操作

Ⅰ. put(byte)

Ⅱ. put(int, byte)

Ⅲ. put(byte[], int, int)

Ⅳ. put(byte[])

Ⅴ. put(ByteBuffer)

Ⅵ. 字节序

Ⅶ. putInt(int)

Ⅷ. putInt(int, int)

6. ByteBuffer的读操作

Ⅰ. get()

Ⅱ. get(int)

Ⅲ. get(byte[], int, int)

Ⅳ. get(byte[])

Ⅴ. getInt()

Ⅵ. getInt(int)

7. ByteBuffer的运用示例

8. ByteBuffer的缺陷

总结

作者信息

推广

一文搞懂ByteBuffer使用与原理

前言

正文

一. Buffer

1. Buffer的特点

2. Buffer的读形式

3. Buffer的写形式

4. Buffer读写形式切换

5. Buffer的rewind操作

6. Buffer的reset操作

二. ByteBuffer

1. ByteBuffer的特点

2. ByteBuffer的创立

3. ByteBuffer的slice操作

4. ByteBuffer的asReadOnlyBuffer操作

5. ByteBuffer的写操作

Ⅰ. put(byte)

Ⅱ. put(int, byte)

Ⅲ. put(byte[], int, int)

Ⅳ. put(byte[])

Ⅴ. put(ByteBuffer)

Ⅵ. 字节序

Ⅶ. putInt(int)

Ⅷ. putInt(int, int)

6. ByteBuffer的读操作

Ⅰ. get()

Ⅱ. get(int)

Ⅲ. get(byte[], int, int)

Ⅳ. get(byte[])

Ⅴ. getInt()

Ⅵ. getInt(int)

7. ByteBuffer的运用示例

8. ByteBuffer的缺陷

总结

相关文章

一个 println 竟然比 volatile 还好使？

100元实践k8s搭建过程

一篇带你搞定Javaの多态

记一次 stackoverflowerror 线上排查过程

作者信息

推广