CompositeByteBuf (Netty API Reference (4.1.22.Final))

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

All Implemented Interfaces:

ReferenceCounted ，java.lang.Comparable < ByteBuf >，java.lang.Iterable < ByteBuf >
```
public class CompositeByteBuf
extends AbstractReferenceCountedByteBuf
implements java.lang.Iterable<ByteBuf>
```
将多个缓冲区显示为单个合并缓冲区的虚拟缓冲区。建议使用ByteBufAllocator.compositeBuffer()或Unpooled.wrappedBuffer(ByteBuf...)而不是显式调用构造函数。

构造方法摘要

构造方法
Constructor and Description
`CompositeByteBuf(ByteBufAllocator alloc, boolean direct, int maxNumComponents)`
`CompositeByteBuf(ByteBufAllocator alloc, boolean direct, int maxNumComponents, ByteBuf... buffers)`
`CompositeByteBuf(ByteBufAllocator alloc, boolean direct, int maxNumComponents, java.lang.Iterable<ByteBuf> buffers)`

方法摘要

所有方法接口方法具体的方法
Modifier and Type	Method and Description
`protected byte`	`_getByte(int index)`
`protected int`	`_getInt(int index)`
`protected int`	`_getIntLE(int index)`
`protected long`	`_getLong(int index)`
`protected long`	`_getLongLE(int index)`
`protected short`	`_getShort(int index)`
`protected short`	`_getShortLE(int index)`
`protected int`	`_getUnsignedMedium(int index)`
`protected int`	`_getUnsignedMediumLE(int index)`
`protected void`	`_setByte(int index, int value)`
`protected void`	`_setInt(int index, int value)`
`protected void`	`_setIntLE(int index, int value)`
`protected void`	`_setLong(int index, long value)`
`protected void`	`_setLongLE(int index, long value)`
`protected void`	`_setMedium(int index, int value)`
`protected void`	`_setMediumLE(int index, int value)`
`protected void`	`_setShort(int index, int value)`
`protected void`	`_setShortLE(int index, int value)`
`CompositeByteBuf`	`addComponent(boolean increaseWriterIndex, ByteBuf buffer)` 添加指定的`ByteBuf` ，增加`writerIndex`如果`increaseWriterIndex`是`true` 。
`CompositeByteBuf`	`addComponent(boolean increaseWriterIndex, int cIndex, ByteBuf buffer)` 添加指定的`ByteBuf`具体指标，并增加了`writerIndex`如果`increaseWriterIndex`是`true` 。
`CompositeByteBuf`	`addComponent(ByteBuf buffer)` 添加给定的`ByteBuf` 。
`CompositeByteBuf`	`addComponent(int cIndex, ByteBuf buffer)` 在特定索引上添加给定的`ByteBuf` 。
`CompositeByteBuf`	`addComponents(boolean increaseWriterIndex, ByteBuf... buffers)` 添加指定的`ByteBuf`个 S和增加`writerIndex`如果`increaseWriterIndex`是`true` 。
`CompositeByteBuf`	`addComponents(boolean increaseWriterIndex, java.lang.Iterable<ByteBuf> buffers)` 添加指定的`ByteBuf`个 S和增加`writerIndex`如果`increaseWriterIndex`是`true` 。
`CompositeByteBuf`	`addComponents(ByteBuf... buffers)` 添加给定的`ByteBuf` 。
`CompositeByteBuf`	`addComponents(int cIndex, ByteBuf... buffers)` 在特定索引上添加给定`ByteBuf`请注意，此方法不会增加`writerIndex`的writerIndex 。
`CompositeByteBuf`	`addComponents(int cIndex, java.lang.Iterable<ByteBuf> buffers)` 将特定索引添加给定的`ByteBuf`请注意，此方法不会增加`writerIndex`的writerIndex 。
`CompositeByteBuf`	`addComponents(java.lang.Iterable<ByteBuf> buffers)` 添加给定的`ByteBuf` 。
`ByteBufAllocator`	`alloc()` 返回创建此缓冲区的`ByteBufAllocator` 。
`byte[]`	`array()` 返回此缓冲区的后备字节数组。
`int`	`arrayOffset()` 返回此缓冲区的后备字节数组中第一个字节的偏移量。
`int`	`capacity()` 返回此缓冲区可包含的字节数（字节）。
`CompositeByteBuf`	`capacity(int newCapacity)` 调整此缓冲区的容量。
`CompositeByteBuf`	`clear()` 将此缓冲区的 `readerIndex`和 `writerIndex`设置为 `0` 。
`ByteBuf`	`component(int cIndex)` 返回指定索引上的`ByteBuf`
`ByteBuf`	`componentAtOffset(int offset)` 返回指定索引上的`ByteBuf`
`CompositeByteBuf`	`consolidate()` 合并组成的`ByteBuf`
`CompositeByteBuf`	`consolidate(int cIndex, int numComponents)` 合并组成的`ByteBuf`
`ByteBuf`	`copy(int index, int length)` 返回此缓冲区的子区域的副本。
`protected void`	`deallocate()` 一次调用 `AbstractReferenceCountedByteBuf.refCnt()`等于0。
`java.util.List<ByteBuf>`	`decompose(int offset, int length)` 除了此方法返回一个列表外，与 `AbstractByteBuf.slice(int, int)`相同。
`CompositeByteBuf`	`discardReadBytes()` 丢弃第0个索引和 `readerIndex`之间的字节。
`CompositeByteBuf`	`discardReadComponents()` 丢弃所有被读取的`ByteBuf` 。
`CompositeByteBuf`	`discardSomeReadBytes()` 与 `ByteBuf.discardReadBytes()`类似，不同之处在于此方法可能会丢弃部分，全部或者全部读取字节，具体取决于其内部实现方式，以减少潜在的额外内存消耗为代价降低整体内存带宽消耗。
`CompositeByteBuf`	`ensureWritable(int minWritableBytes)` 确保 the writable bytes的数量等于或大于指定的值。
`byte`	`getByte(int index)` 获取此缓冲区中指定的绝对 `index`一个字节。
`CompositeByteBuf`	`getBytes(int index, byte[] dst)` 将此缓冲区的数据传输到指定绝对 `index`开始的目标。
`CompositeByteBuf`	`getBytes(int index, byte[] dst, int dstIndex, int length)` 将此缓冲区的数据传输到指定的绝对目标 `index`开始的目标。
`CompositeByteBuf`	`getBytes(int index, ByteBuf dst)` 将该缓冲区的数据传输到指定的目的地，从指定的绝对 `index`开始，直到目标变为不可写。
`CompositeByteBuf`	`getBytes(int index, java.nio.ByteBuffer dst)` 将该缓冲区的数据传输到指定的目的地，从指定的绝对 `index`开始，直到目的地的位置达到其限制。
`CompositeByteBuf`	`getBytes(int index, ByteBuf dst, int length)` 将此缓冲区的数据传输到指定绝对 `index`开始的目标 `index` 。
`CompositeByteBuf`	`getBytes(int index, ByteBuf dst, int dstIndex, int length)` 将此缓冲区的数据传输到指定的绝对 `index`开始的目标。
`int`	`getBytes(int index, java.nio.channels.FileChannel out, long position, int length)` 将此缓冲区的数据从指定的绝对 `index`开始 `index`到指定的通道，从给定的文件位置开始。
`int`	`getBytes(int index, java.nio.channels.GatheringByteChannel out, int length)` 将此缓冲区的数据传输到指定的绝对 `index`开始的通道。
`CompositeByteBuf`	`getBytes(int index, java.io.OutputStream out, int length)` 将此缓冲区的数据传输到指定的绝对 `index`开始的流。
`boolean`	`hasArray()` 当且仅当此缓冲区有一个后备字节数组时返回 `true` 。
`boolean`	`hasMemoryAddress()` 当且仅当此缓冲区引用指向后备数据的低级内存地址时才返回 `true` 。
`ByteBuf`	`internalComponent(int cIndex)` 返回指定索引上的内部`ByteBuf` 。
`ByteBuf`	`internalComponentAtOffset(int offset)` 在指定的偏移量上返回内部`ByteBuf` 。
`java.nio.ByteBuffer`	`internalNioBuffer(int index, int length)` 仅内部使用：公开内部NIO缓冲区。
`boolean`	`isDirect()` 当且仅当此缓冲区由NIO直接缓冲区支持时才返回 `true` 。
`java.util.Iterator<ByteBuf>`	`iterator()`
`CompositeByteBuf`	`markReaderIndex()` 在此缓冲区中标记当前的 `readerIndex` 。
`CompositeByteBuf`	`markWriterIndex()` 在此缓冲区中标记当前 `writerIndex` 。
`int`	`maxNumComponents()` 返回在此实例中组成的最大数量`ByteBuf`
`long`	`memoryAddress()` 返回指向备份数据第一个字节的低级内存地址。
`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缓冲区的位置和限制不会影响此索引和标记缓冲。
`int`	`numComponents()` 返回在此实例中组成的当前编号`ByteBuf`
`java.nio.ByteOrder`	`order()` 返回此缓冲区的 endianness 。
`CompositeByteBuf`	`readBytes(byte[] dst)` 传输此缓冲区的数据到指定的目标并从当前 `readerIndex`并增加了 `readerIndex`由传输的字节（=数量 `dst.length` ）。
`CompositeByteBuf`	`readBytes(byte[] dst, int dstIndex, int length)` 将此缓冲区的数据传输到从当前 `readerIndex`开始的指定目标， `readerIndex`传输字节数（= `length` ）增加 `length` 。
`CompositeByteBuf`	`readBytes(ByteBuf dst)` 将此缓冲区的数据传输到指定的目标，从当前 `readerIndex`开始，直到目标变为不可写入，并将传输字节数增加 `readerIndex` 。
`CompositeByteBuf`	`readBytes(java.nio.ByteBuffer dst)` 将此缓冲区的数据传输到指定的目标，从当前 `readerIndex`开始，直到目标的位置达到其限制，并将 `readerIndex`增加 `readerIndex`的传输字节数。
`CompositeByteBuf`	`readBytes(ByteBuf dst, int length)` 传输此缓冲区的数据到指定的目标并从当前 `readerIndex`并增加了 `readerIndex`由传输的字节（=数量 `length` ）。
`CompositeByteBuf`	`readBytes(ByteBuf dst, int dstIndex, int length)` 传输此缓冲区的数据到指定的目标并从当前 `readerIndex`并增加了 `readerIndex`由传输的字节（=数量 `length` ）。
`CompositeByteBuf`	`readBytes(java.io.OutputStream out, int length)` 将此缓冲区的数据传输到当前 `readerIndex`开始的指定流。
`CompositeByteBuf`	`readerIndex(int readerIndex)` 设置此缓冲区的 `readerIndex` 。
`CompositeByteBuf`	`removeComponent(int cIndex)` 从给定的索引中删除`ByteBuf` 。
`CompositeByteBuf`	`removeComponents(int cIndex, int numComponents)` 从指定索引开始删除`ByteBuf`的数量。
`CompositeByteBuf`	`resetReaderIndex()` 将当前 `readerIndex`重新定位到此缓冲区中标记为 `readerIndex` 。
`CompositeByteBuf`	`resetWriterIndex()` 将当前 `writerIndex`重新定位到此缓冲区中标记为 `writerIndex` 。
`CompositeByteBuf`	`retain()` 将参考计数增加 `1` 。
`CompositeByteBuf`	`retain(int increment)` 通过指定的 `increment`增加引用计数。
`CompositeByteBuf`	`setBoolean(int index, boolean value)` 在此缓冲区中的指定绝对 `index`处设置指定的布尔值。
`CompositeByteBuf`	`setByte(int index, int value)` 在此缓冲区中的指定绝对 `index`处设置指定的字节。
`CompositeByteBuf`	`setBytes(int index, byte[] src)` 将指定的源数组的数据传输到此缓冲区，从指定的绝对 `index` 。
`CompositeByteBuf`	`setBytes(int index, byte[] src, int srcIndex, int length)` 将指定的源数组的数据传输到此缓冲区，从指定的绝对 `index` 。
`CompositeByteBuf`	`setBytes(int index, ByteBuf src)` 将指定的源缓冲区的数据从指定的绝对 `index`开始传输到此缓冲区，直到源缓冲区变得不可读。
`CompositeByteBuf`	`setBytes(int index, java.nio.ByteBuffer src)` 将指定的源缓冲区的数据从指定的绝对 `index`开始传送到此缓冲区，直到源缓冲区的位置达到其限制。
`CompositeByteBuf`	`setBytes(int index, ByteBuf src, int length)` 将指定的源缓冲区的数据从指定的绝对 `index`开始传送到此缓冲区。
`CompositeByteBuf`	`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`开始传送到此缓冲区。
`CompositeByteBuf`	`setChar(int index, int value)` 在此缓冲区的指定绝对 `index`处设置指定的2字节UTF-16字符。
`CompositeByteBuf`	`setDouble(int index, double value)` 在此缓冲区中的指定绝对 `index`处设置指定的64位浮点数。
`CompositeByteBuf`	`setFloat(int index, float value)` 在此缓冲区中的指定绝对 `index`处设置指定的32位浮点数。
`CompositeByteBuf`	`setIndex(int readerIndex, int writerIndex)` `readerIndex`设置此缓冲区的 `readerIndex`和 `writerIndex` 。
`CompositeByteBuf`	`setInt(int index, int value)` 在此缓冲区中的指定绝对 `index`处设置指定的32位整数。
`CompositeByteBuf`	`setLong(int index, long value)` 在此缓冲区中的指定绝对 `index`处设置指定的64位长整数。
`CompositeByteBuf`	`setMedium(int index, int value)` 在此缓冲区中的指定绝对 `index`处设置指定的24位中等整数。
`CompositeByteBuf`	`setShort(int index, int value)` 在此缓冲区中的指定绝对 `index`处设置指定的16位短整数。
`CompositeByteBuf`	`setZero(int index, int length)` `NUL (0x00)`从指定的绝对 `index`开始填充此缓冲区。
`CompositeByteBuf`	`skipBytes(int length)` 此缓冲区中指定的 `length`增加当前 `readerIndex` 。
`int`	`toByteIndex(int cIndex)`
`int`	`toComponentIndex(int offset)` 返回给定偏移量的索引
`java.lang.String`	`toString()` 返回此缓冲区的字符串表示形式。
`CompositeByteBuf`	`touch()` 记录此对象的当前访问位置以进行调试。
`CompositeByteBuf`	`touch(java.lang.Object hint)` 记录此对象的当前访问位置，并附加一些用于调试的任意信息。
`ByteBuf`	`unwrap()` 如果此缓冲区是另一个缓冲区的包装，则返回底层缓冲区实例。
`CompositeByteBuf`	`writeBoolean(boolean value)` 在当前 `writerIndex`处设置指定的布尔值，并在此缓冲区 `writerIndex` `1`增加 `writerIndex` 。
`CompositeByteBuf`	`writeByte(int value)` 在当前 `writerIndex`处设置指定的字节，并在此缓冲区 `writerIndex` `1`增加 `writerIndex` 。
`CompositeByteBuf`	`writeBytes(byte[] src)` 指定的源阵列的数据传送到该缓冲液并从当前 `writerIndex`并增加了 `writerIndex`由传输的字节（=数量 `src.length` ）。
`CompositeByteBuf`	`writeBytes(byte[] src, int srcIndex, int length)` 将指定的源数组的数据传输到此缓冲区，从当前 `writerIndex`开始，并将 `writerIndex`增加 `writerIndex`传输的字节数（= `length` ）。
`CompositeByteBuf`	`writeBytes(ByteBuf src)` 将指定的源缓冲区数据传输到此缓冲区，从当前 `writerIndex`开始，直到源缓冲区变得不可读，并将传输字节数增加 `writerIndex` 。
`CompositeByteBuf`	`writeBytes(java.nio.ByteBuffer src)` 将指定源缓冲区的数据传输到此缓冲区，从当前 `writerIndex`开始，直到源缓冲区的位置达到其限制，并将传输字节数增加 `writerIndex` 。
`CompositeByteBuf`	`writeBytes(ByteBuf src, int length)` 指定的源缓冲区的数据传送到该缓冲液并从当前 `writerIndex`并增加了 `writerIndex`由传输的字节（=数量 `length` ）。
`CompositeByteBuf`	`writeBytes(ByteBuf src, int srcIndex, int length)` 指定的源缓冲区的数据传送到该缓冲液并从当前 `writerIndex`并增加了 `writerIndex`由传输的字节（=数量 `length` ）。
`CompositeByteBuf`	`writeChar(int value)` 在当前 `writerIndex`处设置指定的2字节UTF-16字符，并在此缓冲区 `writerIndex` `2`增加 `writerIndex` 。
`CompositeByteBuf`	`writeDouble(double value)` 在当前 `writerIndex`处设置指定的64位浮点数，并在此缓冲区 `writerIndex` `8`增加 `writerIndex` 。
`CompositeByteBuf`	`writeFloat(float value)` 在当前 `writerIndex`处设置指定的32位浮点数，并在此缓冲区 `writerIndex` `4`增加 `writerIndex` 。
`CompositeByteBuf`	`writeInt(int value)` 在当前 `writerIndex`处设置指定的32位整数，并在此缓冲区 `writerIndex` `4`增加 `writerIndex` 。
`CompositeByteBuf`	`writeLong(long value)` 在当前 `writerIndex`处设置指定的64位长整数，并在此缓冲区 `writerIndex` `8`增加 `writerIndex` 。
`CompositeByteBuf`	`writeMedium(int value)` 在当前 `writerIndex`中设置指定的24位中等整数，并在此缓冲区 `writerIndex` `3`增加 `writerIndex` 。
`CompositeByteBuf`	`writerIndex(int writerIndex)` 设置此缓冲区的 `writerIndex` 。
`CompositeByteBuf`	`writeShort(int value)` 在当前 `writerIndex`处设置指定的16位短整数，并在此缓冲区 `writerIndex` `2`增加 `writerIndex` 。
`CompositeByteBuf`	`writeZero(int length)` 填充这个缓冲器与 `NUL (0x00)`并从当前 `writerIndex`并增加了 `writerIndex`由指定的 `length` 。

Methods inherited from class io.netty.buffer.AbstractReferenceCountedByteBuf
refCnt, release, release, setRefCnt

Methods inherited from class io.netty.buffer.AbstractByteBuf
adjustMarkers, asReadOnly, bytesBefore, bytesBefore, bytesBefore, checkDstIndex, checkIndex, checkIndex, checkNewCapacity, checkReadableBytes, checkSrcIndex, compareTo, copy, duplicate, ensureAccessible, ensureWritable, equals, forEachByte, forEachByte, forEachByteDesc, forEachByteDesc, getBoolean, getChar, getCharSequence, getDouble, getFloat, getInt, getIntLE, getLong, getLongLE, getMedium, getMediumLE, getShort, getShortLE, getUnsignedByte, getUnsignedInt, getUnsignedIntLE, getUnsignedMedium, getUnsignedMediumLE, getUnsignedShort, getUnsignedShortLE, hashCode, indexOf, isReadable, isReadable, isReadOnly, isWritable, isWritable, maxCapacity, maxCapacity, maxWritableBytes, newSwappedByteBuf, nioBuffer, order, readableBytes, readBoolean, readByte, readBytes, readBytes, readBytes, readChar, readCharSequence, readDouble, readerIndex, readFloat, readInt, readIntLE, readLong, readLongLE, readMedium, readMediumLE, readRetainedSlice, readShort, readShortLE, readSlice, readUnsignedByte, readUnsignedInt, readUnsignedIntLE, readUnsignedMedium, readUnsignedMediumLE, readUnsignedShort, readUnsignedShortLE, retainedDuplicate, retainedSlice, retainedSlice, setCharSequence, setIntLE, setLongLE, setMediumLE, setShortLE, slice, slice, toString, toString, writableBytes, writeBytes, writeBytes, writeBytes, writeCharSequence, writeIntLE, writeLongLE, writeMediumLE, writerIndex, writeShortLE

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

Methods inherited from interface java.lang.Iterable
forEach, spliterator

- 构造方法详细信息
  - CompositeByteBuf
```
public CompositeByteBuf(ByteBufAllocator alloc,
                        boolean direct,
                        int maxNumComponents)
```
  - CompositeByteBuf
```
public CompositeByteBuf(ByteBufAllocator alloc,
                        boolean direct,
                        int maxNumComponents,
                        ByteBuf... buffers)
```
  - CompositeByteBuf
```
public CompositeByteBuf(ByteBufAllocator alloc,
                        boolean direct,
                        int maxNumComponents,
                        java.lang.Iterable<ByteBuf> buffers)
```
- 方法详细信息
  - addComponent
```
public CompositeByteBuf addComponent(ByteBuf buffer)
```
    添加给定的ByteBuf 。
    请注意，此方法不会增加writerIndex的writerIndex 。如果你需要增加使用addComponent(boolean, ByteBuf) 。
    
    ReferenceCounted.release()所有权buffer被转移到这个CompositeByteBuf 。
    
    参数
    
    buffer - 要添加ByteBuf 。 ReferenceCounted.release()所有权转移到此CompositeByteBuf 。
  - addComponents
```
public CompositeByteBuf addComponents(ByteBuf... buffers)
```
    添加给定的ByteBuf 。
    请注意，此方法不会增加writerIndex的writerIndex 。如果你需要增加使用addComponents(boolean, ByteBuf[]) 。
    
    ReferenceCounted.release()所有的所有权ByteBuf个的对象buffers被转移到这个CompositeByteBuf 。
    
    参数
    
    buffers - 要添加的ByteBuf 。 ReferenceCounted.release()所有的所有权ReferenceCounted.release()所有的所有权ByteBuf个对象被转移到这个CompositeByteBuf 。
  - addComponents
```
public CompositeByteBuf addComponents(java.lang.Iterable<ByteBuf> buffers)
```
    添加给定的ByteBuf 。
    请注意，此方法不会增加writerIndex的writerIndex 。如果你需要增加使用addComponents(boolean, Iterable) 。
    
    ReferenceCounted.release()所有的所有权ByteBuf个的对象buffers被转移到这个CompositeByteBuf 。
    
    参数
    
    buffers - 要添加的ByteBuf 。 ReferenceCounted.release()所有的所有权ReferenceCounted.release()所有的所有权ByteBuf个对象被转移到这个CompositeByteBuf 。
  - addComponent
```
public CompositeByteBuf addComponent(int cIndex,
                                     ByteBuf buffer)
```
    在特定索引上添加给定的ByteBuf 。
    请注意，此方法不会增加writerIndex的writerIndex 。如果你需要增加使用addComponent(boolean, int, ByteBuf) 。
    
    ReferenceCounted.release()所有权buffer被转移到这个CompositeByteBuf 。
    
    参数
    
    cIndex -在其上的指数ByteBuf将被添加。
    
    buffer - 添加ByteBuf 。 ReferenceCounted.release()所有权转移到此CompositeByteBuf 。
  - addComponent
```
public CompositeByteBuf addComponent(boolean increaseWriterIndex,
                                     ByteBuf buffer)
```
    添加指定的ByteBuf ，增加writerIndex如果increaseWriterIndex是true 。 ReferenceCounted.release()所有权buffer被转移到这个CompositeByteBuf 。
    
    参数
    
    buffer - 添加ByteBuf 。 ReferenceCounted.release()所有权转移到此CompositeByteBuf 。
  - addComponents
```
public CompositeByteBuf addComponents(boolean increaseWriterIndex,
                                      ByteBuf... buffers)
```
    添加指定的ByteBuf个 S和增加writerIndex如果increaseWriterIndex是true 。 ReferenceCounted.release()所有的所有权ByteBuf个的对象buffers被转移到这个CompositeByteBuf 。
    
    参数
    
    buffers - 要添加的ByteBuf 。 ReferenceCounted.release()全部ByteBuf所有权ByteBuf所有权ByteBuf转移到此CompositeByteBuf 。
  - addComponents
```
public CompositeByteBuf addComponents(boolean increaseWriterIndex,
                                      java.lang.Iterable<ByteBuf> buffers)
```
    添加指定的ByteBuf个 S和增加writerIndex如果increaseWriterIndex是true 。 ReferenceCounted.release()所有的所有权ByteBuf个的对象buffers被转移到这个CompositeByteBuf 。
    
    参数
    
    buffers - 要添加的ByteBuf 。 ReferenceCounted.release()所有的所有权ReferenceCounted.release()所有的所有权ByteBuf个对象被转移到这个CompositeByteBuf 。
  - addComponent
```
public CompositeByteBuf addComponent(boolean increaseWriterIndex,
                                     int cIndex,
                                     ByteBuf buffer)
```
    添加指定的ByteBuf具体指标，并增加了writerIndex如果increaseWriterIndex是true 。 ReferenceCounted.release()所有权buffer被转移到这个CompositeByteBuf 。
    
    参数
    
    cIndex -在其上的指数ByteBuf将被添加。
    
    buffer - 要添加ByteBuf 。 ReferenceCounted.release()所有权转移到此CompositeByteBuf 。
  - addComponents
```
public CompositeByteBuf addComponents(int cIndex,
                                      ByteBuf... buffers)
```
    将特定索引添加给定的ByteBuf
    请注意，此方法不会增加writerIndex的writerIndex 。如果你需要增加它，你需要自己处理它。
    
    ReferenceCounted.release()所有的所有权ByteBuf个的对象buffers被转移到这个CompositeByteBuf 。
    
    参数
    
    cIndex -在其上的指数ByteBuf将被添加。 ReferenceCounted.release()所有的所有权ReferenceCounted.release()所有的所有权ByteBuf个对象被转移到这个CompositeByteBuf 。
    
    buffers - 要添加的ByteBuf 。 ReferenceCounted.release()所有权ReferenceCounted.release()全部ByteBuf对象的所有权转移到此CompositeByteBuf 。
  - addComponents
```
public CompositeByteBuf addComponents(int cIndex,
                                      java.lang.Iterable<ByteBuf> buffers)
```
    在特定索引上添加给定的ByteBuf s请注意，此方法不会增加writerIndex的writerIndex 。如果你需要增加它，你需要自己处理它。
    ReferenceCounted.release()所有的所有权ByteBuf个的对象buffers被转移到这个CompositeByteBuf 。
    
    参数
    
    cIndex -在其上的指数ByteBuf将被添加。
    
    buffers - 要添加的ByteBuf 。 ReferenceCounted.release()所有的所有权ReferenceCounted.release()所有的所有权ByteBuf个对象被转移到这个CompositeByteBuf 。
  - removeComponent
```
public CompositeByteBuf removeComponent(int cIndex)
```
    从给定的索引中删除ByteBuf 。
    
    参数
    
    cIndex -从该索引ByteBuf将被除去
  - removeComponents
```
public CompositeByteBuf removeComponents(int cIndex,
                                         int numComponents)
```
    从给定索引开始删除ByteBuf的数量。
    
    参数
    
    cIndex - ByteBuf将开始移除的索引
    
    numComponents - 要移除的组件数量
  - iterator
```
public java.util.Iterator<ByteBuf> iterator()
```
    Specified by:
    
    iterator在界面 java.lang.Iterable<ByteBuf>
  - decompose
```
public java.util.List<ByteBuf> decompose(int offset,
                                         int length)
```
    除了此方法返回一个列表外，与 AbstractByteBuf.slice(int, int)相同。
  - isDirect
```
public boolean isDirect()
```
    从类复制的描述： ByteBuf
    
    当且仅当此缓冲区由NIO直接缓冲区支持时才返回 true 。
    
    Specified by:
    
    isDirect在类 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
  - capacity
```
public int capacity()
```
    从类复制的描述： ByteBuf
    
    返回此缓冲区可包含的字节数（字节）。
    
    Specified by:
    
    capacity在类 ByteBuf
  - capacity
```
public CompositeByteBuf 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
  - numComponents
```
public int numComponents()
```
    返回在此实例中组成的当前编号ByteBuf
  - maxNumComponents
```
public int maxNumComponents()
```
    返回在此实例中组成的最大数量ByteBuf
  - toComponentIndex
```
public int toComponentIndex(int offset)
```
    返回给定偏移量的索引
  - toByteIndex
```
public int toByteIndex(int cIndex)
```
  - getByte
```
public byte getByte(int index)
```
    从类复制的描述： ByteBuf
    
    获取此缓冲区中指定的绝对index一个字节。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    重写：
    
    getByte在类 AbstractByteBuf
  - _getByte
```
protected byte _getByte(int index)
```
    Specified by:
    
    _getByte在类 AbstractByteBuf
  - _getShort
```
protected short _getShort(int index)
```
    Specified by:
    
    _getShort类 AbstractByteBuf
  - _getShortLE
```
protected short _getShortLE(int index)
```
    Specified by:
    
    _getShortLE在类 AbstractByteBuf
  - _getUnsignedMedium
```
protected int _getUnsignedMedium(int index)
```
    Specified by:
    
    _getUnsignedMedium在类 AbstractByteBuf
  - _getUnsignedMediumLE
```
protected int _getUnsignedMediumLE(int index)
```
    Specified by:
    
    _getUnsignedMediumLE在类 AbstractByteBuf
  - _getInt
```
protected int _getInt(int index)
```
    Specified by:
    
    _getInt在类 AbstractByteBuf
  - _getIntLE
```
protected int _getIntLE(int index)
```
    Specified by:
    
    _getIntLE在类 AbstractByteBuf
  - _getLong
```
protected long _getLong(int index)
```
    Specified by:
    
    _getLong在类 AbstractByteBuf
  - _getLongLE
```
protected long _getLongLE(int index)
```
    Specified by:
    
    _getLongLE在类 AbstractByteBuf
  - getBytes
```
public CompositeByteBuf getBytes(int index,
                                 byte[] dst,
                                 int dstIndex,
                                 int length)
```
    从类复制的描述： ByteBuf
    
    将此缓冲区的数据传输到指定绝对index开始的目标index 。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    getBytes在类 ByteBuf
    
    dstIndex - 目的地的第一个索引
    
    length - 要传输的字节数
  - getBytes
```
public CompositeByteBuf getBytes(int index,
                                 java.nio.ByteBuffer dst)
```
    从类中复制的描述： ByteBuf
    
    将此缓冲区的数据传输到指定的目的地，从指定的绝对index开始，直到目标位置达到其限制。此方法不会修改此缓冲区的readerIndex或writerIndex ，而目标的position将会增加。
    
    Specified by:
    
    getBytes在类 ByteBuf
  - getBytes
```
public CompositeByteBuf getBytes(int index,
                                 ByteBuf dst,
                                 int dstIndex,
                                 int length)
```
    从类复制的描述： ByteBuf
    
    将此缓冲区的数据传输到指定的绝对目标index开始的目标。此方法不会修改源（即this ）和目标的readerIndex或writerIndex 。
    
    Specified by:
    
    getBytes在类 ByteBuf
    
    dstIndex - 目的地的第一个索引
    
    length - 要传输的字节数
  - getBytes
```
public int getBytes(int index,
                    java.nio.channels.GatheringByteChannel out,
                    int length)
             throws java.io.IOException
```
    从类复制的描述： ByteBuf
    
    将此缓冲区的数据传输到指定绝对index开始的通道。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    getBytes在类 ByteBuf
    
    length - 传输的最大字节数
    
    结果
    
    写出到指定通道的实际字节数
    
    异常
    
    java.io.IOException - 如果指定的通道在I / O期间引发异常
  - getBytes
```
public int getBytes(int index,
                    java.nio.channels.FileChannel out,
                    long position,
                    int length)
             throws java.io.IOException
```
    从类复制的描述： ByteBuf
    
    将此缓冲区的数据从指定的绝对index开始index到指定的通道，从给定的文件位置开始。此方法不会修改此缓冲区的readerIndex或writerIndex 。此方法不会修改频道的位置。
    
    Specified by:
    
    getBytes在类 ByteBuf
    
    position - 传输开始的文件位置
    
    length - 传输的最大字节数
    
    结果
    
    写出到指定通道的实际字节数
    
    异常
    
    java.io.IOException - 如果指定的通道在I / O期间引发异常
  - getBytes
```
public CompositeByteBuf getBytes(int index,
                                 java.io.OutputStream out,
                                 int length)
                          throws java.io.IOException
```
    从类中复制的描述： ByteBuf
    
    将此缓冲区的数据传输到指定绝对index开始的指定流。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    getBytes在类 ByteBuf
    
    length - 要传输的字节数
    
    异常
    
    java.io.IOException - 如果指定的流在I / O期间抛出异常
  - setByte
```
public CompositeByteBuf setByte(int index,
                                int value)
```
    从类复制的描述： ByteBuf
    
    在此缓冲区中的指定绝对index处设置指定的字节。指定值的24个高位被忽略。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    重写：
    
    setByte在类 AbstractByteBuf
  - _setByte
```
protected void _setByte(int index,
                        int value)
```
    Specified by:
    
    _setByte类 AbstractByteBuf
  - setShort
```
public CompositeByteBuf setShort(int index,
                                 int value)
```
    从类复制的描述： ByteBuf
    
    在此缓冲区中的指定绝对index处设置指定的16位短整数。指定值的16个高位被忽略。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    重写：
    
    setShort在类 AbstractByteBuf
  - _setShort
```
protected void _setShort(int index,
                         int value)
```
    Specified by:
    
    _setShort在类 AbstractByteBuf
  - _setShortLE
```
protected void _setShortLE(int index,
                           int value)
```
    Specified by:
    
    _setShortLE在类 AbstractByteBuf
  - setMedium
```
public CompositeByteBuf setMedium(int index,
                                  int value)
```
    从类复制的描述： ByteBuf
    
    在此缓冲区中的指定绝对index处设置指定的24位中等整数。请注意，最高有效字节在指定值中被忽略。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    重写：
    
    setMedium在类 AbstractByteBuf
  - _setMedium
```
protected void _setMedium(int index,
                          int value)
```
    Specified by:
    
    _setMedium在课堂上 AbstractByteBuf
  - _setMediumLE
```
protected void _setMediumLE(int index,
                            int value)
```
    Specified by:
    
    _setMediumLE类 AbstractByteBuf
  - setInt
```
public CompositeByteBuf setInt(int index,
                               int value)
```
    从类复制的描述： ByteBuf
    
    在此缓冲区中指定的绝对index处设置指定的32位整数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    重写：
    
    setInt在类 AbstractByteBuf
  - _setInt
```
protected void _setInt(int index,
                       int value)
```
    Specified by:
    
    _setInt在类 AbstractByteBuf
  - _setIntLE
```
protected void _setIntLE(int index,
                         int value)
```
    Specified by:
    
    _setIntLE在类 AbstractByteBuf
  - setLong
```
public CompositeByteBuf setLong(int index,
                                long value)
```
    从类复制的描述： ByteBuf
    
    在此缓冲区中的指定绝对index处设置指定的64位长整数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    重写：
    
    setLong在类 AbstractByteBuf
  - _setLong
```
protected void _setLong(int index,
                        long value)
```
    Specified by:
    
    _setLong在类 AbstractByteBuf
  - _setLongLE
```
protected void _setLongLE(int index,
                          long value)
```
    Specified by:
    
    _setLongLE在类 AbstractByteBuf
  - setBytes
```
public CompositeByteBuf setBytes(int index,
                                 byte[] src,
                                 int srcIndex,
                                 int length)
```
    从类复制的描述： ByteBuf
    
    将指定的源数组的数据传输到此缓冲区，从指定的绝对index 。此方法不修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    setBytes在类 ByteBuf
  - setBytes
```
public CompositeByteBuf setBytes(int index,
                                 java.nio.ByteBuffer src)
```
    从类复制的描述： ByteBuf
    
    将指定的源缓冲区的数据从指定的绝对index开始传输到此缓冲区，直到源缓冲区的位置达到其限制。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    setBytes在类 ByteBuf
  - setBytes
```
public CompositeByteBuf setBytes(int index,
                                 ByteBuf src,
                                 int srcIndex,
                                 int length)
```
    从类复制的描述： ByteBuf
    
    将指定的源缓冲区的数据从指定的绝对index开始传送到此缓冲区。此方法不会修改源（即this ）和目标的readerIndex或writerIndex 。
    
    Specified by:
    
    setBytes在类 ByteBuf
    
    srcIndex - 来源的第一个索引
    
    length - 要传输的字节数
  - setBytes
```
public int setBytes(int index,
                    java.io.InputStream in,
                    int length)
             throws java.io.IOException
```
    从类复制的描述： ByteBuf
    
    将指定源流的内容从指定的绝对index开始传输到此缓冲区。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    setBytes在类 ByteBuf
    
    length - 要传输的字节数
    
    结果
    
    从指定通道读入的实际字节数。如果指定的频道已关闭， -1 。
    
    异常
    
    java.io.IOException - 如果指定的流在I / O期间抛出异常
  - setBytes
```
public int setBytes(int index,
                    java.nio.channels.ScatteringByteChannel in,
                    int length)
             throws java.io.IOException
```
    从类复制的描述： ByteBuf
    
    将指定源通道的内容从指定的绝对index开始传输到此缓冲区。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    setBytes在类 ByteBuf
    
    length - 传输的最大字节数
    
    结果
    
    从指定通道读入的实际字节数。 -1如果指定的频道已关闭。
    
    异常
    
    java.io.IOException - 如果指定的通道在I / O期间引发异常
  - setBytes
```
public int setBytes(int index,
                    java.nio.channels.FileChannel in,
                    long position,
                    int length)
             throws java.io.IOException
```
    从类复制的描述： ByteBuf
    
    将从给定文件位置开始的指定源通道的内容传输到此缓冲区，从指定的绝对index 。此方法不会修改此缓冲区的readerIndex或writerIndex 。此方法不会修改频道的位置。
    
    Specified by:
    
    setBytes在类 ByteBuf
    
    position - 传输开始的文件位置
    
    length - 要传输的最大字节数
    
    结果
    
    从指定通道读入的实际字节数。 -1如果指定的频道已关闭。
    
    异常
    
    java.io.IOException - 如果指定的通道在I / O期间引发异常
  - copy
```
public ByteBuf copy(int index,
                    int length)
```
    从类复制的描述： ByteBuf
    
    返回此缓冲区的子区域的副本。修改返回的缓冲区或缓冲区的内容完全不会相互影响。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    Specified by:
    
    copy在类 ByteBuf
  - component
```
public ByteBuf component(int cIndex)
```
    返回指定索引上的ByteBuf
    
    参数
    
    cIndex -查找索引ByteBuf应退还
    
    结果
    
    在指定的索引上buf ByteBuf
  - componentAtOffset
```
public ByteBuf componentAtOffset(int offset)
```
    返回指定索引上的ByteBuf
    
    参数
    
    offset -偏移量为其ByteBuf应退还
    
    结果
    
    指定索引上的ByteBuf
  - internalComponent
```
public ByteBuf internalComponent(int cIndex)
```
    返回指定索引上的内部ByteBuf 。请注意，更新返回缓冲区的索引将导致此缓冲区的未定义行为。
    
    参数
    
    cIndex -查找索引ByteBuf应退还
  - internalComponentAtOffset
```
public ByteBuf internalComponentAtOffset(int offset)
```
    在指定的偏移量上返回内部ByteBuf 。请注意，更新返回缓冲区的索引将导致此缓冲区的未定义行为。
    
    参数
    
    offset -偏移量为其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)
  - internalNioBuffer
```
public java.nio.ByteBuffer internalNioBuffer(int index,
                                             int length)
```
    从类复制的描述： ByteBuf
    
    仅内部使用：公开内部NIO缓冲区。
    
    Specified by:
    
    internalNioBuffer在类 ByteBuf
  - 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(int index,
                                        int length)
```
    从类复制的描述： ByteBuf
    
    以指定的索引和长度公开此缓冲区的字节为NIO ByteBuffer返回的缓冲区共享或包含此缓冲区的复制内容，同时更改返回的NIO缓冲区的位置和限制不会影响此索引和标记缓冲。此方法不会修改此缓冲区的readerIndex或writerIndex 。请注意，如果此缓冲区是动态缓冲区并且它调整了其容量，则返回的NIO缓冲区将不会看到此缓冲区的更改。
    
    Specified by:
    
    nioBuffers在类 ByteBuf
    
    另请参见：
    
    ByteBuf.nioBufferCount() ， ByteBuf.nioBuffer() ， ByteBuf.nioBuffer(int, int)
  - consolidate
```
public CompositeByteBuf consolidate()
```
    合并组成的ByteBuf
  - consolidate
```
public CompositeByteBuf consolidate(int cIndex,
                                    int numComponents)
```
    合并组成的ByteBuf
    
    参数
    
    cIndex - 开始撰写的索引
    
    numComponents - 组成的组件数量
  - discardReadComponents
```
public CompositeByteBuf discardReadComponents()
```
    丢弃所有被读取的ByteBuf 。
  - discardReadBytes
```
public CompositeByteBuf discardReadBytes()
```
    从类复制的描述： ByteBuf
    
    丢弃第0个索引和readerIndex之间的字节。它移动之间的字节readerIndex和writerIndex至第0索引，并且设置readerIndex和writerIndex至0和oldWriterIndex - oldReaderIndex分别。
    请参阅班级文件以获得更详细的解释。
    
    重写：
    
    discardReadBytes在类 AbstractByteBuf
  - toString
```
public java.lang.String toString()
```
    从类复制的描述： ByteBuf
    
    返回此缓冲区的字符串表示形式。这种方法不一定返回缓冲区的全部内容，但返回的主要性能如值ByteBuf.readerIndex() ， ByteBuf.writerIndex()和ByteBuf.capacity() 。
    
    重写：
    
    toString在类 AbstractByteBuf
  - readerIndex
```
public CompositeByteBuf readerIndex(int readerIndex)
```
    从类复制的描述： ByteBuf
    
    设置此缓冲区的 readerIndex 。
    
    重写：
    
    readerIndex在类 AbstractByteBuf
  - writerIndex
```
public CompositeByteBuf writerIndex(int writerIndex)
```
    从类复制的描述： ByteBuf
    
    设置此缓冲区的 writerIndex 。
    
    重写：
    
    writerIndex在类 AbstractByteBuf
  - setIndex
```
public CompositeByteBuf 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); 
```
    重写：
    
    setIndex AbstractByteBuf
  - clear
```
public CompositeByteBuf clear()
```
    从类复制的描述： ByteBuf
    
    将此缓冲区的readerIndex和writerIndex设置为0 。该方法与setIndex(0, 0)完全相同。
    请注意，此方法的行为与NIO缓冲区的行为不同，后者将limit设置为limit的capacity 。
    
    重写：
    
    clear在类 AbstractByteBuf
  - markReaderIndex
```
public CompositeByteBuf markReaderIndex()
```
    从类复制的描述： ByteBuf
    
    在此缓冲区中标记当前的readerIndex 。您可以重新定位当前readerIndex到标记readerIndex通过调用ByteBuf.resetReaderIndex() 。标记的初始值readerIndex是0 。
    
    重写：
    
    markReaderIndex在类 AbstractByteBuf
  - resetReaderIndex
```
public CompositeByteBuf resetReaderIndex()
```
    从类复制的描述： ByteBuf
    
    将当前 readerIndex重新定位到此缓冲区中标记为 readerIndex 。
    
    重写：
    
    resetReaderIndex在类 AbstractByteBuf
  - markWriterIndex
```
public CompositeByteBuf markWriterIndex()
```
    从类复制的描述： ByteBuf
    
    在此缓冲区中标记当前writerIndex 。您可以重新定位当前writerIndex到标记writerIndex通过调用ByteBuf.resetWriterIndex() 。标记的初始值writerIndex是0 。
    
    重写：
    
    markWriterIndex在类 AbstractByteBuf
  - resetWriterIndex
```
public CompositeByteBuf resetWriterIndex()
```
    从类复制的描述： ByteBuf
    
    将当前 writerIndex重新定位到此缓冲区中标记为 writerIndex 。
    
    重写：
    
    resetWriterIndex在类 AbstractByteBuf
  - ensureWritable
```
public CompositeByteBuf ensureWritable(int minWritableBytes)
```
    从类复制的描述： ByteBuf
    
    确保the writable bytes的数量等于或大于指定的值。如果此缓冲区中有足够的可写字节，则此方法返回时无副作用。否则，它会产生一个IllegalArgumentException 。
    
    重写：
    
    ensureWritable在类 AbstractByteBuf
    
    参数
    
    minWritableBytes - 可写入字节的预期最小数量
  - getBytes
```
public CompositeByteBuf getBytes(int index,
                                 ByteBuf dst)
```
    从类复制的描述： ByteBuf
    
    将此缓冲区的数据传输到指定的目的地，从指定的绝对index开始，直到目标变为不可写。此方法与ByteBuf.getBytes(int, ByteBuf, int, int)基本相同，不同之writerIndex于此方法通过传输字节数增加目标的writerIndex ，而ByteBuf.getBytes(int, ByteBuf, int, int)则不增加。此方法不会修改源缓冲区的readerIndex或writerIndex （即this ）。
    
    重写：
    
    getBytes在类 AbstractByteBuf
  - getBytes
```
public CompositeByteBuf 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 ）。
    
    重写：
    
    getBytes上课 AbstractByteBuf
    
    length - 要传输的字节数
  - getBytes
```
public CompositeByteBuf getBytes(int index,
                                 byte[] dst)
```
    从类复制的描述： ByteBuf
    
    将此缓冲区的数据传输到指定的绝对index开始的目标。此方法不会修改此缓冲区的readerIndex或writerIndex
    
    重写：
    
    getBytes在类 AbstractByteBuf
  - setBoolean
```
public CompositeByteBuf setBoolean(int index,
                                   boolean value)
```
    从类复制的描述： ByteBuf
    
    在此缓冲区中的指定绝对index处设置指定的布尔值。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    重写：
    
    setBoolean在类 AbstractByteBuf
  - setChar
```
public CompositeByteBuf setChar(int index,
                                int value)
```
    从类复制的描述： ByteBuf
    
    在此缓冲区中的指定绝对index处设置指定的2字节UTF-16字符。指定值的16个高位被忽略。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    重写：
    
    setChar在类 AbstractByteBuf
  - setFloat
```
public CompositeByteBuf setFloat(int index,
                                 float value)
```
    从类复制的描述： ByteBuf
    
    在此缓冲区中的指定绝对index处设置指定的32位浮点数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    重写：
    
    setFloat在类 AbstractByteBuf
  - setDouble
```
public CompositeByteBuf setDouble(int index,
                                  double value)
```
    从类复制的描述： ByteBuf
    
    在此缓冲区中的指定绝对index处设置指定的64位浮点数。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    重写：
    
    setDouble在类 AbstractByteBuf
  - setBytes
```
public CompositeByteBuf setBytes(int index,
                                 ByteBuf src)
```
    从类复制的描述： ByteBuf
    
    将指定的源缓冲区的数据从指定的绝对index开始传输到此缓冲区，直到源缓冲区变得不可读。此方法与ByteBuf.setBytes(int, ByteBuf, int, int)基本相同，不同之readerIndex于此方法将源缓冲区的readerIndex增加了传输字节数，而ByteBuf.setBytes(int, ByteBuf, int, int)则不增加。此方法不会修改源缓冲区的readerIndex或writerIndex （即this ）。
    
    重写：
    
    setBytes类 AbstractByteBuf
  - setBytes
```
public CompositeByteBuf 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 ）。
    
    重写：
    
    setBytes在类 AbstractByteBuf
    
    length - 要传输的字节数
  - setBytes
```
public CompositeByteBuf setBytes(int index,
                                 byte[] src)
```
    从类复制的描述： ByteBuf
    
    将指定的源数组的数据传输到此缓冲区，从指定的绝对index 。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    重写：
    
    setBytes在类 AbstractByteBuf
  - setZero
```
public CompositeByteBuf setZero(int index,
                                int length)
```
    从类复制的描述： ByteBuf
    
    NUL (0x00)从指定的绝对index开始填充此缓冲区。此方法不会修改此缓冲区的readerIndex或writerIndex 。
    
    重写：
    
    setZero在类 AbstractByteBuf
    
    length - 写入缓冲区的数量为 NUL
  - readBytes
```
public CompositeByteBuf readBytes(ByteBuf dst)
```
    从类复制的描述： ByteBuf
    
    将此缓冲区的数据传输到指定的目标，从当前的readerIndex开始，直到目标变为不可写，并将readerIndex增加readerIndex 。此方法与ByteBuf.readBytes(ByteBuf, int, int)基本相同，只是此方法通过传输字节数增加目标的writerIndex ，而ByteBuf.readBytes(ByteBuf, int, int)则不增加。
    
    重写：
    
    readBytes在课堂上 AbstractByteBuf
  - readBytes
```
public CompositeByteBuf readBytes(ByteBuf dst,
                                  int length)
```
    从类复制的描述： ByteBuf
    
    传输此缓冲区的数据到指定的目标并从当前readerIndex并增加了readerIndex由传输的字节（=数量length ）。此方法与ByteBuf.readBytes(ByteBuf, int, int)基本相同，不同之writerIndex于此方法通过传输的字节数（= length ）增加目标的writerIndex ，而ByteBuf.readBytes(ByteBuf, int, int)则不增加。
    
    重写：
    
    readBytes在类 AbstractByteBuf
  - readBytes
```
public CompositeByteBuf readBytes(ByteBuf dst,
                                  int dstIndex,
                                  int length)
```
    从类复制的描述： ByteBuf
    
    传输此缓冲区的数据到指定的目标并从当前 readerIndex并增加了 readerIndex由传输的字节（=数量 length ）。
    
    重写：
    
    readBytes在类 AbstractByteBuf
    
    dstIndex - 目的地的第一个索引
    
    length - 要传输的字节数
  - readBytes
```
public CompositeByteBuf readBytes(byte[] dst)
```
    从类复制的描述： ByteBuf
    
    将此缓冲区的数据传输到指定的目标，从当前 readerIndex开始，并将 readerIndex增加 readerIndex （传输的字节 dst.length ）（= dst.length ）。
    
    重写：
    
    readBytes在类 AbstractByteBuf
  - readBytes
```
public CompositeByteBuf readBytes(byte[] dst,
                                  int dstIndex,
                                  int length)
```
    从类复制的描述： ByteBuf
    
    传输此缓冲区的数据到指定的目标并从当前 readerIndex并增加了 readerIndex由传输的字节（=数量 length ）。
    
    重写：
    
    readBytes在类 AbstractByteBuf
    
    dstIndex - 目的地的第一个索引
    
    length - 要传输的字节数
  - readBytes
```
public CompositeByteBuf readBytes(java.nio.ByteBuffer dst)
```
    从类复制的描述： ByteBuf
    
    将此缓冲区的数据传输到指定的目标，从当前 readerIndex开始，直到目标的位置达到其限制，并将 readerIndex增加 readerIndex 。
    
    重写：
    
    readBytes在类 AbstractByteBuf
  - readBytes
```
public CompositeByteBuf readBytes(java.io.OutputStream out,
                                  int length)
                           throws java.io.IOException
```
    从类复制的描述： ByteBuf
    
    将此缓冲区的数据传输到当前 readerIndex开始的指定流。
    
    重写：
    
    readBytes在类 AbstractByteBuf
    
    length - 要传输的字节数
    
    异常
    
    java.io.IOException - 如果指定的流在I / O期间抛出异常
  - skipBytes
```
public CompositeByteBuf skipBytes(int length)
```
    从类复制的描述： ByteBuf
    
    在此缓冲区中，按指定的 length增加当前 readerIndex 。
    
    重写：
    
    skipBytes在类 AbstractByteBuf
  - writeBoolean
```
public CompositeByteBuf writeBoolean(boolean value)
```
    从类复制的描述： ByteBuf
    
    在当前 writerIndex设置指定的布尔值，并在此缓冲区 writerIndex 1增加 writerIndex 。
    
    重写：
    
    writeBoolean在类 AbstractByteBuf
  - writeByte
```
public CompositeByteBuf writeByte(int value)
```
    从类复制的描述： ByteBuf
    
    在当前writerIndex处设置指定的字节，并在此缓冲区writerIndex 1增加writerIndex 。指定值的24个高位被忽略。
    
    重写：
    
    writeByte在类 AbstractByteBuf
  - writeShort
```
public CompositeByteBuf writeShort(int value)
```
    从类复制的描述： ByteBuf
    
    在当前writerIndex处设置指定的16位短整数，并在此缓冲区writerIndex 2增加writerIndex 。指定值的16个高位被忽略。
    
    重写：
    
    writeShort在类 AbstractByteBuf
  - writeMedium
```
public CompositeByteBuf writeMedium(int value)
```
    从类复制的描述： ByteBuf
    
    在当前 writerIndex中设置指定的24位中等整数，并在此缓冲区 writerIndex 3增加 writerIndex 。
    
    重写：
    
    writeMedium在类 AbstractByteBuf
  - writeInt
```
public CompositeByteBuf writeInt(int value)
```
    从类复制的描述： ByteBuf
    
    在当前 writerIndex处设置指定的32位整数，并在此缓冲区 writerIndex 4增加 writerIndex 。
    
    重写：
    
    writeInt在类 AbstractByteBuf
  - writeLong
```
public CompositeByteBuf writeLong(long value)
```
    从类复制的描述： ByteBuf
    
    在当前 writerIndex处设置指定的64位长整数，并在此缓冲区 writerIndex 8增加 writerIndex 。
    
    重写：
    
    writeLong在类 AbstractByteBuf
  - writeChar
```
public CompositeByteBuf writeChar(int value)
```
    从类复制的描述： ByteBuf
    
    在当前writerIndex处设置指定的2字节UTF-16字符，并在此缓冲区writerIndex 2增加writerIndex 。指定值的16个高位被忽略。
    
    重写：
    
    writeChar在类 AbstractByteBuf
  - writeFloat
```
public CompositeByteBuf writeFloat(float value)
```
    从类复制的描述： ByteBuf
    
    在当前 writerIndex处设置指定的32位浮点数，并在此缓冲区 writerIndex 4增加 writerIndex 。
    
    重写：
    
    writeFloat在类 AbstractByteBuf
  - writeDouble
```
public CompositeByteBuf writeDouble(double value)
```
    从类复制的描述： ByteBuf
    
    在当前 writerIndex处设置指定的64位浮点数，并在此缓冲区 writerIndex 8增加 writerIndex 。
    
    重写：
    
    writeDouble在类 AbstractByteBuf
  - writeBytes
```
public CompositeByteBuf writeBytes(ByteBuf src)
```
    从类复制的描述： ByteBuf
    
    将指定源缓冲区的数据传输到此缓冲区，从当前writerIndex开始，直到源缓冲区变得不可读，并将传输字节数增加writerIndex 。该方法与ByteBuf.writeBytes(ByteBuf, int, int)基本相同，不同的是此方法将源缓冲区的readerIndex增加了传输字节数，而ByteBuf.writeBytes(ByteBuf, int, int)则不增加。
    
    重写：
    
    writeBytes上课 AbstractByteBuf
  - writeBytes
```
public CompositeByteBuf writeBytes(ByteBuf src,
                                   int length)
```
    从类中复制的描述： ByteBuf
    
    将指定的源缓冲区的数据传输到此缓冲区，从当前的writerIndex开始，并将writerIndex增加writerIndex所传输的字节数（= length ）。此方法与ByteBuf.writeBytes(ByteBuf, int, int)基本相同，不同之readerIndex于此方法将源缓冲区的readerIndex增加了传输字节数（= length ），而ByteBuf.writeBytes(ByteBuf, int, int)不增加ByteBuf.writeBytes(ByteBuf, int, int) 。
    
    重写：
    
    writeBytes在类 AbstractByteBuf
    
    length - 要传输的字节数
  - writeBytes
```
public CompositeByteBuf writeBytes(ByteBuf src,
                                   int srcIndex,
                                   int length)
```
    从类复制的描述： ByteBuf
    
    指定的源缓冲区的数据传送到该缓冲液并从当前 writerIndex并增加了 writerIndex由传输的字节（=数量 length ）。
    
    重写：
    
    writeBytes在类 AbstractByteBuf
    
    srcIndex - 来源的第一个索引
    
    length - 要传输的字节数
  - writeBytes
```
public CompositeByteBuf writeBytes(byte[] src)
```
    从类复制的描述： ByteBuf
    
    指定的源阵列的数据传送到该缓冲液并从当前 writerIndex并增加了 writerIndex由传输的字节（=数量 src.length ）。
    
    重写：
    
    writeBytes在类 AbstractByteBuf
  - writeBytes
```
public CompositeByteBuf writeBytes(byte[] src,
                                   int srcIndex,
                                   int length)
```
    从类复制的描述： ByteBuf
    
    指定的源阵列的数据传送到该缓冲液并从当前 writerIndex并增加了 writerIndex由传输的字节（=数量 length ）。
    
    重写：
    
    writeBytes在类 AbstractByteBuf
    
    srcIndex - 来源的第一个索引
    
    length - 要传输的字节数
  - writeBytes
```
public CompositeByteBuf writeBytes(java.nio.ByteBuffer src)
```
    从类复制的描述： ByteBuf
    
    将指定源缓冲区的数据从当前 writerIndex开始传输到此缓冲区，直到源缓冲区的位置达到其限制，并将传输字节数增加 writerIndex 。
    
    重写：
    
    writeBytes类 AbstractByteBuf
  - writeZero
```
public CompositeByteBuf writeZero(int length)
```
    从类复制的描述： ByteBuf
    
    用 NUL (0x00)从当前 writerIndex开始填充此缓冲区， 并将 writerIndex增加 writerIndex指定的 length 。
    
    重写：
    
    writeZero在类 AbstractByteBuf
    
    参数
    
    length - 写入缓冲区的数量为 NUL
  - retain
```
public CompositeByteBuf retain(int increment)
```
    从接口ReferenceCounted复制的描述
    
    通过指定的 increment增加引用计数。
    
    Specified by:
    
    retain接口 ReferenceCounted
    
    重写：
    
    retain在类 AbstractReferenceCountedByteBuf
  - retain
```
public CompositeByteBuf retain()
```
    从接口ReferenceCounted复制的描述
    
    将引用计数增加 1 。
    
    Specified by:
    
    retain在界面 ReferenceCounted
    
    重写：
    
    retain在类 AbstractReferenceCountedByteBuf
  - touch
```
public CompositeByteBuf touch()
```
    从接口ReferenceCounted复制的描述
    
    记录此对象的当前访问位置以进行调试。如果确定此物体泄漏，则通过此操作记录的信息将通过ResourceLeakDetector提供给您。此方法是touch(null)的快捷方式。
    
    Specified by:
    
    touch ，界面 ReferenceCounted
    
    重写：
    
    touch在类 AbstractReferenceCountedByteBuf
  - touch
```
public CompositeByteBuf touch(java.lang.Object hint)
```
    从接口ReferenceCounted复制的描述
    
    记录此对象的当前访问位置，并附加一些用于调试的任意信息。如果确定此物体泄漏，则通过此操作记录的信息将通过ResourceLeakDetector提供给您。
    
    Specified by:
    
    touch接口 ReferenceCounted
    
    重写：
    
    touch类 AbstractReferenceCountedByteBuf
  - nioBuffers
```
public java.nio.ByteBuffer[] nioBuffers()
```
    从类复制的描述： ByteBuf
    
    以NIO ByteBuffer的形式公开此缓冲区的可读字节。返回的缓冲区共享或包含此缓冲区的复制内容，同时更改返回的NIO缓冲区的位置和限制不会影响此缓冲区的索引和标记。此方法不会修改此缓冲区的readerIndex或writerIndex 。请注意，如果此缓冲区是动态缓冲区并且它调整了其容量，则返回的NIO缓冲区将不会看到此缓冲区的更改。
    
    重写：
    
    nioBuffers在类 AbstractByteBuf
    
    另请参见：
    
    ByteBuf.nioBufferCount() ， ByteBuf.nioBuffer() ， ByteBuf.nioBuffer(int, int)
  - discardSomeReadBytes
```
public CompositeByteBuf discardSomeReadBytes()
```
    从类复制的描述： ByteBuf
    
    类似于 ByteBuf.discardReadBytes()，不同之处在于此方法可能会丢弃部分，全部或者全部读取字节，具体取决于其内部实现方式，以减少潜在的额外内存消耗为代价来降低整体内存带宽消耗。
    
    重写：
    
    discardSomeReadBytes在类 AbstractByteBuf
  - deallocate
```
protected void deallocate()
```
    从类复制的描述： AbstractReferenceCountedByteBuf
    
    一次调用 AbstractReferenceCountedByteBuf.refCnt()等于0。
    
    Specified by:
    
    deallocate在类 AbstractReferenceCountedByteBuf
  - unwrap
```
public ByteBuf unwrap()
```
    从类中复制的描述： ByteBuf
    
    如果此缓冲区是另一个缓冲区的包装，则返回底层缓冲区实例。
    
    Specified by:
    
    unwrap在类 ByteBuf
    
    结果
    
    null如果此缓冲区不是包装

Class CompositeByteBuf

构造方法摘要

方法摘要

Methods inherited from class io.netty.buffer.AbstractReferenceCountedByteBuf

Methods inherited from class io.netty.buffer.AbstractByteBuf

Methods inherited from class io.netty.buffer.ByteBuf

Methods inherited from class java.lang.Object

Methods inherited from interface java.lang.Iterable

构造方法详细信息

CompositeByteBuf

CompositeByteBuf

CompositeByteBuf

方法详细信息

addComponent

addComponents

addComponents

addComponent

addComponent

addComponents

addComponents

addComponent

addComponents

addComponents

removeComponent

removeComponents

iterator

decompose

isDirect

hasArray

array

arrayOffset

hasMemoryAddress

memoryAddress

capacity

capacity

alloc

order

numComponents

maxNumComponents

toComponentIndex

toByteIndex

getByte

_getByte

_getShort

_getShortLE

_getUnsignedMedium

_getUnsignedMediumLE

_getInt

_getIntLE

_getLong

_getLongLE

getBytes

getBytes

getBytes

getBytes

getBytes

getBytes

setByte

_setByte

setShort

_setShort

_setShortLE

setMedium

_setMedium

_setMediumLE

setInt

_setInt

_setIntLE

setLong

_setLong

_setLongLE

setBytes

setBytes

setBytes

setBytes

setBytes

setBytes

copy

component

componentAtOffset