EmptyByteBuf (Netty API Reference (4.1.22.Final))

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

All Implemented Interfaces:

ReferenceCounted ，java.lang.Comparable < ByteBuf >
```
public final class EmptyByteBuf
extends ByteBuf
```
一个空的ByteBuf其容量和最大容量都是0 。

构造方法摘要

构造方法
Constructor and Description
`EmptyByteBuf(ByteBufAllocator alloc)`

方法摘要

所有方法接口方法具体的方法
Modifier and Type	Method and Description
`ByteBufAllocator`	`alloc()` 返回创建此缓冲区的`ByteBufAllocator` 。
`byte[]`	`array()` 返回此缓冲区的后备字节数组。
`int`	`arrayOffset()` 返回此缓冲区的后备字节数组中第一个字节的偏移量。
`ByteBuf`	`asReadOnly()` 返回此缓冲区的只读版本。
`int`	`bytesBefore(byte value)` 定位此缓冲区中第一次出现的指定 `value` 。
`int`	`bytesBefore(int length, byte value)` 定位此缓冲区中第一次出现的指定 `value` 。
`int`	`bytesBefore(int index, int length, byte value)` 定位此缓冲区中第一个出现的指定 `value` 。
`int`	`capacity()` 返回此缓冲区可包含的字节数（字节）。
`ByteBuf`	`capacity(int newCapacity)` 调整此缓冲区的容量。
`ByteBuf`	`clear()` 将此缓冲区的 `readerIndex`和 `writerIndex`设置为 `0` 。
`int`	`compareTo(ByteBuf buffer)` 将指定缓冲区的内容与此缓冲区的内容进行比较。
`ByteBuf`	`copy()` 返回此缓冲区可读字节的副本。
`ByteBuf`	`copy(int index, int length)` 返回此缓冲区的子区域的副本。
`ByteBuf`	`discardReadBytes()` 丢弃第0个索引和 `readerIndex`之间的字节。
`ByteBuf`	`discardSomeReadBytes()` 类似于 `ByteBuf.discardReadBytes()`，不同之处在于此方法可能会丢弃部分，全部或者全部读取字节，具体取决于其内部实现方式，以减少潜在的额外内存消耗为代价来降低整体内存带宽消耗。
`ByteBuf`	`duplicate()` 返回共享此缓冲区整个区域的缓冲区。
`ByteBuf`	`ensureWritable(int minWritableBytes)` 确保 the writable bytes的数量等于或大于指定值。
`int`	`ensureWritable(int minWritableBytes, boolean force)` 尝试确保 the writable bytes的数量等于或大于指定的值。
`boolean`	`equals(java.lang.Object obj)` 确定指定缓冲区的内容是否与此数组的内容相同。
`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, byte[] dst, int dstIndex, int length)` 将此缓冲区的数据传输到指定的绝对目标 `index`开始的目标。
`ByteBuf`	`getBytes(int index, ByteBuf dst)` 将该缓冲区的数据传输到指定的目的地，从指定的绝对 `index`开始，直到目标变为不可写入。
`ByteBuf`	`getBytes(int index, java.nio.ByteBuffer dst)` 将缓冲区的数据传输到指定的目的地，从指定的绝对 `index`开始，直到目的地的位置达到其限制。
`ByteBuf`	`getBytes(int index, ByteBuf dst, int length)` 将此缓冲区的数据传输到指定的绝对目标 `index`开始的目标。
`ByteBuf`	`getBytes(int index, ByteBuf dst, int dstIndex, int length)` 将此缓冲区的数据传输到指定的绝对目标 `index`开始的目标。
`int`	`getBytes(int index, java.nio.channels.FileChannel out, long position, int length)` 将此缓冲区的数据从指定的绝对 `index`到指定的通道，从给定的文件位置开始。
`int`	`getBytes(int index, java.nio.channels.GatheringByteChannel out, int length)` 将此缓冲区的数据传输到指定的通道，从指定的绝对 `index` 。
`ByteBuf`	`getBytes(int index, java.io.OutputStream out, 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)` 在此缓冲区中以小端字节顺序指定的绝对 `index`获取一个32位整数。
`long`	`getLong(int index)` 在此缓冲区中的指定绝对 `index`处获取一个64位长整数。
`long`	`getLongLE(int index)` 以Little Endian字节顺序在此缓冲区中的指定绝对 `index`处获取64位长整数。
`int`	`getMedium(int index)` 在此缓冲区中的指定绝对 `index`处获取一个24位中等整数。
`int`	`getMediumLE(int index)` 以Little Endian Byte Order的形式获取缓冲区中指定绝对 `index`的24位中等整数。
`short`	`getShort(int index)` 在此缓冲区中的指定绝对 `index`处获取一个16位短整数。
`short`	`getShortLE(int index)` 以Little Endian字节顺序在此缓冲区中的指定绝对 `index`处获取一个16位短整数。
`short`	`getUnsignedByte(int index)` 在此缓冲区中的指定绝对 `index`处获取一个无符号字节。
`long`	`getUnsignedInt(int index)` 在此缓冲区中指定的绝对 `index`处获取一个无符号的32位整数。
`long`	`getUnsignedIntLE(int index)` 以小端字节顺序在此缓冲区中的指定绝对 `index`处获取一个无符号的32位整数。
`int`	`getUnsignedMedium(int index)` 在此缓冲区中的指定绝对 `index`处获取一个无符号的24位中等整数。
`int`	`getUnsignedMediumLE(int index)` 以Little Endian Byte Order的形式 `index`此缓冲区中指定绝对 `index`的无符号24位中等整数。
`int`	`getUnsignedShort(int index)` 在此缓冲区中的指定绝对 `index`处获取一个无符号的16位短整数。
`int`	`getUnsignedShortLE(int index)` 以Little Endian Byte Order的形式 `index`此缓冲区中指定绝对 `index`的无符号16位短整数。
`boolean`	`hasArray()` 当且仅当此缓冲区有一个后备字节数组时返回 `true` 。
`int`	`hashCode()` 返回从此缓冲区的内容计算出来的哈希码。
`boolean`	`hasMemoryAddress()` 当且仅当此缓冲区具有对指向后备数据的低级内存地址的引用时才返回 `true` 。
`int`	`indexOf(int fromIndex, int toIndex, byte value)` 定位此缓冲区中第一次出现的指定 `value` 。
`java.nio.ByteBuffer`	`internalNioBuffer(int index, int length)` 仅内部使用：公开内部NIO缓冲区。
`boolean`	`isDirect()` 当且仅当此缓冲区由NIO直接缓冲区支持时才返回 `true` 。
`boolean`	`isReadable()` 返回 `true`当且仅当 `(this.writerIndex - this.readerIndex)`大于 `0` 。
`boolean`	`isReadable(int size)` 当且仅当此缓冲区包含等于或多于指定数量的元素时返回 `true` 。
`boolean`	`isReadOnly()` 当且仅当此缓冲区为只读时才返回 `true` 。
`boolean`	`isWritable()` 返回 `true`当且仅当 `(this.capacity - this.writerIndex)`大于 `0` 。
`boolean`	`isWritable(int size)` 当且仅当此缓冲区有足够的空间允许写入指定数量的元素时才返回 `true` 。
`ByteBuf`	`markReaderIndex()` 在此缓冲区中标记当前 `readerIndex` 。
`ByteBuf`	`markWriterIndex()` 在此缓冲区中标记当前 `writerIndex` 。
`int`	`maxCapacity()` 返回此缓冲区允许的最大容量。
`int`	`maxWritableBytes()` 返回可写入的最大字节数，等于 `(this.maxCapacity - this.writerIndex)` 。
`long`	`memoryAddress()` 返回指向备份数据第一个字节的低级内存地址。
`java.nio.ByteBuffer`	`nioBuffer()` 将此缓冲区的可读字节作为NIO `ByteBuffer` 。
`java.nio.ByteBuffer`	`nioBuffer(int index, int length)` 将此缓冲区的子区域公开为NIO `ByteBuffer` 。
`int`	`nioBufferCount()` 返回构成此缓冲区的NIO `ByteBuffer`的最大数量。
`java.nio.ByteBuffer[]`	`nioBuffers()` 以NIO `ByteBuffer`的形式公开此缓冲区的可读字节。
`java.nio.ByteBuffer[]`	`nioBuffers(int index, int length)` 将此缓冲区的字节公开为指定索引和长度的NIO `ByteBuffer`所返回的缓冲区共享或包含此缓冲区的复制内容，同时更改返回的NIO缓冲区的位置和限制不会影响此索引和标记缓冲。
`java.nio.ByteOrder`	`order()` 返回此缓冲区的 endianness 。
`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`由传输的字节（=数量 `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` 。
`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`开始 `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位浮点数，并在此缓冲区 `readerIndex` `4`增加 `readerIndex` 。
`int`	`readInt()` 在当前 `readerIndex`处获取32位整数，并在此缓冲区 `readerIndex` `4`增加 `readerIndex` 。
`int`	`readIntLE()` 在小端字节顺序的当前 `readerIndex`处获取32位整数，并在此缓冲区 `readerIndex` `4`增加 `readerIndex` 。
`long`	`readLong()` 在当前 `readerIndex`处获取64位整数，并在此缓冲区 `readerIndex` `8`增加 `readerIndex` 。
`long`	`readLongLE()` 在Little Endian字节顺序的当前 `readerIndex`处获取64位整数，并在此缓冲区 `readerIndex` `8`增加 `readerIndex` 。
`int`	`readMedium()` 在当前 `readerIndex`处获取24位中等整数，并在此缓冲区 `readerIndex` `3`增加 `readerIndex` 。
`int`	`readMediumLE()` 在Little Endian Byte Order中获取当前 `readerIndex`的24位中等整数，并在此缓冲区 `readerIndex` `3`增加 `readerIndex` 。
`ByteBuf`	`readRetainedSlice(int length)` 返回此缓冲区的子区域并从当前的一个新的保留切片 `readerIndex`并增加了 `readerIndex`由新的切片（=大小 `length` ）。
`short`	`readShort()` 在当前 `readerIndex`处获取16位短整数，并在此缓冲区 `readerIndex` `2`增加 `readerIndex` 。
`short`	`readShortLE()` 在Little Endian字节顺序的当前 `readerIndex`处获取一个16位短整数，并在该缓冲区中增加 `readerIndex` `2` 。
`ByteBuf`	`readSlice(int length)` 返回此缓冲区的子区域并从当前的新的片 `readerIndex`并增加了 `readerIndex`由新的切片（=大小 `length` ）。
`short`	`readUnsignedByte()` 获取当前 `readerIndex`处的无符号字节，并在此缓冲区 `readerIndex` `1`增加 `readerIndex` 。
`long`	`readUnsignedInt()` 在当前 `readerIndex`处获取一个无符号的32位整数，并在此缓冲区 `readerIndex` `4`增加 `readerIndex` 。
`long`	`readUnsignedIntLE()` 在小端字节顺序的当前 `readerIndex`处获取一个无符号的32位整数，并在此缓冲区 `readerIndex` `4`增加 `readerIndex` 。
`int`	`readUnsignedMedium()` 在当前 `readerIndex`处获取一个无符号的24位中等整数，并在此缓冲区 `readerIndex` `3`增加 `readerIndex` 。
`int`	`readUnsignedMediumLE()` 在Little Endian Byte Order中获取当前 `readerIndex`的无符号24位中等整数，并在此缓冲区 `readerIndex` `3`增加 `readerIndex` 。
`int`	`readUnsignedShort()` 在当前 `readerIndex`处获取一个无符号的16位短整数，并在此缓冲区 `readerIndex` `2`增加 `readerIndex` 。
`int`	`readUnsignedShortLE()` 在Little Endian Byte Order中获取当前 `readerIndex`的无符号16位短整数，并在此缓冲区 `readerIndex` `2`增加 `readerIndex` 。
`int`	`refCnt()` 返回此对象的引用计数。
`boolean`	`release()` 通过减小引用计数 `1`并且如果所述引用计数达到在将释放该对象 `0` 。
`boolean`	`release(int decrement)` 如果引用计数达到 `0`则减少指定的引用计数 `decrement`并释放此对象。
`ByteBuf`	`resetReaderIndex()` 将当前 `readerIndex`重新定位到此缓冲区中标记为 `readerIndex` 。
`ByteBuf`	`resetWriterIndex()` 将当前 `writerIndex`重新定位到此缓冲区中标记为 `writerIndex` 。
`ByteBuf`	`retain()` 将参考计数增加 `1` 。
`ByteBuf`	`retain(int increment)` 将参考计数增加 `increment` 。
`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, byte[] src, int srcIndex, int length)` 从指定的绝对 `index`开始，将指定的源数组的数据传输到此缓冲区。
`ByteBuf`	`setBytes(int index, ByteBuf src)` 将指定的源缓冲区的数据传输到此缓冲区，从指定的绝对 `index`开始，直到源缓冲区变得不可读。
`ByteBuf`	`setBytes(int index, java.nio.ByteBuffer src)` 将指定的源缓冲区的数据从指定的绝对 `index`开始传输到此缓冲区，直到源缓冲区的位置达到其限制。
`ByteBuf`	`setBytes(int index, ByteBuf src, int length)` 将指定的源缓冲区的数据从指定的绝对 `index`开始传送到此缓冲区。
`ByteBuf`	`setBytes(int index, ByteBuf src, int srcIndex, int length)` 将指定的源缓冲区数据传输到此缓冲区，从指定的绝对 `index` 。
`int`	`setBytes(int index, java.nio.channels.FileChannel in, long position, int length)` 将从给定文件位置开始的指定源通道的内容传输到此缓冲区，从指定的绝对 `index` 。
`int`	`setBytes(int index, java.io.InputStream in, int length)` 将指定源流的内容从指定的绝对 `index`开始传输到此缓冲区。
`int`	`setBytes(int index, java.nio.channels.ScatteringByteChannel in, 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)` 使用Little Endian Byte Order在此缓冲区中的指定绝对 `index`处设置指定的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)` 将此缓冲区的子区域解码为具有指定字符集的字符串。
`ByteBuf`	`touch()` 记录此对象的当前访问位置以进行调试。
`ByteBuf`	`touch(java.lang.Object hint)` 记录此对象的当前访问位置，并附加一些用于调试的任意信息。
`ByteBuf`	`unwrap()` 如果此缓冲区是另一个缓冲区的包装，则返回底层缓冲区实例。
`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`增加 `writerIndex` 。
`ByteBuf`	`writeBytes(java.nio.ByteBuffer src)` 将指定的源缓冲区的数据从当前 `writerIndex`开始传送到此缓冲区，直到源缓冲区的位置达到其限制，并将 `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` 。
`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)` 在Little Endian Byte Order中设置当前 `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`增加 `writerIndex`指定的 `length` 。

Methods inherited from class io.netty.buffer.ByteBuf
getDoubleLE, getFloatLE, readDoubleLE, readFloatLE, setDoubleLE, setFloatLE, writeDoubleLE, writeFloatLE

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

- 构造方法详细信息
  - EmptyByteBuf
```
public EmptyByteBuf(ByteBufAllocator alloc)
```
- 方法详细信息
  - capacity
```
public int capacity()
```
    从类复制的描述： ByteBuf
    
    返回此缓冲区可包含的字节数（字节）。
    
    Specified by:
    
    capacity在类 ByteBuf
  - capacity
```
public ByteBuf capacity(int newCapacity)
```
    从类复制的描述： ByteBuf
    
    调整此缓冲区的容量。如果newCapacity小于当前容量，则此缓冲区的内容将被截断。如果newCapacity大于当前容量，则缓冲区会附加长度为(newCapacity - currentCapacity)未指定数据。
    
    Specified by:
    
    capacity在类 ByteBuf
  - alloc
```
public ByteBufAllocator alloc()
```
    从类复制的描述： ByteBuf
    
    返回创建此缓冲区的ByteBufAllocator 。
    
    Specified by:
    
    alloc在类 ByteBuf
  - order
```
public java.nio.ByteOrder order()
```
    从类复制的描述： ByteBuf
    
    返回此缓冲区的 endianness 。
    
    Specified by:
    
    order在类 ByteBuf
  - unwrap
```
public ByteBuf unwrap()
```
    从类复制的描述： ByteBuf
    
    如果此缓冲区是另一个缓冲区的包装，则返回底层缓冲区实例。
    
    Specified by:
    
    unwrap在类 ByteBuf
    
    结果
    
    null如果这个缓冲区不是包装
  - asReadOnly
```
public ByteBuf asReadOnly()
```
    从类复制的描述： ByteBuf
    
    返回此缓冲区的只读版本。
    
    Specified by:
    
    asReadOnly类 ByteBuf
  - isReadOnly
```
public boolean isReadOnly()
```
    从类复制的描述： ByteBuf
    
    当且仅当此缓冲区是只读的时返回 true 。
    
    Specified by:
    
    isReadOnly在类 ByteBuf
  - isDirect
```
public boolean isDirect()
```
    从类复制的描述： ByteBuf
    
    当且仅当此缓冲区由NIO直接缓冲区支持时才返回 true 。
    
    Specified by:
    
    isDirect在类 ByteBuf
  - maxCapacity
```
public int maxCapacity()
```
    从类复制的描述： ByteBuf
    
    返回此缓冲区允许的最大容量。如果用户尝试使用ByteBuf.capacity(int)或ByteBuf.ensureWritable(int)将此缓冲区的容量增加到最大容量以上，那么这些方法将引发IllegalArgumentException 。
    
    Specified by:
    
    maxCapacity在类 ByteBuf
  - order
```
public ByteBuf order(java.nio.ByteOrder endianness)
```
    从类复制的描述： ByteBuf
    
    返回指定endianness的缓冲区，该缓冲区共享此缓冲区的整个区域，索引和标记。修改返回的缓冲区或此缓冲区的内容，索引或标记会影响彼此的内容，索引和标记。如果指定的endianness与此缓冲区的字节顺序相同，则此方法可返回this 。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    order类 ByteBuf
  - 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
  - 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
  - isReadable
```
public boolean isReadable()
```
    从类复制的描述： ByteBuf
    
    返回 true当且仅当 (this.writerIndex - this.readerIndex)大于 0 。
    
    Specified by:
    
    isReadable在类 ByteBuf
  - isWritable
```
public boolean isWritable()
```
    从类复制的描述： ByteBuf
    
    返回 true当且仅当 (this.capacity - this.writerIndex)大于 0 。
    
    Specified by:
    
    isWritable在类 ByteBuf
  - clear
```
public ByteBuf clear()
```
    从类复制的描述： ByteBuf
    
    将此缓冲区的readerIndex和writerIndex设置为0 。该方法与setIndex(0, 0)相同。
    请注意，此方法的行为与NIO缓冲区的行为不同，后者将limit设置为limit的capacity 。
    
    Specified by:
    
    clear在类 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
  - 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如果缓冲区没有足够的字节，但其容量已增加到最大值。
  - getBoolean
```
public boolean getBoolean(int index)
```
    从类复制的描述： ByteBuf
    
    在此缓冲区中获取指定绝对（@code索引）的布尔值。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    getBoolean ByteBuf
  - getByte
```
public byte getByte(int index)
```
    从类复制的描述： ByteBuf
    
    获取此缓冲区中指定绝对index的字节。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    getByte在类 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
  - getShortLE
```
public short getShortLE(int index)
```
    从类复制的描述： ByteBuf
    
    以Little Endian字节顺序在此缓冲区中的指定绝对index处获取一个16位短整数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    getShortLE在类 ByteBuf
  - getUnsignedShort
```
public int getUnsignedShort(int index)
```
    从类复制的描述： ByteBuf
    
    在此缓冲区中指定的绝对index处获取一个无符号的16位短整数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    getUnsignedShort在类 ByteBuf
  - getUnsignedShortLE
```
public int getUnsignedShortLE(int index)
```
    从类复制的描述： ByteBuf
    
    以Little Endian Byte Order的形式index此缓冲区中指定绝对index的无符号16位短整数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    getUnsignedShortLE在类 ByteBuf
  - getMedium
```
public int getMedium(int index)
```
    从类复制的描述： ByteBuf
    
    在此缓冲区中的指定绝对index处获取一个24位中等整数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    getMedium在类 ByteBuf
  - getMediumLE
```
public int getMediumLE(int index)
```
    从类复制的描述： ByteBuf
    
    以Little Endian字节顺序在此缓冲区中的指定绝对index处获取一个24位中等整数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    getMediumLE在类 ByteBuf
  - getUnsignedMedium
```
public int getUnsignedMedium(int index)
```
    从类复制的描述： ByteBuf
    
    在此缓冲区中指定的绝对index处获取一个无符号的24位中等整数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    getUnsignedMedium在类 ByteBuf
  - getUnsignedMediumLE
```
public int getUnsignedMediumLE(int index)
```
    从类中复制的描述： ByteBuf
    
    以小端字节顺序在此缓冲区中的指定绝对index处获取无符号的24位中等整数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    getUnsignedMediumLE在类 ByteBuf
  - getInt
```
public int getInt(int index)
```
    从类复制的描述： ByteBuf
    
    在此缓冲区中的指定绝对index处获取一个32位整数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    getInt在类 ByteBuf
  - getIntLE
```
public int getIntLE(int index)
```
    从类复制的描述： ByteBuf
    
    在此缓冲区中以指定的绝对index获取一个32位整数， index字节顺序。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    getIntLE在类 ByteBuf
  - 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
  - getLongLE
```
public long getLongLE(int index)
```
    从类复制的描述： ByteBuf
    
    以小端字节顺序在此缓冲区中的指定绝对index处获取64位长整数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    getLongLE在类 ByteBuf
  - 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,
                        ByteBuf dst)
```
    从类复制的描述： ByteBuf
    
    将此缓冲区的数据传输到指定的目的地，从指定的绝对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 - 要传输的字节数
  - getBytes
```
public ByteBuf getBytes(int index,
                        ByteBuf dst,
                        int dstIndex,
                        int length)
```
    从类复制的描述： ByteBuf
    
    将此缓冲区的数据传输到指定的绝对目标index开始的目标。此方法不会修改来源（即this ）和目的地的readerIndex或writerIndex 。
    
    Specified by:
    
    getBytes在类 ByteBuf
    
    dstIndex - 目的地的第一个索引
    
    length - 要传输的字节数
  - getBytes
```
public ByteBuf getBytes(int index,
                        byte[] dst)
```
    从类复制的描述： ByteBuf
    
    将此缓冲区的数据传输到指定的绝对目标index开始的目标。此方法不会修改此缓冲区的readerIndex或writerIndex
    
    Specified by:
    
    getBytes在类 ByteBuf
  - getBytes
```
public ByteBuf getBytes(int index,
                        byte[] dst,
                        int dstIndex,
                        int length)
```
    从类复制的描述： ByteBuf
    
    将此缓冲区的数据传输到指定绝对index开始的目标。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    getBytes的 ByteBuf
    
    dstIndex - 目的地的第一个索引
    
    length - 要传输的字节数
  - getBytes
```
public ByteBuf getBytes(int index,
                        java.nio.ByteBuffer dst)
```
    从类复制的描述： ByteBuf
    
    将此缓冲区的数据传输到指定的目标位置，从指定的绝对index开始，直到目标位置达到其限制。此方法不修改此缓冲区的readerIndex或writerIndex ，而目标的position将增加。
    
    Specified by:
    
    getBytes在类 ByteBuf
  - getBytes
```
public ByteBuf getBytes(int index,
                        java.io.OutputStream out,
                        int length)
```
    从类复制的描述： ByteBuf
    
    将此缓冲区的数据传输到指定绝对index开始的指定流。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    getBytes在类 ByteBuf
    
    length - 要传输的字节数
  - getBytes
```
public int getBytes(int index,
                    java.nio.channels.GatheringByteChannel out,
                    int length)
```
    从类复制的描述： ByteBuf
    
    将此缓冲区的数据传送到指定的通道，从指定的绝对index 。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    getBytes在类 ByteBuf
    
    length - 要传输的最大字节数
    
    结果
    
    写出到指定通道的实际字节数
  - getBytes
```
public int getBytes(int index,
                    java.nio.channels.FileChannel out,
                    long position,
                    int length)
```
    从类复制的描述： ByteBuf
    
    将此缓冲区的数据从指定的绝对index开始index到指定的通道，从给定的文件位置开始。此方法不会修改此缓冲区的readerIndex或writerIndex 。此方法不会修改频道的位置。
    
    Specified by:
    
    getBytes在类 ByteBuf
    
    position - 传输开始的文件位置
    
    length - 传输的最大字节数
    
    结果
    
    写出到指定通道的实际字节数
  - getCharSequence
```
public java.lang.CharSequence getCharSequence(int index,
                                              int length,
                                              java.nio.charset.Charset charset)
```
    从类复制的描述： ByteBuf
    
    在给定索引处获取具有给定长度的 CharSequence 。
    
    Specified by:
    
    getCharSequence在类 ByteBuf
    
    length - 阅读的长度
    
    charset - 应该使用
    
    结果
    
    序列
  - setBoolean
```
public ByteBuf setBoolean(int index,
                          boolean value)
```
    从类复制的描述： ByteBuf
    
    在此缓冲区中的指定绝对index处设置指定的布尔值。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    setBoolean在类 ByteBuf
  - setByte
```
public ByteBuf setByte(int index,
                       int value)
```
    从类复制的描述： ByteBuf
    
    在此缓冲区中的指定绝对index处设置指定的字节。指定值的24个高位被忽略。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    setByte在类 ByteBuf
  - setShort
```
public ByteBuf setShort(int index,
                        int value)
```
    从类复制的描述： ByteBuf
    
    在此缓冲区中的指定绝对index处设置指定的16位短整数。指定值的16个高位被忽略。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    setShort在类 ByteBuf
  - setShortLE
```
public ByteBuf setShortLE(int index,
                          int value)
```
    从类ByteBuf复制的描述
    
    使用Little Endian Byte Order在此缓冲区中的指定绝对index处设置指定的16位短整数。指定值的16个高位被忽略。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    setShortLE在类 ByteBuf
  - setMedium
```
public ByteBuf setMedium(int index,
                         int value)
```
    从类复制的描述： ByteBuf
    
    在此缓冲区中的指定绝对index处设置指定的24位中等整数。请注意，最高有效字节在指定值中被忽略。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    setMedium在类 ByteBuf
  - setMediumLE
```
public ByteBuf setMediumLE(int index,
                           int value)
```
    从类复制的描述： ByteBuf
    
    以小端字节顺序在此缓冲区中的指定绝对index处设置指定的24位中等整数。请注意，最高有效字节在指定值中被忽略。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    setMediumLE在类 ByteBuf
  - setInt
```
public ByteBuf setInt(int index,
                      int value)
```
    从类复制的描述： ByteBuf
    
    在此缓冲区中的指定绝对index处设置指定的32位整数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    setInt在类 ByteBuf
  - setIntLE
```
public ByteBuf setIntLE(int index,
                        int value)
```
    从类中复制的描述： ByteBuf
    
    使用Little Endian字节顺序在此缓冲区中的指定绝对index处设置指定的32位整数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    setIntLE在类 ByteBuf
  - setLong
```
public ByteBuf setLong(int index,
                       long value)
```
    从类复制的描述： ByteBuf
    
    在此缓冲区的指定绝对index处设置指定的64位长整数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    setLong在类 ByteBuf
  - setLongLE
```
public ByteBuf setLongLE(int index,
                         long value)
```
    从类复制的描述： ByteBuf
    
    以小端字节顺序在此缓冲区中的指定绝对index处设置指定的64位长整数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    setLongLE在类 ByteBuf
  - setChar
```
public ByteBuf setChar(int index,
                       int value)
```
    从类复制的描述： ByteBuf
    
    在此缓冲区的指定绝对index处设置指定的2字节UTF-16字符。指定值的16个高位被忽略。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    setChar在类 ByteBuf
  - setFloat
```
public ByteBuf setFloat(int index,
                        float value)
```
    从类复制的描述： ByteBuf
    
    在此缓冲区中的指定绝对index处设置指定的32位浮点数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    setFloat在类 ByteBuf
  - setDouble
```
public ByteBuf setDouble(int index,
                         double value)
```
    从类复制的描述： ByteBuf
    
    在此缓冲区中指定的绝对index处设置指定的64位浮点数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    setDouble在类 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增加了传输字节数，而ByteBuf.setBytes(int, ByteBuf, int, int)则不增加。此方法不会修改源缓冲区的readerIndex或writerIndex （即this ）。
    
    Specified by:
    
    setBytes在类 ByteBuf
    
    length - 要传输的字节数
  - setBytes
```
public ByteBuf setBytes(int index,
                        ByteBuf src,
                        int srcIndex,
                        int length)
```
    从类复制的描述： ByteBuf
    
    将指定的源缓冲区的数据从指定的绝对index开始传送到此缓冲区。此方法不会修改源（即this ）和目标的readerIndex或writerIndex 。
    
    Specified by:
    
    setBytes在类 ByteBuf
    
    srcIndex - 来源的第一个索引
    
    length - 要传输的字节数
  - setBytes
```
public ByteBuf setBytes(int index,
                        byte[] src)
```
    从类复制的描述： ByteBuf
    
    将指定的源数组的数据传输到此缓冲区，从指定的绝对index 。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    setBytes在类 ByteBuf
  - setBytes
```
public ByteBuf setBytes(int index,
                        byte[] src,
                        int srcIndex,
                        int length)
```
    从类复制的描述： ByteBuf
    
    将指定的源数组的数据传输到此缓冲区，从指定的绝对index 。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    setBytes在类 ByteBuf
  - setBytes
```
public ByteBuf setBytes(int index,
                        java.nio.ByteBuffer src)
```
    从类复制的描述： ByteBuf
    
    将指定的源缓冲区的数据从指定的绝对index开始传输到此缓冲区，直到源缓冲区的位置达到其限制。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    setBytes在类 ByteBuf
  - setBytes
```
public int setBytes(int index,
                    java.io.InputStream in,
                    int length)
```
    从类复制的描述： ByteBuf
    
    将指定源流的内容从指定的绝对index开始传输到此缓冲区。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    setBytes在类 ByteBuf
    
    length - 要传输的字节数
    
    结果
    
    从指定通道读入的实际字节数。 -1如果指定的频道已关闭。
  - setBytes
```
public int setBytes(int index,
                    java.nio.channels.ScatteringByteChannel in,
                    int length)
```
    从类复制的描述： ByteBuf
    
    将指定源通道的内容从指定的绝对index开始传送到此缓冲区。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    setBytes在类 ByteBuf
    
    length - 传输的最大字节数
    
    结果
    
    从指定通道读入的实际字节数。 -1如果指定的频道已关闭。
  - setBytes
```
public int setBytes(int index,
                    java.nio.channels.FileChannel in,
                    long position,
                    int length)
```
    从类复制的描述： ByteBuf
    
    将从给定文件位置开始的指定源通道的内容传输到此缓冲区，从指定的绝对index 。此方法不会修改此缓冲区的readerIndex或writerIndex 。此方法不会修改频道的位置。
    
    Specified by:
    
    setBytes在类 ByteBuf
    
    position - 传输开始的文件位置
    
    length - 传输的最大字节数
    
    结果
    
    从指定通道读入的实际字节数。 -1如果指定的频道已关闭。
  - 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 - 应该使用。
    
    结果
    
    写入的字节数。
  - readBoolean
```
public boolean readBoolean()
```
    从类复制的描述： ByteBuf
    
    获取当前 readerIndex的布尔值，并在此缓冲区 readerIndex 1增加 readerIndex 。
    
    Specified by:
    
    readBoolean在类 ByteBuf
  - readByte
```
public byte readByte()
```
    从类复制的描述： ByteBuf
    
    获取当前 readerIndex一个字节，并在此缓冲区中增加 readerIndex 1 。
    
    Specified by:
    
    readByte在类 ByteBuf
  - readUnsignedByte
```
public short readUnsignedByte()
```
    从类复制的描述： ByteBuf
    
    获取当前 readerIndex的无符号字节，并在此缓冲区 readerIndex 1增加 readerIndex 。
    
    Specified by:
    
    readUnsignedByte在类 ByteBuf
  - readShort
```
public short readShort()
```
    从类复制的描述： ByteBuf
    
    在当前 readerIndex处获取一个16位短整数，并在此缓冲区 readerIndex 2增加 readerIndex 。
    
    Specified by:
    
    readShort在类 ByteBuf
  - readShortLE
```
public short readShortLE()
```
    从类复制的描述： ByteBuf
    
    在小端字节顺序的当前 readerIndex处获取一个16位短整数，并在此缓冲区中增加 readerIndex 2 。
    
    Specified by:
    
    readShortLE在类 ByteBuf
  - readUnsignedShort
```
public int readUnsignedShort()
```
    从类复制的描述： ByteBuf
    
    在当前 readerIndex处获取一个无符号的16位短整数，并在此缓冲区 readerIndex 2增加 readerIndex 。
    
    Specified by:
    
    readUnsignedShort在类 ByteBuf
  - readUnsignedShortLE
```
public int readUnsignedShortLE()
```
    从类复制的描述： ByteBuf
    
    在小端字节顺序的当前 readerIndex处获取一个无符号的16位短整数，并在此缓冲区 readerIndex 2增加 readerIndex 。
    
    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
    
    在Little Endian Byte Order中获取当前 readerIndex的无符号24位中等整数，并在此缓冲区中增加 readerIndex 3 。
    
    Specified by:
    
    readUnsignedMediumLE在类 ByteBuf
  - readInt
```
public int readInt()
```
    从类复制的描述： ByteBuf
    
    在当前 readerIndex处获取32位整数，并在此缓冲区 readerIndex 4增加 readerIndex 。
    
    Specified by:
    
    readInt在类 ByteBuf
  - readIntLE
```
public int readIntLE()
```
    从类复制的描述： ByteBuf
    
    以小端字节顺序在当前 readerIndex处获取一个32位整数，并在此缓冲区 readerIndex 4增加 readerIndex 。
    
    Specified by:
    
    readIntLE在类 ByteBuf
  - readUnsignedInt
```
public long readUnsignedInt()
```
    从类复制的描述： ByteBuf
    
    在当前 readerIndex处获取一个无符号的32位整数，并在此缓冲区 readerIndex 4增加 readerIndex 。
    
    Specified by:
    
    readUnsignedInt在类 ByteBuf
  - readUnsignedIntLE
```
public long readUnsignedIntLE()
```
    从类复制的描述： ByteBuf
    
    在小端字节顺序的当前 readerIndex处获取一个无符号的32位整数，并在此缓冲区中增加 readerIndex 4 。
    
    Specified by:
    
    readUnsignedIntLE在类 ByteBuf
  - readLong
```
public long readLong()
```
    从类复制的描述： ByteBuf
    
    在当前 readerIndex处获取64位整数，并在此缓冲区 readerIndex 8增加 readerIndex 。
    
    Specified by:
    
    readLong在类 ByteBuf
  - readLongLE
```
public long readLongLE()
```
    从类复制的描述： ByteBuf
    
    在小端字节顺序的当前 readerIndex处获取64位整数，并在此缓冲区 readerIndex 8增加 readerIndex 。
    
    Specified by:
    
    readLongLE在类 ByteBuf
  - readChar
```
public char readChar()
```
    从类复制的描述： ByteBuf
    
    在当前 readerIndex处获取一个2字节的UTF-16字符，并在此缓冲区 readerIndex 2增加 readerIndex 。
    
    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 。
    
    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由新的切片（=大小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(ByteBuf dst)
```
    从类复制的描述： ByteBuf
    
    将此缓冲区的数据传输到指定的目标，从当前的readerIndex开始，直到目标变为不可写，并将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(byte[] dst)
```
    从类复制的描述： ByteBuf
    
    传输此缓冲区的数据到指定的目标并从当前 readerIndex并增加了 readerIndex由传输的字节（=数量 dst.length ）。
    
    Specified by:
    
    readBytes在类 ByteBuf
  - readBytes
```
public ByteBuf readBytes(byte[] 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 ByteBuf readBytes(java.io.OutputStream out,
                         int length)
```
    从类复制的描述： ByteBuf
    
    将此缓冲区的数据传输到当前 readerIndex开始的指定流。
    
    Specified by:
    
    readBytes在类 ByteBuf
    
    length - 要传输的字节数
  - readBytes
```
public int readBytes(java.nio.channels.GatheringByteChannel out,
                     int length)
```
    从类复制的描述： ByteBuf
    
    将此缓冲区的数据传输到当前 readerIndex开始的指定流。
    
    Specified by:
    
    readBytes在类 ByteBuf
    
    length - 要传输的最大字节数
    
    结果
    
    写出到指定通道的实际字节数
  - readBytes
```
public int readBytes(java.nio.channels.FileChannel out,
                     long position,
                     int length)
```
    从类中复制的描述： ByteBuf
    
    将此缓冲区的数据从当前的readerIndex到指定通道，从给定的文件位置开始。此方法不会修改频道的位置。
    
    Specified by:
    
    readBytes在类 ByteBuf
    
    position - 传输开始的文件位置
    
    length - 要传输的最大字节数
    
    结果
    
    写出到指定通道的实际字节数
  - readCharSequence
```
public java.lang.CharSequence readCharSequence(int length,
                                               java.nio.charset.Charset charset)
```
    从类复制的描述： ByteBuf
    
    在当前 readerIndex处获得给定长度的 CharSequence ，并将给定长度增加 readerIndex 。
    
    Specified by:
    
    readCharSequence在类 ByteBuf
    
    参数
    
    length - 阅读的长度
    
    charset - 应该使用
    
    结果
    
    序列
  - skipBytes
```
public ByteBuf skipBytes(int length)
```
    从类复制的描述： ByteBuf
    
    此缓冲区中指定的 length增加当前 readerIndex 。
    
    Specified by:
    
    skipBytes在类 ByteBuf
  - writeBoolean
```
public ByteBuf writeBoolean(boolean value)
```
    从类复制的描述： ByteBuf
    
    在当前 writerIndex处设置指定的布尔值，并在此缓冲区中增加 writerIndex 1 。
    
    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 。指定值的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(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增加 writerIndex的字节数（= length ）。
    
    Specified by:
    
    writeBytes在类 ByteBuf
    
    srcIndex - 来源的第一个索引
    
    length - 要传输的字节数
  - writeBytes
```
public ByteBuf writeBytes(byte[] src)
```
    从类复制的描述： ByteBuf
    
    将指定的源数组的数据传输到此缓冲区，从当前的 writerIndex开始，并将 writerIndex增加 writerIndex传输的字节数（= src.length ）。
    
    Specified by:
    
    writeBytes 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(java.nio.ByteBuffer src)
```
    从类复制的描述： ByteBuf
    
    将指定源缓冲区的数据从当前 writerIndex开始传送到此缓冲区，直到源缓冲区的位置达到其限制，并将传送的字节数增加 writerIndex 。
    
    Specified by:
    
    writeBytes在类 ByteBuf
  - writeBytes
```
public int writeBytes(java.io.InputStream in,
                      int length)
```
    从类复制的描述： ByteBuf
    
    将指定流的内容从当前 writerIndex开始传送到此缓冲区，并将传送的字节数增加到 writerIndex 。
    
    Specified by:
    
    writeBytes在类 ByteBuf
    
    length - 要传输的字节数
    
    结果
    
    从指定的流中读入的实际字节数
  - writeBytes
```
public int writeBytes(java.nio.channels.ScatteringByteChannel in,
                      int length)
```
    从类复制的描述： ByteBuf
    
    将指定通道的内容传输到此缓冲区，从当前 writerIndex开始，并通过传输的字节数增加 writerIndex 。
    
    Specified by:
    
    writeBytes在类 ByteBuf
    
    length - 传输的最大字节数
    
    结果
    
    从指定通道读入的实际字节数
  - writeBytes
```
public int writeBytes(java.nio.channels.FileChannel in,
                      long position,
                      int length)
```
    从类复制的描述： ByteBuf
    
    将从给定文件位置开始的指定通道的内容传输到此缓冲区，从当前writerIndex开始，并将传输字节数增加writerIndex 。此方法不会修改频道的位置。
    
    Specified by:
    
    writeBytes在类 ByteBuf
    
    position - 传输开始的文件位置
    
    length - 传输的最大字节数
    
    结果
    
    从指定通道读入的实际字节数
  - writeZero
```
public ByteBuf writeZero(int length)
```
    从类复制的描述： ByteBuf
    
    用 NUL (0x00)从当前 writerIndex开始填充此缓冲区， 然后将 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 - 应该使用
    
    结果
    
    写入的字节数
  - 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 。
  - copy
```
public ByteBuf copy()
```
    从类复制的描述： ByteBuf
    
    返回此缓冲区可读字节的副本。修改返回的缓冲区或缓冲区的内容完全不会相互影响。此方法与buf.copy(buf.readerIndex(), buf.readableBytes())相同。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    copy上课 ByteBuf
  - copy
```
public ByteBuf copy(int index,
                    int length)
```
    从类复制的描述： ByteBuf
    
    返回此缓冲区的子区域的副本。修改返回的缓冲区或缓冲区的内容完全不会相互影响。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    copy在类 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()类似， 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
  - 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
  - nioBufferCount
```
public int nioBufferCount()
```
    从类复制的描述： ByteBuf
    
    返回构成此缓冲区的NIO ByteBuffer的最大数量。请注意， ByteBuf.nioBuffers()或ByteBuf.nioBuffers(int, int)可能会返回更少数量的ByteBuffer 。
    
    Specified by:
    
    nioBufferCount类 ByteBuf
    
    结果
    
    -1如果此缓冲区没有标的ByteBuffer 。如果此缓冲区至少有一个底层ByteBuffer ，则底层ByteBuffer的ByteBuffer 。请注意，此方法不会返回0以避免混淆。
    
    另请参见：
    
    ByteBuf.nioBuffer() ， ByteBuf.nioBuffer(int, int) ， ByteBuf.nioBuffers() ， ByteBuf.nioBuffers(int, int)
  - 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)
  - nioBuffer
```
public java.nio.ByteBuffer nioBuffer(int index,
                                     int length)
```
    从类复制的描述： ByteBuf
    
    将此缓冲区的子区域公开为NIO ByteBuffer 。返回的缓冲区共享或包含此缓冲区的复制内容，同时更改返回的NIO缓冲区的位置和限制不会影响此缓冲区的索引和标记。此方法不会修改此缓冲区的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)
  - nioBuffers
```
public java.nio.ByteBuffer[] nioBuffers(int index,
                                        int length)
```
    从类复制的描述： ByteBuf
    
    将此缓冲区的字节公开为指定索引和长度的NIO ByteBuffer返回的缓冲区共享或包含此缓冲区的复制内容，同时更改返回的NIO缓冲区的位置和限制不会影响此索引和标记缓冲。此方法不会修改此缓冲区的readerIndex或writerIndex 。请注意，如果此缓冲区是动态缓冲区并且它调整了其容量，则返回的NIO缓冲区将不会看到此缓冲区的更改。
    
    Specified by:
    
    nioBuffers在类 ByteBuf
    
    另请参见：
    
    ByteBuf.nioBufferCount() ， ByteBuf.nioBuffer() ， ByteBuf.nioBuffer(int, int)
  - internalNioBuffer
```
public java.nio.ByteBuffer internalNioBuffer(int index,
                                             int length)
```
    从类复制的描述： ByteBuf
    
    仅内部使用：公开内部NIO缓冲区。
    
    Specified by:
    
    internalNioBuffer在类 ByteBuf
  - hasArray
```
public boolean hasArray()
```
    从类复制的描述： ByteBuf
    
    当且仅当此缓冲区有一个后备字节数组时返回true 。如果此方法返回true，则可以放心地呼叫ByteBuf.array()和ByteBuf.arrayOffset() 。
    
    Specified by:
    
    hasArray在类 ByteBuf
  - array
```
public byte[] array()
```
    从类复制的描述： ByteBuf
    
    返回此缓冲区的后备字节数组。
    
    Specified by:
    
    array在类 ByteBuf
  - arrayOffset
```
public int arrayOffset()
```
    从类复制的描述： ByteBuf
    
    返回此缓冲区的后备字节数组中第一个字节的偏移量。
    
    Specified by:
    
    arrayOffset在类 ByteBuf
  - hasMemoryAddress
```
public boolean hasMemoryAddress()
```
    从类复制的描述： ByteBuf
    
    当且仅当此缓冲区引用指向后备数据的低级内存地址时才返回 true 。
    
    Specified by:
    
    hasMemoryAddress在类 ByteBuf
  - memoryAddress
```
public long memoryAddress()
```
    从类复制的描述： ByteBuf
    
    返回指向备份数据第一个字节的低级内存地址。
    
    Specified by:
    
    memoryAddress在类 ByteBuf
  - 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
  - hashCode
```
public int hashCode()
```
    从类复制的描述： ByteBuf
    
    返回从此缓冲区的内容计算出来的哈希码。如果有一个字节数组是equal to这个数组，则两个数组都应该返回相同的值。
    
    Specified by:
    
    hashCode在类 ByteBuf
  - equals
```
public boolean equals(java.lang.Object obj)
```
    从类复制的描述： ByteBuf
    确定指定缓冲区的内容是否与此数组的内容相同。这里的“相同”意思是：
    - 两个缓冲区内容的大小是相同的
    - 两个缓冲区内容的每个字节都是相同的。
    请注意，它不会比较ByteBuf.readerIndex()和ByteBuf.writerIndex() 。此方法还为null返回false ，并返回一个不是ByteBuf类型实例的对象。
    Specified by:
    
    equals在类 ByteBuf
  - compareTo
```
public int compareTo(ByteBuf buffer)
```
    从类复制的描述： 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
  - isReadable
```
public boolean isReadable(int size)
```
    从类复制的描述： ByteBuf
    
    当且仅当此缓冲区包含等于或多于指定数量的元素时返回 true 。
    
    Specified by:
    
    isReadable在类 ByteBuf
  - isWritable
```
public boolean isWritable(int size)
```
    从类复制的描述： ByteBuf
    
    当且仅当此缓冲区有足够空间允许写入指定数量的元素时才返回 true 。
    
    Specified by:
    
    isWritable在类 ByteBuf
  - refCnt
```
public int refCnt()
```
    从接口ReferenceCounted复制的描述
    
    返回此对象的引用计数。如果0 ，则表示此对象已被释放。
  - retain
```
public ByteBuf retain()
```
    从接口ReferenceCounted复制的描述
    
    将引用计数增加 1 。
    
    Specified by:
    
    retain接口 ReferenceCounted
    
    Specified by:
    
    retain在类 ByteBuf
  - retain
```
public ByteBuf retain(int increment)
```
    从接口ReferenceCounted复制的描述
    
    将参考计数增加 increment 。
    
    Specified by:
    
    retain在界面 ReferenceCounted
    
    Specified by:
    
    retain类 ByteBuf
  - touch
```
public ByteBuf touch()
```
    从接口ReferenceCounted复制的描述
    
    记录此对象的当前访问位置以进行调试。如果确定此物体泄漏，则通过此操作记录的信息将通过ResourceLeakDetector提供给您。此方法是touch(null)的快捷方式。
    
    Specified by:
    
    touch接口 ReferenceCounted
    
    Specified by:
    
    touch在类 ByteBuf
  - touch
```
public ByteBuf touch(java.lang.Object hint)
```
    从接口ReferenceCounted复制的描述
    
    记录此对象的当前访问位置，并附加一些用于调试的任意信息。如果确定此物体泄漏，则通过此操作记录的信息将通过ResourceLeakDetector提供给您。
    
    Specified by:
    
    touch接口 ReferenceCounted
    
    Specified by:
    
    touch在类 ByteBuf
  - release
```
public boolean release()
```
    从接口ReferenceCounted复制的描述
    
    通过减小引用计数 1并且如果所述引用计数达到在将释放该对象 0 。
    
    结果
    
    true当且仅当引用计数变为 0且此对象已被释放
  - release
```
public boolean release(int decrement)
```
    从接口ReferenceCounted复制的描述
    
    如果引用计数达到 0则减少引用计数 decrement并释放此对象。
    
    结果
    
    true当且仅当引用计数变为 0且此对象已被释放

Class EmptyByteBuf

构造方法摘要

方法摘要

Methods inherited from class io.netty.buffer.ByteBuf

Methods inherited from class java.lang.Object

构造方法详细信息

EmptyByteBuf

方法详细信息

capacity

capacity

alloc

order

unwrap

asReadOnly

isReadOnly

isDirect

maxCapacity

order

readerIndex

readerIndex

writerIndex

writerIndex

setIndex

readableBytes

writableBytes

maxWritableBytes

isReadable

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

getDouble

getBytes

getBytes

getBytes

getBytes

getBytes

getBytes

getBytes

getBytes

getBytes

getCharSequence

setBoolean

setByte

setShort

setShortLE

setMedium

setMediumLE

setInt

setIntLE

setLong

setLongLE

setChar

setFloat

setDouble