所有超级接口:

<ChannelBuffer>

所有已知实现类:

AbstractChannelBuffer, ByteBufferBackedChannelBuffer, DynamicChannelBuffer, HeapChannelBuffer, NettyBackedChannelBuffer, NettyBackedChannelBuffer
```
public interface ChannelBuffer
extends <ChannelBuffer>
```
A random and sequential accessible sequence of zero or more bytes (octets). This interface provides an abstract view for one or more primitive byte arrays (byte[]) and .

Creation of a buffer

It is recommended to create a new buffer using the helper methods in ChannelBuffers rather than calling an individual implementation's constructor.

Random Access Indexing

Just like an ordinary primitive byte array, . It means the index of the first byte is always 0 and the index of the last byte is always capacity - 1. For example, to iterate all bytes of a buffer, you can do the following, regardless of its internal implementation:
```
 ChannelBuffer buffer = ...;
 for (int i = 0; i < buffer.capacity(); i ++) {
     byte b = buffer.getByte(i);
     System.out.println((char) b);
 }
 
```
Sequential Access Indexing

ChannelBuffer provides two pointer variables to support sequential read and write operations - readerIndex for a read operation and writerIndex for a write operation respectively. The following diagram shows how a buffer is segmented into three areas by the two pointers:
```
      +-------------------+------------------+------------------+
      | discardable bytes |  readable bytes  |  writable bytes  |
      |                   |     (CONTENT)    |                  |
      +-------------------+------------------+------------------+
      |                   |                  |                  |
      0      <=      readerIndex   <=   writerIndex    <=    capacity
 
```
Readable bytes (the actual content)

This segment is where the actual data is stored. Any operation whose name starts with read or skip will get or skip the data at the current readerIndex and increase it by the number of read bytes. If the argument of the read operation is also a ChannelBuffer and no destination index is specified, the specified buffer's readerIndex is increased together.
If there's not enough content left, is raised. The default value of newly allocated, wrapped or copied buffer's readerIndex is 0.
```
 // Iterates the readable bytes of a buffer.
 ChannelBuffer buffer = ...;
 while (buffer.readable()) {
     System.out.println(buffer.readByte());
 }
 
```
Writable bytes

This segment is a undefined space which needs to be filled. Any operation whose name ends with write will write the data at the current writerIndex and increase it by the number of written bytes. If the argument of the write operation is also a ChannelBuffer, and no source index is specified, the specified buffer's readerIndex is increased together.
If there's not enough writable bytes left, is raised. The default value of newly allocated buffer's writerIndex is 0. The default value of wrapped or copied buffer's writerIndex is the capacity of the buffer.
```
 // Fills the writable bytes of a buffer with random integers.
 ChannelBuffer buffer = ...;
 while (buffer.writableBytes() >= 4) {
     buffer.writeInt(random.nextInt());
 }
 
```
Discardable bytes

This segment contains the bytes which were read already by a read operation. Initially, the size of this segment is 0, but its size increases up to the writerIndex as read operations are executed. The read bytes can be discarded by calling discardReadBytes() to reclaim unused area as depicted by the following diagram:
```
  BEFORE discardReadBytes()

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


  AFTER discardReadBytes()

      +------------------+--------------------------------------+
      |  readable bytes  |    writable bytes (got more space)   |
      +------------------+--------------------------------------+
      |                  |                                      |
 readerIndex (0) <= writerIndex (decreased)        <=        capacity
 
```
Please note that there is no guarantee about the content of writable bytes after calling discardReadBytes(). The writable bytes will not be moved in most cases and could even be filled with completely different data depending on the underlying buffer implementation.

Clearing the buffer indexes

You can set both readerIndex and writerIndex to 0 by calling clear(). It does not clear the buffer content (e.g. filling with 0) but just clears the two pointers. Please also note that the semantic of this operation is different from .
```
  BEFORE clear()

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


  AFTER clear()

      +---------------------------------------------------------+
      |             writable bytes (got more space)             |
      +---------------------------------------------------------+
      |                                                         |
      0 = readerIndex = writerIndex            <=            capacity
 
```
Mark and reset

There are two marker indexes in every buffer. One is for storing readerIndex and the other is for storing writerIndex. You can always reposition one of the two indexes by calling a reset method. It works in a similar fashion to the mark and reset methods in except that there's no readlimit.

Conversion to existing JDK types

Byte array

If a ChannelBuffer is backed by a byte array (i.e. byte[]), you can access it directly via the array() method. To determine if a buffer is backed by a byte array, hasArray() should be used.

NIO Buffers

Various toByteBuffer() methods convert a ChannelBuffer into one or more NIO buffers. These methods avoid buffer allocation and memory copy whenever possible, but there's no guarantee that memory copy will not be involved.

I/O Streams

Please refer to ChannelBufferInputStream and ChannelBufferOutputStream.

方法概要

所有方法实例方法抽象方法
修饰符和类型	方法	说明
`byte[]`	`array()`	Returns the backing byte array of this buffer.
`int`	`arrayOffset()`	Returns the offset of the first byte within the backing byte array of this buffer.
`int`	`capacity()`	Returns the number of bytes (octets) this buffer can contain.
`void`	`clear()`	Sets the `readerIndex` and `writerIndex` of this buffer to `0`.
`ChannelBuffer`	`copy()`	Returns a copy of this buffer's readable bytes.
`ChannelBuffer`	`copy(int index, int length)`	Returns a copy of this buffer's sub-region.
`void`	`discardReadBytes()`	Discards the bytes between the 0th index and `readerIndex`.
`void`	`ensureWritableBytes(int writableBytes)`	Makes sure the number of the writable bytes is equal to or greater than the specified value.
`boolean`	`o)`	Determines if the content of the specified buffer is identical to the content of this array.
`ChannelBufferFactory`	`factory()`	Returns the factory which creates a `ChannelBuffer` whose type and default are same with this buffer.
`byte`	`getByte(int index)`	Gets a byte at the specified absolute `index` in this buffer.
`void`	`getBytes(int index, byte[] dst)`	Transfers this buffer's data to the specified destination starting at the specified absolute `index`.
`void`	`getBytes(int index, byte[] dst, int dstIndex, int length)`	Transfers this buffer's data to the specified destination starting at the specified absolute `index`.
`void`	`getBytes(int index, ChannelBuffer dst)`	Transfers this buffer's data to the specified destination starting at the specified absolute `index` until the destination becomes non-writable.
`void`	`getBytes(int index, ChannelBuffer dst, int length)`	Transfers this buffer's data to the specified destination starting at the specified absolute `index`.
`void`	`getBytes(int index, ChannelBuffer dst, int dstIndex, int length)`	Transfers this buffer's data to the specified destination starting at the specified absolute `index`.
`void`	`getBytes(int index, dst, int length)`	Transfers this buffer's data to the specified stream starting at the specified absolute `index`.
`void`	`getBytes(int index, dst)`	Transfers this buffer's data to the specified destination starting at the specified absolute `index` until the destination's position reaches its limit.
`boolean`	`hasArray()`	Returns `true` if and only if this buffer has a backing byte array.
`boolean`	`isDirect()`	Returns `true` if and only if this buffer is backed by an NIO direct buffer.
`void`	`markReaderIndex()`	Marks the current `readerIndex` in this buffer.
`void`	`markWriterIndex()`	Marks the current `writerIndex` in this buffer.
`boolean`	`readable()`	Returns `true` if and only if `(this.writerIndex - this.readerIndex)` is greater than `0`.
`int`	`readableBytes()`	Returns the number of readable bytes which is equal to `(this.writerIndex - this.readerIndex)`.
`byte`	`readByte()`	Gets a byte at the current `readerIndex` and increases the `readerIndex` by `1` in this buffer.
`void`	`readBytes(byte[] dst)`	Transfers this buffer's data to the specified destination starting at the current `readerIndex` and increases the `readerIndex` by the number of the transferred bytes (= `dst.length`).
`void`	`readBytes(byte[] dst, int dstIndex, int length)`	Transfers this buffer's data to the specified destination starting at the current `readerIndex` and increases the `readerIndex` by the number of the transferred bytes (= `length`).
`ChannelBuffer`	`readBytes(int length)`	Transfers this buffer's data to a newly created buffer starting at the current `readerIndex` and increases the `readerIndex` by the number of the transferred bytes (= `length`).
`void`	`readBytes(ChannelBuffer dst)`	Transfers this buffer's data to the specified destination starting at the current `readerIndex` until the destination becomes non-writable, and increases the `readerIndex` by the number of the transferred bytes.
`void`	`readBytes(ChannelBuffer dst, int length)`	Transfers this buffer's data to the specified destination starting at the current `readerIndex` and increases the `readerIndex` by the number of the transferred bytes (= `length`).
`void`	`readBytes(ChannelBuffer dst, int dstIndex, int length)`	Transfers this buffer's data to the specified destination starting at the current `readerIndex` and increases the `readerIndex` by the number of the transferred bytes (= `length`).
`void`	`dst, int length)`	Transfers this buffer's data to the specified stream starting at the current `readerIndex`.
`void`	`dst)`	Transfers this buffer's data to the specified destination starting at the current `readerIndex` until the destination's position reaches its limit, and increases the `readerIndex` by the number of the transferred bytes.
`int`	`readerIndex()`	Returns the `readerIndex` of this buffer.
`void`	`readerIndex(int readerIndex)`	Sets the `readerIndex` of this buffer.
`void`	`resetReaderIndex()`	Repositions the current `readerIndex` to the marked `readerIndex` in this buffer.
`void`	`resetWriterIndex()`	Marks the current `writerIndex` in this buffer.
`void`	`setByte(int index, int value)`	Sets the specified byte at the specified absolute `index` in this buffer.
`void`	`setBytes(int index, byte[] src)`	Transfers the specified source array's data to this buffer starting at the specified absolute `index`.
`void`	`setBytes(int index, byte[] src, int srcIndex, int length)`	Transfers the specified source array's data to this buffer starting at the specified absolute `index`.
`void`	`setBytes(int index, ChannelBuffer src)`	Transfers the specified source buffer's data to this buffer starting at the specified absolute `index` until the source buffer becomes unreadable.
`void`	`setBytes(int index, ChannelBuffer src, int length)`	Transfers the specified source buffer's data to this buffer starting at the specified absolute `index`.
`void`	`setBytes(int index, ChannelBuffer src, int srcIndex, int length)`	Transfers the specified source buffer's data to this buffer starting at the specified absolute `index`.
`int`	`setBytes(int index, src, int length)`	Transfers the content of the specified source stream to this buffer starting at the specified absolute `index`.
`void`	`setBytes(int index, src)`	Transfers the specified source buffer's data to this buffer starting at the specified absolute `index` until the source buffer's position reaches its limit.
`void`	`setIndex(int readerIndex, int writerIndex)`	Sets the `readerIndex` and `writerIndex` of this buffer in one shot.
`void`	`skipBytes(int length)`	Increases the current `readerIndex` by the specified `length` in this buffer.
	`toByteBuffer()`	Converts this buffer's readable bytes into a NIO buffer.
	`toByteBuffer(int index, int length)`	Converts this buffer's sub-region into a NIO buffer.
`boolean`	`writable()`	Returns `true` if and only if `(this.capacity - this.writerIndex)` is greater than `0`.
`int`	`writableBytes()`	Returns the number of writable bytes which is equal to `(this.capacity - this.writerIndex)`.
`void`	`writeByte(int value)`	Sets the specified byte at the current `writerIndex` and increases the `writerIndex` by `1` in this buffer.
`void`	`writeBytes(byte[] src)`	Transfers the specified source array's data to this buffer starting at the current `writerIndex` and increases the `writerIndex` by the number of the transferred bytes (= `src.length`).
`void`	`writeBytes(byte[] src, int index, int length)`	Transfers the specified source array's data to this buffer starting at the current `writerIndex` and increases the `writerIndex` by the number of the transferred bytes (= `length`).
`void`	`writeBytes(ChannelBuffer src)`	Transfers the specified source buffer's data to this buffer starting at the current `writerIndex` until the source buffer becomes unreadable, and increases the `writerIndex` by the number of the transferred bytes.
`void`	`writeBytes(ChannelBuffer src, int length)`	Transfers the specified source buffer's data to this buffer starting at the current `writerIndex` and increases the `writerIndex` by the number of the transferred bytes (= `length`).
`void`	`writeBytes(ChannelBuffer src, int srcIndex, int length)`	Transfers the specified source buffer's data to this buffer starting at the current `writerIndex` and increases the `writerIndex` by the number of the transferred bytes (= `length`).
`int`	`src, int length)`	Transfers the content of the specified stream to this buffer starting at the current `writerIndex` and increases the `writerIndex` by the number of the transferred bytes.
`void`	`src)`	Transfers the specified source buffer's data to this buffer starting at the current `writerIndex` until the source buffer's position reaches its limit, and increases the `writerIndex` by the number of the transferred bytes.
`int`	`writerIndex()`	Returns the `writerIndex` of this buffer.
`void`	`writerIndex(int writerIndex)`	Sets the `writerIndex` of this buffer.

从接口继承的方法 java.lang.

- 方法详细资料
  - capacity
```
int capacity()
```
    Returns the number of bytes (octets) this buffer can contain.
  - clear
```
void clear()
```
    Sets the readerIndex and writerIndex of this buffer to 0. This method is identical to setIndex(0, 0).
    Please note that the behavior of this method is different from that of NIO buffer, which sets the limit to the capacity of the buffer.
  - copy
```
ChannelBuffer copy()
```
    Returns a copy of this buffer's readable bytes. Modifying the content of the returned buffer or this buffer does not affect each other at all. This method is identical to buf.copy(buf.readerIndex(), buf.readableBytes()). This method does not modify readerIndex or writerIndex of this buffer.
  - copy
```
ChannelBuffer copy(int index,
                   int length)
```
    Returns a copy of this buffer's sub-region. Modifying the content of the returned buffer or this buffer does not affect each other at all. This method does not modify readerIndex or writerIndex of this buffer.
  - discardReadBytes
```
void discardReadBytes()
```
    Discards the bytes between the 0th index and readerIndex. It moves the bytes between readerIndex and writerIndex to the 0th index, and sets readerIndex and writerIndex to 0 and oldWriterIndex - oldReaderIndex respectively.
    Please refer to the class documentation for more detailed explanation.
  - ensureWritableBytes
```
void ensureWritableBytes(int writableBytes)
```
    Makes sure the number of the writable bytes is equal to or greater than the specified value. If there is enough writable bytes in this buffer, this method returns with no side effect. Otherwise:
    
    a non-dynamic buffer will throw an .
    
    a dynamic buffer will expand its capacity so that the number of the writable bytes becomes equal to or greater than the specified value. The expansion involves the reallocation of the internal buffer and consequently memory copy.
    参数:
    
    writableBytes - the expected minimum number of writable bytes
    
    抛出:
    
    - if the writable bytes of this buffer is less than the specified value and if this buffer is not a dynamic buffer
  - equals
```
boolean equals( o)
```
    Determines if the content of the specified buffer is identical to the content of this array. 'Identical' here means:
    
    the size of the contents of the two buffers are same and
    
    every single byte of the content of the two buffers are same.
    
    Please note that it does not compare readerIndex() nor writerIndex(). This method also returns false for null and an object which is not an instance of ChannelBuffer type.
    覆盖:
    
    在类中
  - factory
```
ChannelBufferFactory factory()
```
    Returns the factory which creates a ChannelBuffer whose type and default are same with this buffer.
  - getByte
```
byte getByte(int index)
```
    Gets a byte at the specified absolute index in this buffer. This method does not modify readerIndex or writerIndex of this buffer.
    
    抛出:
    
    - if the specified index is less than 0 or index + 1 is greater than this.capacity
  - getBytes
```
void getBytes(int index,
              byte[] dst)
```
    Transfers this buffer's data to the specified destination starting at the specified absolute index. This method does not modify readerIndex or writerIndex of this buffer
    
    抛出:
    
    - if the specified index is less than 0 or if index + dst.length is greater than this.capacity
  - getBytes
```
void getBytes(int index,
              byte[] dst,
              int dstIndex,
              int length)
```
    Transfers this buffer's data to the specified destination starting at the specified absolute index. This method does not modify readerIndex or writerIndex of this buffer.
    
    参数:
    
    dstIndex - the first index of the destination
    
    length - the number of bytes to transfer
    
    抛出:
    
    - if the specified index is less than 0, if the specified dstIndex is less than 0, if index + length is greater than this.capacity, or if dstIndex + length is greater than dst.length
  - getBytes
```
void getBytes(int index,
               dst)
```
    Transfers this buffer's data to the specified destination starting at the specified absolute index until the destination's position reaches its limit. This method does not modify readerIndex or writerIndex of this buffer while the destination's position will be increased.
    
    抛出:
    
    - if the specified index is less than 0 or if index + dst.remaining() is greater than this.capacity
  - getBytes
```
void getBytes(int index,
              ChannelBuffer dst)
```
    Transfers this buffer's data to the specified destination starting at the specified absolute index until the destination becomes non-writable. This method is basically same with getBytes(int, ChannelBuffer, int, int), except that this method increases the writerIndex of the destination by the number of the transferred bytes while getBytes(int, ChannelBuffer, int, int) does not. This method does not modify readerIndex or writerIndex of the source buffer (i.e. this).
    
    抛出:
    
    - if the specified index is less than 0 or if index + dst.writableBytes is greater than this.capacity
  - getBytes
```
void getBytes(int index,
              ChannelBuffer dst,
              int length)
```
    Transfers this buffer's data to the specified destination starting at the specified absolute index. This method is basically same with getBytes(int, ChannelBuffer, int, int), except that this method increases the writerIndex of the destination by the number of the transferred bytes while getBytes(int, ChannelBuffer, int, int) does not. This method does not modify readerIndex or writerIndex of the source buffer (i.e. this).
    
    参数:
    
    length - the number of bytes to transfer
    
    抛出:
    
    - if the specified index is less than 0, if index + length is greater than this.capacity, or if length is greater than dst.writableBytes
  - getBytes
```
void getBytes(int index,
              ChannelBuffer dst,
              int dstIndex,
              int length)
```
    Transfers this buffer's data to the specified destination starting at the specified absolute index. This method does not modify readerIndex or writerIndex of both the source (i.e. this) and the destination.
    
    参数:
    
    dstIndex - the first index of the destination
    
    length - the number of bytes to transfer
    
    抛出:
    
    - if the specified index is less than 0, if the specified dstIndex is less than 0, if index + length is greater than this.capacity, or if dstIndex + length is greater than dst.capacity
  - getBytes
```
void getBytes(int index,
               dst,
              int length)
       throws 
```
    Transfers this buffer's data to the specified stream starting at the specified absolute index. This method does not modify readerIndex or writerIndex of this buffer.
    
    参数:
    
    length - the number of bytes to transfer
    
    抛出:
    
    - if the specified index is less than 0 or if index + length is greater than this.capacity
    
    - if the specified stream threw an exception during I/O
  - isDirect
```
boolean isDirect()
```
    Returns true if and only if this buffer is backed by an NIO direct buffer.
  - markReaderIndex
```
void markReaderIndex()
```
    Marks the current readerIndex in this buffer. You can reposition the current readerIndex to the marked readerIndex by calling resetReaderIndex(). The initial value of the marked readerIndex is 0.
  - markWriterIndex
```
void markWriterIndex()
```
    Marks the current writerIndex in this buffer. You can reposition the current writerIndex to the marked writerIndex by calling resetWriterIndex(). The initial value of the marked writerIndex is 0.
  - readable
```
boolean readable()
```
    Returns true if and only if (this.writerIndex - this.readerIndex) is greater than 0.
  - readableBytes
```
int readableBytes()
```
    Returns the number of readable bytes which is equal to (this.writerIndex - this.readerIndex).
  - readByte
```
byte readByte()
```
    Gets a byte at the current readerIndex and increases the readerIndex by 1 in this buffer.
    
    抛出:
    
    - if this.readableBytes is less than 1
  - readBytes
```
void readBytes(byte[] dst)
```
    Transfers this buffer's data to the specified destination starting at the current readerIndex and increases the readerIndex by the number of the transferred bytes (= dst.length).
    
    抛出:
    
    - if dst.length is greater than this.readableBytes
  - readBytes
```
void readBytes(byte[] dst,
               int dstIndex,
               int length)
```
    Transfers this buffer's data to the specified destination starting at the current readerIndex and increases the readerIndex by the number of the transferred bytes (= length).
    
    参数:
    
    dstIndex - the first index of the destination
    
    length - the number of bytes to transfer
    
    抛出:
    
    - if the specified dstIndex is less than 0, if length is greater than this.readableBytes, or if dstIndex + length is greater than dst.length
  - readBytes
```
void readBytes( dst)
```
    Transfers this buffer's data to the specified destination starting at the current readerIndex until the destination's position reaches its limit, and increases the readerIndex by the number of the transferred bytes.
    
    抛出:
    
    - if dst.remaining() is greater than this.readableBytes
  - readBytes
```
void readBytes(ChannelBuffer dst)
```
    Transfers this buffer's data to the specified destination starting at the current readerIndex until the destination becomes non-writable, and increases the readerIndex by the number of the transferred bytes. This method is basically same with readBytes(ChannelBuffer, int, int), except that this method increases the writerIndex of the destination by the number of the transferred bytes while readBytes(ChannelBuffer, int, int) does not.
    
    抛出:
    
    - if dst.writableBytes is greater than this.readableBytes
  - readBytes
```
void readBytes(ChannelBuffer dst,
               int length)
```
    Transfers this buffer's data to the specified destination starting at the current readerIndex and increases the readerIndex by the number of the transferred bytes (= length). This method is basically same with readBytes(ChannelBuffer, int, int), except that this method increases the writerIndex of the destination by the number of the transferred bytes (= length) while readBytes(ChannelBuffer, int, int) does not.
    
    抛出:
    
    - if length is greater than this.readableBytes or if length is greater than dst.writableBytes
  - readBytes
```
void readBytes(ChannelBuffer dst,
               int dstIndex,
               int length)
```
    Transfers this buffer's data to the specified destination starting at the current readerIndex and increases the readerIndex by the number of the transferred bytes (= length).
    
    参数:
    
    dstIndex - the first index of the destination
    
    length - the number of bytes to transfer
    
    抛出:
    
    - if the specified dstIndex is less than 0, if length is greater than this.readableBytes, or if dstIndex + length is greater than dst.capacity
  - readBytes
```
ChannelBuffer readBytes(int length)
```
    Transfers this buffer's data to a newly created buffer starting at the current readerIndex and increases the readerIndex by the number of the transferred bytes (= length). The returned buffer's readerIndex and writerIndex are 0 and length respectively.
    
    参数:
    
    length - the number of bytes to transfer
    
    返回:
    
    the newly created buffer which contains the transferred bytes
    
    抛出:
    
    - if length is greater than this.readableBytes
  - resetReaderIndex
```
void resetReaderIndex()
```
    Repositions the current readerIndex to the marked readerIndex in this buffer.
    
    抛出:
    
    - if the current writerIndex is less than the marked readerIndex
  - resetWriterIndex
```
void resetWriterIndex()
```
    Marks the current writerIndex in this buffer. You can reposition the current writerIndex to the marked writerIndex by calling resetWriterIndex(). The initial value of the marked writerIndex is 0.
  - readerIndex
```
int readerIndex()
```
    Returns the readerIndex of this buffer.
  - readerIndex
```
void readerIndex(int readerIndex)
```
    Sets the readerIndex of this buffer.
    
    抛出:
    
    - if the specified readerIndex is less than 0 or greater than this.writerIndex
  - readBytes
```
void readBytes( dst,
               int length)
        throws 
```
    Transfers this buffer's data to the specified stream starting at the current readerIndex.
    
    参数:
    
    length - the number of bytes to transfer
    
    抛出:
    
    - if length is greater than this.readableBytes
    
    - if the specified stream threw an exception during I/O
  - setByte
```
void setByte(int index,
             int value)
```
    Sets the specified byte at the specified absolute index in this buffer. The 24 high-order bits of the specified value are ignored. This method does not modify readerIndex or writerIndex of this buffer.
    
    抛出:
    
    - if the specified index is less than 0 or index + 1 is greater than this.capacity
  - setBytes
```
void setBytes(int index,
              byte[] src)
```
    Transfers the specified source array's data to this buffer starting at the specified absolute index. This method does not modify readerIndex or writerIndex of this buffer.
    
    抛出:
    
    - if the specified index is less than 0 or if index + src.length is greater than this.capacity
  - setBytes
```
void setBytes(int index,
              byte[] src,
              int srcIndex,
              int length)
```
    Transfers the specified source array's data to this buffer starting at the specified absolute index. This method does not modify readerIndex or writerIndex of this buffer.
    
    抛出:
    
    - if the specified index is less than 0, if the specified srcIndex is less than 0, if index + length is greater than this.capacity, or if srcIndex + length is greater than src.length
  - setBytes
```
void setBytes(int index,
               src)
```
    Transfers the specified source buffer's data to this buffer starting at the specified absolute index until the source buffer's position reaches its limit. This method does not modify readerIndex or writerIndex of this buffer.
    
    抛出:
    
    - if the specified index is less than 0 or if index + src.remaining() is greater than this.capacity
  - setBytes
```
void setBytes(int index,
              ChannelBuffer src)
```
    Transfers the specified source buffer's data to this buffer starting at the specified absolute index until the source buffer becomes unreadable. This method is basically same with setBytes(int, ChannelBuffer, int, int), except that this method increases the readerIndex of the source buffer by the number of the transferred bytes while setBytes(int, ChannelBuffer, int, int) does not. This method does not modify readerIndex or writerIndex of the source buffer (i.e. this).
    
    抛出:
    
    - if the specified index is less than 0 or if index + src.readableBytes is greater than this.capacity
  - setBytes
```
void setBytes(int index,
              ChannelBuffer src,
              int length)
```
    Transfers the specified source buffer's data to this buffer starting at the specified absolute index. This method is basically same with setBytes(int, ChannelBuffer, int, int), except that this method increases the readerIndex of the source buffer by the number of the transferred bytes while setBytes(int, ChannelBuffer, int, int) does not. This method does not modify readerIndex or writerIndex of the source buffer (i.e. this).
    
    参数:
    
    length - the number of bytes to transfer
    
    抛出:
    
    - if the specified index is less than 0, if index + length is greater than this.capacity, or if length is greater than src.readableBytes
  - setBytes
```
void setBytes(int index,
              ChannelBuffer src,
              int srcIndex,
              int length)
```
    Transfers the specified source buffer's data to this buffer starting at the specified absolute index. This method does not modify readerIndex or writerIndex of both the source (i.e. this) and the destination.
    
    参数:
    
    srcIndex - the first index of the source
    
    length - the number of bytes to transfer
    
    抛出:
    
    - if the specified index is less than 0, if the specified srcIndex is less than 0, if index + length is greater than this.capacity, or if srcIndex + length is greater than src.capacity
  - setBytes
```
int setBytes(int index,
              src,
             int length)
      throws 
```
    Transfers the content of the specified source stream to this buffer starting at the specified absolute index. This method does not modify readerIndex or writerIndex of this buffer.
    
    参数:
    
    length - the number of bytes to transfer
    
    返回:
    
    the actual number of bytes read in from the specified channel. -1 if the specified channel is closed.
    
    抛出:
    
    - if the specified index is less than 0 or if index + length is greater than this.capacity
    
    - if the specified stream threw an exception during I/O
  - setIndex
```
void setIndex(int readerIndex,
              int writerIndex)
```
    Sets the readerIndex and writerIndex of this buffer in one shot. This method is useful when you have to worry about the invocation order of readerIndex(int) and writerIndex(int) methods. For example, the following code will fail:
    
    // Create a buffer whose readerIndex, writerIndex and capacity are // 0, 0 and 8 respectively. ChannelBuffer buf = ChannelBuffers.buffer(8); // IndexOutOfBoundsException is thrown because the specified // readerIndex (2) cannot be greater than the current writerIndex (0). buf.readerIndex(2); buf.writerIndex(4);
    
    The following code will also fail:
    
    // Create a buffer whose readerIndex, writerIndex and capacity are // 0, 8 and 8 respectively. ChannelBuffer buf = ChannelBuffers.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);
    
    By contrast, setIndex(int, int) guarantees that it never throws an as long as the specified indexes meet basic constraints, regardless what the current index values of the buffer are:
    
    // 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);
    抛出:
    
    - if the specified readerIndex is less than 0, if the specified writerIndex is less than the specified readerIndex or if the specified writerIndex is greater than this.capacity
  - skipBytes
```
void skipBytes(int length)
```
    Increases the current readerIndex by the specified length in this buffer.
    
    抛出:
    
    - if length is greater than this.readableBytes
  - toByteBuffer
```
 toByteBuffer()
```
    Converts this buffer's readable bytes into a NIO buffer. The returned buffer might or might not share the content with this buffer, while they have separate indexes and marks. This method is identical to buf.toByteBuffer(buf.readerIndex(), buf.readableBytes()). This method does not modify readerIndex or writerIndex of this buffer.
  - toByteBuffer
```
 toByteBuffer(int index,
                        int length)
```
    Converts this buffer's sub-region into a NIO buffer. The returned buffer might or might not share the content with this buffer, while they have separate indexes and marks. This method does not modify readerIndex or writerIndex of this buffer.
  - writable
```
boolean writable()
```
    Returns true if and only if (this.capacity - this.writerIndex) is greater than 0.
  - writableBytes
```
int writableBytes()
```
    Returns the number of writable bytes which is equal to (this.capacity - this.writerIndex).
  - writeByte
```
void writeByte(int value)
```
    Sets the specified byte at the current writerIndex and increases the writerIndex by 1 in this buffer. The 24 high-order bits of the specified value are ignored.
    
    抛出:
    
    - if this.writableBytes is less than 1
  - writeBytes
```
void writeBytes(byte[] src)
```
    Transfers the specified source array's data to this buffer starting at the current writerIndex and increases the writerIndex by the number of the transferred bytes (= src.length).
    
    抛出:
    
    - if src.length is greater than this.writableBytes
  - writeBytes
```
void writeBytes(byte[] src,
                int index,
                int length)
```
    Transfers the specified source array's data to this buffer starting at the current writerIndex and increases the writerIndex by the number of the transferred bytes (= length).
    
    参数:
    
    index - the first index of the source
    
    length - the number of bytes to transfer
    
    抛出:
    
    - if the specified srcIndex is less than 0, if srcIndex + length is greater than src.length, or if length is greater than this.writableBytes
  - writeBytes
```
void writeBytes( src)
```
    Transfers the specified source buffer's data to this buffer starting at the current writerIndex until the source buffer's position reaches its limit, and increases the writerIndex by the number of the transferred bytes.
    
    抛出:
    
    - if src.remaining() is greater than this.writableBytes
  - writeBytes
```
void writeBytes(ChannelBuffer src)
```
    Transfers the specified source buffer's data to this buffer starting at the current writerIndex until the source buffer becomes unreadable, and increases the writerIndex by the number of the transferred bytes. This method is basically same with writeBytes(ChannelBuffer, int, int), except that this method increases the readerIndex of the source buffer by the number of the transferred bytes while writeBytes(ChannelBuffer, int, int) does not.
    
    抛出:
    
    - if src.readableBytes is greater than this.writableBytes
  - writeBytes
```
void writeBytes(ChannelBuffer src,
                int length)
```
    Transfers the specified source buffer's data to this buffer starting at the current writerIndex and increases the writerIndex by the number of the transferred bytes (= length). This method is basically same with writeBytes(ChannelBuffer, int, int), except that this method increases the readerIndex of the source buffer by the number of the transferred bytes (= length) while writeBytes(ChannelBuffer, int, int) does not.
    
    参数:
    
    length - the number of bytes to transfer
    
    抛出:
    
    - if length is greater than this.writableBytes or if length is greater then src.readableBytes
  - writeBytes
```
void writeBytes(ChannelBuffer src,
                int srcIndex,
                int length)
```
    Transfers the specified source buffer's data to this buffer starting at the current writerIndex and increases the writerIndex by the number of the transferred bytes (= length).
    
    参数:
    
    srcIndex - the first index of the source
    
    length - the number of bytes to transfer
    
    抛出:
    
    - if the specified srcIndex is less than 0, if srcIndex + length is greater than src.capacity, or if length is greater than this.writableBytes
  - writeBytes
```
int writeBytes( src,
               int length)
        throws 
```
    Transfers the content of the specified stream to this buffer starting at the current writerIndex and increases the writerIndex by the number of the transferred bytes.
    
    参数:
    
    length - the number of bytes to transfer
    
    返回:
    
    the actual number of bytes read in from the specified stream
    
    抛出:
    
    - if length is greater than this.writableBytes
    
    - if the specified stream threw an exception during I/O
  - writerIndex
```
int writerIndex()
```
    Returns the writerIndex of this buffer.
  - writerIndex
```
void writerIndex(int writerIndex)
```
    Sets the writerIndex of this buffer.
    
    抛出:
    
    - if the specified writerIndex is less than this.readerIndex or greater than this.capacity
  - array
```
byte[] array()
```
    Returns the backing byte array of this buffer.
    
    抛出:
    
    - if there no accessible backing byte array
  - hasArray
```
boolean hasArray()
```
    Returns true if and only if this buffer has a backing byte array. If this method returns true, you can safely call array() and arrayOffset().
  - arrayOffset
```
int arrayOffset()
```
    Returns the offset of the first byte within the backing byte array of this buffer.
    
    抛出:
    
    - if there no accessible backing byte array

接口 ChannelBuffer

Creation of a buffer

Random Access Indexing

Sequential Access Indexing

Readable bytes (the actual content)

Writable bytes

Discardable bytes

Clearing the buffer indexes

Mark and reset

Conversion to existing JDK types

Byte array

NIO Buffers

I/O Streams

方法概要

从接口继承的方法 java.lang.

方法详细资料

capacity

clear

copy

copy

discardReadBytes

ensureWritableBytes

equals

factory

getByte

getBytes

getBytes

getBytes

getBytes

getBytes

getBytes

getBytes

isDirect

markReaderIndex

markWriterIndex

readable

readableBytes

readByte

readBytes

readBytes

readBytes

readBytes

readBytes

readBytes

readBytes

resetReaderIndex

resetWriterIndex

readerIndex

readerIndex

readBytes

setByte

setBytes

setBytes

setBytes

setBytes

setBytes

setBytes

setBytes

setIndex

skipBytes

toByteBuffer

toByteBuffer

writable

writableBytes

writeByte

writeBytes

writeBytes

writeBytes

writeBytes

writeBytes

writeBytes

writeBytes

writerIndex

writerIndex

array

hasArray

arrayOffset