ByteBuf (Netty API Reference (4.1.22.Final))

java.lang.Object
- io.netty.buffer.ByteBuf

All Implemented Interfaces:

ReferenceCounted ，java.lang.Comparable < ByteBuf >

已知直接子类：

AbstractByteBuf ， EmptyByteBuf ， SwappedByteBuf
```
public abstract class ByteBuf
extends java.lang.Object
implements ReferenceCounted, java.lang.Comparable<ByteBuf>
```
一个零或更多字节（八位字节）的随机和顺序访问序列。该接口为一个或多个基元字节数组（ byte[] ）和NIO缓冲区提供了一个抽象视图。
创建一个缓冲区
建议使用Unpooled中的帮助程序方法创建新缓冲区，而不是调用单个实现的构造函数。
随机访问索引
就像普通的原始字节数组一样， ByteBuf使用zero-based indexing 。这意味着第一个字节的索引始终为0 ，最后一个字节的索引始终为capacity - 1 。例如，要迭代缓冲区的所有字节，无论其内部实现如何，都可以执行以下操作：
```
  ByteBuf buffer = ...;
 for (int i = 0; i < buffer.capacity(); i ++) {
     byte b = buffer.getByte(i);
     System.out.println((char) b);
 } 
```
顺序访问索引
ByteBuf提供了两个指针变量来支持顺序读取和写入操作 - readerIndex用于读取操作， writerIndex用于写入操作。下图显示了两个指针如何将缓冲区分割为三个区域：
```
  +-------------------+------------------+------------------+
      | discardable bytes |  readable bytes  |  writable bytes  |
      |                   |     (CONTENT)    |                  |
      +-------------------+------------------+------------------+
      |                   |                  |                  |
      0      <=      readerIndex   <=   writerIndex    <=    capacity 
```
可读字节数（实际内容）
这部分是实际数据存储的地方。名称以read或skip开头的任何操作skip将获取或跳过当前readerIndex的数据并将其增加读取字节数。如果读操作的参数也是ByteBuf，并且没有指定目标索引，则指定缓冲区的writerIndex一起增加。
如果没有足够的内容， IndexOutOfBoundsException引发IndexOutOfBoundsException 。新分配，打包或复制的缓冲区readerIndex的默认值是0 。
```
  // Iterates the readable bytes of a buffer.
 ByteBuf buffer = ...;
 while (buffer.isReadable()) {
     System.out.println(buffer.readByte());
 } 
```
可写字节
这部分是一个未定义的空间，需要填写。任何名称以write开头的操作都会将数据写入当前的writerIndex，并将其增加写入的字节数。如果写入操作的参数也是ByteBuf ，并且没有指定源索引，则指定缓冲区的readerIndex将一起增加。
如果没有足够的可写字节，则引发IndexOutOfBoundsException 。新分配的缓冲区writerIndex的默认值是0 。裹或复制缓冲区的默认值writerIndex是capacity的缓冲液中。
```
  // Fills the writable bytes of a buffer with random integers.
 ByteBuf buffer = ...;
 while (buffer.maxWritableBytes() >= 4) {
     buffer.writeInt(random.nextInt());
 } 
```
可丢弃的字节
该段包含读取操作已读取的字节。最初，该段的大小为0 ，但随着读取操作的执行，其大小增加至writerIndex 。通过调用discardReadBytes()可以丢弃读取的字节，以回收未使用的区域，如下图所示：
```
  BEFORE discardReadBytes()

      +-------------------+------------------+------------------+
      | discardable bytes |  readable bytes  |  writable bytes  |
      +-------------------+------------------+------------------+
      |                   |                  |                  |
      0      <=      readerIndex   <=   writerIndex    <=    capacity


  AFTER discardReadBytes()

      +------------------+--------------------------------------+
      |  readable bytes  |    writable bytes (got more space)   |
      +------------------+--------------------------------------+
      |                  |                                      |
 readerIndex (0) <= writerIndex (decreased)        <=        capacity 
```
请注意，在调用discardReadBytes()之后，无法保证可写字节的内容。可写字节在大多数情况下不会被移动，甚至可能会被完全不同的数据填充，这取决于底层的缓冲区实现。
清除缓冲区索引
您可以拨打 clear()将0和writerIndex设置为0 。它不清除缓冲区内容（例如填写0 ），但只是清除了两个指针。另请注意，此操作的语义不同于Buffer.clear() 。
```
  BEFORE clear()

      +-------------------+------------------+------------------+
      | discardable bytes |  readable bytes  |  writable bytes  |
      +-------------------+------------------+------------------+
      |                   |                  |                  |
      0      <=      readerIndex   <=   writerIndex    <=    capacity


  AFTER clear()

      +---------------------------------------------------------+
      |             writable bytes (got more space)             |
      +---------------------------------------------------------+
      |                                                         |
      0 = readerIndex = writerIndex            <=            capacity 
```
搜索操作
对于简单的单字节搜索，请使用indexOf(int, int, byte)和bytesBefore(int, int, byte) 。 bytesBefore(byte)在处理NUL终止的字符串时特别有用。对于复杂的搜索，请使用forEachByte(int, int, ByteProcessor)和ByteProcessor实现。
标记并重置
每个缓冲区中有两个标记索引。一个用于存储readerIndex ，另一个用于存储writerIndex 。您可以通过调用重置方法来始终重新定位两个索引中的一个。它与InputStream的标记和重置方法InputStream ，但没有readlimit 。
派生缓冲区
您可以通过调用以下方法之一来创建现有缓冲区的视图：
A衍生缓冲器将有一个独立的readerIndex ， writerIndex和标记索引，而这股其他内部数据表示，就像一个NIO缓冲器一样。
如果需要全新的现有缓冲区副本，请拨打copy()方法。

非保留和保留的派生缓冲区
需要注意的是duplicate() ， slice() ， slice(int, int)和readSlice(int)不调用retain()对返回的派生缓冲，因而其引用计数将不会增加。如果你需要创建一个增加引用计数派生缓冲，可以考虑使用retainedDuplicate() ， retainedSlice() ， retainedSlice(int, int)和readRetainedSlice(int)这可能返回产生较少的垃圾一个缓冲区实现。
转换为现有的JDK类型

字节数组
如果ByteBuf由字节数组支持（即byte[] ），则可以通过array()方法直接访问它。要确定缓冲区是否由字节数组支持，应使用hasArray() 。
NIO缓冲区
如果ByteBuf可以转换为共享其内容（即查看缓冲区）的NIO ByteBuffer ，则可以通过nioBuffer()方法获取它。要确定是否可以将缓冲区转换为NIO缓冲区，请使用nioBufferCount() 。
字符串
各种toString(Charset)方法将ByteBuf转换为String 。请注意， toString()不是一种转换方法。
I / O流
请参阅ByteBufInputStream和ByteBufOutputStream 。

构造方法摘要

构造方法
Constructor and Description
`ByteBuf()`

方法摘要

所有方法接口方法抽象方法具体的方法弃用的方法
Modifier and Type	Method and Description
`abstract ByteBufAllocator`	`alloc()` 返回创建此缓冲区的`ByteBufAllocator` 。
`abstract byte[]`	`array()` 返回此缓冲区的后备字节数组。
`abstract int`	`arrayOffset()` 返回此缓冲区的后备字节数组中第一个字节的偏移量。
`abstract ByteBuf`	`asReadOnly()` 返回此缓冲区的只读版本。
`abstract int`	`bytesBefore(byte value)` 定位此缓冲区中第一次出现的指定 `value` 。
`abstract int`	`bytesBefore(int length, byte value)` 定位此缓冲区中第一次出现的指定 `value` 。
`abstract int`	`bytesBefore(int index, int length, byte value)` 定位此缓冲区中第一次出现的指定 `value` 。
`abstract int`	`capacity()` 返回此缓冲区可包含的字节数（字节）。
`abstract ByteBuf`	`capacity(int newCapacity)` 调整此缓冲区的容量。
`abstract ByteBuf`	`clear()` 将此缓冲区的 `readerIndex`和 `writerIndex`设置为 `0` 。
`abstract int`	`compareTo(ByteBuf buffer)` 将指定缓冲区的内容与此缓冲区的内容进行比较。
`abstract ByteBuf`	`copy()` 返回此缓冲区可读字节的副本。
`abstract ByteBuf`	`copy(int index, int length)` 返回此缓冲区的子区域的副本。
`abstract ByteBuf`	`discardReadBytes()` 丢弃第0个索引和 `readerIndex`之间的字节。
`abstract ByteBuf`	`discardSomeReadBytes()` 类似于 `discardReadBytes()`，不同之处在于此方法可能会丢弃部分，全部或者全部读取字节，具体取决于其内部实现方式，以减少潜在的额外内存消耗为代价降低整体内存带宽消耗。
`abstract ByteBuf`	`duplicate()` 返回共享此缓冲区整个区域的缓冲区。
`abstract ByteBuf`	`ensureWritable(int minWritableBytes)` 确保 the writable bytes的数量等于或大于指定的值。
`abstract int`	`ensureWritable(int minWritableBytes, boolean force)` 尝试确保 the writable bytes的数量等于或大于指定的值。
`abstract boolean`	`equals(java.lang.Object obj)` 确定指定缓冲区的内容是否与此数组的内容相同。
`abstract int`	`forEachByte(ByteProcessor processor)` 以指定的 `processor`按升序对此缓冲区的可读字节进行迭代。
`abstract int`	`forEachByte(int index, int length, ByteProcessor processor)` 以指定的 `processor`按升序对此缓冲区的指定区域进行迭代。
`abstract int`	`forEachByteDesc(ByteProcessor processor)` 使用指定的 `processor`以降序遍历此缓冲区的可读字节。
`abstract int`	`forEachByteDesc(int index, int length, ByteProcessor processor)` 以指定的 `processor`降序遍历此缓冲区的指定区域。
`abstract boolean`	`getBoolean(int index)` 在此缓冲区中获取指定绝对（@code索引）的布尔值。
`abstract byte`	`getByte(int index)` 在此缓冲区中的指定绝对 `index`处获取一个字节。
`abstract ByteBuf`	`getBytes(int index, byte[] dst)` 将此缓冲区的数据传输到指定绝对 `index`开始的目标。
`abstract ByteBuf`	`getBytes(int index, byte[] dst, int dstIndex, int length)` 将此缓冲区的数据传输到指定的绝对目标 `index`开始的目标。
`abstract ByteBuf`	`getBytes(int index, ByteBuf dst)` 将此缓冲区的数据传输到指定的目的地，从指定的绝对 `index`开始，直到目标变为不可写。
`abstract ByteBuf`	`getBytes(int index, java.nio.ByteBuffer dst)` 将此缓冲区的数据传输到指定的目标位置，从指定的绝对 `index`开始，直到目标位置达到其限制。
`abstract ByteBuf`	`getBytes(int index, ByteBuf dst, int length)` 将此缓冲区的数据传输到指定的绝对 `index`开始的目标。
`abstract ByteBuf`	`getBytes(int index, ByteBuf dst, int dstIndex, int length)` 将此缓冲区的数据传输到指定的绝对目标 `index`开始的目标。
`abstract int`	`getBytes(int index, java.nio.channels.FileChannel out, long position, int length)` 将此缓冲区的数据从指定的绝对 `index`开始 `index`到指定的通道，从给定的文件位置开始。
`abstract int`	`getBytes(int index, java.nio.channels.GatheringByteChannel out, int length)` 将此缓冲区的数据传输到指定绝对 `index`开始的指定通道。
`abstract ByteBuf`	`getBytes(int index, java.io.OutputStream out, int length)` 将此缓冲区的数据传输到指定的绝对 `index`开始的流。
`abstract char`	`getChar(int index)` 在此缓冲区中指定的绝对 `index`处获取一个2字节的UTF-16字符。
`abstract java.lang.CharSequence`	`getCharSequence(int index, int length, java.nio.charset.Charset charset)` 在给定索引处获得具有给定长度的 `CharSequence` 。
`abstract double`	`getDouble(int index)` 在此缓冲区中的指定绝对 `index`处获取一个64位浮点数。
`double`	`getDoubleLE(int index)` 以Little Endian Byte Order的形式 `index`此缓冲区中指定绝对 `index`处的64位浮点数。
`abstract float`	`getFloat(int index)` 在此缓冲区中的指定绝对 `index`处获取一个32位浮点数。
`float`	`getFloatLE(int index)` 以Little Endian Byte Order的 `index`在此缓冲区中的指定绝对 `index`处获取一个32位浮点数。
`abstract int`	`getInt(int index)` 在此缓冲区中的指定绝对 `index`处获取一个32位整数。
`abstract int`	`getIntLE(int index)` 在此缓冲区中以指定的绝对 `index`获取一个32位整数， `index`字节顺序。
`abstract long`	`getLong(int index)` 在此缓冲区中的指定绝对 `index`处获取一个64位长整数。
`abstract long`	`getLongLE(int index)` 以小端字节顺序在此缓冲区中的指定绝对 `index`处获取64位长整数。
`abstract int`	`getMedium(int index)` 在此缓冲区中的指定绝对 `index`处获取一个24位中等整数。
`abstract int`	`getMediumLE(int index)` 以小端字节顺序在此缓冲区中的指定绝对 `index`处获取一个24位中等整数。
`abstract short`	`getShort(int index)` 在此缓冲区中的指定绝对 `index`处获取一个16位短整数。
`abstract short`	`getShortLE(int index)` 以小端字节顺序在此缓冲区中的指定绝对 `index`处获取一个16位短整数。
`abstract short`	`getUnsignedByte(int index)` 在此缓冲区中的指定绝对 `index`处获取一个无符号字节。
`abstract long`	`getUnsignedInt(int index)` 在此缓冲区中指定的绝对 `index`处获取一个无符号的32位整数。
`abstract long`	`getUnsignedIntLE(int index)` 以Little Endian字节顺序在此缓冲区中的指定绝对 `index`处获取无符号的32位整数。
`abstract int`	`getUnsignedMedium(int index)` 在此缓冲区中指定的绝对 `index`处获取一个无符号的24位中等整数。
`abstract int`	`getUnsignedMediumLE(int index)` 以Little Endian字节顺序在此缓冲区中的指定绝对 `index`处获取无符号的24位中等整数。
`abstract int`	`getUnsignedShort(int index)` 在此缓冲区中指定的绝对 `index`处获取一个无符号的16位短整数。
`abstract int`	`getUnsignedShortLE(int index)` 以Little Endian Byte Order的形式 `index`此缓冲区中指定绝对 `index`的无符号16位短整数。
`abstract boolean`	`hasArray()` 当且仅当此缓冲区有一个后备字节数组时，才返回 `true` 。
`abstract int`	`hashCode()` 返回从此缓冲区的内容计算出来的哈希码。
`abstract boolean`	`hasMemoryAddress()` 当且仅当此缓冲区具有对指向后备数据的低级内存地址的引用时才返回 `true` 。
`abstract int`	`indexOf(int fromIndex, int toIndex, byte value)` 在此缓冲区中找到指定 `value`的第一个匹配项。
`abstract java.nio.ByteBuffer`	`internalNioBuffer(int index, int length)` 仅内部使用：公开内部NIO缓冲区。
`abstract boolean`	`isDirect()` 当且仅当此缓冲区由NIO直接缓冲区支持时才返回 `true` 。
`abstract boolean`	`isReadable()` 返回 `true`当且仅当 `(this.writerIndex - this.readerIndex)`大于 `0` 。
`abstract boolean`	`isReadable(int size)` 当且仅当此缓冲区包含等于或多于指定数量的元素时才返回 `true` 。
`abstract boolean`	`isReadOnly()` 当且仅当此缓冲区为只读时才返回 `true` 。
`abstract boolean`	`isWritable()` 返回 `true`当且仅当 `(this.capacity - this.writerIndex)`大于 `0` 。
`abstract boolean`	`isWritable(int size)` 当且仅当此缓冲区有足够空间允许写入指定数量的元素时才返回 `true` 。
`abstract ByteBuf`	`markReaderIndex()` 在此缓冲区中标记当前 `readerIndex` 。
`abstract ByteBuf`	`markWriterIndex()` 在此缓冲区中标记当前 `writerIndex` 。
`abstract int`	`maxCapacity()` 返回此缓冲区允许的最大容量。
`abstract int`	`maxWritableBytes()` 返回可写入的最大字节数，等于 `(this.maxCapacity - this.writerIndex)` 。
`abstract long`	`memoryAddress()` 返回指向备份数据第一个字节的低级内存地址。
`abstract java.nio.ByteBuffer`	`nioBuffer()` 将此缓冲区的可读字节作为NIO `ByteBuffer` 。
`abstract java.nio.ByteBuffer`	`nioBuffer(int index, int length)` 将此缓冲区的子区域公开为NIO `ByteBuffer` 。
`abstract int`	`nioBufferCount()` 返回构成此缓冲区的NIO `ByteBuffer`的最大数量。
`abstract java.nio.ByteBuffer[]`	`nioBuffers()` 以NIO `ByteBuffer`的形式公开此缓冲区的可读字节。
`abstract java.nio.ByteBuffer[]`	`nioBuffers(int index, int length)` 将此缓冲区的字节公开为指定索引和长度的NIO `ByteBuffer`返回的缓冲区共享或包含此缓冲区的复制内容，同时更改返回的NIO缓冲区的位置和限制不会影响此索引和标记缓冲。
`abstract java.nio.ByteOrder`	`order()` 已过时。使用Little Endian访问器，例如`getShortLE`和`getIntLE`而不是使用交换的`endianness`创建缓冲区。
`abstract ByteBuf`	`order(java.nio.ByteOrder endianness)` 已过时。使用小端存取，如`getShortLE` ， `getIntLE` ，而不是用交换创建一个缓冲区`endianness` 。
`abstract int`	`readableBytes()` 返回等于 `(this.writerIndex - this.readerIndex)`的可读字节数。
`abstract boolean`	`readBoolean()` 获取当前 `readerIndex`的布尔值，并在此缓冲区 `readerIndex` `1`增加 `readerIndex` 。
`abstract byte`	`readByte()` 获取当前 `readerIndex`一个字节，并在此缓冲区 `readerIndex` `1`增加 `readerIndex` 。
`abstract ByteBuf`	`readBytes(byte[] dst)` 将此缓冲区的数据传输到指定的目标，从当前的 `readerIndex`开始，并将 `readerIndex`增加 `readerIndex`所传输的字节数（= `dst.length` ）。
`abstract ByteBuf`	`readBytes(byte[] dst, int dstIndex, int length)` 传输此缓冲区的数据到指定的目标并从当前 `readerIndex`并增加了 `readerIndex`由传输的字节（=数量 `length` ）。
`abstract ByteBuf`	`readBytes(ByteBuf dst)` 将此缓冲区的数据传输到指定的目标，从当前的 `readerIndex`开始，直到目标变为不可写入，并将 `readerIndex`增加 `readerIndex`所传输的字节数。
`abstract ByteBuf`	`readBytes(java.nio.ByteBuffer dst)` 将此缓冲区的数据传输到指定的目标，从当前的 `readerIndex`开始，直到目标的位置达到其限制，并将 `readerIndex`增加 `readerIndex`传输的字节数。
`abstract ByteBuf`	`readBytes(ByteBuf dst, int length)` 传输此缓冲区的数据到指定的目标并从当前 `readerIndex`并增加了 `readerIndex`由传输的字节（=数量 `length` ）。
`abstract ByteBuf`	`readBytes(ByteBuf dst, int dstIndex, int length)` 传输此缓冲区的数据到指定的目标并从当前 `readerIndex`并增加了 `readerIndex`由传输的字节（=数量 `length` ）。
`abstract int`	`readBytes(java.nio.channels.FileChannel out, long position, int length)` 将此缓冲区的数据从当前 `readerIndex`开始 `readerIndex`到指定通道，从给定的文件位置开始。
`abstract int`	`readBytes(java.nio.channels.GatheringByteChannel out, int length)` 将此缓冲区的数据传输到从当前 `readerIndex`开始的指定流。
`abstract ByteBuf`	`readBytes(int length)` 传输此缓冲区的数据到一个新创建的缓冲器并从当前 `readerIndex`并增加了 `readerIndex`由传输的字节（=数量 `length` ）。
`abstract ByteBuf`	`readBytes(java.io.OutputStream out, int length)` 将此缓冲区的数据传输到当前 `readerIndex`开始的指定流。
`abstract char`	`readChar()` 在当前 `readerIndex`处获取一个2字节的UTF-16字符，并在此缓冲区 `readerIndex` `2`增加 `readerIndex` 。
`abstract java.lang.CharSequence`	`readCharSequence(int length, java.nio.charset.Charset charset)` 获取一个 `CharSequence`与所述给定长度在当前 `readerIndex`并增加了 `readerIndex`由给定的长度。
`abstract double`	`readDouble()` 在当前 `readerIndex`处获取64位浮点数，并在此缓冲区 `readerIndex` `8`增加 `readerIndex` 。
`double`	`readDoubleLE()` 在当前 `readerIndex`以Little Endian字节顺序获取一个64位浮点数， `8`在此缓冲区 `readerIndex` `8`增加 `readerIndex` 。
`abstract int`	`readerIndex()` 返回此缓冲区的 `readerIndex` 。
`abstract ByteBuf`	`readerIndex(int readerIndex)` 设置此缓冲区的 `readerIndex` 。
`abstract float`	`readFloat()` 在当前 `readerIndex`处获取32位浮点数，并在此缓冲区 `readerIndex` `4`增加 `readerIndex` 。
`float`	`readFloatLE()` 在Little Endian Byte Order获取当前 `readerIndex`的32位浮点数， `4`在此缓冲区 `readerIndex` `4`增加 `readerIndex` 。
`abstract int`	`readInt()` 在当前 `readerIndex`处获取一个32位整数，并在此缓冲区 `readerIndex` `4`增加 `readerIndex` 。
`abstract int`	`readIntLE()` 在Little Endian Byte Order中获取当前 `readerIndex`的32位整数，并在此缓冲区 `readerIndex` `4`增加 `readerIndex` 。
`abstract long`	`readLong()` 在当前 `readerIndex`处获取64位整数，并在此缓冲区 `readerIndex` `8`增加 `readerIndex` 。
`abstract long`	`readLongLE()` 在小尾字节顺序的当前 `readerIndex`处获取64位整数，并在此缓冲区 `readerIndex` `8`增加 `readerIndex` 。
`abstract int`	`readMedium()` 在当前 `readerIndex`处获取24位中等整数，并在此缓冲区 `readerIndex` `3`增加 `readerIndex` 。
`abstract int`	`readMediumLE()` 以小端字节顺序获取当前 `readerIndex`中的24位中等整数，并在此缓冲区 `readerIndex` `3`增加 `readerIndex` 。
`abstract ByteBuf`	`readRetainedSlice(int length)` 从当前 `readerIndex`开始返回此缓冲区的子区域的新保留切片，并将 `readerIndex`增加 `readerIndex`新切片的大小（= `length` ）。
`abstract short`	`readShort()` 在当前 `readerIndex`处获取一个16位短整数，并在此缓冲区 `readerIndex` `2`增加 `readerIndex` 。
`abstract short`	`readShortLE()` 在小端字节顺序的当前 `readerIndex`处获取一个16位短整数，并在此缓冲区中增加 `readerIndex` `2` 。
`abstract ByteBuf`	`readSlice(int length)` 从当前 `readerIndex`开始返回此缓冲区的子区域的新切片，并将 `readerIndex`增加 `readerIndex`新切片的大小（= `length` ）。
`abstract short`	`readUnsignedByte()` 获取当前 `readerIndex`的无符号字节，并在此缓冲区 `readerIndex` `1`增加 `readerIndex` 。
`abstract long`	`readUnsignedInt()` 在当前 `readerIndex`处获取一个无符号的32位整数，并在此缓冲区 `readerIndex` `4`增加 `readerIndex` 。
`abstract long`	`readUnsignedIntLE()` 在Little Endian Byte Order中获取当前 `readerIndex`的无符号32位整数，并在此缓冲区 `readerIndex` `4`增加 `readerIndex` 。
`abstract int`	`readUnsignedMedium()` 获取当前 `readerIndex`的无符号24位中等整数，并在此缓冲区 `readerIndex` `3`增加 `readerIndex` `3` 。
`abstract int`	`readUnsignedMediumLE()` 在小端字节顺序的当前 `readerIndex`处获取一个无符号的24位中等整数，并在此缓冲区 `readerIndex` `3`增加 `readerIndex` 。
`abstract int`	`readUnsignedShort()` 在当前 `readerIndex`处获取一个无符号的16位短整数，并在此缓冲区 `readerIndex` `2`增加 `readerIndex` 。
`abstract int`	`readUnsignedShortLE()` 在当前 `readerIndex`以Little Endian字节顺序获取一个无符号的16位短整数，并在此缓冲区 `readerIndex` `2`增加 `readerIndex` 。
`abstract ByteBuf`	`resetReaderIndex()` 将当前 `readerIndex`重新定位到此缓冲区中标记为 `readerIndex` 。
`abstract ByteBuf`	`resetWriterIndex()` 将当前 `writerIndex`重新定位到此缓冲区中标记为 `writerIndex` 。
`abstract ByteBuf`	`retain()` 将参考计数增加 `1` 。
`abstract ByteBuf`	`retain(int increment)` 增加参考计数 `increment` 。
`abstract ByteBuf`	`retainedDuplicate()` 返回共享此缓冲区整个区域的保留缓冲区。
`abstract ByteBuf`	`retainedSlice()` 返回此缓冲区可读字节的保留片段。
`abstract ByteBuf`	`retainedSlice(int index, int length)` 返回此缓冲区的子区域的保留切片。
`abstract ByteBuf`	`setBoolean(int index, boolean value)` 在此缓冲区中的指定绝对 `index`处设置指定的布尔值。
`abstract ByteBuf`	`setByte(int index, int value)` 在此缓冲区中的指定绝对 `index`处设置指定的字节。
`abstract ByteBuf`	`setBytes(int index, byte[] src)` 将指定的源数组的数据传输到此缓冲区，从指定的绝对 `index` 。
`abstract ByteBuf`	`setBytes(int index, byte[] src, int srcIndex, int length)` 将指定的源数组的数据传输到此缓冲区，从指定的绝对 `index` 。
`abstract ByteBuf`	`setBytes(int index, ByteBuf src)` 将指定的源缓冲区的数据从指定的绝对 `index`开始传输到此缓冲区，直到源缓冲区变得不可读。
`abstract ByteBuf`	`setBytes(int index, java.nio.ByteBuffer src)` 将指定的源缓冲区的数据从指定的绝对 `index`开始传输到此缓冲区，直到源缓冲区的位置达到其限制。
`abstract ByteBuf`	`setBytes(int index, ByteBuf src, int length)` 将指定的源缓冲区的数据从指定的绝对 `index`开始传送到此缓冲区。
`abstract ByteBuf`	`setBytes(int index, ByteBuf src, int srcIndex, int length)` 将指定的源缓冲区的数据从指定的绝对 `index`开始传输到此缓冲区。
`abstract int`	`setBytes(int index, java.nio.channels.FileChannel in, long position, int length)` 将从给定文件位置开始的指定源通道的内容传输到此缓冲区，从指定的绝对 `index` 。
`abstract int`	`setBytes(int index, java.io.InputStream in, int length)` 将指定源流的内容从指定绝对 `index`开始传输到此缓冲区。
`abstract int`	`setBytes(int index, java.nio.channels.ScatteringByteChannel in, int length)` 将指定源通道的内容从指定绝对 `index`开始传送到此缓冲区。
`abstract ByteBuf`	`setChar(int index, int value)` 在此缓冲区的指定绝对 `index`处设置指定的2字节UTF-16字符。
`abstract int`	`setCharSequence(int index, java.lang.CharSequence sequence, java.nio.charset.Charset charset)` 将指定 `CharSequence`在当前 `writerIndex`并增加了 `writerIndex`由写入的字节。
`abstract ByteBuf`	`setDouble(int index, double value)` 在此缓冲区中的指定绝对 `index`处设置指定的64位浮点数。
`ByteBuf`	`setDoubleLE(int index, double value)` 以小端字节顺序在此缓冲区中的指定绝对 `index`处设置指定的64位浮点数。
`abstract ByteBuf`	`setFloat(int index, float value)` 在此缓冲区中的指定绝对 `index`处设置指定的32位浮点数。
`ByteBuf`	`setFloatLE(int index, float value)` 以小端字节顺序在此缓冲区中的指定绝对 `index`处设置指定的32位浮点数。
`abstract ByteBuf`	`setIndex(int readerIndex, int writerIndex)` `readerIndex`设置此缓冲区的 `readerIndex`和 `writerIndex` 。
`abstract ByteBuf`	`setInt(int index, int value)` 在此缓冲区中的指定绝对 `index`处设置指定的32位整数。
`abstract ByteBuf`	`setIntLE(int index, int value)` 以小端字节顺序在此缓冲区中的指定绝对 `index`处设置指定的32位整数。
`abstract ByteBuf`	`setLong(int index, long value)` 在此缓冲区的指定绝对 `index`处设置指定的64位长整数。
`abstract ByteBuf`	`setLongLE(int index, long value)` 以小端字节顺序在此缓冲区中的指定绝对 `index`处设置指定的64位长整数。
`abstract ByteBuf`	`setMedium(int index, int value)` 在此缓冲区中指定的绝对 `index`处设置指定的24位中等整数。
`abstract ByteBuf`	`setMediumLE(int index, int value)` 以小端字节顺序在此缓冲区中的指定绝对 `index`处设置指定的24位中等整数。
`abstract ByteBuf`	`setShort(int index, int value)` 在此缓冲区中的指定绝对 `index`处设置指定的16位短整数。
`abstract ByteBuf`	`setShortLE(int index, int value)` 使用Little Endian Byte Order在此缓冲区中的指定绝对 `index`处设置指定的16位短整数。
`abstract ByteBuf`	`setZero(int index, int length)` `NUL (0x00)`从指定的绝对 `index`开始填充此缓冲区。
`abstract ByteBuf`	`skipBytes(int length)` 在此缓冲区中，按指定的 `length`增加 `readerIndex`的当前 `readerIndex` 。
`abstract ByteBuf`	`slice()` 返回此缓冲区可读字节的一部分。
`abstract ByteBuf`	`slice(int index, int length)` 返回此缓冲区的子区域的一部分。
`abstract java.lang.String`	`toString()` 返回此缓冲区的字符串表示形式。
`abstract java.lang.String`	`toString(java.nio.charset.Charset charset)` 将此缓冲区的可读字节解码为具有指定字符集名称的字符串。
`abstract java.lang.String`	`toString(int index, int length, java.nio.charset.Charset charset)` 将此缓冲区的子区域解码为具有指定字符集的字符串。
`abstract ByteBuf`	`touch()` 记录此对象的当前访问位置以进行调试。
`abstract ByteBuf`	`touch(java.lang.Object hint)` 记录此对象的当前访问位置，并附加一些用于调试的任意信息。
`abstract ByteBuf`	`unwrap()` 如果此缓冲区是另一个缓冲区的包装，则返回底层缓冲区实例。
`abstract int`	`writableBytes()` 返回等于 `(this.capacity - this.writerIndex)`的可写入字节数。
`abstract ByteBuf`	`writeBoolean(boolean value)` 在当前 `writerIndex`处设置指定的布尔值，并在此缓冲区 `writerIndex` `1`增加 `writerIndex` 。
`abstract ByteBuf`	`writeByte(int value)` 在当前 `writerIndex`处设置指定的字节，并在此缓冲区 `writerIndex` `1`增加 `writerIndex` 。
`abstract ByteBuf`	`writeBytes(byte[] src)` 指定的源阵列的数据传送到该缓冲液并从当前 `writerIndex`并增加了 `writerIndex`由传输的字节（=数量 `src.length` ）。
`abstract ByteBuf`	`writeBytes(byte[] src, int srcIndex, int length)` 指定的源阵列的数据传送到该缓冲液并从当前 `writerIndex`并增加了 `writerIndex`由传输的字节（=数量 `length` ）。
`abstract ByteBuf`	`writeBytes(ByteBuf src)` 将指定源缓冲区的数据从当前 `writerIndex`开始传输到此缓冲区，直到源缓冲区变得不可读，并将传输字节数增加 `writerIndex` 。
`abstract ByteBuf`	`writeBytes(java.nio.ByteBuffer src)` 将指定源缓冲区的数据传输到此缓冲区，从当前 `writerIndex`开始，直到源缓冲区的位置达到其限制，并将传输字节数增加 `writerIndex` 。
`abstract ByteBuf`	`writeBytes(ByteBuf src, int length)` 将指定源缓冲区的数据传输到此缓冲区，从当前的 `writerIndex`开始，并将 `writerIndex`增加 `writerIndex`所传输的字节数（= `length` ）。
`abstract ByteBuf`	`writeBytes(ByteBuf src, int srcIndex, int length)` 指定的源缓冲区的数据传送到该缓冲液并从当前 `writerIndex`并增加了 `writerIndex`由传输的字节（=数量 `length` ）。
`abstract int`	`writeBytes(java.nio.channels.FileChannel in, long position, int length)` 将从给定文件位置开始的指定通道的内容传输到此缓冲区，从当前 `writerIndex`开始，并将传输字节数增加 `writerIndex` 。
`abstract int`	`writeBytes(java.io.InputStream in, int length)` 将指定流的内容从当前 `writerIndex`开始传送到此缓冲区，并将传送的字节数增加到 `writerIndex` 。
`abstract int`	`writeBytes(java.nio.channels.ScatteringByteChannel in, int length)` 将指定通道的内容从当前 `writerIndex`开始传送到此缓冲区，并将传送的字节数增加到 `writerIndex` 。
`abstract ByteBuf`	`writeChar(int value)` 在当前 `writerIndex`处设置指定的2字节UTF-16字符，并在此缓冲区 `writerIndex` `2`增加 `writerIndex` 。
`abstract int`	`writeCharSequence(java.lang.CharSequence sequence, java.nio.charset.Charset charset)` 写入指定的 `CharSequence`在当前的 `writerIndex` ， `writerIndex`写入的字节增加 `writerIndex` 。
`abstract ByteBuf`	`writeDouble(double value)` 在当前 `writerIndex`处设置指定的64位浮点数，并在此缓冲区 `writerIndex` `8`增加 `writerIndex` 。
`ByteBuf`	`writeDoubleLE(double value)` 以小端字节顺序在当前 `writerIndex`处设置指定的64位浮点数， `8`在此缓冲区 `writerIndex` `8`增加 `writerIndex` 。
`abstract ByteBuf`	`writeFloat(float value)` 在当前 `writerIndex`处设置指定的32位浮点数，并在此缓冲区 `writerIndex` `4`增加 `writerIndex` 。
`ByteBuf`	`writeFloatLE(float value)` 以小端字节顺序在当前 `writerIndex`处设置指定的32位浮点数， `4`在此缓冲区中增加 `writerIndex` `4` 。
`abstract ByteBuf`	`writeInt(int value)` 在当前 `writerIndex`处设置指定的32位整数，并在此缓冲区 `writerIndex` `4`增加 `writerIndex` 。
`abstract ByteBuf`	`writeIntLE(int value)` 以小端字节顺序在当前 `writerIndex`处设置指定的32位整数，并在此缓冲区 `writerIndex` `4`增加 `writerIndex` 。
`abstract ByteBuf`	`writeLong(long value)` 在当前 `writerIndex`处设置指定的64位长整数，并在此缓冲区 `writerIndex` `8`增加 `writerIndex` 。
`abstract ByteBuf`	`writeLongLE(long value)` 以小端字节顺序在当前 `writerIndex`处设置指定的64位长整数，并在此缓冲区 `writerIndex` `8`增加 `writerIndex` 。
`abstract ByteBuf`	`writeMedium(int value)` 在当前 `writerIndex`处设置指定的24位中等整数，并在此缓冲区 `writerIndex` `3`增加 `writerIndex` 。
`abstract ByteBuf`	`writeMediumLE(int value)` 以小端字节顺序在当前 `writerIndex`中设置指定的24位中等整数，并在此缓冲区 `writerIndex` `3`增加 `writerIndex` 。
`abstract int`	`writerIndex()` 返回此缓冲区的 `writerIndex` 。
`abstract ByteBuf`	`writerIndex(int writerIndex)` 设置此缓冲区的 `writerIndex` 。
`abstract ByteBuf`	`writeShort(int value)` 在当前 `writerIndex`处设置指定的16位短整数，并在此缓冲区 `writerIndex` `2`增加 `writerIndex` 。
`abstract ByteBuf`	`writeShortLE(int value)` 在当前 `writerIndex`处设置Little Endian Byte Order中指定的16位短整数，并在此缓冲区 `writerIndex` `2`增加 `writerIndex` 。
`abstract ByteBuf`	`writeZero(int length)` 用 `NUL (0x00)`从当前 `writerIndex`开始填充此缓冲区， `然后`将 `writerIndex`增加 `writerIndex`指定的 `length` 。

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface io.netty.util.ReferenceCounted
refCnt, release, release

- 构造方法详细信息
  - ByteBuf
```
public ByteBuf()
```
- 方法详细信息
  - capacity
```
public abstract int capacity()
```
    返回此缓冲区可包含的字节数（字节）。
  - capacity
```
public abstract ByteBuf capacity(int newCapacity)
```
    调整此缓冲区的容量。如果newCapacity小于当前容量，则此缓冲区的内容将被截断。如果newCapacity大于当前容量，则缓冲区会附加长度为(newCapacity - currentCapacity)未指定数据。
  - maxCapacity
```
public abstract int maxCapacity()
```
    返回此缓冲区允许的最大容量。如果用户尝试使用capacity(int)或ensureWritable(int)增加此缓冲区的容量超出最大容量，那么这些方法将引发IllegalArgumentException 。
  - alloc
```
public abstract ByteBufAllocator alloc()
```
    返回创建此缓冲区的ByteBufAllocator 。
  - order
```
@Deprecated
public abstract java.nio.ByteOrder order()
```
    已过时。使用小端存取，如getShortLE ， getIntLE ，而不是用交换创建一个缓冲区endianness 。
    
    返回此缓冲区的 endianness 。
  - order
```
@Deprecated
public abstract ByteBuf order(java.nio.ByteOrder endianness)
```
    已过时。使用小端存取，如getShortLE ， getIntLE ，而不是用交换创建一个缓冲区endianness 。
    
    返回指定endianness的缓冲区，该缓冲区共享此缓冲区的整个区域，索引和标记。修改返回的缓冲区或此缓冲区的内容，索引或标记会影响彼此的内容，索引和标记。如果指定的endianness与此缓冲区的字节顺序相同，则此方法可返回this 。此方法不会修改此缓冲区的readerIndex或writerIndex 。
  - unwrap
```
public abstract ByteBuf unwrap()
```
    如果此缓冲区是另一个缓冲区的包装，则返回底层缓冲区实例。
    
    结果
    
    null如果这个缓冲区不是包装
  - isDirect
```
public abstract boolean isDirect()
```
    当且仅当此缓冲区由NIO直接缓冲区支持时才返回 true 。
  - isReadOnly
```
public abstract boolean isReadOnly()
```
    当且仅当此缓冲区为只读时才返回 true 。
  - asReadOnly
```
public abstract ByteBuf asReadOnly()
```
    返回此缓冲区的只读版本。
  - readerIndex
```
public abstract int readerIndex()
```
    返回此缓冲区的 readerIndex 。
  - readerIndex
```
public abstract ByteBuf readerIndex(int readerIndex)
```
    设置此缓冲区的 readerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 readerIndex小于 0或大于 this.writerIndex
  - writerIndex
```
public abstract int writerIndex()
```
    返回此缓冲区的 writerIndex 。
  - writerIndex
```
public abstract ByteBuf writerIndex(int writerIndex)
```
    设置此缓冲区的 writerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 writerIndex小于 this.readerIndex或大于 this.capacity
  - setIndex
```
public abstract ByteBuf setIndex(int readerIndex,
                                 int writerIndex)
```
    readerIndex设置此缓冲区的readerIndex和writerIndex 。当您不得不担心readerIndex(int)和writerIndex(int)方法的调用顺序时，此方法非常有用。例如，以下代码将失败：
```
  // Create a buffer whose readerIndex, writerIndex and capacity are
 // 0, 0 and 8 respectively.
 ByteBuf buf = Unpooled.buffer(8);

 // IndexOutOfBoundsException is thrown because the specified
 // readerIndex (2) cannot be greater than the current writerIndex (0).
 buf.readerIndex(2);
 buf.writerIndex(4); 
```
    以下代码也将失败：
```
  // Create a buffer whose readerIndex, writerIndex and capacity are
 // 0, 8 and 8 respectively.
 ByteBuf buf = Unpooled.wrappedBuffer(new byte[8]);

 // readerIndex becomes 8.
 buf.readLong();

 // IndexOutOfBoundsException is thrown because the specified
 // writerIndex (4) cannot be less than the current readerIndex (8).
 buf.writerIndex(4);
 buf.readerIndex(2); 
```
    相比之下，只要指定的索引满足基本约束，该方法就保证它不会抛出IndexOutOfBoundsException ，无论缓冲区的当前索引值是什么：
```
  // No matter what the current state of the buffer is, the following
 // call always succeeds as long as the capacity of the buffer is not
 // less than 4.
 buf.setIndex(2, 4); 
```
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 readerIndex小于0，如果指定的 writerIndex小于指定的 readerIndex或者指定的 writerIndex大于 this.capacity
  - readableBytes
```
public abstract int readableBytes()
```
    返回等于 (this.writerIndex - this.readerIndex)的可读字节数。
  - writableBytes
```
public abstract int writableBytes()
```
    返回等于 (this.capacity - this.writerIndex)的可写入字节数。
  - maxWritableBytes
```
public abstract int maxWritableBytes()
```
    返回可写入的最大字节数，等于 (this.maxCapacity - this.writerIndex) 。
  - isReadable
```
public abstract boolean isReadable()
```
    返回 true当且仅当 (this.writerIndex - this.readerIndex)大于 0 。
  - isReadable
```
public abstract boolean isReadable(int size)
```
    当且仅当此缓冲区包含等于或多于指定数量的元素时才返回 true 。
  - isWritable
```
public abstract boolean isWritable()
```
    返回 true当且仅当 (this.capacity - this.writerIndex)大于 0 。
  - isWritable
```
public abstract boolean isWritable(int size)
```
    当且仅当此缓冲区有足够的空间允许写入指定数量的元素时才返回 true 。
  - clear
```
public abstract ByteBuf clear()
```
    将此缓冲区的readerIndex和writerIndex设置为0 。该方法与setIndex(0, 0)相同。
    请注意，此方法的行为与NIO缓冲区的行为不同，后者将limit设置为limit的capacity 。
  - markReaderIndex
```
public abstract ByteBuf markReaderIndex()
```
    在此缓冲区中标记当前readerIndex 。您可以重新定位当前readerIndex到标记readerIndex通过调用resetReaderIndex() 。标记的初始值readerIndex是0 。
  - resetReaderIndex
```
public abstract ByteBuf resetReaderIndex()
```
    将当前 readerIndex重新定位到此缓冲区中标记为 readerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果当前 writerIndex小于标记 readerIndex
  - markWriterIndex
```
public abstract ByteBuf markWriterIndex()
```
    在此缓冲区中标记当前writerIndex 。您可以重新定位当前writerIndex到标记writerIndex通过调用resetWriterIndex() 。标记writerIndex的初始值是0 。
  - resetWriterIndex
```
public abstract ByteBuf resetWriterIndex()
```
    将当前 writerIndex重新定位到此缓冲区中标记为 writerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果当前 readerIndex大于标记 writerIndex
  - discardReadBytes
```
public abstract ByteBuf discardReadBytes()
```
    丢弃第0个索引和readerIndex之间的字节。它移动之间的字节readerIndex和writerIndex至第0索引，并且设置readerIndex和writerIndex至0和oldWriterIndex - oldReaderIndex分别。
    请参阅班级文件以获得更详细的解释。
  - discardSomeReadBytes
```
public abstract ByteBuf discardSomeReadBytes()
```
    类似于 discardReadBytes()，不同之处在于此方法可能会放弃部分，全部或者全部读取字节，具体取决于其内部实现方式，以减少潜在的额外内存消耗为代价降低整体内存带宽消耗。
  - ensureWritable
```
public abstract ByteBuf ensureWritable(int minWritableBytes)
```
    确保the writable bytes的数量等于或大于指定值。如果此缓冲区中有足够的可写字节，则此方法返回时无副作用。否则，它会产生一个IllegalArgumentException 。
    
    参数
    
    minWritableBytes - 可写入字节的预期最小数量
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 writerIndex() + minWritableBytes > maxCapacity()
  - ensureWritable
```
public abstract int ensureWritable(int minWritableBytes,
                                   boolean force)
```
    尝试确保the writable bytes的数量等于或大于指定的值。与ensureWritable(int)不同，此方法不引发异常但返回代码。
    参数
    
    minWritableBytes - 可写入字节的预期最小数量
    force - 当writerIndex() + minWritableBytes > maxCapacity() ：
    
    true - 缓冲区的容量扩大到maxCapacity()
    
    false - 缓冲区容量不变
    结果
    
    0如果缓冲区有足够的可写字节，并且其容量不变。 1如果缓冲区没有足够的字节，并且其容量不变。 2如果缓冲区有足够的可写字节，并且其容量已增加。 3如果缓冲区没有足够的字节，但其容量已增加到其最大值。
  - getBoolean
```
public abstract boolean getBoolean(int index)
```
    在此缓冲区中获取指定绝对（@code索引）的布尔值。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0或 index + 1大于 this.capacity
  - getByte
```
public abstract byte getByte(int index)
```
    获取此缓冲区中指定的绝对index一个字节。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0或 index + 1大于 this.capacity
  - getUnsignedByte
```
public abstract short getUnsignedByte(int index)
```
    在此缓冲区的指定绝对index处获取一个无符号字节。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0或 index + 1大于 this.capacity
  - getShort
```
public abstract short getShort(int index)
```
    在此缓冲区中的指定绝对index处获取一个16位短整数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0或 index + 2大于 this.capacity
  - getShortLE
```
public abstract short getShortLE(int index)
```
    以小端字节顺序在此缓冲区中的指定绝对index处获取一个16位短整数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0或 index + 2大于 this.capacity
  - getUnsignedShort
```
public abstract int getUnsignedShort(int index)
```
    在此缓冲区中的指定绝对index处获取一个无符号的16位短整数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0或 index + 2大于 this.capacity
  - getUnsignedShortLE
```
public abstract int getUnsignedShortLE(int index)
```
    以小端字节顺序在此缓冲区中的指定绝对index处获取一个无符号的16位短整数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0或 index + 2大于 this.capacity
  - getMedium
```
public abstract int getMedium(int index)
```
    在此缓冲区中的指定绝对index处获取一个24位中等整数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0或 index + 3大于 this.capacity
  - getMediumLE
```
public abstract int getMediumLE(int index)
```
    以Little Endian字节顺序在此缓冲区中的指定绝对index处获取一个24位中等整数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0或 index + 3大于 this.capacity
  - getUnsignedMedium
```
public abstract int getUnsignedMedium(int index)
```
    在此缓冲区中的指定绝对index处获取一个无符号的24位中等整数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0或 index + 3大于 this.capacity
  - getUnsignedMediumLE
```
public abstract int getUnsignedMediumLE(int index)
```
    以Little Endian字节顺序在此缓冲区中的指定绝对index处获取无符号的24位中等整数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0或 index + 3大于 this.capacity
  - getInt
```
public abstract int getInt(int index)
```
    在此缓冲区中指定的绝对index处获取一个32位整数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0或 index + 4大于 this.capacity
  - getIntLE
```
public abstract int getIntLE(int index)
```
    在具有Little Endian Byte Order的缓冲区中的指定绝对index处获取一个32位整数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0或 index + 4大于 this.capacity
  - getUnsignedInt
```
public abstract long getUnsignedInt(int index)
```
    在此缓冲区中指定的绝对index处获取一个无符号的32位整数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0或 index + 4大于 this.capacity
  - getUnsignedIntLE
```
public abstract long getUnsignedIntLE(int index)
```
    以小端字节顺序在此缓冲区中指定的绝对index处获取一个无符号的32位整数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0或 index + 4大于 this.capacity
  - getLong
```
public abstract long getLong(int index)
```
    在此缓冲区中的指定绝对index处获取一个64位长整数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0或 index + 8大于 this.capacity
  - getLongLE
```
public abstract long getLongLE(int index)
```
    以小端字节顺序在此缓冲区中的指定绝对index处获取64位长整数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0或 index + 8大于 this.capacity
  - getChar
```
public abstract char getChar(int index)
```
    在此缓冲区中的指定绝对index处获取一个2字节的UTF-16字符。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0或 index + 2大于 this.capacity
  - getFloat
```
public abstract float getFloat(int index)
```
    在此缓冲区中的指定绝对index处获取一个32位浮点数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0或 index + 4大于 this.capacity
  - getFloatLE
```
public float getFloatLE(int index)
```
    以小端字节顺序在此缓冲区中的指定绝对index处获取32位浮点数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0或 index + 4大于 this.capacity
  - getDouble
```
public abstract double getDouble(int index)
```
    在此缓冲区中的指定绝对index处获取一个64位浮点数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0或 index + 8大于 this.capacity
  - getDoubleLE
```
public double getDoubleLE(int index)
```
    以Little Endian字节顺序在此缓冲区中的指定绝对index处获取64位浮点数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0或 index + 8大于 this.capacity
  - getBytes
```
public abstract ByteBuf getBytes(int index,
                                 ByteBuf dst)
```
    将此缓冲区的数据传输到指定的目标位置，从指定的绝对index开始，直到目标变为不可写。此方法与getBytes(int, ByteBuf, int, int)基本相同，不同之writerIndex于此方法将目标的writerIndex增加了传输字节数，而getBytes(int, ByteBuf, int, int)则不增加。此方法不会修改源缓冲区的readerIndex或writerIndex （即this ）。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0或者 index + dst.writableBytes大于 this.capacity
  - getBytes
```
public abstract ByteBuf getBytes(int index,
                                 ByteBuf dst,
                                 int length)
```
    将此缓冲区的数据传输到指定绝对index开始的目标index 。此方法与getBytes(int, ByteBuf, int, int)基本相同，只是此方法通过传输字节数增加目标的writerIndex ，而getBytes(int, ByteBuf, int, int)则不增加。此方法不会修改源缓冲区的readerIndex或writerIndex （即this ）。
    
    参数
    
    length - 要传输的字节数
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0 ，如果 index + length大于 this.capacity ，或者 length大于 dst.writableBytes
  - getBytes
```
public abstract ByteBuf getBytes(int index,
                                 ByteBuf dst,
                                 int dstIndex,
                                 int length)
```
    将此缓冲区的数据传输到指定的绝对index开始的目标。此方法不会修改源（即this ）和目标的readerIndex或writerIndex 。
    
    参数
    
    dstIndex - 目的地的第一个索引
    
    length - 要传输的字节数
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0 ，如果指定的 dstIndex小于 0 ，如果 index + length大于 this.capacity ，或者 dstIndex + length大于 dst.capacity
  - getBytes
```
public abstract ByteBuf getBytes(int index,
                                 byte[] dst)
```
    将此缓冲区的数据传输到指定绝对index开始的目标。此方法不会修改此缓冲区的readerIndex或writerIndex
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0或者 index + dst.length大于 this.capacity
  - getBytes
```
public abstract ByteBuf getBytes(int index,
                                 byte[] dst,
                                 int dstIndex,
                                 int length)
```
    将此缓冲区的数据传输到指定的绝对目标index开始的目标。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    参数
    
    dstIndex - 目的地的第一个索引
    
    length - 要传输的字节数
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0 ，如果指定的 dstIndex小于 0 ，如果 index + length大于 this.capacity ，或者 dstIndex + length大于 dst.length
  - getBytes
```
public abstract ByteBuf getBytes(int index,
                                 java.nio.ByteBuffer dst)
```
    将此缓冲区的数据传输到指定的目标位置，从指定的绝对index开始，直到目标位置达到其限制。此方法不会修改此缓冲区的readerIndex或writerIndex ，而目标的position将会增加。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0或者 index + dst.remaining()大于 this.capacity
  - getBytes
```
public abstract ByteBuf getBytes(int index,
                                 java.io.OutputStream out,
                                 int length)
                          throws java.io.IOException
```
    将此缓冲区的数据传输到指定的绝对值为index流。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    参数
    
    length - 要传输的字节数
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0或者 index + length大于 this.capacity
    
    java.io.IOException - 如果指定的流在I / O期间抛出异常
  - getBytes
```
public abstract int getBytes(int index,
                             java.nio.channels.GatheringByteChannel out,
                             int length)
                      throws java.io.IOException
```
    将此缓冲区的数据传输到指定的绝对index开始的通道。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    参数
    
    length - 传输的最大字节数
    
    结果
    
    写出到指定通道的实际字节数
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0或者 index + length大于 this.capacity
    
    java.io.IOException - 如果指定的通道在I / O期间引发异常
  - getBytes
```
public abstract int getBytes(int index,
                             java.nio.channels.FileChannel out,
                             long position,
                             int length)
                      throws java.io.IOException
```
    将该缓冲区的数据从指定的绝对index开始index到指定的通道，从给定的文件位置开始。此方法不会修改此缓冲区的readerIndex或writerIndex 。此方法不会修改频道的位置。
    
    参数
    
    position - 传输开始的文件位置
    
    length - 传输的最大字节数
    
    结果
    
    写出到指定通道的实际字节数
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0或者 index + length大于 this.capacity
    
    java.io.IOException - 如果指定的通道在I / O期间引发异常
  - getCharSequence
```
public abstract java.lang.CharSequence getCharSequence(int index,
                                                       int length,
                                                       java.nio.charset.Charset charset)
```
    在给定索引处获得具有给定长度的 CharSequence 。
    
    参数
    
    length - 要阅读的长度
    
    charset - 应该使用
    
    结果
    
    序列
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 length大于 this.readableBytes
  - setBoolean
```
public abstract ByteBuf setBoolean(int index,
                                   boolean value)
```
    在此缓冲区中的指定绝对index处设置指定的布尔值。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0或 index + 1大于 this.capacity
  - setByte
```
public abstract ByteBuf setByte(int index,
                                int value)
```
    在此缓冲区中的指定绝对index处设置指定的字节。指定值的24个高位被忽略。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0或 index + 1大于 this.capacity
  - setShort
```
public abstract ByteBuf setShort(int index,
                                 int value)
```
    在此缓冲区中的指定绝对index处设置指定的16位短整数。指定值的16个高位被忽略。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0或 index + 2大于 this.capacity
  - setShortLE
```
public abstract ByteBuf setShortLE(int index,
                                   int value)
```
    使用Little Endian Byte Order在此缓冲区中的指定绝对index处设置指定的16位短整数。指定值的16个高位被忽略。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0或 index + 2大于 this.capacity
  - setMedium
```
public abstract ByteBuf setMedium(int index,
                                  int value)
```
    在此缓冲区中的指定绝对index处设置指定的24位中等整数。请注意，最高有效字节在指定值中被忽略。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0或 index + 3大于 this.capacity
  - setMediumLE
```
public abstract ByteBuf setMediumLE(int index,
                                    int value)
```
    以小端字节顺序在此缓冲区中的指定绝对index处设置指定的24位中等整数。请注意，最高有效字节在指定值中被忽略。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0或 index + 3大于 this.capacity
  - setInt
```
public abstract ByteBuf setInt(int index,
                               int value)
```
    在此缓冲区中的指定绝对index处设置指定的32位整数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0或 index + 4大于 this.capacity
  - setIntLE
```
public abstract ByteBuf setIntLE(int index,
                                 int value)
```
    使用Little Endian字节顺序在此缓冲区中的指定绝对index处设置指定的32位整数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0或 index + 4大于 this.capacity
  - setLong
```
public abstract ByteBuf setLong(int index,
                                long value)
```
    在此缓冲区的指定绝对index处设置指定的64位长整数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0或 index + 8大于 this.capacity
  - setLongLE
```
public abstract ByteBuf setLongLE(int index,
                                  long value)
```
    以小端字节顺序在此缓冲区中的指定绝对index处设置指定的64位长整数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0或 index + 8大于 this.capacity
  - setChar
```
public abstract ByteBuf setChar(int index,
                                int value)
```
    在此缓冲区的指定绝对index处设置指定的2字节UTF-16字符。指定值的16个高位被忽略。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0或 index + 2大于 this.capacity
  - setFloat
```
public abstract ByteBuf setFloat(int index,
                                 float value)
```
    在此缓冲区的指定绝对index处设置指定的32位浮点数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0或 index + 4大于 this.capacity
  - setFloatLE
```
public ByteBuf setFloatLE(int index,
                          float value)
```
    以小端字节顺序在此缓冲区中的指定绝对index处设置指定的32位浮点数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0或 index + 4大于 this.capacity
  - setDouble
```
public abstract ByteBuf setDouble(int index,
                                  double value)
```
    在此缓冲区中的指定绝对index处设置指定的64位浮点数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0或 index + 8大于 this.capacity
  - setDoubleLE
```
public ByteBuf setDoubleLE(int index,
                           double value)
```
    以小端字节顺序在此缓冲区中的指定绝对index处设置指定的64位浮点数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0或 index + 8大于 this.capacity
  - setBytes
```
public abstract ByteBuf setBytes(int index,
                                 ByteBuf src)
```
    将指定的源缓冲区的数据从指定的绝对index开始传输到此缓冲区，直到源缓冲区变得不可读。此方法与setBytes(int, ByteBuf, int, int)基本相同，只是此方法将源缓冲区的readerIndex增加了传输字节数，而setBytes(int, ByteBuf, int, int)则不增加。此方法不会修改源缓冲区的readerIndex或writerIndex （即this ）。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0或者 index + src.readableBytes大于 this.capacity
  - setBytes
```
public abstract ByteBuf setBytes(int index,
                                 ByteBuf src,
                                 int length)
```
    将指定的源缓冲区的数据从指定的绝对index开始传输到此缓冲区。此方法与setBytes(int, ByteBuf, int, int)基本相同，区别在于此方法将源缓冲区的readerIndex增加了传输字节数，而setBytes(int, ByteBuf, int, int)则不增加。此方法不会修改源缓冲区的readerIndex或writerIndex （即this ）。
    
    参数
    
    length - 要传输的字节数
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0 ，如果 index + length大于 this.capacity ，或者 length大于 src.readableBytes
  - setBytes
```
public abstract ByteBuf setBytes(int index,
                                 ByteBuf src,
                                 int srcIndex,
                                 int length)
```
    将指定的源缓冲区的数据从指定的绝对index开始传送到此缓冲区。此方法不会修改源（即this ）和目标的readerIndex或writerIndex 。
    
    参数
    
    srcIndex - 来源的第一个索引
    
    length - 要传输的字节数
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0 ，如果指定的 srcIndex小于 0 ，如果 index + length大于 this.capacity ，或者 srcIndex + length大于 src.capacity
  - setBytes
```
public abstract ByteBuf setBytes(int index,
                                 byte[] src)
```
    将指定的源数组的数据传输到此缓冲区，从指定的绝对index 。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0或者 index + src.length大于 this.capacity
  - setBytes
```
public abstract ByteBuf setBytes(int index,
                                 byte[] src,
                                 int srcIndex,
                                 int length)
```
    将指定的源数组的数据传输到此缓冲区，从指定的绝对index 。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0 ，如果指定的 srcIndex小于 0 ，如果 index + length大于 this.capacity ，或者 srcIndex + length大于 src.length
  - setBytes
```
public abstract ByteBuf setBytes(int index,
                                 java.nio.ByteBuffer src)
```
    将指定的源缓冲区的数据从指定的绝对index开始传送到此缓冲区，直到源缓冲区的位置达到其限制。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0或者 index + src.remaining()大于 this.capacity
  - setBytes
```
public abstract int setBytes(int index,
                             java.io.InputStream in,
                             int length)
                      throws java.io.IOException
```
    将指定源流的内容从指定的绝对index开始传输到此缓冲区。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    参数
    
    length - 要传输的字节数
    
    结果
    
    从指定通道读入的实际字节数。 -1如果指定的频道已关闭。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0或者 index + length大于 this.capacity
    
    java.io.IOException - 如果指定的流在I / O期间抛出异常
  - setBytes
```
public abstract int setBytes(int index,
                             java.nio.channels.ScatteringByteChannel in,
                             int length)
                      throws java.io.IOException
```
    将指定源通道的内容从指定绝对index开始传输到此缓冲区。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    参数
    
    length - 要传输的最大字节数
    
    结果
    
    从指定通道读入的实际字节数。 -1如果指定的频道关闭。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0或者 index + length大于 this.capacity
    
    java.io.IOException - 如果指定的通道在I / O期间引发异常
  - setBytes
```
public abstract int setBytes(int index,
                             java.nio.channels.FileChannel in,
                             long position,
                             int length)
                      throws java.io.IOException
```
    将从给定文件位置开始的指定源通道的内容传输到此缓冲区，从指定绝对index 。此方法不会修改此缓冲区的readerIndex或writerIndex 。此方法不会修改频道的位置。
    
    参数
    
    position - 传输开始的文件位置
    
    length - 要传输的最大字节数
    
    结果
    
    从指定通道读入的实际字节数。 -1如果指定的频道已关闭。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0或者 index + length大于 this.capacity
    
    java.io.IOException - 如果指定的通道在I / O期间引发异常
  - setZero
```
public abstract ByteBuf setZero(int index,
                                int length)
```
    NUL (0x00)从指定的绝对index开始填充此缓冲区。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    参数
    
    length - 写入缓冲区的数量为 NUL
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 index小于 0或者 index + length大于 this.capacity
  - setCharSequence
```
public abstract int setCharSequence(int index,
                                    java.lang.CharSequence sequence,
                                    java.nio.charset.Charset charset)
```
    将指定 CharSequence在当前 writerIndex并增加了 writerIndex由写入的字节。
    
    参数
    
    index - 应写入序列
    
    sequence - 写
    
    charset - 应该使用。
    
    结果
    
    写入的字节数。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 this.writableBytes不足以写入整个序列
  - readBoolean
```
public abstract boolean readBoolean()
```
    获取当前 readerIndex的布尔值，并在此缓冲区 readerIndex 1增加 readerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 this.readableBytes小于 1
  - readByte
```
public abstract byte readByte()
```
    获取当前 readerIndex处的一个字节，并在此缓冲区 readerIndex 1增加 readerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 this.readableBytes小于 1
  - readUnsignedByte
```
public abstract short readUnsignedByte()
```
    获取当前 readerIndex的无符号字节，并在此缓冲区 readerIndex 1增加 readerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 this.readableBytes小于 1
  - readShort
```
public abstract short readShort()
```
    在当前 readerIndex处获取一个16位短整数，并在此缓冲区 readerIndex 2增加 readerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 this.readableBytes小于 2
  - readShortLE
```
public abstract short readShortLE()
```
    在Little Endian字节顺序的当前 readerIndex处获取一个16位短整数，并在此缓冲区 readerIndex 2增加 readerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 this.readableBytes小于 2
  - readUnsignedShort
```
public abstract int readUnsignedShort()
```
    在当前 readerIndex处获取一个无符号的16位短整数，并在此缓冲区 readerIndex 2增加 readerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 this.readableBytes小于 2
  - readUnsignedShortLE
```
public abstract int readUnsignedShortLE()
```
    在小端字节顺序的当前 readerIndex处获取一个无符号的16位短整数，并在此缓冲区 readerIndex 2增加 readerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 this.readableBytes小于 2
  - readMedium
```
public abstract int readMedium()
```
    在当前 readerIndex处获取24位中等整数，并在此缓冲区 readerIndex 3增加 readerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 this.readableBytes小于 3
  - readMediumLE
```
public abstract int readMediumLE()
```
    在Little Endian字节顺序的当前 readerIndex处获取24位中等整数，并在此缓冲区 readerIndex 3增加 readerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 this.readableBytes小于 3
  - readUnsignedMedium
```
public abstract int readUnsignedMedium()
```
    在当前 readerIndex处获取无符号的24位中等整数，并在此缓冲区 readerIndex 3增加 readerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 this.readableBytes小于 3
  - readUnsignedMediumLE
```
public abstract int readUnsignedMediumLE()
```
    在小端字节顺序的当前 readerIndex处获取一个无符号的24位中等整数，并在此缓冲区 readerIndex 3增加 readerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 this.readableBytes小于 3
  - readInt
```
public abstract int readInt()
```
    在当前 readerIndex处获取32位整数，并在此缓冲区 readerIndex 4增加 readerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 this.readableBytes小于 4
  - readIntLE
```
public abstract int readIntLE()
```
    在Little Endian Byte Order中获取当前 readerIndex的32位整数，并在此缓冲区 readerIndex 4增加 readerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 this.readableBytes小于 4
  - readUnsignedInt
```
public abstract long readUnsignedInt()
```
    在当前 readerIndex处获取一个无符号的32位整数，并在此缓冲区 readerIndex 4增加 readerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 this.readableBytes小于 4
  - readUnsignedIntLE
```
public abstract long readUnsignedIntLE()
```
    在Little Endian Byte Order中获取当前 readerIndex的无符号32位整数，并在此缓冲区 readerIndex 4增加 readerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 this.readableBytes小于 4
  - readLong
```
public abstract long readLong()
```
    在当前 readerIndex处获取一个64位整数，并在此缓冲区 readerIndex 8增加 readerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 this.readableBytes小于 8
  - readLongLE
```
public abstract long readLongLE()
```
    在Little Endian字节顺序的当前 readerIndex处获取64位整数，并在此缓冲区 readerIndex 8增加 readerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 this.readableBytes小于 8
  - readChar
```
public abstract char readChar()
```
    在当前 readerIndex处获取一个2字节的UTF-16字符，并在此缓冲区 readerIndex 2增加 readerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 this.readableBytes小于 2
  - readFloat
```
public abstract float readFloat()
```
    在当前 readerIndex处获取一个32位浮点数，并在此缓冲区 readerIndex 4增加 readerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 this.readableBytes小于 4
  - readFloatLE
```
public float readFloatLE()
```
    在Little Endian Byte Order中获取当前 readerIndex的32位浮点数， 4在此缓冲区 readerIndex 4增加 readerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 this.readableBytes小于 4
  - readDouble
```
public abstract double readDouble()
```
    在当前 readerIndex处获取64位浮点数，并在此缓冲区 readerIndex 8增加 readerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 this.readableBytes小于 8
  - readDoubleLE
```
public double readDoubleLE()
```
    在当前 readerIndex以Little Endian字节顺序获取一个64位浮点数， 8在此缓冲区 readerIndex 8增加 readerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 this.readableBytes小于 8
  - readBytes
```
public abstract ByteBuf readBytes(int length)
```
    传输此缓冲区的数据到一个新创建的缓冲器并从当前readerIndex并增加了readerIndex由传输的字节（=数量length ）。返回缓冲区的readerIndex和writerIndex是0和length分别。
    
    参数
    
    length - 要传输的字节数
    
    结果
    
    新创建的包含传输字节的缓冲区
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 length大于 this.readableBytes
  - readSlice
```
public abstract ByteBuf readSlice(int length)
```
    从当前readerIndex开始返回此缓冲区的子区域的新片段，并将readerIndex增加readerIndex新片段的大小（= length ）。
    另外请注意，此方法不会调用retain() ，因此引用计数不会增加。
    
    参数
    
    length - 新切片的大小
    
    结果
    
    新创建的切片
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 length大于 this.readableBytes
  - readRetainedSlice
```
public abstract ByteBuf readRetainedSlice(int length)
```
    从当前的readerIndex开始返回此缓冲区的子区域的新保留切片，并将readerIndex增加readerIndex新切片的大小（= length ）。
    请注意，与readSlice(int)不同，此方法返回retained缓冲区。此方法的行为与readSlice(...).retain()类似， readSlice(...).retain()在于此方法可能会返回生成较少垃圾的缓冲区实现。
    
    参数
    
    length - 新切片的大小
    
    结果
    
    新创建的切片
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 length大于 this.readableBytes
  - readBytes
```
public abstract ByteBuf readBytes(ByteBuf dst)
```
    将此缓冲区的数据传输到指定的目标，从当前readerIndex开始，直到目标变为不可写入，并将传输字节数增加readerIndex 。此方法与readBytes(ByteBuf, int, int)基本相同，不同之writerIndex于此方法通过传输字节数增加目标的writerIndex ，而readBytes(ByteBuf, int, int)则不增加。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 dst.writableBytes大于 this.readableBytes
  - readBytes
```
public abstract ByteBuf readBytes(ByteBuf dst,
                                  int length)
```
    传输此缓冲区的数据到指定的目标并从当前readerIndex并增加了readerIndex由传输的字节（=数量length ）。此方法与readBytes(ByteBuf, int, int)基本相同，不同之writerIndex于此方法通过传输的字节数（= length ）增加目标的writerIndex ，而readBytes(ByteBuf, int, int)则不增加。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 length大于 this.readableBytes或者 length大于 dst.writableBytes
  - readBytes
```
public abstract ByteBuf readBytes(ByteBuf dst,
                                  int dstIndex,
                                  int length)
```
    传输此缓冲区的数据到指定的目标并从当前 readerIndex并增加了 readerIndex由传输的字节（=数量 length ）。
    
    参数
    
    dstIndex - 目的地的第一个索引
    
    length - 要传输的字节数
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 dstIndex小于 0 ，如果 length大于 this.readableBytes ，或者 dstIndex + length大于 dst.capacity
  - readBytes
```
public abstract ByteBuf readBytes(byte[] dst)
```
    传输此缓冲区的数据到指定的目标并从当前 readerIndex并增加了 readerIndex由传输的字节（=数量 dst.length ）。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 dst.length大于 this.readableBytes
  - readBytes
```
public abstract ByteBuf readBytes(byte[] dst,
                                  int dstIndex,
                                  int length)
```
    传输此缓冲区的数据到指定的目标并从当前 readerIndex并增加了 readerIndex由传输的字节（=数量 length ）。
    
    参数
    
    dstIndex - 目的地的第一个索引
    
    length - 要传输的字节数
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 dstIndex小于 0 ，如果 length大于 this.readableBytes ，或者 dstIndex + length大于 dst.length
  - readBytes
```
public abstract ByteBuf readBytes(java.nio.ByteBuffer dst)
```
    将此缓冲区的数据传输到指定的目标，从当前 readerIndex开始，直到目标的位置达到其限制，并将 readerIndex增加 readerIndex所传输的字节数。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 dst.remaining()大于 this.readableBytes
  - readBytes
```
public abstract ByteBuf readBytes(java.io.OutputStream out,
                                  int length)
                           throws java.io.IOException
```
    将此缓冲区的数据传输到当前 readerIndex开始的指定流。
    
    参数
    
    length - 要传输的字节数
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 length大于 this.readableBytes
    
    java.io.IOException - 如果指定的流在I / O期间抛出异常
  - readBytes
```
public abstract int readBytes(java.nio.channels.GatheringByteChannel out,
                              int length)
                       throws java.io.IOException
```
    将此缓冲区的数据传输到当前 readerIndex开始的指定流。
    
    参数
    
    length - 要传输的最大字节数
    
    结果
    
    写出到指定通道的实际字节数
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 length大于 this.readableBytes
    
    java.io.IOException - 如果指定的通道在I / O期间引发异常
  - readCharSequence
```
public abstract java.lang.CharSequence readCharSequence(int length,
                                                        java.nio.charset.Charset charset)
```
    在当前 readerIndex处获得给定长度的 CharSequence ，并将给定长度增加 readerIndex 。
    
    参数
    
    length - 要阅读的长度
    
    charset - 应该使用
    
    结果
    
    序列
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 length大于 this.readableBytes
  - readBytes
```
public abstract int readBytes(java.nio.channels.FileChannel out,
                              long position,
                              int length)
                       throws java.io.IOException
```
    将此缓冲区的数据从当前的readerIndex开始readerIndex到指定通道，从给定的文件位置开始。此方法不会修改频道的位置。
    
    参数
    
    position - 传输开始的文件位置
    
    length - 传输的最大字节数
    
    结果
    
    写出到指定通道的实际字节数
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 length大于 this.readableBytes
    
    java.io.IOException - 如果指定的通道在I / O期间引发异常
  - skipBytes
```
public abstract ByteBuf skipBytes(int length)
```
    此缓冲区中指定的 length增加当前 readerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 length大于 this.readableBytes
  - writeBoolean
```
public abstract ByteBuf writeBoolean(boolean value)
```
    在当前 writerIndex处设置指定的布尔值，并在此缓冲区 writerIndex 1增加 writerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 this.writableBytes小于 1
  - writeByte
```
public abstract ByteBuf writeByte(int value)
```
    在当前writerIndex处设置指定的字节，并在此缓冲区writerIndex 1增加writerIndex 。指定值的24个高位被忽略。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 this.writableBytes小于 1
  - writeShort
```
public abstract ByteBuf writeShort(int value)
```
    在当前writerIndex处设置指定的16位短整数，并在此缓冲区writerIndex 2增加writerIndex 。指定值的16个高位被忽略。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 this.writableBytes小于 2
  - writeShortLE
```
public abstract ByteBuf writeShortLE(int value)
```
    在当前writerIndex处设置Little Endian Byte Order中指定的16位短整数，并在此缓冲区writerIndex 2增加writerIndex 。指定值的16个高位被忽略。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 this.writableBytes小于 2
  - writeMedium
```
public abstract ByteBuf writeMedium(int value)
```
    在当前 writerIndex中设置指定的24位中等整数，并在此缓冲区 writerIndex 3增加 writerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 this.writableBytes小于 3
  - writeMediumLE
```
public abstract ByteBuf writeMediumLE(int value)
```
    以小端字节顺序在当前 writerIndex中设置指定的24位中等整数，并在此缓冲区 writerIndex 3增加 writerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 this.writableBytes小于 3
  - writeInt
```
public abstract ByteBuf writeInt(int value)
```
    在当前 writerIndex处设置指定的32位整数，并在此缓冲区 writerIndex 4增加 writerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 this.writableBytes小于 4
  - writeIntLE
```
public abstract ByteBuf writeIntLE(int value)
```
    以小端字节顺序在当前 writerIndex处设置指定的32位整数，并在此缓冲区 writerIndex 4增加 writerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 this.writableBytes小于 4
  - writeLong
```
public abstract ByteBuf writeLong(long value)
```
    在当前 writerIndex处设置指定的64位长整数，并在此缓冲区 writerIndex 8增加 writerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 this.writableBytes小于 8
  - writeLongLE
```
public abstract ByteBuf writeLongLE(long value)
```
    以小端字节顺序在当前 writerIndex处设置指定的64位长整数，并在此缓冲区 writerIndex 8增加 writerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 this.writableBytes小于 8
  - writeChar
```
public abstract ByteBuf writeChar(int value)
```
    在当前writerIndex处设置指定的2字节UTF-16字符，并在此缓冲区writerIndex 2增加writerIndex 。指定值的16个高位被忽略。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 this.writableBytes小于 2
  - writeFloat
```
public abstract ByteBuf writeFloat(float value)
```
    在当前 writerIndex处设置指定的32位浮点数，并在此缓冲区 writerIndex 4增加 writerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 this.writableBytes小于 4
  - writeFloatLE
```
public ByteBuf writeFloatLE(float value)
```
    以小端字节顺序在当前 writerIndex处设置指定的32位浮点数， 4在此缓冲区 writerIndex 4增加 writerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 this.writableBytes小于 4
  - writeDouble
```
public abstract ByteBuf writeDouble(double value)
```
    在当前 writerIndex处设置指定的64位浮点数，并在此缓冲区 writerIndex 8增加 writerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 this.writableBytes小于 8
  - writeDoubleLE
```
public ByteBuf writeDoubleLE(double value)
```
    在Little Endian Byte Order中设置当前 writerIndex的指定64位浮点数， 8在此缓冲区中增加 writerIndex 8 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 this.writableBytes小于 8
  - writeBytes
```
public abstract ByteBuf writeBytes(ByteBuf src)
```
    将指定源缓冲区的数据传输到此缓冲区，从当前writerIndex开始，直到源缓冲区变得不可读，并将传输字节数增加writerIndex 。此方法与writeBytes(ByteBuf, int, int)基本相同，不同之readerIndex于此方法将源缓冲区的readerIndex增加了传输字节数，而writeBytes(ByteBuf, int, int)则不增加。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 src.readableBytes大于 this.writableBytes
  - writeBytes
```
public abstract ByteBuf writeBytes(ByteBuf src,
                                   int length)
```
    指定的源缓冲区的数据传送到该缓冲液并从当前writerIndex并增加了writerIndex由传输的字节（=数量length ）。此方法与writeBytes(ByteBuf, int, int)基本相同，不同之readerIndex于此方法将源缓冲区的readerIndex增加了传输字节数（= length ），而writeBytes(ByteBuf, int, int)不增加。
    
    参数
    
    length - 要传输的字节数
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 length大于 this.writableBytes或者 length大于 src.readableBytes
  - writeBytes
```
public abstract ByteBuf writeBytes(ByteBuf src,
                                   int srcIndex,
                                   int length)
```
    指定的源缓冲区的数据传送到该缓冲液并从当前 writerIndex并增加了 writerIndex由传输的字节（=数量 length ）。
    
    参数
    
    srcIndex - 来源的第一个索引
    
    length - 要传输的字节数
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 srcIndex小于 0 ，如果 srcIndex + length大于 src.capacity ，或者 length大于 this.writableBytes
  - writeBytes
```
public abstract ByteBuf writeBytes(byte[] src)
```
    指定的源阵列的数据传送到该缓冲液并从当前 writerIndex并增加了 writerIndex由传输的字节（=数量 src.length ）。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 src.length大于 this.writableBytes
  - writeBytes
```
public abstract ByteBuf writeBytes(byte[] src,
                                   int srcIndex,
                                   int length)
```
    指定的源阵列的数据传送到该缓冲液并从当前 writerIndex并增加了 writerIndex由传输的字节（=数量 length ）。
    
    参数
    
    srcIndex - 来源的第一个索引
    
    length - 要传输的字节数
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果指定的 srcIndex小于 0 ，如果 srcIndex + length大于 src.length ，或者 length大于 this.writableBytes
  - writeBytes
```
public abstract ByteBuf writeBytes(java.nio.ByteBuffer src)
```
    将指定源缓冲区的数据从当前 writerIndex开始传送到此缓冲区，直到源缓冲区的位置达到其限制，并将传送的字节数增加 writerIndex 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 src.remaining()大于 this.writableBytes
  - writeBytes
```
public abstract int writeBytes(java.io.InputStream in,
                               int length)
                        throws java.io.IOException
```
    将指定流的内容从当前 writerIndex开始传输到此缓冲区，并将传输字节数增加 writerIndex 。
    
    参数
    
    length - 要传输的字节数
    
    结果
    
    从指定的流中读入的实际字节数
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 length大于 this.writableBytes
    
    java.io.IOException - 如果指定的流在I / O期间抛出异常
  - writeBytes
```
public abstract int writeBytes(java.nio.channels.ScatteringByteChannel in,
                               int length)
                        throws java.io.IOException
```
    将指定通道的内容从当前 writerIndex开始传送到此缓冲区，并将传送的字节数增加 writerIndex 。
    
    参数
    
    length - 传输的最大字节数
    
    结果
    
    从指定通道读入的实际字节数
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 length大于 this.writableBytes
    
    java.io.IOException - 如果指定的通道在I / O期间引发异常
  - writeBytes
```
public abstract int writeBytes(java.nio.channels.FileChannel in,
                               long position,
                               int length)
                        throws java.io.IOException
```
    将从给定文件位置开始的指定通道的内容传输到此缓冲区，从当前writerIndex开始，并将传输字节数增加writerIndex 。此方法不会修改频道的位置。
    
    参数
    
    position - 传输开始的文件位置
    
    length - 传输的最大字节数
    
    结果
    
    从指定通道读入的实际字节数
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 length大于 this.writableBytes
    
    java.io.IOException - 如果指定的通道在I / O期间引发异常
  - writeZero
```
public abstract ByteBuf writeZero(int length)
```
    填充这个缓冲器与 NUL (0x00)并从当前 writerIndex并增加了 writerIndex由指定的 length 。
    
    参数
    
    length - 写入缓冲区的数量为 NUL
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 length大于 this.writableBytes
  - writeCharSequence
```
public abstract int writeCharSequence(java.lang.CharSequence sequence,
                                      java.nio.charset.Charset charset)
```
    将指定CharSequence在当前writerIndex并增加了writerIndex由写入的字节。在这个缓冲区中。
    
    参数
    
    sequence - 写
    
    charset - 应该使用
    
    结果
    
    写入的字节数
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 this.writableBytes不足以写入整个序列
  - indexOf
```
public abstract int indexOf(int fromIndex,
                            int toIndex,
                            byte value)
```
    定位此缓冲区中第一次出现的指定value 。搜索从指定的fromIndex （含）到指定的toIndex （ toIndex ）。
    如果fromIndex大于toIndex ，则搜索按相反顺序执行。
    
    此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    结果
    
    如果找到第一个出现的绝对索引。否则为-1 。
  - bytesBefore
```
public abstract int bytesBefore(byte value)
```
    定位此缓冲区中第一次出现的指定value 。搜索从当前readerIndex （含）到当前writerIndex （ writerIndex ）。
    此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    结果
    
    当前readerIndex与第一个匹配项之间的字节数（如果找到）。否则为-1 。
  - bytesBefore
```
public abstract int bytesBefore(int length,
                                byte value)
```
    在此缓冲区中找到指定value的第一个匹配项。搜索从当前readerIndex （含）开始并持续指定的length 。
    此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    结果
    
    当前readerIndex与第一个匹配项之间的字节数（如果找到）。否则为-1 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 length大于 this.readableBytes
  - bytesBefore
```
public abstract int bytesBefore(int index,
                                int length,
                                byte value)
```
    定位此缓冲区中第一次出现的指定value 。搜索从指定的index （含）开始并持续指定的length 。
    此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    结果
    
    指定的index与第一个匹配项之间的字节数（如果找到）。否则为-1 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 index + length大于 this.capacity
  - forEachByte
```
public abstract int forEachByte(ByteProcessor processor)
```
    使用指定的 processor按升序对此缓冲区的可读字节进行迭代。
    
    结果
    
    -1如果处理器迭代到或超出可读字节的末尾。最后访问的索引如果ByteProcessor.process(byte)返回false 。
  - forEachByte
```
public abstract int forEachByte(int index,
                                int length,
                                ByteProcessor processor)
```
    以指定的processor按升序对此缓冲区的指定区域进行迭代。（即index ， (index + 1) ，.. (index + length - 1) ）
    
    结果
    
    -1如果处理器迭代到或超出指定区域的末尾。上次访问的索引如果ByteProcessor.process(byte)返回false 。
  - forEachByteDesc
```
public abstract int forEachByteDesc(ByteProcessor processor)
```
    使用指定的 processor按降序对此缓冲区的可读字节进行迭代。
    
    结果
    
    -1如果处理器迭代到或超出可读字节的开始位置。最后访问的索引如果ByteProcessor.process(byte)返回false 。
  - forEachByteDesc
```
public abstract int forEachByteDesc(int index,
                                    int length,
                                    ByteProcessor processor)
```
    以指定的processor降序遍历此缓冲区的指定区域。（即(index + length - 1) ， (index + length - 2) ，... index ）
    
    结果
    
    -1如果处理器迭代到或超出指定区域的开始位置。上次访问的索引如果ByteProcessor.process(byte)返回false 。
  - copy
```
public abstract ByteBuf copy()
```
    返回此缓冲区可读字节的副本。修改返回的缓冲区或缓冲区的内容完全不会相互影响。该方法与buf.copy(buf.readerIndex(), buf.readableBytes())相同。此方法不会修改此缓冲区的readerIndex或writerIndex 。
  - copy
```
public abstract ByteBuf copy(int index,
                             int length)
```
    返回此缓冲区的子区域的副本。修改返回的缓冲区或缓冲区的内容完全不会相互影响。此方法不会修改此缓冲区的readerIndex或writerIndex 。
  - slice
```
public abstract ByteBuf slice()
```
    返回此缓冲区可读字节的一部分。修改返回的缓冲区或缓冲区的内容会影响彼此的内容，同时维护单独的索引和标记。该方法与buf.slice(buf.readerIndex(), buf.readableBytes())相同。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    另外请注意，此方法不会调用retain() ，因此引用计数不会增加。
  - retainedSlice
```
public abstract ByteBuf retainedSlice()
```
    返回此缓冲区可读字节的保留片段。修改返回的缓冲区或缓冲区的内容会影响彼此的内容，同时维护单独的索引和标记。此方法与buf.slice(buf.readerIndex(), buf.readableBytes())相同。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    请注意，与slice()不同，此方法返回retained缓冲区。此方法的行为与slice().retain()类似， slice().retain()在于此方法可能会返回一个生成较少垃圾的缓冲区实现。
  - slice
```
public abstract ByteBuf slice(int index,
                              int length)
```
    返回此缓冲区的子区域的一部分。修改返回的缓冲区或缓冲区的内容会影响彼此的内容，同时维护单独的索引和标记。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    另外请注意，此方法不会调用retain() ，因此引用计数不会增加。
  - retainedSlice
```
public abstract ByteBuf retainedSlice(int index,
                                      int length)
```
    返回此缓冲区的子区域的保留切片。修改返回的缓冲区或缓冲区的内容会影响彼此的内容，同时维护单独的索引和标记。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    请注意，与slice(int, int)不同，此方法返回retained缓冲区。此方法的行为与slice(...).retain()类似，只是此方法可能会返回一个生成较少垃圾的缓冲区实现。
  - duplicate
```
public abstract ByteBuf duplicate()
```
    返回共享此缓冲区整个区域的缓冲区。修改返回的缓冲区或缓冲区的内容会影响彼此的内容，同时维护单独的索引和标记。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    读者和作家的标记不会重复。另外请注意，此方法不会调用retain() ，因此引用计数不会增加。
    
    结果
    
    其可读内容等同于由slice()返回的缓冲区的缓冲区。然而，这个缓冲区将共享底层缓冲区的容量，因此如果需要的话允许访问所有的底层内容。
  - retainedDuplicate
```
public abstract ByteBuf retainedDuplicate()
```
    返回共享此缓冲区整个区域的保留缓冲区。修改返回的缓冲区或缓冲区的内容会影响彼此的内容，同时维护单独的索引和标记。该方法与buf.slice(0, buf.capacity())完全相同。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    请注意，与slice(int, int)不同，此方法返回retained缓冲区。此方法的行为与duplicate().retain()类似， duplicate().retain()在于此方法可能会返回一个生成较少垃圾的缓冲区实现。
  - nioBufferCount
```
public abstract int nioBufferCount()
```
    返回构成此缓冲区的NIO ByteBuffer的最大数量。请注意， nioBuffers()或nioBuffers(int, int)可能会返回更少数量的ByteBuffer 。
    
    结果
    
    -1如果此缓冲区没有基础ByteBuffer 。如果此缓冲区至少有一个基础ByteBuffer ，则基础ByteBuffer的ByteBuffer 。请注意，此方法不返回0以避免混淆。
    
    另请参见：
    
    nioBuffer() ， nioBuffer(int, int) ， nioBuffers() ， nioBuffers(int, int)
  - nioBuffer
```
public abstract java.nio.ByteBuffer nioBuffer()
```
    以NIO ByteBuffer公开此缓冲区的可读字节。返回的缓冲区共享或包含此缓冲区的复制内容，同时更改返回的NIO缓冲区的位置和限制不会影响此缓冲区的索引和标记。该方法与buf.nioBuffer(buf.readerIndex(), buf.readableBytes())相同。此方法不会修改此缓冲区的readerIndex或writerIndex 。请注意，如果此缓冲区是动态缓冲区并且它调整了其容量，则返回的NIO缓冲区将不会看到此缓冲区的更改。
    
    异常
    
    java.lang.UnsupportedOperationException - 如果此缓冲区无法创建与自身共享内容的 ByteBuffer
    
    另请参见：
    
    nioBufferCount() ， nioBuffers() ， nioBuffers(int, int)
  - nioBuffer
```
public abstract java.nio.ByteBuffer nioBuffer(int index,
                                              int length)
```
    将此缓冲区的子区域公开为NIO ByteBuffer 。返回的缓冲区共享或包含此缓冲区的复制内容，同时更改返回的NIO缓冲区的位置和限制不会影响此缓冲区的索引和标记。此方法不会修改此缓冲区的readerIndex或writerIndex 。请注意，如果此缓冲区是动态缓冲区并且它调整了其容量，则返回的NIO缓冲区将不会看到此缓冲区的更改。
    
    异常
    
    java.lang.UnsupportedOperationException - 如果此缓冲区无法创建与自己共享内容的 ByteBuffer
    
    另请参见：
    
    nioBufferCount() ， nioBuffers() ， nioBuffers(int, int)
  - internalNioBuffer
```
public abstract java.nio.ByteBuffer internalNioBuffer(int index,
                                                      int length)
```
    仅内部使用：公开内部NIO缓冲区。
  - nioBuffers
```
public abstract java.nio.ByteBuffer[] nioBuffers()
```
    以NIO ByteBuffer的形式公开此缓冲区的可读字节。返回的缓冲区共享或包含此缓冲区的复制内容，同时更改返回的NIO缓冲区的位置和限制不会影响此缓冲区的索引和标记。此方法不会修改此缓冲区的readerIndex或writerIndex 。请注意，如果此缓冲区是动态缓冲区并且它调整了其容量，则返回的NIO缓冲区将不会看到此缓冲区的更改。
    
    异常
    
    java.lang.UnsupportedOperationException - 如果此缓冲区无法创建与自己共享内容的 ByteBuffer
    
    另请参见：
    
    nioBufferCount() ， nioBuffer() ， nioBuffer(int, int)
  - nioBuffers
```
public abstract java.nio.ByteBuffer[] nioBuffers(int index,
                                                 int length)
```
    以指定的索引和长度公开此缓冲区的字节为NIO ByteBuffer返回的缓冲区共享或包含此缓冲区的复制内容，同时更改返回的NIO缓冲区的位置和限制不会影响此索引和标记缓冲。此方法不会修改此缓冲区的readerIndex或writerIndex 。请注意，如果此缓冲区是动态缓冲区并且它调整了其容量，则返回的NIO缓冲区将不会看到此缓冲区的更改。
    
    异常
    
    java.lang.UnsupportedOperationException - 如果此缓冲区无法创建与自身共享内容的 ByteBuffer
    
    另请参见：
    
    nioBufferCount() ， nioBuffer() ， nioBuffer(int, int)
  - hasArray
```
public abstract boolean hasArray()
```
    当且仅当此缓冲区有一个后备字节数组时，才返回true 。如果此方法返回true，则可以放心地呼叫array()和arrayOffset() 。
  - array
```
public abstract byte[] array()
```
    返回此缓冲区的后备字节数组。
    
    异常
    
    java.lang.UnsupportedOperationException - 如果没有可访问的备份字节数组
  - arrayOffset
```
public abstract int arrayOffset()
```
    返回此缓冲区的后备字节数组中第一个字节的偏移量。
    
    异常
    
    java.lang.UnsupportedOperationException - 如果没有可访问的备份字节数组
  - hasMemoryAddress
```
public abstract boolean hasMemoryAddress()
```
    当且仅当此缓冲区引用指向后备数据的低级内存地址时才返回 true 。
  - memoryAddress
```
public abstract long memoryAddress()
```
    返回指向备份数据第一个字节的低级内存地址。
    
    异常
    
    java.lang.UnsupportedOperationException - 如果此缓冲区不支持访问低级内存地址
  - toString
```
public abstract java.lang.String toString(java.nio.charset.Charset charset)
```
    将此缓冲区的可读字节解码为具有指定字符集名称的字符串。该方法与buf.toString(buf.readerIndex(), buf.readableBytes(), charsetName)相同。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    异常
    
    java.nio.charset.UnsupportedCharsetException - 如果指定的字符集名称不被当前VM支持
  - toString
```
public abstract java.lang.String toString(int index,
                                          int length,
                                          java.nio.charset.Charset charset)
```
    将此缓冲区的子区域解码为具有指定字符集的字符串。此方法不会修改此缓冲区的readerIndex或writerIndex 。
  - hashCode
```
public abstract int hashCode()
```
    返回从此缓冲区的内容计算出来的哈希码。如果有一个字节数组是equal to这个数组，那么两个数组都应该返回相同的值。
    
    重写：
    
    hashCode在类 java.lang.Object
  - equals
```
public abstract boolean equals(java.lang.Object obj)
```
    确定指定缓冲区的内容是否与此数组的内容相同。这里的“相同”意思是：
    - 两个缓冲区内容的大小是相同的
    - 两个缓冲区内容的每个字节都是相同的。
    请注意，它不会比较readerIndex()和writerIndex() 。此方法还会为null返回false ，并返回一个不是ByteBuf类型实例的对象。
    重写：
    
    equals在类 java.lang.Object
  - compareTo
```
public abstract int compareTo(ByteBuf buffer)
```
    将指定缓冲区的内容与此缓冲区的内容进行比较。比较在与各种语言如的字符串比较功能相同的方式进行strcmp ， memcmp和String.compareTo(String) 。
    
    Specified by:
    
    compareTo接口 java.lang.Comparable<ByteBuf>
  - toString
```
public abstract java.lang.String toString()
```
    返回此缓冲区的字符串表示形式。这种方法不一定返回缓冲区的全部内容，但返回的主要性能如值readerIndex() ， writerIndex()和capacity() 。
    
    重写：
    
    toString在类 java.lang.Object
  - retain
```
public abstract ByteBuf retain(int increment)
```
    从接口ReferenceCounted复制的描述
    
    将参考计数增加 increment 。
    
    Specified by:
    
    retain接口 ReferenceCounted
  - retain
```
public abstract ByteBuf retain()
```
    从接口ReferenceCounted复制的描述
    
    将引用计数增加 1 。
    
    Specified by:
    
    retain在界面 ReferenceCounted
  - touch
```
public abstract ByteBuf touch()
```
    从接口ReferenceCounted复制的描述
    
    记录此对象的当前访问位置以进行调试。如果确定此物体泄漏，则通过此操作记录的信息将通过ResourceLeakDetector提供给您。此方法是touch(null)的快捷方式。
    
    Specified by:
    
    touch在界面 ReferenceCounted
  - touch
```
public abstract ByteBuf touch(java.lang.Object hint)
```
    从接口ReferenceCounted复制的描述
    
    记录此对象的当前访问位置，并附加一些用于调试的任意信息。如果确定此物体泄漏，则通过此操作记录的信息将通过ResourceLeakDetector提供给您。
    
    Specified by:
    
    touch接口 ReferenceCounted

Class ByteBuf

创建一个缓冲区

随机访问索引

顺序访问索引

可读字节数（实际内容）

可写字节

可丢弃的字节

清除缓冲区索引

搜索操作

标记并重置

派生缓冲区

非保留和保留的派生缓冲区

转换为现有的JDK类型

字节数组

NIO缓冲区

字符串

I / O流

构造方法摘要

方法摘要

Methods inherited from class java.lang.Object

Methods inherited from interface io.netty.util.ReferenceCounted

构造方法详细信息

ByteBuf

方法详细信息

capacity

capacity

maxCapacity

alloc

order

order

unwrap

isDirect

isReadOnly

asReadOnly

readerIndex

readerIndex

writerIndex

writerIndex

setIndex

readableBytes

writableBytes

maxWritableBytes

isReadable

isReadable

isWritable

isWritable

clear

markReaderIndex

resetReaderIndex

markWriterIndex

resetWriterIndex

discardReadBytes

discardSomeReadBytes

ensureWritable

ensureWritable

getBoolean

getByte

getUnsignedByte

getShort

getShortLE

getUnsignedShort

getUnsignedShortLE

getMedium

getMediumLE

getUnsignedMedium

getUnsignedMediumLE

getInt

getIntLE

getUnsignedInt

getUnsignedIntLE

getLong

getLongLE

getChar

getFloat

getFloatLE

getDouble

getDoubleLE

getBytes

getBytes

getBytes