org.jboss.netty.buffer
接口 ChannelBuffer

所有超级接口：

java.lang.Comparable<ChannelBuffer>

所有已知子接口：

WrappedChannelBuffer

所有已知实现类：

AbstractChannelBuffer, BigEndianHeapChannelBuffer, ByteBufferBackedChannelBuffer, CompositeChannelBuffer, DuplicatedChannelBuffer, DynamicChannelBuffer, HeapChannelBuffer, LittleEndianHeapChannelBuffer, ReadOnlyChannelBuffer, SlicedChannelBuffer, TruncatedChannelBuffer

public interface ChannelBuffer
extends java.lang.Comparable<ChannelBuffer>

随机和顺序访问序列零个或多个字节. 这个接口为一个或多个原始字节数组和NIO 缓冲提供抽象视图.

创建一个缓冲区

相比通过调用个别构造函数创建一个新的缓冲区，更建议使用ChannelBuffers帮助类创建一个新的缓冲区.

随机访问索引

就像一个普通的原始字节数组, ChannelBuffer 使用 从0开始的索引. 这意味着第一个字节的索引始终是0和字节的最后索引总是capacity - 1 .例如，要遍历缓冲区里的所有字节，你可以如下操作,不管它内部的实现:

 ChannelBuffer buffer = ...;
 for (int i = 0; i < buffer.capacity(); i ++) {
     byte b = array.getByte(i);
     System.out.println((char) b);
 }
 

顺序访问序列索引

ChannelBuffer提供两个指针变量以支持顺序读写操作 - readerIndex 读操作和writerIndex写操作. 下图显示了使用两个指针把一个缓冲区分割成两三个区域:

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

可读字节（实际内容）

这部分就是保存实际数据. 任何名字以read或skip开头的操作都会获得或跳过当前的 readerIndex, 并增加可读数量. 如果读操作的参数也是一个 ChannelBuffer并没有指定目的索引, 这个指定的缓冲区的readerIndex 也会跟着增加.

如果没有足够的可读字节, 会抛出IndexOutOfBoundsException. 新分配、封装或复制缓冲区的 readerIndex的默认值是0.

 // Iterates the readable bytes of a buffer.
 ChannelBuffer buffer = ...;
 while (buffer.readable()) {
     System.out.println(buffer.readByte());
 }
 

可写字节

这部分是需要被填充的不确定空间. 任何名字以write开头的操作都在当前writerIndex处写数据,并增加可写数量. 如果读操作的参数也是一个 ChannelBuffer并没有指定目的索引, 这个指定的缓冲区的readerIndex 也会跟着增加.

如果没有足够的可写字节, 会抛出IndexOutOfBoundsException. 新分配的缓冲区 writerIndex的默认值为0. 封装缓冲或拷贝缓冲的 writerIndex的默认值是这个缓冲的 capacity.

 // Fills the writable bytes of a buffer with random integers.
 ChannelBuffer buffer = ...;
 while (buffer.writableBytes() >= 4) {
     buffer.writeInt(random.nextInt());
 }
 

可丢弃字节

这部分包含已经通过读操作已读的字节. 初始化, 这部分的大小为0, 但是大小会随着读操作被执行增加到 writerIndex . 读取的字节可以调用discardReadBytes() 被丢弃并回收未使用的空间，如下图所示:

  BEFORE discardReadBytes()
 
      +-------------------+------------------+------------------+
      | discardable bytes |  readable bytes  |  writable bytes  |
      +-------------------+------------------+------------------+
      |                   |                  |                  |
      0      <=      readerIndex   <=   writerIndex    <=    capacity
 
 
  AFTER discardReadBytes()
 
      +------------------+--------------------------------------+
      |  readable bytes  |    writable bytes (got more space)   |
      +------------------+--------------------------------------+
      |                  |                                      |
 readerIndex (0) <= writerIndex (decreased)        <=        capacity
 

请注意，调用discardReadBytes() 后并不对可写字节内容做任何保证.大多数情况下可写字节不会被移除，甚至会根据底层的实现填充完全不同的数据.

清除缓冲区索引

你可以调用clear()设置 readerIndex 和 writerIndex 为 0.这仅仅是清除两个指针并不清空缓冲区内容 (如填充 0). 请注意这个操作的语义并不同于Buffer.clear().

  BEFORE clear()
 
      +-------------------+------------------+------------------+
      | discardable bytes |  readable bytes  |  writable bytes  |
      +-------------------+------------------+------------------+
      |                   |                  |                  |
      0      <=      readerIndex   <=   writerIndex    <=    capacity
 
 
  AFTER clear()
 
      +---------------------------------------------------------+
      |             writable bytes (got more space)             |
      +---------------------------------------------------------+
      |                                                         |
      0 = readerIndex = writerIndex            <=            capacity
 

查找操作

不同的 indexOf(int, int, byte)方法帮助你查找符合标准的一个值的索引. 复杂的动态顺序查找可以用 ChannelBufferIndexFinder以及简单的静态单字节查找.

如果你是解码可变长度数据如以NUL结尾的字符串，你会发现使用bytesBefore(byte)更加有用.

标记和重置

每个缓冲区多有两个标记. 一个是保存 readerIndex, 另一个是保存 writerIndex. 你可以调用reset方法复位任何一个标记. 它的工作原理和 InputStream的mark和reset方法非常相似,除了没有 readlimit.

衍生缓冲区

你可以调用duplicate(), slice() 或者 slice(int, int) 为一个存在的缓冲区创建一个视图. 一个独立的衍生缓冲区拥有独立的 readerIndex, writerIndex 和 标记索引, 而共享其他的内部数据表现，就像NIO缓冲一样.

有些时候对现有的缓冲区使用完全拷贝是必须的，请使用方法copy() .

转化成JDK类型

字节数组

如果一个ChannelBuffer 是由一个字节数组而来 (如 byte[]), 你可以通过 array()方法直接访问它 . 要检测一个缓冲区是否由一个字节数据而来可以使用hasArray()方法

NIO缓冲

不同的 toByteBuffer()方法和 toByteBuffers()方法可以把一个 ChannelBuffer 转化成一个或多个NIO缓冲. 只要有可能这些方法会避免缓冲分配和内存复制，但并不保证内存复制不会被调用.

字符串

不同的 toString(String) 方法可以把ChannelBuffer转化成一个String. 请注意 toString()并不是一个转化方法.

I/O流

请参阅ChannelBufferInputStream 和 ChannelBufferOutputStream.

方法摘要

byte[]	array() 返回该缓冲支持的字节数组.
int	arrayOffset() 返回该缓冲内部的字节数组的第一个字节的偏移量
int	bytesBefore(byte value) 在该缓冲区当前的readerIndex(包含)到writerIndex(不包含)区间查找第一个发现的 value.
int	bytesBefore(ChannelBufferIndexFinder indexFinder) 在该缓冲区当前的readerIndex(包含)到writerIndex (不包含)区间查找indexFinder返回true的第一个地方.
int	bytesBefore(int length, byte value) 在该缓冲区当前的readerIndex(包含)到readerIndex + length (不包含)区间查找第一个发现value的地方 .
int	bytesBefore(int length, ChannelBufferIndexFinder indexFinder) 在该缓冲区当前的readerIndex(包含)到readerIndex + length (不包含)区间查找indexFinder首次发现的地方.
int	bytesBefore(int index, int length, byte value) 在该缓冲区指定的index(包含)到index + length (不包含)区间查找第一个发现value的地方.
int	bytesBefore(int index, int length, ChannelBufferIndexFinder indexFinder) 在该缓冲区指定的index(包含)到index + length (不包含)区间查找indexFinder首次发现的地方.
int	capacity() 返回缓冲区包含字节数量.
void	clear() 同时设置缓冲区的readerIndex和writerIndex为0.
int	compareTo(ChannelBuffer buffer) 和指定的缓冲进行内容比较 .
ChannelBuffer	copy() 返回该缓冲可读字节的拷贝.修改其中任何一个缓冲对另一个都不会有影响.
ChannelBuffer	copy(int index, int length) 返回该缓冲的子部分,修改其中任何一个缓冲对另一个都不会有影响.且并不修改该缓冲区的 readerIndex和 writerIndex.
void	discardReadBytes() 丢弃索引介于0和readerIndex之间的字节.
ChannelBuffer	duplicate() 返回该缓冲全部分.修改其中任何一个缓冲对另一个都会有影响,不过它们维护着各自的索引和标记,该方法等同于 buf.slice(0, buf.capacity()).
void	ensureWritableBytes(int writableBytes) 保证可写字节数量大于等于指定的值.
boolean	equals(java.lang.Object obj) 检测指定的缓冲内容是否和该缓冲内容一样,这里'一样'意味着: 两个缓冲的内容大小一样 两个缓冲的每个单一字节一样.
ChannelBufferFactory	factory() 返回一个用于创建与这个缓冲相同类型和默认ByteOrder的ChannelBuffer的工厂.
byte	getByte(int index) 在指定绝对值index处获取一个字节.该方法并不修改缓冲的 readerIndex 和 writerIndex.
void	getBytes(int index, byte[] dst) 在该缓冲区指定绝对值index开始处传输数据到指定的目标.
void	getBytes(int index, byte[] dst, int dstIndex, int length) 在该缓冲区指定绝对值index开始处传输数据到指定的目标.
void	getBytes(int index, java.nio.ByteBuffer dst) 在该缓冲区指定绝对值index开始处传输数据到指定的目标,直到目标的position到达限制为止.
void	getBytes(int index, ChannelBuffer dst) 在该缓冲区指定绝对值index开始处传输数据到指定的目标,直到目标不可写为止.
void	getBytes(int index, ChannelBuffer dst, int length) 在该缓冲区指定绝对值index开始处传输数据到指定的目标.
void	getBytes(int index, ChannelBuffer dst, int dstIndex, int length) 在该缓冲区指定绝对值index开始处传输数据到指定的目标.
int	getBytes(int index, java.nio.channels.GatheringByteChannel out, int length) 在该缓冲区指定绝对值index开始处传输数据到指定的通道.该方法并不修改该缓冲区的 readerIndex 和 writerIndex.
void	getBytes(int index, java.io.OutputStream out, int length) 在该缓冲区指定绝对值index开始处传输数据到指定的数据流.该方法并不修改该缓冲区的 readerIndex 和 writerIndex.
char	getChar(int index) 在指定绝对值index处获取一个2字节的UTF16字符.该方法并不修改缓冲的 readerIndex 和 writerIndex.
double	getDouble(int index) 在指定绝对值index处获取一个64位浮点数.该方法并不修改缓冲的 readerIndex 和 writerIndex.
float	getFloat(int index) 在指定绝对值index处获取一个32位浮点数.该方法并不修改缓冲的 readerIndex 和 writerIndex.
int	getInt(int index) 在指定绝对值index处获取一个32位符号整型.该方法并不修改缓冲的 readerIndex 和 writerIndex.
long	getLong(int index) 在指定绝对值index处获取一个64位整型.该方法并不修改缓冲的 readerIndex 和 writerIndex.
int	getMedium(int index) 在指定绝对值index处获取一个24位整型.该方法并不修改缓冲的 readerIndex 和 writerIndex.
short	getShort(int index) 在指定绝对值index处获取一个16位整型.该方法并不修改缓冲的 readerIndex 和 writerIndex.
short	getUnsignedByte(int index) 在指定绝对值index处获取一个无符号字节.该方法并不修改缓冲的 readerIndex 和 writerIndex.
long	getUnsignedInt(int index) 在指定绝对值index处获取一个32位无符号整型.该方法并不修改缓冲的 readerIndex 和 writerIndex.
int	getUnsignedMedium(int index) 在指定绝对值index处获取一个24位无符号整型.该方法并不修改缓冲的 readerIndex 和 writerIndex.
int	getUnsignedShort(int index) 在指定绝对值index处获取一个16位无符号整型.该方法并不修改缓冲的 readerIndex 和 writerIndex.
boolean	hasArray() 只有当该缓冲有一个支持的字节数组才返回true,如果该方法返回true,你可以安全的调用 array() 和 arrayOffset().
int	hashCode() 返回该缓冲区内容的哈希值.如果有一个字节数据与该缓冲一样,那么两数组返回的值都相同.
int	indexOf(int fromIndex, int toIndex, byte value) 在该缓冲区指定的fromIndex(包含)到toIndex(不包含)区间查找第一个发现的value .
int	indexOf(int fromIndex, int toIndex, ChannelBufferIndexFinder indexFinder) 在该缓冲区指定的fromIndex(包含)到toIndex (不包含)区间查找indexFinder返回true的第一个发现的地方.
boolean	isDirect() 判断该缓冲区是否是由NIO direct缓冲支持.
void	markReaderIndex() 标记缓冲区当前的readerIndex.你可以通过调用 resetReaderIndex()把当前的 readerIndex复位到标记的readerIndex.
void	markWriterIndex() 标记缓冲区当前的writerIndex.你可以通过调用 resetWriterIndex()把当前的 writerIndex复位到标记的writerIndex.
java.nio.ByteOrder	order() 返回缓冲区的 字节序.
boolean	readable() 只有当(this.writerIndex - this.readerIndex)大于0才返回true .
int	readableBytes() 返回可读字节的数量，等同于(this.writerIndex - this.readerIndex).
byte	readByte() 在当前readerIndex位置获取一个字节，并为 readerIndex加1.
void	readBytes(byte[] dst) 从该缓冲当前的readerIndex处传输数据到指定的目标, 并使用传输的字节数量( =dst.length )增加readerIndex.
void	readBytes(byte[] dst, int dstIndex, int length) 从该缓冲当前的readerIndex处传输数据到指定的目标, 并使用传输的字节数量( =length )增加readerIndex.
void	readBytes(java.nio.ByteBuffer dst) 从该缓冲当前的readerIndex处传输数据到指定的目标,直到目标的position到达限制为止, 并使用传输的字节数量 增加readerIndex.
void	readBytes(ChannelBuffer dst) 从该缓冲当前的readerIndex处传输数据到指定的目标,直到目标不可写为止, 并使用传输的字节数量增加readerIndex.
ChannelBuffer	readBytes(ChannelBufferIndexFinder indexFinder) 已过时。 以被bytesBefore(ChannelBufferIndexFinder)和 readBytes(int)代替.
void	readBytes(ChannelBuffer dst, int length) 从该缓冲当前的readerIndex处传输数据到指定的目标,直到目标不可写为止, 并使用传输的字节数量( =length )增加readerIndex.
void	readBytes(ChannelBuffer dst, int dstIndex, int length) 从该缓冲当前的readerIndex处传输数据到指定的目标, 并使用传输的字节数量( =length )增加readerIndex.
int	readBytes(java.nio.channels.GatheringByteChannel out, int length) 从该缓冲当前的readerIndex处传输数据到指定的通道.
ChannelBuffer	readBytes(int length) 在当前的readerIndex处传输该缓冲区数据到一个新创建的缓冲区中,并使用传输的字节数(= length)增加 readerIndex.
void	readBytes(java.io.OutputStream out, int length) 从该缓冲当前的readerIndex处传输数据到指定的输出流.
char	readChar() 在当前readerIndex位置获取一个2字节UTF-16字符，并为 readerIndex加2.
double	readDouble() 在当前readerIndex位置获取一个64位浮点数，并为 readerIndex加8.
int	readerIndex() 返回该缓冲的readerIndex值
void	readerIndex(int readerIndex) 设置readerIndex值.
float	readFloat() 在当前readerIndex位置获取一个32位浮点数，并为 readerIndex加4.
int	readInt() 在当前readerIndex位置获取一个32位整型，并为 readerIndex加4.
long	readLong() 在当前readerIndex位置获取一个64位整型，并为 readerIndex加8.
int	readMedium() 在当前readerIndex位置获取一个24位整型，并为 readerIndex加3.
short	readShort() 在当前readerIndex位置获取一个16位短整型，并为 readerIndex加2.
ChannelBuffer	readSlice(ChannelBufferIndexFinder indexFinder) 已过时。 使用bytesBefore(ChannelBufferIndexFinder)和 readSlice(int)代替.
ChannelBuffer	readSlice(int length) 在当前的readerIndex开始处切割该缓冲区的子范围作为新的缓冲区，并使用新切割的大小增加readerIndex (= length).
short	readUnsignedByte() 在当前readerIndex位置获取一个无符号字节，并为 readerIndex加1.
long	readUnsignedInt() 在当前readerIndex位置获取一个32位 无符号整型，并为 readerIndex加4.
int	readUnsignedMedium() 在当前readerIndex位置获取一个24位无符号整型，并为 readerIndex加3.
int	readUnsignedShort() 在当前readerIndex位置获取一个 16位无符号短整型，并为 readerIndex加2.
void	resetReaderIndex() 复位当前 readerIndex到标记的readerIndex.
void	resetWriterIndex() 复位当前 writerIndex到标记的writerIndex.
void	setByte(int index, int value) 在指定绝对值index处设置指定的字节. 24高序位会被忽略.
void	setBytes(int index, byte[] src) 把指定的源数组的数据传输到该缓冲区指定绝对值index的位置 .
void	setBytes(int index, byte[] src, int srcIndex, int length) 把指定的源数组的数据传输到该缓冲区指定绝对值index的位置 .
void	setBytes(int index, java.nio.ByteBuffer src) 把指定的源缓冲的数据传输到该缓冲区指定绝对值index的位置 ,直到源缓冲的position到达限制为止.
void	setBytes(int index, ChannelBuffer src) 把指定的源缓冲区的数据传输到该缓冲区指定绝对值index的位置 ,直到源缓冲区没有可读数据为止.
void	setBytes(int index, ChannelBuffer src, int length) 把指定的源缓冲区的数据传输到该缓冲区指定绝对值index的位置.
void	setBytes(int index, ChannelBuffer src, int srcIndex, 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的位置 .
void	setChar(int index, int value) 在指定绝对值index处设置指定的2字节的UTF16字符 . 16高序位的值会被忽略.该方法并不修改该缓冲区的 readerIndex 和 writerIndex.
void	setDouble(int index, double value) 在指定绝对值index处设置指定的64位浮点数 .
void	setFloat(int index, float value) 在指定绝对值index处设置指定的32位浮点数 .
void	setIndex(int readerIndex, int writerIndex) 一次性设置 readerIndex和writerIndex.
void	setInt(int index, int value) 在指定绝对值index处设置指定的32位整型.
void	setLong(int index, long value) 在指定绝对值index处设置指定的64位长整型.
void	setMedium(int index, int value) 在指定绝对值index处设置指定的24位整型.
void	setShort(int index, int value) 在指定绝对值index处设置指定的16位短整型. 16高序位会被忽略.
void	setZero(int index, int length) 在指定绝对值index的位置填充NUL(0x00).该方法并不修改该缓冲区和源缓冲区的 readerIndex 和 writerIndex.
int	skipBytes(ChannelBufferIndexFinder indexFinder) 已过时。 使用bytesBefore(ChannelBufferIndexFinder)和 skipBytes(int)代替.
void	skipBytes(int length) 使用指定的length增加该缓冲区的readerIndex.
ChannelBuffer	slice() 返回该缓冲可读字节的切片.修改其中任何一个缓冲对另一个都会有影响,不过它们维护着各自的索引和标记,该方法等同于 buf.slice(buf.readerIndex(), buf.readableBytes()).
ChannelBuffer	slice(int index, int length) 返回该缓冲子部分的切片.修改其中任何一个缓冲对另一个都会有影响,不过它们维护着各自的索引和标记,且并不修改该缓冲区的 readerIndex和writerIndex.
java.nio.ByteBuffer	toByteBuffer() 转化该缓冲区的可读字节到一个NIO缓冲区.返回的缓冲区可能有或没有和该缓冲共享内容,但是它们有各自的索引和标记.该方法等同于 buf.toByteBuffer(buf.readerIndex(), buf.readableBytes()).
java.nio.ByteBuffer	toByteBuffer(int index, int length) 转化该缓冲区的子部分到一个NIO缓冲区.返回的缓冲区可能有或没有和该缓冲共享内容,但是它们有各自的索引和标记.
java.nio.ByteBuffer[]	toByteBuffers() 转化该缓冲区的可读字节到一个NIO缓冲数组,返回的缓冲数组可能有或没有和该缓冲共享内容,但是它们有各自的索引和标记 ,该方法等同于 buf.toByteBuffers(buf.readerIndex(), buf.readableBytes()).
java.nio.ByteBuffer[]	toByteBuffers(int index, int length) 转化该缓冲区的子部分到一个NIO缓冲数组,返回的缓冲数组可能有或没有和该缓冲共享内容,但是它们有各自的索引和标记 , 且并不修改该缓冲区的 readerIndex和 writerIndex.
java.lang.String	toString() 返回该缓冲的字符串表示形式.
java.lang.String	toString(java.nio.charset.Charset charset) 使用一个指定的字符集解码该缓冲子部分为一个字符串.该方法等同于 buf.toString(buf.readerIndex(), buf.readableBytes(), charsetName) .
java.lang.String	toString(int index, int length, java.nio.charset.Charset charset) 使用一个指定的字符集解码该缓冲子部分为一个字符串,该方法并不修改readerIndex和 writerIndex.
java.lang.String	toString(int index, int length, java.lang.String charsetName) 已过时。 使用bytesBefore(int, int, ChannelBufferIndexFinder)和 toString(int, int, Charset) 代替.
java.lang.String	toString(int index, int length, java.lang.String charsetName, ChannelBufferIndexFinder terminatorFinder) 已过时。 使用 bytesBefore(int, int, ChannelBufferIndexFinder)和 toString(int, int, Charset)代替.
java.lang.String	toString(java.lang.String charsetName) 已过时。 使用toString(Charset)代替.
java.lang.String	toString(java.lang.String charsetName, ChannelBufferIndexFinder terminatorFinder) 已过时。 使用bytesBefore(ChannelBufferIndexFinder)和 toString(int, int, Charset)代替.
boolean	writable() 只有当(this.capacity - this.writerIndex)大于0才返回true.
int	writableBytes() 返回可写字节的数量，等同于(this.capacity - this.writerIndex).
void	writeByte(int value) 在当前的writerIndex设置指定的字节,并为writerIndex加1. 24高序位会被忽略.
void	writeBytes(byte[] src) 从指定的源数组中传输数据到该缓冲区的当前writerIndex处,并使用传输的字节数( = src.length )增加 wirterIndex.
void	writeBytes(byte[] src, int srcIndex, int length) 从指定的源数组中传输数据到该缓冲区的当前writerIndex处,并使用传输的字节数( = length )增加 wirterIndex.
void	writeBytes(java.nio.ByteBuffer src) 从指定的源缓冲中传输数据到该缓冲区的当前writerIndex处,直到源缓冲的position达到限制为止,并使用传输的字节数增加 wirterIndex.
void	writeBytes(ChannelBuffer src) 从指定的源缓冲区中传输数据到该缓冲区的当前writerIndex处,直到源缓冲不可读为止,并使用传输的字节数增加 wirterIndex.除了该方法会使用传输的字节数增加源缓冲区的readerIndex 外,基本 writeBytes(ChannelBuffer, int, int)和方法一样 .
void	writeBytes(ChannelBuffer src, int length) 从指定的源缓冲区中传输数据到该缓冲区的当前writerIndex处,并使用传输的字节数( = length )增加 wirterIndex.除了该方法会使用传输的字节数( =length )增加源缓冲区的 readerIndex 外,基本 writeBytes(ChannelBuffer, int, int) 和方法一样 ..
void	writeBytes(ChannelBuffer src, int srcIndex, int length) 从指定的源缓冲区中传输数据到该缓冲区的当前writerIndex处,并使用传输的字节数( = length )增加 wirterIndex
int	writeBytes(java.io.InputStream in, int length) 从指定的源输入流中传输数据到该缓冲区的当前writerIndex处,并使用传输的字节数( = length )增加 wirterIndex.
int	writeBytes(java.nio.channels.ScatteringByteChannel in, int length) 从指定的源通道中传输数据到该缓冲区的当前writerIndex处,并使用传输的字节数增加 wirterIndex.
void	writeChar(int value) 在当前的writerIndex设置指定的2字节UTF-16字符,并为writerIndex加2. 16位高序位会被忽略.
void	writeDouble(double value) 在当前的writerIndex设置指定的64位浮点数,并为writerIndex加8.
void	writeFloat(float value) 在当前的writerIndex设置指定的32位浮点数,并为writerIndex加4.
void	writeInt(int value) 在当前的writerIndex设置指定的32位整型,并为writerIndex加4.
void	writeLong(long value) 在当前的writerIndex设置指定的64位长整型,并为writerIndex加8.
void	writeMedium(int value) 在当前的writerIndex设置指定的24位整型,并为writerIndex加3.
int	writerIndex() 返回该缓冲的 writerIndex值.
void	writerIndex(int writerIndex) 设置writerIndex值.
void	writeShort(int value) 在当前的writerIndex设置指定的16位短整型,并为writerIndex加2. 16高序位会被忽略.
void	writeZero(int length) 在当前的writerIndex处填充NUL (0x00),并使用指定的length增加writerIndex.

方法详细信息

factory

ChannelBufferFactory factory()

返回一个用于创建与这个缓冲相同类型和默认ByteOrder的ChannelBuffer的工厂.

capacity

int capacity()

返回缓冲区包含字节数量.

order

java.nio.ByteOrder order()

返回缓冲区的 字节序.

isDirect

boolean isDirect()

判断该缓冲区是否是由NIO direct缓冲支持.

readerIndex

int readerIndex()

返回该缓冲的readerIndex值

readerIndex

void readerIndex(int readerIndex)

设置readerIndex值.

抛出：

java.lang.IndexOutOfBoundsException - 如果指定的 readerIndex小于0或大于 this.writerIndex，则抛出异常

writerIndex

int writerIndex()

返回该缓冲的 writerIndex值.

writerIndex

void writerIndex(int writerIndex)

设置writerIndex值.

抛出：

java.lang.IndexOutOfBoundsException - 如果指定的writerIndex小于this.readerIndex或大于 this.capacity

setIndex

void setIndex(int readerIndex,
              int writerIndex)

一次性设置 readerIndex和writerIndex. 如果对调用 readerIndex(int)和writerIndex(int)方法有顺序要求时这个方法很有用. 比如，下面代码会失败:

 // 创建一个readerIndex,writerIndex和capacity分别为0,0,8的缓冲.
 ChannelBuffer buf = ChannelBuffers.buffer(8);
 
 // 因为readerIndex(2)大于当前的writerIndex(0)，所以IndexOutOfBoundsException会被抛出.
 buf.readerIndex(2);
 buf.writerIndex(4);
 

下面代码也会失败:

 // 创建一个readerIndex,writerIndex和capacity分别为0,8,8的缓冲.
 ChannelBuffer buf = ChannelBuffers.wrappedBuffer(new byte[8]);
 
 // readerIndex为8.
 buf.readLong();
 
 // 因为writerIndex(4)小于当前的readerIndex(8)，所以IndexOutOfBoundsException会被抛出.
 buf.writerIndex(4);
 buf.readerIndex(2);
 

相比之下，只要符合基本限制，不管当前缓冲的索引值是什么，setIndex(int, int)保证不会抛出 IndexOutOfBoundsException:

 // 不管当前缓冲的状态是什么，只要缓冲区的 容量capacity不小于4，下面的调用总是成功的.
 buf.setIndex(2, 4);
 

抛出：

java.lang.IndexOutOfBoundsException - 如果readerIndex小于0、writerIndex小于 readerIndex或者writerIndex大于 this.capacity都会抛出异常

readableBytes

int readableBytes()

返回可读字节的数量，等同于(this.writerIndex - this.readerIndex).

writableBytes

int writableBytes()

返回可写字节的数量，等同于(this.capacity - this.writerIndex).

readable

boolean readable()

只有当(this.writerIndex - this.readerIndex)大于0才返回true .

writable

boolean writable()

只有当(this.capacity - this.writerIndex)大于0才返回true.

clear

void clear()

同时设置缓冲区的readerIndex和writerIndex为0. 这个方法等同于 setIndex(0, 0).

请注意这个方法的行为不同于NIO缓冲，NIO会设置 limit为缓冲的capacity.

markReaderIndex

void markReaderIndex()

标记缓冲区当前的readerIndex.你可以通过调用 resetReaderIndex()把当前的 readerIndex复位到标记的readerIndex. 标记的readerIndex初始值为 0.

resetReaderIndex

void resetReaderIndex()

复位当前 readerIndex到标记的readerIndex.

抛出：

java.lang.IndexOutOfBoundsException - 如果当前的writerIndex小于标记的 readerIndex,抛出异常

markWriterIndex

void markWriterIndex()

标记缓冲区当前的writerIndex.你可以通过调用 resetWriterIndex()把当前的 writerIndex复位到标记的writerIndex. 标记的writerIndex初始值为 0.

resetWriterIndex

void resetWriterIndex()

复位当前 writerIndex到标记的writerIndex.

抛出：

java.lang.IndexOutOfBoundsException - 如果当前的readerIndex大于标记的 writerIndex,抛出异常

discardReadBytes

void discardReadBytes()

丢弃索引介于0和readerIndex之间的字节. 移动字节直到readerIndex和 writerIndex之间的的索引为0,并分别设置readerIndex和 writerIndex 为0和oldWriterIndex - oldReaderIndex .

请参阅类文档了解更多的解释.

ensureWritableBytes

void ensureWritableBytes(int writableBytes)

保证可写字节数量大于等于指定的值. 如果有足够的可写字节，该方法会不做任何操作直接返回. 否则:

• 非动态缓冲会抛出 IndexOutOfBoundsException.
• 动态缓冲会自动扩展容量以便 writable bytes的数量大于等于指定的值. 该扩展包含内部缓冲重新分配及内存复制.

参数：

writableBytes - 最小期望的可写字节

抛出：

java.lang.IndexOutOfBoundsException - 如果该缓冲不是动态缓冲，并且可写字节小于指定的值,则抛出异常

getByte

byte getByte(int index)

在指定绝对值index处获取一个字节.该方法并不修改缓冲的 readerIndex 和 writerIndex.

抛出：

java.lang.IndexOutOfBoundsException - 如果指定的index小于0或 index + 1大于 this.capacity,则抛出异常

getUnsignedByte

short getUnsignedByte(int index)

在指定绝对值index处获取一个无符号字节.该方法并不修改缓冲的 readerIndex 和 writerIndex.

抛出：

java.lang.IndexOutOfBoundsException - 如果指定的index小于0或 index + 1大于 this.capacity,则抛出异常

getShort

short getShort(int index)

在指定绝对值index处获取一个16位整型.该方法并不修改缓冲的 readerIndex 和 writerIndex.

抛出：

java.lang.IndexOutOfBoundsException - 如果指定的index小于0或 index + 2大于 this.capacity,则抛出异常

getUnsignedShort

int getUnsignedShort(int index)

在指定绝对值index处获取一个16位无符号整型.该方法并不修改缓冲的 readerIndex 和 writerIndex.

抛出：

java.lang.IndexOutOfBoundsException - 如果指定的index小于0或 index + 2大于 this.capacity,则抛出异常

getMedium

int getMedium(int index)

在指定绝对值index处获取一个24位整型.该方法并不修改缓冲的 readerIndex 和 writerIndex.

抛出：

java.lang.IndexOutOfBoundsException - 如果指定的index小于0或 index + 3大于 this.capacity,则抛出异常

getUnsignedMedium

int getUnsignedMedium(int index)

在指定绝对值index处获取一个24位无符号整型.该方法并不修改缓冲的 readerIndex 和 writerIndex.

抛出：

java.lang.IndexOutOfBoundsException - 如果指定的index小于0或 index + 3大于 this.capacity,则抛出异常

getInt

int getInt(int index)

在指定绝对值index处获取一个32位符号整型.该方法并不修改缓冲的 readerIndex 和 writerIndex.

抛出：

java.lang.IndexOutOfBoundsException - 如果指定的index小于0或 index + 4大于 this.capacity,则抛出异常

getUnsignedInt

long getUnsignedInt(int index)

在指定绝对值index处获取一个32位无符号整型.该方法并不修改缓冲的 readerIndex 和 writerIndex.

抛出：

java.lang.IndexOutOfBoundsException - 如果指定的index小于0或 index + 4大于 this.capacity,则抛出异常

getLong

long getLong(int index)

在指定绝对值index处获取一个64位整型.该方法并不修改缓冲的 readerIndex 和 writerIndex.

抛出：

java.lang.IndexOutOfBoundsException - 如果指定的index小于0或 index + 8大于 this.capacity,则抛出异常

getChar

char getChar(int index)

在指定绝对值index处获取一个2字节的UTF16字符.该方法并不修改缓冲的 readerIndex 和 writerIndex.

抛出：

java.lang.IndexOutOfBoundsException - 如果指定的index小于0或 index + 2大于 this.capacity,则抛出异常

getFloat

float getFloat(int index)

在指定绝对值index处获取一个32位浮点数.该方法并不修改缓冲的 readerIndex 和 writerIndex.

抛出：

java.lang.IndexOutOfBoundsException - 如果指定的index小于0或 index + 4大于 this.capacity,则抛出异常

getDouble

double getDouble(int index)

在指定绝对值index处获取一个64位浮点数.该方法并不修改缓冲的 readerIndex 和 writerIndex.

抛出：

java.lang.IndexOutOfBoundsException - 如果指定的index小于0或 index + 8大于

getBytes

void getBytes(int index,
              ChannelBuffer dst)

在该缓冲区指定绝对值index开始处传输数据到指定的目标,直到目标不可写为止. 该方法除了会使用传输的字节数量增加目标缓冲区的 writerIndex外,基本与getBytes(int, ChannelBuffer, int, int) 一样. 该方法并不修改源缓冲区的 readerIndex 和 writerIndex. (如：本缓冲区).

抛出：

java.lang.IndexOutOfBoundsException - 当指定的index小于0或者 index + dst.writableBytes大于 this.capacity 时抛出异常

getBytes

void getBytes(int index,
              ChannelBuffer dst,
              int length)

在该缓冲区指定绝对值index开始处传输数据到指定的目标. 该方法除了会使用传输的字节数量增加目标缓冲区的 writerIndex外,基本与getBytes(int, ChannelBuffer, int, int) 一样. 该方法并不修改源缓冲区的 readerIndex 和 writerIndex. (如：本缓冲区).

参数：

length - 传输字节数量

抛出：

java.lang.IndexOutOfBoundsException - 当指定的index小于0、 index + length 大于 this.capacity或者 length 大于 dst.writableBytes时抛出异常

getBytes

void getBytes(int index,
              ChannelBuffer dst,
              int dstIndex,
              int length)

在该缓冲区指定绝对值index开始处传输数据到指定的目标. 该方法并不修改源缓冲区和目标缓冲区的 readerIndex 和 writerIndex

参数：

dstIndex - 目标缓冲区的开始索引

length - 传输字节数量

抛出：

java.lang.IndexOutOfBoundsException - 当指定的index小于0、 指定的dstIndex小于0、 index + length大于this.capacity, 或者 dstIndex + length大于 dst.capacity时抛出异常

getBytes

void getBytes(int index,
              byte[] dst)

在该缓冲区指定绝对值index开始处传输数据到指定的目标. 该方法并不修改该缓冲区的 readerIndex 和 writerIndex

抛出：

java.lang.IndexOutOfBoundsException - 当指定的index小于0或者 index + dst.length大于 this.capacity时抛出异常

getBytes

void getBytes(int index,
              byte[] dst,
              int dstIndex,
              int length)

在该缓冲区指定绝对值index开始处传输数据到指定的目标. 该方法并不修改该缓冲区的 readerIndex 和 writerIndex.

参数：

dstIndex - 目标缓冲区的开始索引

length - 传输的字节数量

抛出：

java.lang.IndexOutOfBoundsException - 当指定的index小于0、指定的dstIndex小于0、 index + length大于this.capacity, 或者 dstIndex + length大于 dst.length时抛出异常

getBytes

void getBytes(int index,
              java.nio.ByteBuffer dst)

在该缓冲区指定绝对值index开始处传输数据到指定的目标,直到目标的position到达限制为止. 该方法并不修改该缓冲区的 readerIndex 和 writerIndex,但会增加目标的 position.

抛出：

java.lang.IndexOutOfBoundsException - 当指定的index小于0或者 index + dst.remaining()大于 this.capacity时抛出异常

getBytes

void getBytes(int index,
              java.io.OutputStream out,
              int length)
              throws java.io.IOException

在该缓冲区指定绝对值index开始处传输数据到指定的数据流.该方法并不修改该缓冲区的 readerIndex 和 writerIndex.

参数：

length - 传输字节的数量

抛出：

java.lang.IndexOutOfBoundsException - 当index小于0或者 index + length大于 this.capacity时抛出异常

java.io.IOException - 指定的数据流在I/O期间抛出的异常

getBytes

int getBytes(int index,
             java.nio.channels.GatheringByteChannel out,
             int length)
             throws java.io.IOException

在该缓冲区指定绝对值index开始处传输数据到指定的通道.该方法并不修改该缓冲区的 readerIndex 和 writerIndex.

参数：

length - 传输字节的最大数

返回：

传输的实际字节数

抛出：

java.lang.IndexOutOfBoundsException - 当index小于0或者 index + length大于 this.capacity时抛出异常

java.io.IOException - 指定的通道在I/O期间抛出的异常

setByte

void setByte(int index,
             int value)

在指定绝对值index处设置指定的字节. 24高序位会被忽略. 该方法并不修改该缓冲区的 readerIndex 和 writerIndex.

抛出：

java.lang.IndexOutOfBoundsException - 当指定的index小于0或 index + 1大于 this.capacity是抛出异常

setShort

void setShort(int index,
              int value)

在指定绝对值index处设置指定的16位短整型. 16高序位会被忽略. 该方法并不修改该缓冲区的 readerIndex 和 writerIndex.

抛出：

java.lang.IndexOutOfBoundsException - 当index小于0或 index + 2大于 this.capacity时抛出异常

setMedium

void setMedium(int index,
               int value)

在指定绝对值index处设置指定的24位整型. 请注意大多数有意义的字节会被忽略. 该方法并不修改该缓冲区的 readerIndex 和 writerIndex.

抛出：

java.lang.IndexOutOfBoundsException - 当index小于0或 index + 3大于 this.capacity时抛出异常

setInt

void setInt(int index,
            int value)

在指定绝对值index处设置指定的32位整型. 该方法并不修改该缓冲区的 readerIndex 和 writerIndex.

抛出：

java.lang.IndexOutOfBoundsException - 当指定的index小于0或 index + 4大于 this.capacity

setLong

void setLong(int index,
             long value)

在指定绝对值index处设置指定的64位长整型. 该方法并不修改该缓冲区的 readerIndex 和 writerIndex.

抛出：

java.lang.IndexOutOfBoundsException - 当指定的index小于0或 index + 8大于 this.capacity时抛出异常

setChar

void setChar(int index,
             int value)

在指定绝对值index处设置指定的2字节的UTF16字符 . 16高序位的值会被忽略.该方法并不修改该缓冲区的 readerIndex 和 writerIndex.

抛出：

java.lang.IndexOutOfBoundsException - 当指定的index小于0或 index + 2大于 this.capacity时抛出异常

setFloat

void setFloat(int index,
              float value)

在指定绝对值index处设置指定的32位浮点数 . 该方法并不修改该缓冲区的 readerIndex 和 writerIndex.

抛出：

java.lang.IndexOutOfBoundsException - 当指定的index小于0或 index + 4大于 this.capacity时抛出异常

setDouble

void setDouble(int index,
               double value)

在指定绝对值index处设置指定的64位浮点数 . 该方法并不修改该缓冲区的 readerIndex 和 writerIndex.

抛出：

java.lang.IndexOutOfBoundsException - 当指定的index小于0或 index + 8大于 this.capacity时抛出异常

setBytes

void setBytes(int index,
              ChannelBuffer src)

把指定的源缓冲区的数据传输到该缓冲区指定绝对值index的位置 ,直到源缓冲区没有可读数据为止. 该方法除了会使用传输的字节数增加源缓冲区的readerIndex外，基本与 setBytes(int, ChannelBuffer, int, int)一样. 该方法并不修改该缓冲区的 readerIndex 和 writerIndex.

抛出：

java.lang.IndexOutOfBoundsException - 当index小于0或 index + src.readableBytes 大于 this.capacity时抛出异常

setBytes

void setBytes(int index,
              ChannelBuffer src,
              int length)

把指定的源缓冲区的数据传输到该缓冲区指定绝对值index的位置. 该方法除了会使用传输的字节数增加源缓冲区的 readerIndex外，基本与 setBytes(int, ChannelBuffer, int, int) 一样. 该方法并不修改该缓冲区的 readerIndex 和 writerIndex.

参数：

length - 传输的字节数

抛出：

java.lang.IndexOutOfBoundsException - 当index小于0、 index + length大于 this.capacity, 或length大于 src.readableBytes时抛出异常

setBytes

void setBytes(int index,
              ChannelBuffer src,
              int srcIndex,
              int length)

把指定的源缓冲区的数据传输到该缓冲区指定绝对值index的位置 . 该方法并不修改该缓冲区和源缓冲区的 readerIndex 和 writerIndex.

参数：

srcIndex - 源缓冲区的开始索引

length - 传输的字节数

抛出：

java.lang.IndexOutOfBoundsException - 当index小于0、srcIndex小于0、 index + length大于this.capacity或者 srcIndex + length大于 src.capacity时抛出异常

setBytes

void setBytes(int index,
              byte[] src)

把指定的源数组的数据传输到该缓冲区指定绝对值index的位置 . 该方法并不修改该缓冲区和源缓冲区的 readerIndex 和 writerIndex.

抛出：

java.lang.IndexOutOfBoundsException - 当index小于0或 index + src.length大于 this.capacity时抛出异常

setBytes

void setBytes(int index,
              byte[] src,
              int srcIndex,
              int length)

把指定的源数组的数据传输到该缓冲区指定绝对值index的位置 . 该方法并不修改该缓冲区和源缓冲区的 readerIndex 和 writerIndex.

抛出：

java.lang.IndexOutOfBoundsException - 当index小于0、srcIndex小于0、 index + length大于this.capacity或 srcIndex + length大于 src.length时抛出异常

setBytes

void setBytes(int index,
              java.nio.ByteBuffer src)

把指定的源缓冲的数据传输到该缓冲区指定绝对值index的位置 ,直到源缓冲的position到达限制为止. 该方法并不修改该缓冲区和源缓冲区的 readerIndex 和 writerIndex.

抛出：

java.lang.IndexOutOfBoundsException - 当index小于0或 index + src.remaining()大于 this.capacity时抛出异常

setBytes

int setBytes(int index,
             java.io.InputStream in,
             int length)
             throws java.io.IOException

把指定的源输入流的数据传输到该缓冲区指定绝对值index的位置 . 该方法并不修改该缓冲区和源缓冲区的 readerIndex 和 writerIndex.

参数：

length - 传输的字节数

返回：

返回从输入流读取的实际字节数.如果指定的输入流被关闭则返回 -1.

抛出：

java.lang.IndexOutOfBoundsException - 当index小于0或 index + length大于 this.capacity时抛出异常

java.io.IOException - 输入流在IO期间抛出的异常

setBytes

int setBytes(int index,
             java.nio.channels.ScatteringByteChannel in,
             int length)
             throws java.io.IOException

把指定的源通道的数据传输到该缓冲区指定绝对值index的位置 . 该方法并不修改该缓冲区和源缓冲区的 readerIndex 和 writerIndex.

参数：

length - 最大的传输字节数

返回：

返回从通道读取的实际字节数.如果指定的通道被关闭则返回 -1.

抛出：

java.lang.IndexOutOfBoundsException - 当index小于0或 index + length大于 this.capacity时抛出异常

java.io.IOException - 通道在IO期间抛出的异常

setZero

void setZero(int index,
             int length)

在指定绝对值index的位置填充NUL(0x00).该方法并不修改该缓冲区和源缓冲区的 readerIndex 和 writerIndex.

参数：

length - 填充NUL的数量

抛出：

java.lang.IndexOutOfBoundsException - 当index小于0或 index + length大于 this.capacity抛出异常

readByte

byte readByte()

在当前readerIndex位置获取一个字节，并为 readerIndex加1.

抛出：

java.lang.IndexOutOfBoundsException - 当this.readableBytes小于1时抛出异常

readUnsignedByte

short readUnsignedByte()

在当前readerIndex位置获取一个无符号字节，并为 readerIndex加1.

抛出：

java.lang.IndexOutOfBoundsException - 当this.readableBytes小于1时抛出异常

readShort

short readShort()

在当前readerIndex位置获取一个16位短整型，并为 readerIndex加2.

抛出：

java.lang.IndexOutOfBoundsException - 当this.readableBytes小于2时抛出异常

readUnsignedShort

int readUnsignedShort()

在当前readerIndex位置获取一个 16位无符号短整型，并为 readerIndex加2.

抛出：

java.lang.IndexOutOfBoundsException - 当this.readableBytes小于2时抛出异常

readMedium

int readMedium()

在当前readerIndex位置获取一个24位整型，并为 readerIndex加3.

抛出：

java.lang.IndexOutOfBoundsException - 当this.readableBytes小于3时抛出异常

readUnsignedMedium

int readUnsignedMedium()

在当前readerIndex位置获取一个24位无符号整型，并为 readerIndex加3.

抛出：

java.lang.IndexOutOfBoundsException - 当this.readableBytes小于3时抛出异常

readInt

int readInt()

在当前readerIndex位置获取一个32位整型，并为 readerIndex加4.

抛出：

java.lang.IndexOutOfBoundsException - 当this.readableBytes小于4时抛出异常

readUnsignedInt

long readUnsignedInt()

在当前readerIndex位置获取一个32位 无符号整型，并为 readerIndex加4.

抛出：

java.lang.IndexOutOfBoundsException - 当this.readableBytes小于4时抛出异常

readLong

long readLong()

在当前readerIndex位置获取一个64位整型，并为 readerIndex加8.

抛出：

java.lang.IndexOutOfBoundsException - 当this.readableBytes小于8时抛出异常

readChar

char readChar()

在当前readerIndex位置获取一个2字节UTF-16字符，并为 readerIndex加2.

抛出：

java.lang.IndexOutOfBoundsException - 当this.readableBytes小于2时抛出异常

readFloat

float readFloat()

在当前readerIndex位置获取一个32位浮点数，并为 readerIndex加4.

抛出：

java.lang.IndexOutOfBoundsException - 当this.readableBytes小于4时抛出异常

readDouble

double readDouble()

在当前readerIndex位置获取一个64位浮点数，并为 readerIndex加8.

抛出：

java.lang.IndexOutOfBoundsException - 当this.readableBytes小于8时抛出异常

readBytes

ChannelBuffer readBytes(int length)

在当前的readerIndex处传输该缓冲区数据到一个新创建的缓冲区中,并使用传输的字节数(= length)增加 readerIndex. 返回一个readerIndex和writerIndex分别为0和 length .

参数：

length - 传输的字节数

返回：

包含已经传输字节的新缓冲

抛出：

java.lang.IndexOutOfBoundsException - 当length大于this.readableBytes时抛出异常

readBytes

@Deprecated
ChannelBuffer readBytes(ChannelBufferIndexFinder indexFinder)

已过时。 以被bytesBefore(ChannelBufferIndexFinder)和 readBytes(int)代替.

readSlice

ChannelBuffer readSlice(int length)

在当前的readerIndex开始处切割该缓冲区的子范围作为新的缓冲区，并使用新切割的大小增加readerIndex (= length).

参数：

length - 要切割的长度

返回：

一个新的切割缓冲

抛出：

java.lang.IndexOutOfBoundsException - 当length大于this.readableBytes时抛出异常

readSlice

@Deprecated
ChannelBuffer readSlice(ChannelBufferIndexFinder indexFinder)

已过时。 使用bytesBefore(ChannelBufferIndexFinder)和 readSlice(int)代替.

readBytes

void readBytes(ChannelBuffer dst)

从该缓冲当前的readerIndex处传输数据到指定的目标,直到目标不可写为止, 并使用传输的字节数量增加readerIndex. 该方法除了会使用传输的字节数量增加目标的writerIndex外,基本与 readBytes(ChannelBuffer, int, int)一样.

抛出：

java.lang.IndexOutOfBoundsException - 当dst.writableBytes大于 this.readableBytes时抛出异常

readBytes

void readBytes(ChannelBuffer dst,
               int length)

从该缓冲当前的readerIndex处传输数据到指定的目标,直到目标不可写为止, 并使用传输的字节数量( =length )增加readerIndex. 该方法除了会使用传输的字节数量( =length )增加目标的writerIndex外,基本与 readBytes(ChannelBuffer, int, int)一样.

抛出：

java.lang.IndexOutOfBoundsException - 当length大于this.readableBytes或 length大于 dst.writableBytes时抛出异常

readBytes

void readBytes(ChannelBuffer dst,
               int dstIndex,
               int length)

从该缓冲当前的readerIndex处传输数据到指定的目标, 并使用传输的字节数量( =length )增加readerIndex.

参数：

dstIndex - 目标的开始索引

length - 传输字节数量

抛出：

java.lang.IndexOutOfBoundsException - 当指定的dstIndex小于0、 length大于 this.readableBytes或 dstIndex + length大于 dst.capacity时抛出异常

readBytes

void readBytes(byte[] dst)

从该缓冲当前的readerIndex处传输数据到指定的目标, 并使用传输的字节数量( =dst.length )增加readerIndex.

抛出：

java.lang.IndexOutOfBoundsException - 当dst.length大于 this.readableBytes时抛出异常

readBytes

void readBytes(byte[] dst,
               int dstIndex,
               int length)

从该缓冲当前的readerIndex处传输数据到指定的目标, 并使用传输的字节数量( =length )增加readerIndex.

参数：

dstIndex - 目标的开始索引

length - 传输的字节数

抛出：

java.lang.IndexOutOfBoundsException - 当dstIndex小于0、 length大于 this.readableBytes或 dstIndex + length大于 dst.length时抛出异常

readBytes

void readBytes(java.nio.ByteBuffer dst)

从该缓冲当前的readerIndex处传输数据到指定的目标,直到目标的position到达限制为止, 并使用传输的字节数量 增加readerIndex.

抛出：

java.lang.IndexOutOfBoundsException - 当dst.remaining()大于 this.readableBytes时抛出异常

readBytes

void readBytes(java.io.OutputStream out,
               int length)
               throws java.io.IOException

从该缓冲当前的readerIndex处传输数据到指定的输出流.

参数：

length - 传输的字节数

抛出：

java.lang.IndexOutOfBoundsException - 当length大于this.readableBytes时抛出异常

java.io.IOException - 指定输出流在I/O期间抛出的异常

readBytes

int readBytes(java.nio.channels.GatheringByteChannel out,
              int length)
              throws java.io.IOException

从该缓冲当前的readerIndex处传输数据到指定的通道.

参数：

length - 要传输的最大字节数

返回：

被写到指定通道的实际字节数

抛出：

java.lang.IndexOutOfBoundsException - 当length大于this.readableBytes时抛出异常

java.io.IOException - 指定通道在I/O期间抛出的异常

skipBytes

void skipBytes(int length)

使用指定的length增加该缓冲区的readerIndex.

抛出：

java.lang.IndexOutOfBoundsException - 当length大于this.readableBytes时抛出异常

skipBytes

@Deprecated
int skipBytes(ChannelBufferIndexFinder indexFinder)

已过时。 使用bytesBefore(ChannelBufferIndexFinder)和 skipBytes(int)代替.

writeByte

void writeByte(int value)

在当前的writerIndex设置指定的字节,并为writerIndex加1. 24高序位会被忽略.

抛出：

java.lang.IndexOutOfBoundsException - 当this.writableBytes小于1时抛出异常

writeShort

void writeShort(int value)

在当前的writerIndex设置指定的16位短整型,并为writerIndex加2. 16高序位会被忽略.

抛出：

java.lang.IndexOutOfBoundsException - 当this.writableBytes小于2时抛出异常

writeMedium

void writeMedium(int value)

在当前的writerIndex设置指定的24位整型,并为writerIndex加3.

抛出：

java.lang.IndexOutOfBoundsException - 当this.writableBytes小于3时抛出异常

writeInt

void writeInt(int value)

在当前的writerIndex设置指定的32位整型,并为writerIndex加4.

抛出：

java.lang.IndexOutOfBoundsException - 当this.writableBytes小于4时抛出异常

writeLong

void writeLong(long value)

在当前的writerIndex设置指定的64位长整型,并为writerIndex加8.

抛出：

java.lang.IndexOutOfBoundsException - 当this.writableBytes小于8时抛出异常

writeChar

void writeChar(int value)

在当前的writerIndex设置指定的2字节UTF-16字符,并为writerIndex加2. 16位高序位会被忽略.

抛出：

java.lang.IndexOutOfBoundsException - 当this.writableBytes小于2时抛出异常

writeFloat

void writeFloat(float value)

在当前的writerIndex设置指定的32位浮点数,并为writerIndex加4.

抛出：

java.lang.IndexOutOfBoundsException - 当this.writableBytes小于4时抛出异常

writeDouble

void writeDouble(double value)

在当前的writerIndex设置指定的64位浮点数,并为writerIndex加8.

抛出：

java.lang.IndexOutOfBoundsException - 当this.writableBytes小于8时抛出异常

writeBytes

void writeBytes(ChannelBuffer src)

从指定的源缓冲区中传输数据到该缓冲区的当前writerIndex处,直到源缓冲不可读为止,并使用传输的字节数增加 wirterIndex.除了该方法会使用传输的字节数增加源缓冲区的readerIndex 外,基本 writeBytes(ChannelBuffer, int, int)和方法一样 .

抛出：

java.lang.IndexOutOfBoundsException - 当src.readableBytes大于 this.writableBytes时抛出异常

writeBytes

void writeBytes(ChannelBuffer src,
                int length)

从指定的源缓冲区中传输数据到该缓冲区的当前writerIndex处,并使用传输的字节数( = length )增加 wirterIndex.除了该方法会使用传输的字节数( =length )增加源缓冲区的 readerIndex 外,基本 writeBytes(ChannelBuffer, int, int) 和方法一样 ..

参数：

length - 要传输的字节数

抛出：

java.lang.IndexOutOfBoundsException - 当length大于this.writableBytes 或length大于 src.readableBytes时抛出异常

writeBytes

void writeBytes(ChannelBuffer src,
                int srcIndex,
                int length)

从指定的源缓冲区中传输数据到该缓冲区的当前writerIndex处,并使用传输的字节数( = length )增加 wirterIndex

参数：

srcIndex - 源缓冲区的开始索引

length - 要传输的字节数

抛出：

java.lang.IndexOutOfBoundsException - 当srcIndex小于0、 srcIndex + length大于 src.capacity或length大于 this.writableBytes时抛出异常

writeBytes

void writeBytes(byte[] src)

从指定的源数组中传输数据到该缓冲区的当前writerIndex处,并使用传输的字节数( = src.length )增加 wirterIndex.

抛出：

java.lang.IndexOutOfBoundsException - 当src.length大于 this.writableBytes时抛出异常

writeBytes

void writeBytes(byte[] src,
                int srcIndex,
                int length)

从指定的源数组中传输数据到该缓冲区的当前writerIndex处,并使用传输的字节数( = length )增加 wirterIndex.

参数：

srcIndex - 源数组的开始索引

length - 要传输的字节数

抛出：

java.lang.IndexOutOfBoundsException - 当srcIndex小于0、 srcIndex + length大于 src.length或 length大于 this.writableBytes时抛出异常

writeBytes

void writeBytes(java.nio.ByteBuffer src)

从指定的源缓冲中传输数据到该缓冲区的当前writerIndex处,直到源缓冲的position达到限制为止,并使用传输的字节数增加 wirterIndex.

抛出：

java.lang.IndexOutOfBoundsException - 当src.remaining()大于 this.writableBytes时抛出异常

writeBytes

int writeBytes(java.io.InputStream in,
               int length)
               throws java.io.IOException

从指定的源输入流中传输数据到该缓冲区的当前writerIndex处,并使用传输的字节数( = length )增加 wirterIndex.

参数：

length - 要传输的字节数

返回：

从指定流中读取到的实际字节数

抛出：

java.lang.IndexOutOfBoundsException - 当length大于this.writableBytes时抛出异常

java.io.IOException - 指定流在I/O期间抛出的异常

writeBytes

int writeBytes(java.nio.channels.ScatteringByteChannel in,
               int length)
               throws java.io.IOException

从指定的源通道中传输数据到该缓冲区的当前writerIndex处,并使用传输的字节数增加 wirterIndex.

参数：

length - 最大的传输字节数

返回：

从指定的通道中读取到的实际字节数

抛出：

java.lang.IndexOutOfBoundsException - 当length大于this.writableBytes时抛出异常

java.io.IOException - 指定通道在I/O期间抛出的异常

writeZero

void writeZero(int length)

在当前的writerIndex处填充NUL (0x00),并使用指定的length增加writerIndex.

参数：

length - 填充到该缓冲区的NUL数量

抛出：

java.lang.IndexOutOfBoundsException - 当length大于this.writableBytes时抛出异常

indexOf

int indexOf(int fromIndex,
            int toIndex,
            byte value)

在该缓冲区指定的fromIndex(包含)到toIndex(不包含)区间查找第一个发现的value .

如果fromIndex大于toIndex,则查找会反顺序执行.

该方法并不修改readerIndex和writerIndex.

返回：

返回第一个发现的绝对索引值,否则返回-1.

indexOf

int indexOf(int fromIndex,
            int toIndex,
            ChannelBufferIndexFinder indexFinder)

在该缓冲区指定的fromIndex(包含)到toIndex (不包含)区间查找indexFinder返回true的第一个发现的地方.

如果fromIndex大于toIndex,则查找会反顺序执行.

该方法并不修改readerIndex和writerIndex.

返回：

返回指定indexFinder返回true的首个地方的绝对索引.若indexFinder根本不返回true,则返回-1.

bytesBefore

int bytesBefore(byte value)

在该缓冲区当前的readerIndex(包含)到writerIndex(不包含)区间查找第一个发现的 value.

该方法并不修改readerIndex和writerIndex.

返回：

返回第一个发现的绝对索引值,否则返回-1.

bytesBefore

int bytesBefore(ChannelBufferIndexFinder indexFinder)

在该缓冲区当前的readerIndex(包含)到writerIndex (不包含)区间查找indexFinder返回true的第一个地方.

该方法并不修改readerIndex和writerIndex.

返回：

返回readerIndex和indexFinder返回true的首个地方之间的字节数.若indexFinder根本不返回true,则返回 -1.

bytesBefore

int bytesBefore(int length,
                byte value)

在该缓冲区当前的readerIndex(包含)到readerIndex + length (不包含)区间查找第一个发现value的地方 .

该方法并不修改readerIndex和writerIndex.

返回：

返回readerIndex和首次发现value之间的字节数量.若未发现value,则返回-1

抛出：

java.lang.IndexOutOfBoundsException - 当length大于this.readableBytes时抛出异常

bytesBefore

int bytesBefore(int length,
                ChannelBufferIndexFinder indexFinder)

在该缓冲区当前的readerIndex(包含)到readerIndex + length (不包含)区间查找indexFinder首次发现的地方.

该方法并不修改readerIndex和writerIndex.

返回：

返回readerIndex和indexFinder返回true的首个地方之间的字节数.若indexFinder根本不返回true,则返回 -1.

抛出：

java.lang.IndexOutOfBoundsException - 当length大于this.readableBytes时抛出异常

bytesBefore

int bytesBefore(int index,
                int length,
                byte value)

在该缓冲区指定的index(包含)到index + length (不包含)区间查找第一个发现value的地方.

该方法并不修改readerIndex和writerIndex.

返回：

返回index和首次发现value之间的字节数量.若未发现value,则返回-1

抛出：

java.lang.IndexOutOfBoundsException - 如果index + length大于 this.capacity时抛出异常

bytesBefore

int bytesBefore(int index,
                int length,
                ChannelBufferIndexFinder indexFinder)

在该缓冲区指定的index(包含)到index + length (不包含)区间查找indexFinder首次发现的地方.

该方法并不修改readerIndex和writerIndex.

返回：

返回index和indexFinder首次返回true之间的字节数量.若未发现value,则返回-1

抛出：

java.lang.IndexOutOfBoundsException - 如果index + length大于 this.capacity时抛出异常

copy

ChannelBuffer copy()

返回该缓冲可读字节的拷贝.修改其中任何一个缓冲对另一个都不会有影响. 该方法等同于 buf.copy(buf.readerIndex(), buf.readableBytes()). 且并不修改该缓冲区的 readerIndex和writerIndex.

copy

ChannelBuffer copy(int index,
                   int length)

返回该缓冲的子部分,修改其中任何一个缓冲对另一个都不会有影响.且并不修改该缓冲区的 readerIndex和 writerIndex.

slice

ChannelBuffer slice()

返回该缓冲可读字节的切片.修改其中任何一个缓冲对另一个都会有影响,不过它们维护着各自的索引和标记,该方法等同于 buf.slice(buf.readerIndex(), buf.readableBytes()). 且并不修改该缓冲区的 readerIndex和writerIndex.

slice

ChannelBuffer slice(int index,
                    int length)

返回该缓冲子部分的切片.修改其中任何一个缓冲对另一个都会有影响,不过它们维护着各自的索引和标记,且并不修改该缓冲区的 readerIndex和writerIndex.

duplicate

ChannelBuffer duplicate()

返回该缓冲全部分.修改其中任何一个缓冲对另一个都会有影响,不过它们维护着各自的索引和标记,该方法等同于 buf.slice(0, buf.capacity()). 且并不修改该缓冲区的 readerIndex和 writerIndex.

toByteBuffer

java.nio.ByteBuffer toByteBuffer()

转化该缓冲区的可读字节到一个NIO缓冲区.返回的缓冲区可能有或没有和该缓冲共享内容,但是它们有各自的索引和标记.该方法等同于 buf.toByteBuffer(buf.readerIndex(), buf.readableBytes()). 且并不修改该缓冲区的 readerIndex和 writerIndex.

toByteBuffer

java.nio.ByteBuffer toByteBuffer(int index,
                                 int length)

转化该缓冲区的子部分到一个NIO缓冲区.返回的缓冲区可能有或没有和该缓冲共享内容,但是它们有各自的索引和标记. 且并不修改该缓冲区的 readerIndex和 writerIndex.

toByteBuffers

java.nio.ByteBuffer[] toByteBuffers()

转化该缓冲区的可读字节到一个NIO缓冲数组,返回的缓冲数组可能有或没有和该缓冲共享内容,但是它们有各自的索引和标记 ,该方法等同于 buf.toByteBuffers(buf.readerIndex(), buf.readableBytes()). 且并不修改该缓冲区的 readerIndex和 writerIndex.

toByteBuffers

java.nio.ByteBuffer[] toByteBuffers(int index,
                                    int length)

转化该缓冲区的子部分到一个NIO缓冲数组,返回的缓冲数组可能有或没有和该缓冲共享内容,但是它们有各自的索引和标记 , 且并不修改该缓冲区的 readerIndex和 writerIndex.

hasArray

boolean hasArray()

只有当该缓冲有一个支持的字节数组才返回true,如果该方法返回true,你可以安全的调用 array() 和 arrayOffset().

array

byte[] array()

返回该缓冲支持的字节数组.

抛出：

java.lang.UnsupportedOperationException - 如果没有可访问的字节数组则抛出异常

arrayOffset

int arrayOffset()

返回该缓冲内部的字节数组的第一个字节的偏移量

抛出：

java.lang.UnsupportedOperationException - 如果没有可访问的字节数组则抛出异常

toString

java.lang.String toString(java.nio.charset.Charset charset)

使用一个指定的字符集解码该缓冲子部分为一个字符串.该方法等同于 buf.toString(buf.readerIndex(), buf.readableBytes(), charsetName) . 该方法并不修改readerIndex和 writerIndex.

抛出：

java.nio.charset.UnsupportedCharsetException - 如果指定的字符集在当前VM中不支持,则抛出异常

toString

java.lang.String toString(int index,
                          int length,
                          java.nio.charset.Charset charset)

使用一个指定的字符集解码该缓冲子部分为一个字符串,该方法并不修改readerIndex和 writerIndex.

toString

@Deprecated
java.lang.String toString(java.lang.String charsetName)

已过时。 使用toString(Charset)代替.

toString

@Deprecated
java.lang.String toString(java.lang.String charsetName,
                                     ChannelBufferIndexFinder terminatorFinder)

已过时。 使用bytesBefore(ChannelBufferIndexFinder)和 toString(int, int, Charset)代替.

toString

@Deprecated
java.lang.String toString(int index,
                                     int length,
                                     java.lang.String charsetName)

已过时。 使用bytesBefore(int, int, ChannelBufferIndexFinder)和 toString(int, int, Charset) 代替.

toString

@Deprecated
java.lang.String toString(int index,
                                     int length,
                                     java.lang.String charsetName,
                                     ChannelBufferIndexFinder terminatorFinder)

已过时。 使用 bytesBefore(int, int, ChannelBufferIndexFinder)和 toString(int, int, Charset)代替.

hashCode

int hashCode()

返回该缓冲区内容的哈希值.如果有一个字节数据与该缓冲一样,那么两数组返回的值都相同.

覆盖：

类 java.lang.Object 中的 hashCode

equals

boolean equals(java.lang.Object obj)

检测指定的缓冲内容是否和该缓冲内容一样,这里'一样'意味着:

• 两个缓冲的内容大小一样
• 两个缓冲的每个单一字节一样.

请注意,并不比较readerIndex()和 writerIndex(). 如果指定的对象不是 ChannelBuffer类型或为null，则返回false.

覆盖：

类 java.lang.Object 中的 equals

compareTo

int compareTo(ChannelBuffer buffer)

和指定的缓冲进行内容比较 . 和大多数语言的字符串比较方法那样会一相同的方式比较如 strcmp, memcmp 和String.compareTo(String).

指定者：

接口 java.lang.Comparable<ChannelBuffer> 中的 compareTo

toString

java.lang.String toString()

返回该缓冲的字符串表示形式. 该方法并不返回缓冲区的全部内容,但会返回关键属性的值,如readerIndex(), writerIndex()和capacity().

覆盖：

类 java.lang.Object 中的 toString