AbstractByteBuf (Netty API Reference (4.1.22.Final))

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

All Implemented Interfaces:

ReferenceCounted ，java.lang.Comparable < ByteBuf >

已知直接子类：

AbstractDerivedByteBuf ， AbstractReferenceCountedByteBuf
```
public abstract class AbstractByteBuf
extends ByteBuf
```
缓冲区的骨架实现。

构造方法摘要

构造方法
Modifier	Constructor and Description
`protected`	`AbstractByteBuf(int maxCapacity)`

方法摘要

所有方法接口方法抽象方法具体的方法
Modifier and Type	Method and Description
`protected abstract byte`	`_getByte(int index)`
`protected abstract int`	`_getInt(int index)`
`protected abstract int`	`_getIntLE(int index)`
`protected abstract long`	`_getLong(int index)`
`protected abstract long`	`_getLongLE(int index)`
`protected abstract short`	`_getShort(int index)`
`protected abstract short`	`_getShortLE(int index)`
`protected abstract int`	`_getUnsignedMedium(int index)`
`protected abstract int`	`_getUnsignedMediumLE(int index)`
`protected abstract void`	`_setByte(int index, int value)`
`protected abstract void`	`_setInt(int index, int value)`
`protected abstract void`	`_setIntLE(int index, int value)`
`protected abstract void`	`_setLong(int index, long value)`
`protected abstract void`	`_setLongLE(int index, long value)`
`protected abstract void`	`_setMedium(int index, int value)`
`protected abstract void`	`_setMediumLE(int index, int value)`
`protected abstract void`	`_setShort(int index, int value)`
`protected abstract void`	`_setShortLE(int index, int value)`
`protected void`	`adjustMarkers(int decrement)`
`ByteBuf`	`asReadOnly()` 返回此缓冲区的只读版本。
`int`	`bytesBefore(byte value)` 定位此缓冲区中第一次出现的指定 `value` 。
`int`	`bytesBefore(int length, byte value)` 定位该缓冲区中第一次出现的指定 `value` 。
`int`	`bytesBefore(int index, int length, byte value)` 定位此缓冲区中第一次出现的指定 `value` 。
`protected void`	`checkDstIndex(int index, int length, int dstIndex, int dstCapacity)`
`protected void`	`checkIndex(int index)`
`protected void`	`checkIndex(int index, int fieldLength)`
`protected void`	`checkNewCapacity(int newCapacity)`
`protected void`	`checkReadableBytes(int minimumReadableBytes)` 如果此缓冲区的当前 readable bytes小于指定值，则抛出 `IndexOutOfBoundsException` 。
`protected void`	`checkSrcIndex(int index, int length, int srcIndex, int srcCapacity)`
`ByteBuf`	`clear()` 将此缓冲区的 `readerIndex`和 `writerIndex`设置为 `0` 。
`int`	`compareTo(ByteBuf that)` 将指定缓冲区的内容与此缓冲区的内容进行比较。
`ByteBuf`	`copy()` 返回此缓冲区可读字节的副本。
`ByteBuf`	`discardReadBytes()` 丢弃第0个索引和 `readerIndex`之间的字节。
`ByteBuf`	`discardSomeReadBytes()` 类似于 `ByteBuf.discardReadBytes()`，只是此方法可能会丢弃部分，全部或者全部读取字节，具体取决于其内部实现方式，以减少潜在的额外内存消耗为代价来降低整体内存带宽消耗。
`ByteBuf`	`duplicate()` 返回共享此缓冲区整个区域的缓冲区。
`protected void`	`ensureAccessible()` 应该被尝试访问缓冲区内容的每种方法调用，以检查缓冲区是否在之前被释放。
`ByteBuf`	`ensureWritable(int minWritableBytes)` 确保 the writable bytes的数量等于或大于指定值。
`int`	`ensureWritable(int minWritableBytes, boolean force)` 尝试确保 the writable bytes的数量等于或大于指定的值。
`boolean`	`equals(java.lang.Object o)` 确定指定缓冲区的内容是否与此数组的内容相同。
`int`	`forEachByte(ByteProcessor processor)` 以指定的 `processor`按升序对此缓冲区的可读字节进行迭代。
`int`	`forEachByte(int index, int length, ByteProcessor processor)` 以指定的 `processor`按升序对此缓冲区的指定区域进行迭代。
`int`	`forEachByteDesc(ByteProcessor processor)` 使用指定的 `processor`按降序对此缓冲区的可读字节进行迭代。
`int`	`forEachByteDesc(int index, int length, ByteProcessor processor)` 以指定的 `processor`以降序遍历此缓冲区的指定区域。
`boolean`	`getBoolean(int index)` 在此缓冲区中获取指定绝对（@code索引）的布尔值。
`byte`	`getByte(int index)` 在此缓冲区中的指定绝对 `index`处获取一个字节。
`ByteBuf`	`getBytes(int index, byte[] dst)` 将此缓冲区的数据传送到指定的目标，从指定的绝对 `index` 。
`ByteBuf`	`getBytes(int index, ByteBuf dst)` 将此缓冲区的数据传输到指定的目标，从指定的绝对 `index`开始，直到目标变为不可写。
`ByteBuf`	`getBytes(int index, ByteBuf dst, int length)` 将此缓冲区的数据传输到指定的绝对目标 `index`开始的目标。
`char`	`getChar(int index)` 在此缓冲区的指定绝对 `index`处获取一个2字节的UTF-16字符。
`java.lang.CharSequence`	`getCharSequence(int index, int length, java.nio.charset.Charset charset)` 在给定索引处获得具有给定长度的 `CharSequence` 。
`double`	`getDouble(int index)` 在此缓冲区中的指定绝对 `index`处获取一个64位浮点数。
`float`	`getFloat(int index)` 在此缓冲区中指定的绝对 `index`处获取一个32位浮点数。
`int`	`getInt(int index)` 在此缓冲区中的指定绝对 `index`处获取一个32位整数。
`int`	`getIntLE(int index)` 在具有Little Endian Byte Order的缓冲区中的指定绝对 `index`处获取一个32位整数。
`long`	`getLong(int index)` 在此缓冲区中指定的绝对 `index`处获取64位长整数。
`long`	`getLongLE(int index)` 以小端字节顺序在此缓冲区中的指定绝对 `index`处获取64位长整数。
`int`	`getMedium(int index)` 在此缓冲区中指定的绝对 `index`处获取一个24位中等整数。
`int`	`getMediumLE(int index)` 以Little Endian字节顺序在此缓冲区中的指定绝对 `index`处获取一个24位中等整数。
`short`	`getShort(int index)` 在此缓冲区中指定的绝对 `index`处获取一个16位短整数。
`short`	`getShortLE(int index)` 以小端字节顺序在此缓冲区中的指定绝对 `index`处获取一个16位短整数。
`short`	`getUnsignedByte(int index)` 在此缓冲区中的指定绝对 `index`处获取一个无符号字节。
`long`	`getUnsignedInt(int index)` 在此缓冲区中指定的绝对 `index`处获取一个无符号的32位整数。
`long`	`getUnsignedIntLE(int index)` 以小 `index`字节顺序在此缓冲区中的指定绝对 `index`处获取无符号的32位整数。
`int`	`getUnsignedMedium(int index)` 在此缓冲区中指定的绝对 `index`处获取一个无符号的24位中等整数。
`int`	`getUnsignedMediumLE(int index)` 以小端字节顺序在此缓冲区中的指定绝对 `index`处获取无符号的24位中等整数。
`int`	`getUnsignedShort(int index)` 在此缓冲区中指定的绝对 `index`处获取一个无符号的16位短整数。
`int`	`getUnsignedShortLE(int index)` 以小端字节顺序在此缓冲区中的指定绝对 `index`处获取一个无符号的16位短整数。
`int`	`hashCode()` 返回从此缓冲区的内容计算出来的哈希码。
`int`	`indexOf(int fromIndex, int toIndex, byte value)` 在此缓冲区中找到指定 `value`的第一个匹配项。
`boolean`	`isReadable()` 当且仅当 `(this.writerIndex - this.readerIndex)`大于 `true`时，返回 `0` 。
`boolean`	`isReadable(int numBytes)` 当且仅当此缓冲区包含等于或多于指定数量的元素时返回 `true` 。
`boolean`	`isReadOnly()` 当且仅当此缓冲区为只读时返回 `true` 。
`boolean`	`isWritable()` 返回 `true`当且仅当 `(this.capacity - this.writerIndex)`大于 `0` 。
`boolean`	`isWritable(int numBytes)` 当且仅当此缓冲区有足够空间允许写入指定数量的元素时返回 `true` 。
`ByteBuf`	`markReaderIndex()` 在此缓冲区中标记当前的 `readerIndex` 。
`ByteBuf`	`markWriterIndex()` 在此缓冲区中标记当前的 `writerIndex` 。
`int`	`maxCapacity()` 返回此缓冲区允许的最大容量。
`protected void`	`maxCapacity(int maxCapacity)`
`int`	`maxWritableBytes()` 返回可写入的最大字节数，等于 `(this.maxCapacity - this.writerIndex)` 。
`protected SwappedByteBuf`	`newSwappedByteBuf()` 为此`ByteBuf`实例创建一个新的`SwappedByteBuf` 。
`java.nio.ByteBuffer`	`nioBuffer()` 以NIO `ByteBuffer`公开此缓冲区的可读字节。
`java.nio.ByteBuffer[]`	`nioBuffers()` 以NIO `ByteBuffer`的形式公开此缓冲区的可读字节。
`ByteBuf`	`order(java.nio.ByteOrder endianness)` 返回指定 `endianness`的缓冲区，该缓冲区共享此缓冲区的整个区域，索引和标记。
`int`	`readableBytes()` 返回等于 `(this.writerIndex - this.readerIndex)`的可读字节数。
`boolean`	`readBoolean()` 在当前 `readerIndex`处获取一个布尔值，并在此缓冲区 `readerIndex` `1`增加 `readerIndex` 。
`byte`	`readByte()` 获取当前 `readerIndex`一个字节，并在此缓冲区 `readerIndex` `1`增加 `readerIndex` 。
`ByteBuf`	`readBytes(byte[] dst)` 将此缓冲区的数据传输到指定的目标，从当前的 `readerIndex`开始，并将 `readerIndex`增加 `readerIndex`所传输的字节数（= `dst.length` ）。
`ByteBuf`	`readBytes(byte[] dst, int dstIndex, int length)` 传输此缓冲区的数据到指定的目标并从当前 `readerIndex`并增加了 `readerIndex`由传输的字节（=数量 `length` ）。
`ByteBuf`	`readBytes(ByteBuf dst)` 将此缓冲区的数据传输到从当前 `readerIndex`开始的指定目标，直到目标变为不可写入，并将传输字节数增加 `readerIndex` 。
`ByteBuf`	`readBytes(java.nio.ByteBuffer dst)` 将此缓冲区的数据传输到从当前 `readerIndex`开始的指定目标，直到目标的位置达到其限制，并将 `readerIndex`增加 `readerIndex`所传输的字节数。
`ByteBuf`	`readBytes(ByteBuf dst, int length)` 传输此缓冲区的数据到指定的目标并从当前 `readerIndex`并增加了 `readerIndex`由传输的字节（=数量 `length` ）。
`ByteBuf`	`readBytes(ByteBuf dst, int dstIndex, int length)` 传输此缓冲区的数据到指定的目标并从当前 `readerIndex`并增加了 `readerIndex`由传输的字节（=数量 `length` ）。
`int`	`readBytes(java.nio.channels.FileChannel out, long position, int length)` 将此缓冲区的数据从当前的 `readerIndex`到指定的通道，从给定的文件位置开始。
`int`	`readBytes(java.nio.channels.GatheringByteChannel out, int length)` 将此缓冲区的数据传输到当前 `readerIndex`开始的指定流。
`ByteBuf`	`readBytes(int length)` 传输此缓冲区的数据到一个新创建的缓冲器并从当前 `readerIndex`并增加了 `readerIndex`由传输的字节（=数量 `length` ）。
`ByteBuf`	`readBytes(java.io.OutputStream out, int length)` 将此缓冲区的数据传输到当前 `readerIndex`开始的指定流。
`char`	`readChar()` 在当前的 `readerIndex`处获取一个2字节的UTF-16字符，并在此缓冲区 `readerIndex` `2`增加 `readerIndex` 。
`java.lang.CharSequence`	`readCharSequence(int length, java.nio.charset.Charset charset)` 在当前 `readerIndex`处获得具有给定长度的 `CharSequence` ，并将给定长度增加 `readerIndex` 。
`double`	`readDouble()` 在当前的 `readerIndex`处获取64位浮点数，并在此缓冲区 `readerIndex` `8`增加 `readerIndex` 。
`int`	`readerIndex()` 返回此缓冲区的 `readerIndex` 。
`ByteBuf`	`readerIndex(int readerIndex)` 设置此缓冲区的 `readerIndex` 。
`float`	`readFloat()` 在当前的 `readerIndex`处获取一个32位浮点数， `4`此缓冲区中的 `readerIndex`增加 `readerIndex` 。
`int`	`readInt()` 在当前的 `readerIndex`处获得32位整数，并在此缓冲区 `readerIndex` `4`增加 `readerIndex` 。
`int`	`readIntLE()` 获取当前的32位整数 `readerIndex`在Little Endian字节序，并增加了 `readerIndex`通过 `4`在该缓冲液。
`long`	`readLong()` 在当前 `readerIndex`处获取64位整数，并在此缓冲区 `readerIndex` `8`增加 `readerIndex` 。
`long`	`readLongLE()` 在当前 `readerIndex`中以Little Endian字节顺序获取一个64位整数，并在此缓冲区 `readerIndex` `8`增加 `readerIndex` 。
`int`	`readMedium()` 在当前 `readerIndex`处获取24位中等整数，并在此缓冲区 `readerIndex` `3`增加 `readerIndex` 。
`int`	`readMediumLE()` 在当前 `readerIndex`以Little Endian字节顺序获取24位中等整数，并在此缓冲区 `readerIndex` `3`增加 `readerIndex` 。
`ByteBuf`	`readRetainedSlice(int length)` 返回此缓冲区的子区域并从当前的一个新的保留切片 `readerIndex`并增加了 `readerIndex`由新的切片（=大小 `length` ）。
`short`	`readShort()` 在当前 `readerIndex`处获取16位短整数，并在此缓冲区 `readerIndex` `2`增加 `readerIndex` 。
`short`	`readShortLE()` 在当前 `readerIndex`以Little Endian字节顺序获取一个16位短整数，并在此缓冲区 `readerIndex` `2`增加 `readerIndex` 。
`ByteBuf`	`readSlice(int length)` 返回此缓冲区的子区域并从当前的新的片 `readerIndex`并增加了 `readerIndex`由新的切片（=大小 `length` ）。
`short`	`readUnsignedByte()` 获取当前无符号字节 `readerIndex`并增加了 `readerIndex`通过 `1`在该缓冲液。
`long`	`readUnsignedInt()` 在当前的 `readerIndex`处获取一个无符号的32位整数，并在此缓冲区 `readerIndex` `4`增加 `readerIndex` 。
`long`	`readUnsignedIntLE()` 获取当前无符号的32位整数 `readerIndex`在Little Endian字节序，并增加了 `readerIndex`通过 `4`在该缓冲液。
`int`	`readUnsignedMedium()` 在当前 `readerIndex`处获取一个无符号的24位中等整数，并在此缓冲区 `readerIndex` `3`增加 `readerIndex` 。
`int`	`readUnsignedMediumLE()` 获取当前 `readerIndex`中Little Endian字节顺序的无符号24位中等整数，并在此缓冲区 `readerIndex` `3`增加 `readerIndex` 。
`int`	`readUnsignedShort()` 获取当前的16位无符号短整型 `readerIndex`并增加了 `readerIndex`通过 `2`在该缓冲液。
`int`	`readUnsignedShortLE()` 获取当前的16位无符号短整型 `readerIndex`在Little Endian字节序，并增加了 `readerIndex`通过 `2`在缓冲区中。
`ByteBuf`	`resetReaderIndex()` 将当前 `readerIndex`重新定位到此缓冲区中标记为 `readerIndex` 。
`ByteBuf`	`resetWriterIndex()` 将当前 `writerIndex`重新定位到此缓冲区中标记为 `writerIndex` 。
`ByteBuf`	`retainedDuplicate()` 返回共享此缓冲区整个区域的保留缓冲区。
`ByteBuf`	`retainedSlice()` 返回此缓冲区可读字节的保留片段。
`ByteBuf`	`retainedSlice(int index, int length)` 返回此缓冲区的子区域的保留切片。
`ByteBuf`	`setBoolean(int index, boolean value)` 在此缓冲区中的指定绝对 `index`处设置指定的布尔值。
`ByteBuf`	`setByte(int index, int value)` 在此缓冲区中的指定绝对 `index`处设置指定的字节。
`ByteBuf`	`setBytes(int index, byte[] src)` 将指定的源数组的数据传输到此缓冲区，从指定的绝对 `index` 。
`ByteBuf`	`setBytes(int index, ByteBuf src)` 将指定的源缓冲区的数据从指定的绝对 `index`开始传输到此缓冲区，直到源缓冲区变得不可读。
`ByteBuf`	`setBytes(int index, ByteBuf src, int length)` 将指定的源缓冲区的数据从指定的绝对 `index`开始传输到此缓冲区。
`ByteBuf`	`setChar(int index, int value)` 在此缓冲区的指定绝对 `index`处设置指定的2字节UTF-16字符。
`int`	`setCharSequence(int index, java.lang.CharSequence sequence, java.nio.charset.Charset charset)` 将指定 `CharSequence`在当前 `writerIndex`并增加了 `writerIndex`由写入的字节。
`ByteBuf`	`setDouble(int index, double value)` 在此缓冲区的指定绝对 `index`处设置指定的64位浮点数。
`ByteBuf`	`setFloat(int index, float value)` 在此缓冲区中指定的绝对 `index`处设置指定的32位浮点数。
`ByteBuf`	`setIndex(int readerIndex, int writerIndex)` `readerIndex`设置此缓冲区的 `readerIndex`和 `writerIndex` 。
`ByteBuf`	`setInt(int index, int value)` 在此缓冲区中指定的绝对 `index`处设置指定的32位整数。
`ByteBuf`	`setIntLE(int index, int value)` 使用Little Endian字节顺序在此缓冲区中的指定绝对 `index`处设置指定的32位整数。
`ByteBuf`	`setLong(int index, long value)` 在此缓冲区中的指定绝对 `index`处设置指定的64位长整数。
`ByteBuf`	`setLongLE(int index, long value)` 以小端字节顺序在此缓冲区中的指定绝对 `index`处设置指定的64位长整数。
`ByteBuf`	`setMedium(int index, int value)` 在此缓冲区中的指定绝对 `index`处设置指定的24位中等整数。
`ByteBuf`	`setMediumLE(int index, int value)` 以小端字节顺序在此缓冲区中的指定绝对 `index`处设置指定的24位中等整数。
`ByteBuf`	`setShort(int index, int value)` 在此缓冲区中的指定绝对 `index`处设置指定的16位短整数。
`ByteBuf`	`setShortLE(int index, int value)` 在此缓冲区中的指定绝对 `index`使用Little Endian字节顺序设置指定的16位短整数。
`ByteBuf`	`setZero(int index, int length)` 用 `NUL (0x00)`填充该缓冲区，以指定的绝对 `index` 。
`ByteBuf`	`skipBytes(int length)` 在此缓冲区中，按指定的 `length`增加当前 `readerIndex` 。
`ByteBuf`	`slice()` 返回此缓冲区可读字节的一部分。
`ByteBuf`	`slice(int index, int length)` 返回此缓冲区的子区域的一部分。
`java.lang.String`	`toString()` 返回此缓冲区的字符串表示形式。
`java.lang.String`	`toString(java.nio.charset.Charset charset)` 将此缓冲区的可读字节解码为具有指定字符集名称的字符串。
`java.lang.String`	`toString(int index, int length, java.nio.charset.Charset charset)` 将此缓冲区的子区域解码为具有指定字符集的字符串。
`int`	`writableBytes()` 返回等于 `(this.capacity - this.writerIndex)`的可写入字节数。
`ByteBuf`	`writeBoolean(boolean value)` 在当前 `writerIndex`处设置指定的布尔值，并在此缓冲区 `writerIndex` `1`增加 `writerIndex` 。
`ByteBuf`	`writeByte(int value)` 在当前的 `writerIndex`处设置指定的字节，并在此缓冲区 `writerIndex` `1`增加 `writerIndex` 。
`ByteBuf`	`writeBytes(byte[] src)` 指定的源阵列的数据传送到该缓冲液并从当前 `writerIndex`并增加了 `writerIndex`由传输的字节（=数量 `src.length` ）。
`ByteBuf`	`writeBytes(byte[] src, int srcIndex, int length)` 指定的源阵列的数据传送到该缓冲液并从当前 `writerIndex`并增加了 `writerIndex`由传输的字节（=数量 `length` ）。
`ByteBuf`	`writeBytes(ByteBuf src)` 将指定源缓冲区的数据从当前的 `writerIndex`开始传输到此缓冲区，直到源缓冲区变得不可读，并将传输字节数增加 `writerIndex` 。
`ByteBuf`	`writeBytes(java.nio.ByteBuffer src)` 将指定源缓冲区的数据从当前 `writerIndex`开始传输到此缓冲区，直到源缓冲区的位置达到其限制，并将传输字节数增加 `writerIndex` 。
`ByteBuf`	`writeBytes(ByteBuf src, int length)` 指定的源缓冲区的数据传送到该缓冲液并从当前 `writerIndex`并增加了 `writerIndex`由传输的字节（=数量 `length` ）。
`ByteBuf`	`writeBytes(ByteBuf src, int srcIndex, int length)` 指定的源缓冲区的数据传送到该缓冲液并从当前 `writerIndex`并增加了 `writerIndex`由传输的字节（=数量 `length` ）。
`int`	`writeBytes(java.nio.channels.FileChannel in, long position, int length)` 将从给定文件位置开始的指定通道的内容传输到此缓冲区，从当前的 `writerIndex`开始，并将 `writerIndex`增加 `writerIndex` 。
`int`	`writeBytes(java.io.InputStream in, int length)` 将指定流的内容从当前的 `writerIndex`开始传送到此缓冲区，并将传送的字节数增加到 `writerIndex` 。
`int`	`writeBytes(java.nio.channels.ScatteringByteChannel in, int length)` 将指定通道的内容从当前的 `writerIndex`开始传送到此缓冲区，并将传送的字节数增加到 `writerIndex` 。
`ByteBuf`	`writeChar(int value)` 在当前的 `writerIndex`处设置指定的2字节UTF-16字符，并在此缓冲区 `writerIndex` `2`增加 `writerIndex` 。
`int`	`writeCharSequence(java.lang.CharSequence sequence, java.nio.charset.Charset charset)` 将指定 `CharSequence`在当前 `writerIndex`并增加了 `writerIndex`由写入的字节。
`ByteBuf`	`writeDouble(double value)` 在当前 `writerIndex`处设置指定的64位浮点数，并在此缓冲区 `writerIndex` `8`增加 `writerIndex` 。
`ByteBuf`	`writeFloat(float value)` 在当前的 `writerIndex`处设置指定的32位浮点数并在此缓冲区 `writerIndex` `4`增加 `writerIndex` 。
`ByteBuf`	`writeInt(int value)` 在当前 `writerIndex`处设置指定的32位整数，并在此缓冲区 `writerIndex` `4`增加 `writerIndex` 。
`ByteBuf`	`writeIntLE(int value)` 以小端字节顺序在当前 `writerIndex`处设置指定的32位整数，并在此缓冲区 `writerIndex` `4`增加 `writerIndex` 。
`ByteBuf`	`writeLong(long value)` 在当前 `writerIndex`处设置指定的64位长整数，并在此缓冲区 `writerIndex` `8`增加 `writerIndex` 。
`ByteBuf`	`writeLongLE(long value)` 以小端字节顺序在当前 `writerIndex`处设置指定的64位长整数，并在此缓冲区 `writerIndex` `8`增加 `writerIndex` 。
`ByteBuf`	`writeMedium(int value)` 在当前的 `writerIndex`处设置指定的24位中等整数，并在此缓冲区 `writerIndex` `3`增加 `writerIndex` 。
`ByteBuf`	`writeMediumLE(int value)` 以小端字节顺序在当前 `writerIndex`中设置指定的24位中等整数，并在此缓冲区 `writerIndex` `3`增加 `writerIndex` 。
`int`	`writerIndex()` 返回此缓冲区的 `writerIndex` 。
`ByteBuf`	`writerIndex(int writerIndex)` 设置此缓冲区的 `writerIndex` 。
`ByteBuf`	`writeShort(int value)` 在当前的 `writerIndex`处设置指定的16位短整数，并在此缓冲区 `writerIndex` `2`增加 `writerIndex` 。
`ByteBuf`	`writeShortLE(int value)` 在当前 `writerIndex`处设置Little Endian Byte Order中指定的16位短整数，并在此缓冲区 `writerIndex` `2`增加 `writerIndex` 。
`ByteBuf`	`writeZero(int length)` 填充这个缓冲器与 `NUL (0x00)`并从当前 `writerIndex`并增加了 `writerIndex`由指定的 `length` 。

Methods inherited from class io.netty.buffer.ByteBuf
alloc, array, arrayOffset, capacity, capacity, copy, getBytes, getBytes, getBytes, getBytes, getBytes, getBytes, getDoubleLE, getFloatLE, hasArray, hasMemoryAddress, internalNioBuffer, isDirect, memoryAddress, nioBuffer, nioBufferCount, nioBuffers, order, readDoubleLE, readFloatLE, retain, retain, setBytes, setBytes, setBytes, setBytes, setBytes, setBytes, setDoubleLE, setFloatLE, touch, touch, unwrap, writeDoubleLE, writeFloatLE

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

- 构造方法详细信息
  - AbstractByteBuf
```
protected AbstractByteBuf(int maxCapacity)
```
- 方法详细信息
  - isReadOnly
```
public boolean isReadOnly()
```
    从类复制的描述： ByteBuf
    
    当且仅当此缓冲区为只读时才返回 true 。
    
    Specified by:
    
    isReadOnly ByteBuf
  - asReadOnly
```
public ByteBuf asReadOnly()
```
    从类复制的描述： ByteBuf
    
    返回此缓冲区的只读版本。
    
    Specified by:
    
    asReadOnly在课程 ByteBuf
  - maxCapacity
```
public int maxCapacity()
```
    从类复制的描述： ByteBuf
    
    返回此缓冲区允许的最大容量。如果用户试图使用ByteBuf.capacity(int)或ByteBuf.ensureWritable(int)将此缓冲区的容量增加到最大容量以外，那么这些方法将引发IllegalArgumentException 。
    
    Specified by:
    
    maxCapacity ByteBuf
  - maxCapacity
```
protected final void maxCapacity(int maxCapacity)
```
  - readerIndex
```
public int readerIndex()
```
    从类复制的描述： ByteBuf
    
    返回此缓冲区的 readerIndex 。
    
    Specified by:
    
    readerIndex在课程 ByteBuf
  - readerIndex
```
public ByteBuf readerIndex(int readerIndex)
```
    从类复制的描述： ByteBuf
    
    设置此缓冲区的 readerIndex 。
    
    Specified by:
    
    readerIndex的 ByteBuf
  - writerIndex
```
public int writerIndex()
```
    从类复制的描述： ByteBuf
    
    返回此缓冲区的 writerIndex 。
    
    Specified by:
    
    writerIndex ByteBuf
  - writerIndex
```
public ByteBuf writerIndex(int writerIndex)
```
    从类复制的描述： ByteBuf
    
    设置此缓冲区的 writerIndex 。
    
    Specified by:
    
    writerIndex ByteBuf
  - setIndex
```
public ByteBuf setIndex(int readerIndex,
                        int writerIndex)
```
    从类复制的描述： ByteBuf
    readerIndex设置此缓冲区的readerIndex和writerIndex 。当您不得不担心ByteBuf.readerIndex(int)和ByteBuf.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); 
```
    Specified by:
    
    setIndex类 ByteBuf
  - clear
```
public ByteBuf clear()
```
    从类复制的描述： ByteBuf
    
    将此缓冲区的readerIndex和writerIndex设置为0 。该方法与setIndex(0, 0)相同。
    请注意，此方法的行为与NIO缓冲区的行为不同，后者将limit设置为limit的capacity 。
    
    Specified by:
    
    clear ByteBuf
  - isReadable
```
public boolean isReadable()
```
    从类复制的描述： ByteBuf
    
    返回 true当且仅当 (this.writerIndex - this.readerIndex)大于 0 。
    
    Specified by:
    
    isReadable在课程 ByteBuf
  - isReadable
```
public boolean isReadable(int numBytes)
```
    从类复制的描述： ByteBuf
    
    当且仅当此缓冲区包含等于或多于指定数量的元素时才返回 true 。
    
    Specified by:
    
    isReadable在课程 ByteBuf
  - isWritable
```
public boolean isWritable()
```
    从类复制的描述： ByteBuf
    
    当且仅当 (this.capacity - this.writerIndex)大于 true时，返回 0 。
    
    Specified by:
    
    isWritable在课程 ByteBuf
  - isWritable
```
public boolean isWritable(int numBytes)
```
    从类复制的描述： ByteBuf
    
    当且仅当此缓冲区有足够空间允许写入指定数量的元素时才返回 true 。
    
    Specified by:
    
    isWritable在课堂 ByteBuf
  - readableBytes
```
public int readableBytes()
```
    从类复制的描述： ByteBuf
    
    返回等于 (this.writerIndex - this.readerIndex)的可读字节数。
    
    Specified by:
    
    readableBytes ByteBuf
  - writableBytes
```
public int writableBytes()
```
    从类复制的描述： ByteBuf
    
    返回等于 (this.capacity - this.writerIndex)的可写字节数。
    
    Specified by:
    
    writableBytes的 ByteBuf
  - maxWritableBytes
```
public int maxWritableBytes()
```
    从类复制的描述： ByteBuf
    
    返回可写入的最大字节数，等于 (this.maxCapacity - this.writerIndex) 。
    
    Specified by:
    
    maxWritableBytes ByteBuf
  - markReaderIndex
```
public ByteBuf markReaderIndex()
```
    从类复制的描述： ByteBuf
    
    在此缓冲区中标记当前的readerIndex 。您可以重新定位当前readerIndex到标记readerIndex通过调用ByteBuf.resetReaderIndex() 。标记的readerIndex的初始值是0 。
    
    Specified by:
    
    markReaderIndex在课程 ByteBuf
  - resetReaderIndex
```
public ByteBuf resetReaderIndex()
```
    从类复制的描述： ByteBuf
    
    将当前 readerIndex重新定位到此缓冲区中标记为 readerIndex 。
    
    Specified by:
    
    resetReaderIndex在课堂上 ByteBuf
  - markWriterIndex
```
public ByteBuf markWriterIndex()
```
    从类复制的描述： ByteBuf
    
    在此缓冲区中标记当前的writerIndex 。您可以重新定位当前writerIndex到标记writerIndex通过调用ByteBuf.resetWriterIndex() 。标记的初始值writerIndex是0 。
    
    Specified by:
    
    markWriterIndex在课程 ByteBuf
  - resetWriterIndex
```
public ByteBuf resetWriterIndex()
```
    从类复制的描述： ByteBuf
    
    将当前 writerIndex重新定位到此缓冲区中标记为 writerIndex 。
    
    Specified by:
    
    resetWriterIndex在课程 ByteBuf
  - discardReadBytes
```
public ByteBuf discardReadBytes()
```
    从类复制的描述： ByteBuf
    
    丢弃第0个索引和readerIndex之间的字节。它移动之间的字节readerIndex和writerIndex至第0索引，并且设置readerIndex和writerIndex至0和oldWriterIndex - oldReaderIndex分别。
    请参阅班级文件以获得更详细的解释。
    
    Specified by:
    
    discardReadBytes在课堂上 ByteBuf
  - discardSomeReadBytes
```
public ByteBuf discardSomeReadBytes()
```
    从类复制的描述： ByteBuf
    
    类似于 ByteBuf.discardReadBytes()，不同之处在于此方法可能会根据其内部实施情况丢弃部分，全部或者全部读取字节，以减少潜在的额外内存消耗为代价的整体内存带宽消耗。
    
    Specified by:
    
    discardSomeReadBytes ByteBuf
  - adjustMarkers
```
protected final void adjustMarkers(int decrement)
```
  - ensureWritable
```
public ByteBuf ensureWritable(int minWritableBytes)
```
    从类复制的描述： ByteBuf
    
    确保the writable bytes的数量等于或大于指定的值。如果此缓冲区中有足够的可写字节，则此方法返回时无副作用。否则，它会产生一个IllegalArgumentException 。
    
    Specified by:
    
    ensureWritable ByteBuf
    
    参数
    
    minWritableBytes - 可写入字节的预期最小数量
  - ensureWritable
```
public int ensureWritable(int minWritableBytes,
                          boolean force)
```
    从类复制的描述： ByteBuf
    
    尝试确保the writable bytes的数量等于或大于指定的值。与ByteBuf.ensureWritable(int)不同，此方法不引发异常但返回代码。
    Specified by:
    
    ensureWritable ，上课 ByteBuf
    
    参数
    
    minWritableBytes - 可写入字节的预期最小数量
    force - 当ByteBuf.writerIndex() + minWritableBytes > ByteBuf.maxCapacity() ：
    
    true - 缓冲区的容量扩展到ByteBuf.maxCapacity()
    
    false - 缓冲区的容量不变
    结果
    
    0如果缓冲区有足够的可写字节，并且其容量不变。 1如果缓冲区没有足够的字节，并且其容量不变。 2如果缓冲区有足够的可写字节，并且其容量已增加。 3如果缓冲区没有足够的字节，但其容量已增加到其最大值。
  - order
```
public ByteBuf order(java.nio.ByteOrder endianness)
```
    从类复制的描述： ByteBuf
    
    返回指定endianness的缓冲区，该缓冲区共享此缓冲区的整个区域，索引和标记。修改返回的缓冲区或此缓冲区的内容，索引或标记会影响彼此的内容，索引和标记。如果指定的endianness与此缓冲区的字节顺序相同，则此方法可返回this 。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    order ByteBuf
  - newSwappedByteBuf
```
protected SwappedByteBuf newSwappedByteBuf()
```
    为此ByteBuf实例创建一个新的SwappedByteBuf 。
  - getByte
```
public byte getByte(int index)
```
    从类复制的描述： ByteBuf
    
    在此缓冲区中的指定绝对index处获取一个字节。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    getByte的 ByteBuf
  - _getByte
```
protected abstract byte _getByte(int index)
```
  - getBoolean
```
public boolean getBoolean(int index)
```
    从类复制的描述： ByteBuf
    
    在此缓冲区中获取指定绝对（@code索引）的布尔值。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    getBoolean在课堂 ByteBuf
  - getUnsignedByte
```
public short getUnsignedByte(int index)
```
    从类复制的描述： ByteBuf
    
    在此缓冲区中的指定绝对index处获取无符号字节。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    getUnsignedByte ByteBuf
  - getShort
```
public short getShort(int index)
```
    从类复制的描述： ByteBuf
    
    在此缓冲区中的指定绝对index处获取一个16位短整数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    getShort在课程 ByteBuf
  - _getShort
```
protected abstract short _getShort(int index)
```
  - getShortLE
```
public short getShortLE(int index)
```
    从类复制的描述： ByteBuf
    
    以小端字节顺序在此缓冲区中的指定绝对index处获取16位短整数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    getShortLE在课程 ByteBuf
  - _getShortLE
```
protected abstract short _getShortLE(int index)
```
  - getUnsignedShort
```
public int getUnsignedShort(int index)
```
    从类复制的描述： ByteBuf
    
    在此缓冲区中指定的绝对index处获取一个无符号的16位短整数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    getUnsignedShort ByteBuf
  - getUnsignedShortLE
```
public int getUnsignedShortLE(int index)
```
    从类复制的描述： ByteBuf
    
    以Little Endian字节顺序在此缓冲区中的指定绝对index处获取一个无符号的16位短整数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    getUnsignedShortLE ByteBuf
  - getUnsignedMedium
```
public int getUnsignedMedium(int index)
```
    从类复制的描述： ByteBuf
    
    在此缓冲区中指定的绝对index处获取一个无符号的24位中等整数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    getUnsignedMedium ByteBuf
  - _getUnsignedMedium
```
protected abstract int _getUnsignedMedium(int index)
```
  - getUnsignedMediumLE
```
public int getUnsignedMediumLE(int index)
```
    从类复制的描述： ByteBuf
    
    以小端字节顺序在此缓冲区中的指定绝对index处获取无符号的24位中等整数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    getUnsignedMediumLE的 ByteBuf
  - _getUnsignedMediumLE
```
protected abstract int _getUnsignedMediumLE(int index)
```
  - getMedium
```
public int getMedium(int index)
```
    从类复制的描述： ByteBuf
    
    在此缓冲区中指定的绝对index处获取一个24位中等整数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    getMedium类 ByteBuf
  - getMediumLE
```
public int getMediumLE(int index)
```
    从类复制的描述： ByteBuf
    
    以小端字节顺序在此缓冲区中的指定绝对index处获取24位中等整数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    getMediumLE类 ByteBuf
  - getInt
```
public int getInt(int index)
```
    从类复制的描述： ByteBuf
    
    在此缓冲区中的指定绝对index处获取一个32位整数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    getInt在课堂上 ByteBuf
  - _getInt
```
protected abstract int _getInt(int index)
```
  - getIntLE
```
public int getIntLE(int index)
```
    从类复制的描述： ByteBuf
    
    在此缓冲区中的指定绝对index处获取一个32位整数，其index字节顺序。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    getIntLE ByteBuf
  - _getIntLE
```
protected abstract int _getIntLE(int index)
```
  - getUnsignedInt
```
public long getUnsignedInt(int index)
```
    从类复制的描述： ByteBuf
    
    在此缓冲区中指定的绝对index处获取一个无符号的32位整数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    getUnsignedInt ，上课 ByteBuf
  - getUnsignedIntLE
```
public long getUnsignedIntLE(int index)
```
    从类复制的描述： ByteBuf
    
    以小端字节顺序在此缓冲区中的指定绝对index处获取一个无符号的32位整数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    getUnsignedIntLE在课堂上 ByteBuf
  - getLong
```
public long getLong(int index)
```
    从类复制的描述： ByteBuf
    
    在此缓冲区中指定的绝对index处获取64位长整数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    getLong在课程 ByteBuf
  - _getLong
```
protected abstract long _getLong(int index)
```
  - getLongLE
```
public long getLongLE(int index)
```
    从类复制的描述： ByteBuf
    
    以小端字节顺序在此缓冲区中的指定绝对index处获取64位长整数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    getLongLE在课程 ByteBuf
  - _getLongLE
```
protected abstract long _getLongLE(int index)
```
  - getChar
```
public char getChar(int index)
```
    从类复制的描述： ByteBuf
    
    在此缓冲区中指定的绝对index处获取一个2字节的UTF-16字符。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    getChar在课程 ByteBuf
  - getFloat
```
public float getFloat(int index)
```
    从类复制的描述： ByteBuf
    
    在此缓冲区中的指定绝对index处获取一个32位浮点数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    getFloat在课堂 ByteBuf
  - getDouble
```
public double getDouble(int index)
```
    从类复制的描述： ByteBuf
    
    在此缓冲区中的指定绝对index处获取一个64位浮点数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    getDouble在课程 ByteBuf
  - getBytes
```
public ByteBuf getBytes(int index,
                        byte[] dst)
```
    从类复制的描述： ByteBuf
    
    将此缓冲区的数据传输到指定的目标，从指定的绝对index 。此方法不会修改此缓冲区的readerIndex或writerIndex
    
    Specified by:
    
    getBytes在课堂 ByteBuf
  - getBytes
```
public ByteBuf getBytes(int index,
                        ByteBuf dst)
```
    从类复制的描述： ByteBuf
    
    将此缓冲区的数据传输到指定的目标位置，从指定的绝对index开始index直到目标位置变为不可写入。该方法与ByteBuf.getBytes(int, ByteBuf, int, int)基本相同，不同之writerIndex于此方法通过传输字节数增加目标的writerIndex ，而ByteBuf.getBytes(int, ByteBuf, int, int)则不增加。此方法不会修改源缓冲区的readerIndex或writerIndex （即this ）。
    
    Specified by:
    
    getBytes在课程 ByteBuf
  - getBytes
```
public ByteBuf getBytes(int index,
                        ByteBuf dst,
                        int length)
```
    从类复制的描述： ByteBuf
    
    将此缓冲区的数据传输到指定的目标，从指定的绝对index 。此方法与ByteBuf.getBytes(int, ByteBuf, int, int)基本相同，不同之writerIndex于此方法通过传输字节数增加目标的writerIndex ，而ByteBuf.getBytes(int, ByteBuf, int, int)则不增加。此方法不会修改源缓冲区的readerIndex或writerIndex （即this ）。
    
    Specified by:
    
    getBytes在课堂 ByteBuf
    
    length - 要传输的字节数
  - getCharSequence
```
public java.lang.CharSequence getCharSequence(int index,
                                              int length,
                                              java.nio.charset.Charset charset)
```
    从类复制的描述： ByteBuf
    
    在给定索引处获得具有给定长度的 CharSequence 。
    
    Specified by:
    
    getCharSequence在课程 ByteBuf
    
    length - 阅读的长度
    
    charset - 应该使用
    
    结果
    
    序列
  - readCharSequence
```
public java.lang.CharSequence readCharSequence(int length,
                                               java.nio.charset.Charset charset)
```
    从类复制的描述： ByteBuf
    
    在当前 readerIndex处获得给定长度的 CharSequence ，并将给定长度增加 readerIndex 。
    
    Specified by:
    
    readCharSequence的 ByteBuf
    
    参数
    
    length - 要读取的长度
    
    charset - 应该使用
    
    结果
    
    序列
  - setByte
```
public ByteBuf setByte(int index,
                       int value)
```
    从类复制的描述： ByteBuf
    
    在此缓冲区中的指定绝对index处设置指定的字节。指定值的24个高位被忽略。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    setByte ByteBuf
  - _setByte
```
protected abstract void _setByte(int index,
                                 int value)
```
  - setBoolean
```
public ByteBuf setBoolean(int index,
                          boolean value)
```
    从类复制的描述： ByteBuf
    
    在此缓冲区中的指定绝对index处设置指定的布尔值。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    setBoolean类 ByteBuf
  - setShort
```
public ByteBuf setShort(int index,
                        int value)
```
    从类复制的描述： ByteBuf
    
    在此缓冲区中的指定绝对index处设置指定的16位短整数。指定值的16个高位被忽略。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    setShort在课程 ByteBuf
  - _setShort
```
protected abstract void _setShort(int index,
                                  int value)
```
  - setShortLE
```
public ByteBuf setShortLE(int index,
                          int value)
```
    从类复制的描述： ByteBuf
    
    在此缓冲区的指定绝对index处设置指定的16位短整数，并使用Little Endian Byte Order。指定值的16个高位被忽略。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    setShortLE在课堂上 ByteBuf
  - _setShortLE
```
protected abstract void _setShortLE(int index,
                                    int value)
```
  - setChar
```
public ByteBuf setChar(int index,
                       int value)
```
    从类复制的描述： ByteBuf
    
    在此缓冲区的指定绝对index处设置指定的2字节UTF-16字符。指定值的16个高位被忽略。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    setChar在类 ByteBuf
  - setMedium
```
public ByteBuf setMedium(int index,
                         int value)
```
    从类复制的描述： ByteBuf
    
    在此缓冲区中的指定绝对index处设置指定的24位中等整数。请注意，最高有效字节在指定值中被忽略。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    setMedium在课程 ByteBuf
  - _setMedium
```
protected abstract void _setMedium(int index,
                                   int value)
```
  - setMediumLE
```
public ByteBuf setMediumLE(int index,
                           int value)
```
    从类复制的描述： ByteBuf
    
    以Little Endian字节顺序在此缓冲区中的指定绝对index处设置指定的24位中等整数。请注意，最高有效字节在指定值中被忽略。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    setMediumLE在课堂 ByteBuf
  - _setMediumLE
```
protected abstract void _setMediumLE(int index,
                                     int value)
```
  - setInt
```
public ByteBuf setInt(int index,
                      int value)
```
    从类复制的描述： ByteBuf
    
    在此缓冲区中指定的绝对index处设置指定的32位整数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    setInt在课程 ByteBuf
  - _setInt
```
protected abstract void _setInt(int index,
                                int value)
```
  - setIntLE
```
public ByteBuf setIntLE(int index,
                        int value)
```
    从类复制的描述： ByteBuf
    
    以小端字节顺序在此缓冲区中的指定绝对index处设置指定的32位整数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    setIntLE的 ByteBuf
  - _setIntLE
```
protected abstract void _setIntLE(int index,
                                  int value)
```
  - setFloat
```
public ByteBuf setFloat(int index,
                        float value)
```
    从类复制的描述： ByteBuf
    
    在此缓冲区中指定的绝对index处设置指定的32位浮点数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    setFloat ByteBuf
  - setLong
```
public ByteBuf setLong(int index,
                       long value)
```
    从类复制的描述： ByteBuf
    
    在此缓冲区中的指定绝对index处设置指定的64位长整数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    setLong ByteBuf
  - _setLong
```
protected abstract void _setLong(int index,
                                 long value)
```
  - setLongLE
```
public ByteBuf setLongLE(int index,
                         long value)
```
    从类复制的描述： ByteBuf
    
    以小端字节顺序在此缓冲区中的指定绝对index处设置指定的64位长整数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    setLongLE在课程 ByteBuf
  - _setLongLE
```
protected abstract void _setLongLE(int index,
                                   long value)
```
  - setDouble
```
public ByteBuf setDouble(int index,
                         double value)
```
    从类复制的描述： ByteBuf
    
    在此缓冲区中指定的绝对index处设置指定的64位浮点数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    setDouble ByteBuf
  - setBytes
```
public ByteBuf setBytes(int index,
                        byte[] src)
```
    从类复制的描述： ByteBuf
    
    将指定的源数组的数据传输到此缓冲区，从指定的绝对index 。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    setBytes ByteBuf
  - setBytes
```
public ByteBuf setBytes(int index,
                        ByteBuf src)
```
    从类复制的描述： ByteBuf
    
    将指定的源缓冲区的数据从指定的绝对index开始传输到此缓冲区，直到源缓冲区变得不可读。此方法与ByteBuf.setBytes(int, ByteBuf, int, int)基本相同，不同之readerIndex于此方法将源缓冲区的readerIndex增加了传输字节数，而ByteBuf.setBytes(int, ByteBuf, int, int)则不增加。此方法不会修改源缓冲区的readerIndex或writerIndex （即this ）。
    
    Specified by:
    
    setBytes ByteBuf
  - setBytes
```
public ByteBuf setBytes(int index,
                        ByteBuf src,
                        int length)
```
    从类复制的描述： ByteBuf
    
    将指定的源缓冲区数据传输到此缓冲区，从指定的绝对index 。此方法与ByteBuf.setBytes(int, ByteBuf, int, int)基本相同，不同之readerIndex于此方法将源缓冲区的readerIndex增加了传输字节数，而ByteBuf.setBytes(int, ByteBuf, int, int)则不增加。此方法不会修改源缓冲区的readerIndex或writerIndex （即this ）。
    
    Specified by:
    
    setBytes ByteBuf
    
    length - 要传输的字节数
  - setZero
```
public ByteBuf setZero(int index,
                       int length)
```
    从类复制的描述： ByteBuf
    
    NUL (0x00)从指定的绝对index开始填充此缓冲区。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    setZero ByteBuf
    
    length - 要写入缓冲区的数量 NUL
  - setCharSequence
```
public int setCharSequence(int index,
                           java.lang.CharSequence sequence,
                           java.nio.charset.Charset charset)
```
    从类复制的描述： ByteBuf
    
    将指定 CharSequence在当前 writerIndex并增加了 writerIndex由写入的字节。
    
    Specified by:
    
    setCharSequence ，上课 ByteBuf
    
    参数
    
    index - 应在其上写入序列
    
    sequence - 写
    
    charset - 应该使用。
    
    结果
    
    写入的字节数。
  - readByte
```
public byte readByte()
```
    从类复制的描述： ByteBuf
    
    在当前 readerIndex处获取一个字节，并在此缓冲区 readerIndex 1增加 readerIndex 。
    
    Specified by:
    
    readByte的 ByteBuf
  - readBoolean
```
public boolean readBoolean()
```
    从类复制的描述： ByteBuf
    
    获取当前 readerIndex的布尔值，并在此缓冲区 readerIndex 1增加 readerIndex 。
    
    Specified by:
    
    readBoolean ，上课 ByteBuf
  - readUnsignedByte
```
public short readUnsignedByte()
```
    从类复制的描述： ByteBuf
    
    获取当前 readerIndex的无符号字节，并在此缓冲区 readerIndex 1增加 readerIndex 。
    
    Specified by:
    
    readUnsignedByte ByteBuf
  - readShort
```
public short readShort()
```
    从类复制的描述： ByteBuf
    
    获取当前16位短整数 readerIndex并增加了 readerIndex通过 2在该缓冲液。
    
    Specified by:
    
    readShort ByteBuf
  - readShortLE
```
public short readShortLE()
```
    从类复制的描述： ByteBuf
    
    获取当前16位的短整型 readerIndex在Little Endian字节序，并增加了 readerIndex通过 2在缓冲区中。
    
    Specified by:
    
    readShortLE在课堂 ByteBuf
  - readUnsignedShort
```
public int readUnsignedShort()
```
    从类复制的描述： ByteBuf
    
    获取当前的16位无符号短整型 readerIndex并增加了 readerIndex通过 2在该缓冲液。
    
    Specified by:
    
    readUnsignedShort在课程 ByteBuf
  - readUnsignedShortLE
```
public int readUnsignedShortLE()
```
    从类复制的描述： ByteBuf
    
    获取当前的16位无符号短整型 readerIndex在Little Endian字节序，并增加了 readerIndex通过 2在缓冲区中。
    
    Specified by:
    
    readUnsignedShortLE ByteBuf
  - readMedium
```
public int readMedium()
```
    从类复制的描述： ByteBuf
    
    在当前 readerIndex处获取24位中等整数，并在此缓冲区 readerIndex 3增加 readerIndex 。
    
    Specified by:
    
    readMedium在课堂 ByteBuf
  - readMediumLE
```
public int readMediumLE()
```
    从类复制的描述： ByteBuf
    
    在当前 readerIndex以Little Endian字节顺序获取一个24位中等整数，并在此缓冲区 readerIndex 3增加 readerIndex 。
    
    Specified by:
    
    readMediumLE在课堂 ByteBuf
  - readUnsignedMedium
```
public int readUnsignedMedium()
```
    从类复制的描述： ByteBuf
    
    在当前 readerIndex处获取一个无符号的24位中等整数，并在此缓冲区 readerIndex 3增加 readerIndex 。
    
    Specified by:
    
    readUnsignedMedium在课程 ByteBuf
  - readUnsignedMediumLE
```
public int readUnsignedMediumLE()
```
    从类复制的描述： ByteBuf
    
    在当前 readerIndex中以Little Endian Byte顺序获取一个无符号的24位中等整数，并在此缓冲区 readerIndex 3增加 readerIndex 。
    
    Specified by:
    
    readUnsignedMediumLE ByteBuf
  - readInt
```
public int readInt()
```
    从类复制的描述： ByteBuf
    
    获取当前的32位整数 readerIndex并增加了 readerIndex通过 4在该缓冲液。
    
    Specified by:
    
    readInt的 ByteBuf
  - readIntLE
```
public int readIntLE()
```
    从类复制的描述： ByteBuf
    
    获取当前的32位整数 readerIndex在Little Endian字节序，并增加了 readerIndex通过 4在该缓冲液。
    
    Specified by:
    
    readIntLE在课程 ByteBuf
  - readUnsignedInt
```
public long readUnsignedInt()
```
    从类复制的描述： ByteBuf
    
    在当前 readerIndex处获取一个无符号的32位整数，并在此缓冲区 readerIndex 4增加 readerIndex 。
    
    Specified by:
    
    readUnsignedInt的 ByteBuf
  - readUnsignedIntLE
```
public long readUnsignedIntLE()
```
    从类复制的描述： ByteBuf
    
    在当前 readerIndex以Little Endian字节顺序获取一个无符号的32位整数，并在此缓冲区 readerIndex 4增加 readerIndex 。
    
    Specified by:
    
    readUnsignedIntLE ，课时 ByteBuf
  - readLong
```
public long readLong()
```
    从类复制的描述： ByteBuf
    
    在当前 readerIndex处获取64位整数，并在此缓冲区 readerIndex 8增加 readerIndex 。
    
    Specified by:
    
    readLong的 ByteBuf
  - readLongLE
```
public long readLongLE()
```
    从类复制的描述： ByteBuf
    
    获取当前64位整数 readerIndex在Little Endian字节序，并增加了 readerIndex通过 8在该缓冲液。
    
    Specified by:
    
    readLongLE ByteBuf
  - readChar
```
public char readChar()
```
    从类复制的描述： ByteBuf
    
    获取当前的2字节的UTF-16字符 readerIndex并增加了 readerIndex通过 2在该缓冲液。
    
    Specified by:
    
    readChar的 ByteBuf
  - readFloat
```
public float readFloat()
```
    从类复制的描述： ByteBuf
    
    在当前的 readerIndex处获得一个32位浮点数，并在此缓冲区 readerIndex 4增加 readerIndex 。
    
    Specified by:
    
    readFloat ByteBuf
  - readDouble
```
public double readDouble()
```
    从类复制的描述： ByteBuf
    
    在当前 readerIndex处获取一个64位浮点数，并在此缓冲区 readerIndex 8增加 readerIndex 。
    
    Specified by:
    
    readDouble在课堂 ByteBuf
  - readBytes
```
public ByteBuf readBytes(int length)
```
    从类复制的描述： ByteBuf
    
    传输此缓冲区的数据到一个新创建的缓冲器并从当前readerIndex并增加了readerIndex由传输的字节（=数量length ）。返回缓冲区的readerIndex和writerIndex是0和length分别。
    
    Specified by:
    
    readBytes在课程 ByteBuf
    
    参数
    
    length - 要传输的字节数
    
    结果
    
    新创建的包含传输字节的缓冲区
  - readSlice
```
public ByteBuf readSlice(int length)
```
    从类复制的描述： ByteBuf
    
    从当前的readerIndex开始返回此缓冲区子区域的一个新切片，并将该readerIndex的大小增加readerIndex （= length ）。
    另外请注意，此方法不会调用ByteBuf.retain() ，因此引用计数不会增加。
    
    Specified by:
    
    readSlice ByteBuf
    
    参数
    
    length - 新切片的大小
    
    结果
    
    新创建的切片
  - readRetainedSlice
```
public ByteBuf readRetainedSlice(int length)
```
    从类复制的描述： ByteBuf
    
    返回此缓冲区的子区域并从当前的一个新的保留切片readerIndex并增加了readerIndex由新的切片（=大小length ）。
    请注意，与ByteBuf.readSlice(int)不同，此方法返回retained缓冲区。此方法的行为与readSlice(...).retain()类似，只不过此方法可能会返回一个生成较少垃圾的缓冲区实现。
    
    Specified by:
    
    readRetainedSlice在课堂上 ByteBuf
    
    参数
    
    length - 新切片的大小
    
    结果
    
    新创建的切片
  - readBytes
```
public ByteBuf readBytes(byte[] dst,
                         int dstIndex,
                         int length)
```
    从类复制的描述： ByteBuf
    
    传输此缓冲区的数据到指定的目标并从当前 readerIndex并增加了 readerIndex由传输的字节（=数量 length ）。
    
    Specified by:
    
    readBytes的 ByteBuf
    
    dstIndex - 目的地的第一个索引
    
    length - 要传输的字节数
  - readBytes
```
public ByteBuf readBytes(byte[] dst)
```
    从类复制的描述： ByteBuf
    
    传输此缓冲区的数据到指定的目标并从当前 readerIndex并增加了 readerIndex由传输的字节（=数量 dst.length ）。
    
    Specified by:
    
    readBytes ByteBuf
  - readBytes
```
public ByteBuf readBytes(ByteBuf dst)
```
    从类复制的描述： ByteBuf
    
    将此缓冲区的数据传输到指定的目标，从当前的readerIndex开始，直到目标变为不可写，并将传输字节数增加readerIndex 。此方法与ByteBuf.readBytes(ByteBuf, int, int)基本相同，不同之writerIndex于此方法通过传输字节数增加目标的writerIndex ，而ByteBuf.readBytes(ByteBuf, int, int)则不增加。
    
    Specified by:
    
    readBytes在课堂 ByteBuf
  - readBytes
```
public ByteBuf readBytes(ByteBuf dst,
                         int length)
```
    从类复制的描述： ByteBuf
    
    传输此缓冲区的数据到指定的目标并从当前readerIndex并增加了readerIndex由传输的字节（=数量length ）。此方法与ByteBuf.readBytes(ByteBuf, int, int)基本相同，不同之writerIndex于此方法通过传输的字节数（= length ）增加目标的writerIndex ，而ByteBuf.readBytes(ByteBuf, int, int)则不增加。
    
    Specified by:
    
    readBytes ByteBuf
  - readBytes
```
public ByteBuf readBytes(ByteBuf dst,
                         int dstIndex,
                         int length)
```
    从类复制的描述： ByteBuf
    
    传输此缓冲区的数据到指定的目标并从当前 readerIndex并增加了 readerIndex由传输的字节（=数量 length ）。
    
    Specified by:
    
    readBytes在课程 ByteBuf
    
    dstIndex - 目的地的第一个索引
    
    length - 要传输的字节数
  - readBytes
```
public ByteBuf readBytes(java.nio.ByteBuffer dst)
```
    从类复制的描述： ByteBuf
    
    将此缓冲区的数据传输到从当前 readerIndex开始的指定目标，直到目标的位置达到其限制，并将 readerIndex增加 readerIndex传输的字节数。
    
    Specified by:
    
    readBytes在课程 ByteBuf
  - readBytes
```
public int readBytes(java.nio.channels.GatheringByteChannel out,
                     int length)
              throws java.io.IOException
```
    从类复制的描述： ByteBuf
    
    将此缓冲区的数据传输到当前 readerIndex开始的指定流。
    
    Specified by:
    
    readBytes在课程 ByteBuf
    
    length - 传输的最大字节数
    
    结果
    
    写出到指定通道的实际字节数
    
    异常
    
    java.io.IOException - 如果指定的通道在I / O期间引发异常
  - readBytes
```
public int readBytes(java.nio.channels.FileChannel out,
                     long position,
                     int length)
              throws java.io.IOException
```
    从类复制的描述： ByteBuf
    
    将此缓冲区的数据从当前的readerIndex到指定通道，从给定的文件位置开始。此方法不会修改频道的位置。
    
    Specified by:
    
    readBytes在课堂 ByteBuf
    
    position - 传输开始的文件位置
    
    length - 传输的最大字节数
    
    结果
    
    写出到指定通道的实际字节数
    
    异常
    
    java.io.IOException - 如果指定的通道在I / O期间引发异常
  - readBytes
```
public ByteBuf readBytes(java.io.OutputStream out,
                         int length)
                  throws java.io.IOException
```
    从类复制的描述： ByteBuf
    
    将此缓冲区的数据传输到当前 readerIndex开始的指定流。
    
    Specified by:
    
    readBytes在课程 ByteBuf
    
    length - 要传输的字节数
    
    异常
    
    java.io.IOException - 如果指定的流在I / O期间抛出异常
  - skipBytes
```
public ByteBuf skipBytes(int length)
```
    从类复制的描述： ByteBuf
    
    通过此缓冲区中指定的 length增加当前 readerIndex 。
    
    Specified by:
    
    skipBytes在课程 ByteBuf
  - writeBoolean
```
public ByteBuf writeBoolean(boolean value)
```
    从类复制的描述： ByteBuf
    
    在当前的 writerIndex处设置指定的布尔值，并在此缓冲区 writerIndex 1增加 writerIndex 。
    
    Specified by:
    
    writeBoolean在课堂 ByteBuf
  - writeByte
```
public ByteBuf writeByte(int value)
```
    从类复制的描述： ByteBuf
    
    在当前的writerIndex处设置指定的字节，并在此缓冲区writerIndex 1增加writerIndex 。指定值的24个高位被忽略。
    
    Specified by:
    
    writeByte在课程 ByteBuf
  - writeShort
```
public ByteBuf writeShort(int value)
```
    从类复制的描述： ByteBuf
    
    在当前的writerIndex处设置指定的16位短整数，并在此缓冲区writerIndex 2增加writerIndex 。指定值的16个高位被忽略。
    
    Specified by:
    
    writeShort在课程 ByteBuf
  - writeShortLE
```
public ByteBuf writeShortLE(int value)
```
    从类复制的描述： ByteBuf
    
    在当前writerIndex处设置Little Endian Byte Order中指定的16位短整数，并在此缓冲区writerIndex 2增加writerIndex 。指定值的16个高位被忽略。
    
    Specified by:
    
    writeShortLE的 ByteBuf
  - writeMedium
```
public ByteBuf writeMedium(int value)
```
    从类复制的描述： ByteBuf
    
    在当前的 writerIndex中设置指定的24位中等整数，并在此缓冲区 writerIndex 3增加 writerIndex 。
    
    Specified by:
    
    writeMedium在课堂 ByteBuf
  - writeMediumLE
```
public ByteBuf writeMediumLE(int value)
```
    从类复制的描述： ByteBuf
    
    以小端字节顺序在当前 writerIndex处设置指定的24位中等整数，并在此缓冲区 writerIndex 3增加 writerIndex 。
    
    Specified by:
    
    writeMediumLE在课程 ByteBuf
  - writeInt
```
public ByteBuf writeInt(int value)
```
    从类复制的描述： ByteBuf
    
    在当前 writerIndex处设置指定的32位整数，并在此缓冲区 writerIndex 4增加 writerIndex 。
    
    Specified by:
    
    writeInt的 ByteBuf
  - writeIntLE
```
public ByteBuf writeIntLE(int value)
```
    从类复制的描述： ByteBuf
    
    以小端字节顺序在当前 writerIndex处设置指定的32位整数，并在此缓冲区 writerIndex 4增加 writerIndex 。
    
    Specified by:
    
    writeIntLE在 ByteBuf
  - writeLong
```
public ByteBuf writeLong(long value)
```
    从类复制的描述： ByteBuf
    
    在当前的 writerIndex处设置指定的64位长整数，并在此缓冲区 writerIndex 8增加 writerIndex 。
    
    Specified by:
    
    writeLong在课程 ByteBuf
  - writeLongLE
```
public ByteBuf writeLongLE(long value)
```
    从类复制的描述： ByteBuf
    
    以小端字节顺序在当前 writerIndex处设置指定的64位长整数，并在此缓冲区 writerIndex 8增加 writerIndex 。
    
    Specified by:
    
    writeLongLE ByteBuf
  - writeChar
```
public ByteBuf writeChar(int value)
```
    从类复制的描述： ByteBuf
    
    在当前writerIndex处设置指定的2字节UTF-16字符，并在此缓冲区writerIndex 2增加writerIndex 。指定值的16个高位被忽略。
    
    Specified by:
    
    writeChar在课程 ByteBuf
  - writeFloat
```
public ByteBuf writeFloat(float value)
```
    从类复制的描述： ByteBuf
    
    在当前的 writerIndex处设置指定的32位浮点数，并在此缓冲区 writerIndex 4增加 writerIndex 。
    
    Specified by:
    
    writeFloat ByteBuf
  - writeDouble
```
public ByteBuf writeDouble(double value)
```
    从类复制的描述： ByteBuf
    
    在当前的 writerIndex处设置指定的64位浮点数，并在此缓冲区 writerIndex 8增加 writerIndex 。
    
    Specified by:
    
    writeDouble在课堂 ByteBuf
  - writeBytes
```
public ByteBuf writeBytes(byte[] src,
                          int srcIndex,
                          int length)
```
    从类复制的描述： ByteBuf
    
    指定的源阵列的数据传送到该缓冲液并从当前 writerIndex并增加了 writerIndex由传输的字节（=数量 length ）。
    
    Specified by:
    
    writeBytes的 ByteBuf
    
    srcIndex - 来源的第一个索引
    
    length - 要传输的字节数
  - writeBytes
```
public ByteBuf writeBytes(byte[] src)
```
    从类复制的描述： ByteBuf
    
    指定的源阵列的数据传送到该缓冲液并从当前 writerIndex并增加了 writerIndex由传输的字节（=数量 src.length ）。
    
    Specified by:
    
    writeBytes在课堂上 ByteBuf
  - writeBytes
```
public ByteBuf writeBytes(ByteBuf src)
```
    从类复制的描述： ByteBuf
    
    将指定源缓冲区的数据从当前的writerIndex开始传输到此缓冲区，直到源缓冲区变得不可读，并将传输字节数增加writerIndex 。该方法与ByteBuf.writeBytes(ByteBuf, int, int)基本相同，不同之readerIndex于此方法将源缓冲区的readerIndex增加了传输字节数，而ByteBuf.writeBytes(ByteBuf, int, int)则不增加。
    
    Specified by:
    
    writeBytes在课堂上 ByteBuf
  - writeBytes
```
public ByteBuf writeBytes(ByteBuf src,
                          int length)
```
    从类复制的描述： ByteBuf
    
    指定的源缓冲区的数据传送到该缓冲液并从当前writerIndex并增加了writerIndex由传输的字节（=数量length ）。此方法与ByteBuf.writeBytes(ByteBuf, int, int)基本相同，不同之readerIndex于此方法将源缓冲区的readerIndex增加了传输字节数（= length ），而ByteBuf.writeBytes(ByteBuf, int, int)则不增加。
    
    Specified by:
    
    writeBytes在课堂 ByteBuf
    
    length - 要传输的字节数
  - writeBytes
```
public ByteBuf writeBytes(ByteBuf src,
                          int srcIndex,
                          int length)
```
    从类复制的描述： ByteBuf
    
    指定的源缓冲区的数据传送到该缓冲液并从当前 writerIndex并增加了 writerIndex由传输的字节（=数量 length ）。
    
    Specified by:
    
    writeBytes类 ByteBuf
    
    srcIndex - 来源的第一个索引
    
    length - 要传输的字节数
  - writeBytes
```
public ByteBuf writeBytes(java.nio.ByteBuffer src)
```
    从类复制的描述： ByteBuf
    
    将指定源缓冲区的数据从当前的 writerIndex开始传输到此缓冲区，直到源缓冲区的位置达到其限制，并将传输字节数增加 writerIndex 。
    
    Specified by:
    
    writeBytes ByteBuf
  - writeBytes
```
public int writeBytes(java.io.InputStream in,
                      int length)
               throws java.io.IOException
```
    从类复制的描述： ByteBuf
    
    将指定流的内容从当前 writerIndex开始传送到此缓冲区，并将传送的字节数增加到 writerIndex 。
    
    Specified by:
    
    writeBytes的 ByteBuf
    
    length - 要传输的字节数
    
    结果
    
    从指定的流中读入的实际字节数
    
    异常
    
    java.io.IOException - 如果指定的流在I / O期间抛出异常
  - writeBytes
```
public int writeBytes(java.nio.channels.ScatteringByteChannel in,
                      int length)
               throws java.io.IOException
```
    从类复制的描述： ByteBuf
    
    将指定通道的内容从当前 writerIndex开始传送到此缓冲区，并将传送的字节数增加到 writerIndex 。
    
    Specified by:
    
    writeBytes ByteBuf
    
    length - 传输的最大字节数
    
    结果
    
    从指定通道读入的实际字节数
    
    异常
    
    java.io.IOException - 如果指定的通道在I / O期间引发异常
  - writeBytes
```
public int writeBytes(java.nio.channels.FileChannel in,
                      long position,
                      int length)
               throws java.io.IOException
```
    从类复制的描述： ByteBuf
    
    将从给定文件位置开始的指定通道的内容传输到此缓冲区，从当前的writerIndex开始，并将writerIndex增加writerIndex 。此方法不会修改频道的位置。
    
    Specified by:
    
    writeBytes类 ByteBuf
    
    position - 传输开始的文件位置
    
    length - 传输的最大字节数
    
    结果
    
    从指定通道读入的实际字节数
    
    异常
    
    java.io.IOException - 如果指定的通道在I / O期间引发异常
  - writeZero
```
public ByteBuf writeZero(int length)
```
    从类复制的描述： ByteBuf
    
    填充这个缓冲器与 NUL (0x00)并从当前 writerIndex并增加了 writerIndex由指定的 length 。
    
    Specified by:
    
    writeZero ，上课 ByteBuf
    
    参数
    
    length - 要写入缓冲区的 NUL的数量
  - writeCharSequence
```
public int writeCharSequence(java.lang.CharSequence sequence,
                             java.nio.charset.Charset charset)
```
    从类复制的描述： ByteBuf
    
    将指定CharSequence在当前writerIndex并增加了writerIndex由写入的字节。在这个缓冲区中。
    
    Specified by:
    
    writeCharSequence在课程 ByteBuf
    
    参数
    
    sequence - 写
    
    charset - 应该使用
    
    结果
    
    写入的字节数
  - copy
```
public ByteBuf copy()
```
    从类复制的描述： ByteBuf
    
    返回此缓冲区可读字节的副本。修改返回的缓冲区或缓冲区的内容完全不会相互影响。该方法与buf.copy(buf.readerIndex(), buf.readableBytes())相同。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    copy的 ByteBuf
  - duplicate
```
public ByteBuf duplicate()
```
    从类复制的描述： ByteBuf
    
    返回共享此缓冲区整个区域的缓冲区。修改返回的缓冲区或缓冲区的内容会影响彼此的内容，同时维护单独的索引和标记。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    读者和作家的标记不会重复。另外请注意，此方法不会调用ByteBuf.retain() ，因此引用计数不会增加。
    
    Specified by:
    
    duplicate在课堂上 ByteBuf
    
    结果
    
    其可读内容等同于ByteBuf.slice()返回的缓冲区的缓冲区。然而，这个缓冲区将共享底层缓冲区的容量，因此如果需要的话允许访问所有的底层内容。
  - retainedDuplicate
```
public ByteBuf retainedDuplicate()
```
    从类复制的描述： ByteBuf
    
    返回共享此缓冲区整个区域的保留缓冲区。修改返回的缓冲区或缓冲区的内容会影响彼此的内容，同时维护单独的索引和标记。此方法与buf.slice(0, buf.capacity())相同。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    请注意，与ByteBuf.slice(int, int)不同，此方法返回retained缓冲区。此方法的行为与duplicate().retain()类似，只是此方法可能会返回一个生成较少垃圾的缓冲区实现。
    
    Specified by:
    
    retainedDuplicate在课程 ByteBuf
  - slice
```
public ByteBuf slice()
```
    从类复制的描述： ByteBuf
    
    返回此缓冲区可读字节的一部分。修改返回的缓冲区或缓冲区的内容会影响彼此的内容，同时维护单独的索引和标记。该方法与buf.slice(buf.readerIndex(), buf.readableBytes())相同。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    另外请注意，此方法不会调用ByteBuf.retain() ，因此引用计数不会增加。
    
    Specified by:
    
    slice在课程 ByteBuf
  - retainedSlice
```
public ByteBuf retainedSlice()
```
    从类复制的描述： ByteBuf
    
    返回此缓冲区可读字节的保留片段。修改返回的缓冲区或缓冲区的内容会影响彼此的内容，同时维护单独的索引和标记。该方法与buf.slice(buf.readerIndex(), buf.readableBytes())相同。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    请注意，与ByteBuf.slice()不同，此方法返回retained缓冲区。此方法的行为与slice().retain()类似，只是此方法可能会返回一个生成较少垃圾的缓冲区实现。
    
    Specified by:
    
    retainedSlice ByteBuf
  - slice
```
public ByteBuf slice(int index,
                     int length)
```
    从类复制的描述： ByteBuf
    
    返回此缓冲区的子区域的一部分。修改返回的缓冲区或缓冲区的内容会影响彼此的内容，同时维护单独的索引和标记。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    另外请注意，此方法不会调用ByteBuf.retain() ，因此引用计数不会增加。
    
    Specified by:
    
    slice在课堂 ByteBuf
  - retainedSlice
```
public ByteBuf retainedSlice(int index,
                             int length)
```
    从类复制的描述： ByteBuf
    
    返回此缓冲区的子区域的保留切片。修改返回的缓冲区或缓冲区的内容会影响彼此的内容，同时维护单独的索引和标记。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    请注意，与ByteBuf.slice(int, int)不同，此方法返回retained缓冲区。此方法的行为与slice(...).retain()类似，只不过此方法可能会返回一个生成较少垃圾的缓冲区实现。
    
    Specified by:
    
    retainedSlice在课堂 ByteBuf
  - nioBuffer
```
public java.nio.ByteBuffer nioBuffer()
```
    从类复制的描述： ByteBuf
    
    将此缓冲区的可读字节作为NIO ByteBuffer 。返回的缓冲区共享或包含此缓冲区的复制内容，同时更改返回的NIO缓冲区的位置和限制不会影响此缓冲区的索引和标记。该方法与buf.nioBuffer(buf.readerIndex(), buf.readableBytes())相同。此方法不会修改此缓冲区的readerIndex或writerIndex 。请注意，如果此缓冲区是动态缓冲区并且它调整了其容量，则返回的NIO缓冲区将不会看到此缓冲区的更改。
    
    Specified by:
    
    nioBuffer ByteBuf
    
    另请参见：
    
    ByteBuf.nioBufferCount() ， ByteBuf.nioBuffers() ， ByteBuf.nioBuffers(int, int)
  - nioBuffers
```
public java.nio.ByteBuffer[] nioBuffers()
```
    从类复制的描述： ByteBuf
    
    以NIO ByteBuffer的形式公开此缓冲区的可读字节。返回的缓冲区共享或包含此缓冲区的复制内容，同时更改返回的NIO缓冲区的位置和限制不会影响此缓冲区的索引和标记。此方法不会修改此缓冲区的readerIndex或writerIndex 。请注意，如果此缓冲区是动态缓冲区并且它调整了其容量，则返回的NIO缓冲区将不会看到此缓冲区的更改。
    
    Specified by:
    
    nioBuffers在课程 ByteBuf
    
    另请参见：
    
    ByteBuf.nioBufferCount() ， ByteBuf.nioBuffer() ， ByteBuf.nioBuffer(int, int)
  - toString
```
public java.lang.String toString(java.nio.charset.Charset charset)
```
    从类复制的描述： ByteBuf
    
    将此缓冲区的可读字节解码为具有指定字符集名称的字符串。该方法与buf.toString(buf.readerIndex(), buf.readableBytes(), charsetName)相同。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    toString ByteBuf
  - toString
```
public java.lang.String toString(int index,
                                 int length,
                                 java.nio.charset.Charset charset)
```
    从类复制的描述： ByteBuf
    
    将此缓冲区的子区域解码为具有指定字符集的字符串。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    toString ByteBuf
  - indexOf
```
public int indexOf(int fromIndex,
                   int toIndex,
                   byte value)
```
    从类复制的描述： ByteBuf
    
    定位此缓冲区中第一次出现的指定value 。搜索从指定的fromIndex （含）到指定的toIndex （ toIndex ）。
    如果fromIndex大于toIndex ，则搜索按相反顺序执行。
    
    此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    indexOf在课堂 ByteBuf
    
    结果
    
    如果找到第一个出现的绝对索引。 -1否则。
  - bytesBefore
```
public int bytesBefore(byte value)
```
    从类复制的描述： ByteBuf
    
    定位此缓冲区中第一次出现的指定value 。搜索从当前的readerIndex （含）至当前的writerIndex （ writerIndex ）。
    此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    bytesBefore在课程 ByteBuf
    
    结果
    
    当前readerIndex与第一个匹配项之间的字节数（如果找到）。 -1否则。
  - bytesBefore
```
public int bytesBefore(int length,
                       byte value)
```
    从类复制的描述： ByteBuf
    
    定位此缓冲区中第一次出现的指定value 。搜索从当前的readerIndex （含）开始并持续指定的length 。
    此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    bytesBefore ByteBuf
    
    结果
    
    当前readerIndex与第一个匹配项之间的字节数（如果找到）。 -1否则。
  - bytesBefore
```
public int bytesBefore(int index,
                       int length,
                       byte value)
```
    从类复制的描述： ByteBuf
    
    定位此缓冲区中第一次出现的指定value 。搜索从指定的index （含）开始并持续指定的length 。
    此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    bytesBefore在课程 ByteBuf
    
    结果
    
    指定的index与第一个匹配项之间的字节数（如果找到）。否则-1 。
  - forEachByte
```
public int forEachByte(ByteProcessor processor)
```
    从类复制的描述： ByteBuf
    
    使用指定的 processor按升序对此缓冲区的可读字节进行迭代。
    
    Specified by:
    
    forEachByte ByteBuf
    
    结果
    
    -1如果处理器迭代到或超出可读字节的末尾。上次访问的索引如果ByteProcessor.process(byte)返回false 。
  - forEachByte
```
public int forEachByte(int index,
                       int length,
                       ByteProcessor processor)
```
    从类复制的描述： ByteBuf
    
    以指定的processor按升序迭代该缓冲区的指定区域。（即index ， (index + 1) ，.. (index + length - 1) ）
    
    Specified by:
    
    forEachByte在课程 ByteBuf
    
    结果
    
    -1如果处理器迭代到或超出指定区域的末尾。上次访问的索引如果ByteProcessor.process(byte)返回false 。
  - forEachByteDesc
```
public int forEachByteDesc(ByteProcessor processor)
```
    从类复制的描述： ByteBuf
    
    以指定的 processor降序遍历此缓冲区的可读字节。
    
    Specified by:
    
    forEachByteDesc ByteBuf
    
    结果
    
    -1如果处理器迭代到或超出可读字节的开始位置。最后访问的索引如果ByteProcessor.process(byte)返回false 。
  - forEachByteDesc
```
public int forEachByteDesc(int index,
                           int length,
                           ByteProcessor processor)
```
    从类复制的描述： ByteBuf
    
    以指定的processor以降序遍历此缓冲区的指定区域。（即(index + length - 1) ， (index + length - 2) ，... index ）
    
    Specified by:
    
    forEachByteDesc在课程 ByteBuf
    
    结果
    
    -1如果处理器迭代到或超出指定区域的开始位置。上次访问的索引如果ByteProcessor.process(byte)返回false 。
  - hashCode
```
public int hashCode()
```
    从类复制的描述： ByteBuf
    
    返回从此缓冲区的内容计算出来的哈希码。如果有一个字节数组是equal to这个数组，那么这两个数组都应该返回相同的值。
    
    Specified by:
    
    hashCode ByteBuf
  - equals
```
public boolean equals(java.lang.Object o)
```
    从类复制的描述： ByteBuf
    确定指定缓冲区的内容是否与此数组的内容相同。这里的“相同”意思是：
    - 两个缓冲区内容的大小是相同的
    - 两个缓冲区内容的每个字节都是相同的。
    请注意，它不会比较ByteBuf.readerIndex()和ByteBuf.writerIndex() 。此方法还会为null返回false ，并返回一个不是ByteBuf类型实例的对象。
    Specified by:
    
    equals在课堂上 ByteBuf
  - compareTo
```
public int compareTo(ByteBuf that)
```
    从类复制的描述： ByteBuf
    
    将指定缓冲区的内容与此缓冲区的内容进行比较。比较在与各种语言如的字符串比较功能相同的方式进行strcmp ， memcmp和String.compareTo(String) 。
    
    Specified by:
    
    compareTo接口 java.lang.Comparable<ByteBuf>
    
    Specified by:
    
    compareTo在课程 ByteBuf
  - toString
```
public java.lang.String toString()
```
    从类复制的描述： ByteBuf
    
    返回此缓冲区的字符串表示形式。这种方法不一定返回缓冲区的全部内容，但返回的主要性能如值ByteBuf.readerIndex() ， ByteBuf.writerIndex()和ByteBuf.capacity() 。
    
    Specified by:
    
    toString ByteBuf
  - checkIndex
```
protected final void checkIndex(int index)
```
  - checkIndex
```
protected final void checkIndex(int index,
                                int fieldLength)
```
  - checkSrcIndex
```
protected final void checkSrcIndex(int index,
                                   int length,
                                   int srcIndex,
                                   int srcCapacity)
```
  - checkDstIndex
```
protected final void checkDstIndex(int index,
                                   int length,
                                   int dstIndex,
                                   int dstCapacity)
```
  - checkReadableBytes
```
protected final void checkReadableBytes(int minimumReadableBytes)
```
    如果此缓冲区的当前 readable bytes小于指定值，则会抛出 IndexOutOfBoundsException 。
  - checkNewCapacity
```
protected final void checkNewCapacity(int newCapacity)
```
  - ensureAccessible
```
protected final void ensureAccessible()
```
    应该被尝试访问缓冲区内容的每种方法调用，以检查缓冲区是否在之前被释放。

Class AbstractByteBuf

构造方法摘要

方法摘要

Methods inherited from class io.netty.buffer.ByteBuf

Methods inherited from class java.lang.Object

Methods inherited from interface io.netty.util.ReferenceCounted

构造方法详细信息

AbstractByteBuf

方法详细信息

isReadOnly

asReadOnly

maxCapacity

maxCapacity

readerIndex

readerIndex

writerIndex

writerIndex

setIndex

clear

isReadable

isReadable

isWritable

isWritable

readableBytes

writableBytes

maxWritableBytes

markReaderIndex

resetReaderIndex

markWriterIndex

resetWriterIndex

discardReadBytes

discardSomeReadBytes

adjustMarkers

ensureWritable

ensureWritable

order

newSwappedByteBuf

getByte

_getByte

getBoolean

getUnsignedByte

getShort

_getShort

getShortLE

_getShortLE

getUnsignedShort

getUnsignedShortLE

getUnsignedMedium

_getUnsignedMedium

getUnsignedMediumLE

_getUnsignedMediumLE

getMedium

getMediumLE

getInt

_getInt

getIntLE

_getIntLE

getUnsignedInt

getUnsignedIntLE

getLong

_getLong

getLongLE

_getLongLE

getChar

getFloat

getDouble

getBytes

getBytes

getBytes

getCharSequence

readCharSequence

setByte

_setByte

setBoolean

setShort

_setShort

setShortLE

_setShortLE

setChar

setMedium