net.hasor.neta.bytebuf

接口 ByteBuf

所有超级接口:

AutoCloseable, ByteChannel, Channel, Closeable, ReadableByteChannel, WritableByteChannel

所有已知实现类:

AbstractByteBuf, ArrayByteBuf, ByteBufAdapter, PooledNioByteBuf, SliceNioByteBuf

public interface ByteBuf
extends ByteChannel

readMark <= readIndex <= writerMark <= writerIndex <= capacity

方法概要

限定符和类型	方法和说明
ByteBufAllocator	alloc() Returns the ByteBufAllocator which created this buffer.
byte[]	array() ByteBuf 的字节数组形态
ByteBuffer	asByteBuffer() 返回 ByteBuffer 形态，PooledNioByteBuf 不支持该方法
int	capacity() 最大限制
default void	clear() reset the markWriter, and skip all readable data
default void	close()
ByteBuf	copy() 复制个 ByteBuf , 连同 buffer 的数据一起复制
default int	expect(char expect, Charset charset) 查找下一个 expect 字符的出现的位置（使用指定的编码），该方法不会更新 readerIndex 值。
default int	expect(String expect, Charset charset) 查找下一个 expect 字符串的出现的位置（使用指定的编码），该方法不会更新 readerIndex 值。
default int	expectLast(char expect, Charset charset) 查找最后一个 expect 字符的出现的位置（使用指定的编码），该方法不会更新 readerIndex 值。
default int	expectLast(String expect, Charset charset) 查找最后一个 expect 字符串的出现的位置（使用指定的编码），该方法不会更新 readerIndex 值。
default int	expectLine() 查找最近的一个 '\n'，该方法不会更新 readerIndex 值。
default ByteBuf	flush() same as markWriter()
void	free() 释放 Buffer 占用的内存
byte	getByte(int offset) 从 offset 偏移量的位置上开始读取 1 字节。
default int	getBytes(int offset, byte[] b) 从 offset 偏移量的位置上开始读取一定数量的字节，并将它们存储到缓冲区数组 b 中。
int	getBytes(int offset, byte[] b, int off, int len) 从 offset 偏移量的位置上开始读取 len 数量的字节，并将它们存储到 off 位置开始的缓冲区数组 b 中。
default float	getFloat32(int offset) 读取 4 字节的 float（大端字节序），该方法不会更新 readerIndex 值。
default float	getFloat32LE(int offset) 读取 4 字节的 float（小端字节序），该方法不会更新 readerIndex 值。
default double	getFloat64(int offset) 读取 8 字节的 double（大端字节序），该方法不会更新 readerIndex 值。
default double	getFloat64LE(int offset) 读取 8 字节的 double（小端字节序），该方法不会更新 readerIndex 值。
short	getInt16(int offset) 读取 2 字节的 short（大端字节序），该方法不会更新 readerIndex 值。
short	getInt16LE(int offset) 读取 2 字节的 short（小端字节序），该方法不会更新 readerIndex 值。
int	getInt24(int offset) 读取 3 字节的 int（大端字节序），该方法不会更新 readerIndex 值。
int	getInt24LE(int offset) 读取 3 字节的 int（小端字节序），该方法不会更新 readerIndex 值。
int	getInt32(int offset) 读取 4 字节的 int（大端字节序），该方法不会更新 readerIndex 值。
int	getInt32LE(int offset) 读取 4 字节的 int（小端字节序），该方法不会更新 readerIndex 值。
long	getInt64(int offset) 读取 8 字节的 long（大端字节序），该方法不会更新 readerIndex 值。
long	getInt64LE(int offset) 读取 8 字节的 long（小端字节序），该方法不会更新 readerIndex 值。
default String	getString(int offset, int len, Charset charset) 从 offset 开始读取 len 个字节，并构造一个 String，该方法不会更新 readerIndex 值。
int	getUInt16(int offset) 读取 2 字节的 无符号 sort（小端字节序），该方法不会更新 readerIndex 值。
int	getUInt16LE(int offset) 读取 2 字节的 无符号 sort（小端字节序），该方法不会更新 readerIndex 值。
int	getUInt24(int offset) 读取 3 字节的 无符号 int（小端字节序），该方法不会更新 readerIndex 值。
int	getUInt24LE(int offset) 读取 3 字节的 无符号 int（小端字节序），该方法不会更新 readerIndex 值。
long	getUInt32(int offset) 读取 4 字节的 无符号 int（小端字节序），该方法不会更新 readerIndex 值。
long	getUInt32LE(int offset) 读取 4 字节的 无符号 int（小端字节序），该方法不会更新 readerIndex 值。
short	getUInt8(int offset) 读取 1 字节的 byte 返回 0～255 之间的一个数（小端字节序），该方法不会更新 readerIndex 值。
default boolean	hasLine() 具有行结尾
default boolean	hasReadable() 可以进行读
default boolean	hasWritable() 可以进行写入
boolean	isDirect() ByteBuf 是否为堆外方式
boolean	isFree() 是否已经释放
ByteBuf	markReader() Marks the current readerIndex in this buffer.
ByteBuf	markWriter() Marks the current writerIndex in this buffer.
ByteOrder	order() 字节序
ByteBuf	order(ByteOrder newOrder) 设置字节序
default int	read(ByteBuf dst) use copy to dst
int	read(ByteBuffer dst) use copy to dst
int	read(ByteBuf dst, int len) use copy to dst
int	readableBytes() Returns the number of readable bytes which is equal to (this.markedWriterIndex - this.readerIndex).
byte	readByte() 读取 1 字节。
int	readBytes() Returns the number of read bytes which is equal to (readIndex - readMark).
default int	readBytes(byte[] b) 读取一定数量的字节，并将它们存储到缓冲区数组 b 中。
int	readBytes(byte[] b, int off, int len) 读取 len 数量的字节，并将它们存储到 off 位置开始的缓冲区数组 b 中。
int	readerIndex() Returns the readerIndex of this buffer.
default String	readExpect(char expect, Charset charset) 从当前位置开始读取，直到遇到第一个 expect 字符串读完。
default String	readExpect(String expect, Charset charset) 从当前位置开始读取，直到遇到第一个 expect 字符串读完。
default String	readExpectLast(char expect, Charset charset) 从当前位置开始读取，直到遇到最后一个 expect 字符串读完。
default String	readExpectLast(String expect, Charset charset) 从当前位置开始读取，直到遇到最后一个 expect 字符串读完。
default float	readFloat32() 读取 4 字节的 float（大端字节序），读取后 readerIndex 会增加 4。
default float	readFloat32LE() 读取 4 字节的 float（小端字节序），读取后 readerIndex 会增加 4。
default double	readFloat64() 读取 8 字节的 double（大端字节序），读取后 readerIndex 会增加 8。
default double	readFloat64LE() 读取 8 字节的 double（小端字节序），读取后 readerIndex 会增加 8。
short	readInt16() 读取 2 字节的 short（大端字节序），读取后 readerIndex 会增加 2。
short	readInt16LE() 读取 2 字节的 short（小端字节序），读取后 readerIndex 会增加 2。
int	readInt24() 读取 3 字节的 int（大端字节序），读取后 readerIndex 会增加 3。
int	readInt24LE() 读取 3 字节的 int（小端字节序），读取后 readerIndex 会增加 3。
int	readInt32() 读取 4 字节的 int（大端字节序），读取后 readerIndex 会增加 4。
int	readInt32LE() 读取 4 字节的 int（小端字节序），读取后 readerIndex 会增加 4。
long	readInt64() 读取 8 字节的 long（大端字节序），读取后 readerIndex 会增加 8。
long	readInt64LE() 读取 8 字节的 long（小端字节序），读取后 readerIndex 会增加 8。
default String	readLine() 读一整行
default String	readLine(Charset charset) 读一整行
default String	readString(int len, Charset charset) 读取 len 字节并将其构造成 String，读取后 readerIndex 会增加 len。
int	readUInt16() 读取 2 字节的 无符号 sort（大端字节序），读取后 readerIndex 会增加 2。
int	readUInt16LE() 读取 2 字节的 无符号 sort（小端字节序），读取后 readerIndex 会增加 2。
int	readUInt24() 读取 3 字节的 无符号 int（大端字节序），读取后 readerIndex 会增加 3。
int	readUInt24LE() 读取 3 字节的 无符号 int（小端字节序），读取后 readerIndex 会增加 3。
long	readUInt32() 读取 4 字节的 无符号 int（大端字节序），读取后 readerIndex 会增加 4。
long	readUInt32LE() 读取 4 字节的 无符号 int（小端字节序），读取后 readerIndex 会增加 4。
short	readUInt8() 读取 1 字节的 byte 返回 0～255 之间的一个数（大端字节序），读取后 readerIndex 会增加 1。
ByteBuf	resetReader() Repositions the current readerIndex to the marked readerIndex in this buffer.
ByteBuf	resetWriter() Repositions the current writerIndex to the marked writerIndex in this buffer.
void	setByte(int offset, byte n) 在 offset 偏移量的位置上向后覆盖方式写入 1 字节的 byte，该方法不会更新 writerIndex 值。
void	setBytes(int offset, byte[] b) 在 offset 偏移量的位置上向后覆盖方式写入 b 数组的数据，该方法不会更新 writerIndex 值。
void	setBytes(int offset, byte[] b, int off, int len) 在 offset 偏移量的位置上向后覆盖方式写入 b 数组的数据，该方法不会更新 writerIndex 值。
default void	setFloat32(int offset, float n) 在 offset 偏移量的位置上向后覆盖方式写入 4 字节长度的 float（大端字节序），该方法不会更新 writerIndex 值。
default void	setFloat32LE(int offset, float n) 在 offset 偏移量的位置上向后覆盖方式写入 4 字节长度的 float（小端字节序），该方法不会更新 writerIndex 值。
default void	setFloat64(int offset, double n) 在 offset 偏移量的位置上向后覆盖方式写入 8 字节长度的 float（大端字节序），该方法不会更新 writerIndex 值。
default void	setFloat64LE(int offset, double n) 在 offset 偏移量的位置上向后覆盖方式写入 8 字节长度的 float（小端字节序），该方法不会更新 writerIndex 值。
void	setInt16(int offset, short n) 在 offset 偏移量的位置上向后覆盖方式写入 2 字节长度的 sort（大端字节序），该方法不会更新 writerIndex 值。
void	setInt16LE(int offset, short n) 在 offset 偏移量的位置上向后覆盖方式写入 2 字节长度的 sort（小端字节序），该方法不会更新 writerIndex 值。
void	setInt24(int offset, int n) 在 offset 偏移量的位置上向后覆盖方式写入 3 字节长度的 int（大端字节序），该方法不会更新 writerIndex 值。
void	setInt24LE(int offset, int n) 在 offset 偏移量的位置上向后覆盖方式写入 3 字节长度的 int（小端字节序），该方法不会更新 writerIndex 值。
void	setInt32(int offset, int n) 在 offset 偏移量的位置上向后覆盖方式写入 4 字节长度的 int（大端字节序），该方法不会更新 writerIndex 值。
void	setInt32LE(int offset, int n) 在 offset 偏移量的位置上向后覆盖方式写入 4 字节长度的 int（小端字节序），该方法不会更新 writerIndex 值。
void	setInt64(int offset, long n) 在 offset 偏移量的位置上向后覆盖方式写入 8 字节长度的 long（大端字节序），该方法不会更新 writerIndex 值。
void	setInt64LE(int offset, long n) 在 offset 偏移量的位置上向后覆盖方式写入 8 字节长度的 long（小端字节序），该方法不会更新 writerIndex 值。
default int	setString(int offset, String string, Charset charset) 在 offset 偏移量的位置上向后覆盖方式写入字符串，字符串会通过 str.getBytes(charset) 方式转换为字节数组，该方法不会更新 writerIndex 值。
ByteBuf	skipReadableBytes(int length)
ByteBuf	skipWritableBytes(int length)
int	writableBytes() Returns the number of writable bytes which is equal to (maxCapacity - (writerIndex - readMark)).
int	write(ByteBuf src) use copy form src ByteBuffer
int	write(ByteBuffer src) use copy form src ByteBuffer
void	writeByte(byte n) 写入 1 字节的 byte，写入后 writerIndex 会 + 1。
default void	writeBytes(byte[] b) 数据写入，写入后 writerIndex 会增加 b.length。
void	writeBytes(byte[] b, int off, int len) 数据写入，写入后 writerIndex 会增加 len。
int	writedBytes() Returns the number of writed bytes which is equal to (writerIndex - writerMark).
default void	writeFloat32(float n) 写入 4 字节的 float（大端字节序），写入后 writerIndex 会 + 4。
default void	writeFloat32LE(float n) 写入 4 字节的 float（小端字节序），写入后 writerIndex 会 + 4。
default void	writeFloat64(double n) 写入 8 字节的 double（大端字节序），写入后 writerIndex 会 + 8。
default void	writeFloat64LE(double n) 写入 8 字节的 double（小端字节序），写入后 writerIndex 会 + 8。
void	writeInt16(short n) 写入 2 字节的 sort（大端字节序），写入后 writerIndex 会 + 2。
void	writeInt16LE(short n) 写入 2 字节的 sort（小端字节序），写入后 writerIndex 会 + 2。
void	writeInt24(int n) 写入 3 字节的 int（大端字节序），写入后 writerIndex 会 + 3。
void	writeInt24LE(int n) 写入 3 字节的 int（小端字节序），写入后 writerIndex 会 + 3。
void	writeInt32(int n) 写入 4 字节的 int（大端字节序），写入后 writerIndex 会 + 4。
void	writeInt32LE(int n) 写入 4 字节的 int（小端字节序），写入后 writerIndex 会 + 4。
void	writeInt64(long n) 写入 8 字节的 long（大端字节序），写入后 writerIndex 会 + 8。
void	writeInt64LE(long n) 写入 8 字节的 int（小端字节序），写入后 writerIndex 会 + 8。
int	writerIndex() Returns the writerIndex of this buffer.
default int	writeString(String string, Charset charset) 字符串会以 str.getBytes(charset) 方式转换为字节数组并写入缓存。
void	writeUInt32(long n) 写入 4 字节的无符号 int（大端字节序），写入后 writerIndex 会 + 4。
void	writeUInt32LE(long n) 写入 4 字节的无符号 int（小端字节序），写入后 writerIndex 会 + 4。

从接口继承的方法 java.nio.channels.Channel

isOpen

方法详细资料

alloc

ByteBufAllocator alloc()

Returns the ByteBufAllocator which created this buffer.

readerIndex

int readerIndex()

Returns the readerIndex of this buffer.

writerIndex

int writerIndex()

Returns the writerIndex of this buffer.

capacity

int capacity()

最大限制

array

byte[] array()

ByteBuf 的字节数组形态

isDirect

boolean isDirect()

ByteBuf 是否为堆外方式

copy

ByteBuf copy()

复制个 ByteBuf , 连同 buffer 的数据一起复制

asByteBuffer

ByteBuffer asByteBuffer()

返回 ByteBuffer 形态，PooledNioByteBuf 不支持该方法

order

ByteOrder order()

字节序

order

ByteBuf order(ByteOrder newOrder)

设置字节序

free

void free()

释放 Buffer 占用的内存

close

default void close()
            throws IOException

指定者:

close 在接口中 AutoCloseable

指定者:

close 在接口中 Channel

指定者:

close 在接口中 Closeable

抛出:

IOException

isFree

boolean isFree()

是否已经释放

readableBytes

int readableBytes()

Returns the number of readable bytes which is equal to (this.markedWriterIndex - this.readerIndex).

readBytes

int readBytes()

Returns the number of read bytes which is equal to (readIndex - readMark).

hasReadable

default boolean hasReadable()

可以进行读

writableBytes

int writableBytes()

Returns the number of writable bytes which is equal to (maxCapacity - (writerIndex - readMark)).

writedBytes

int writedBytes()

Returns the number of writed bytes which is equal to (writerIndex - writerMark).

hasWritable

default boolean hasWritable()

可以进行写入

markReader

ByteBuf markReader()

Marks the current readerIndex in this buffer. You can reposition the current readerIndex to the marked readerIndex by calling resetReader(). The initial value of the marked readerIndex is 0.

markWriter

ByteBuf markWriter()

Marks the current writerIndex in this buffer. You can reposition the current writerIndex to the marked writerIndex by calling resetWriter(). The initial value of the marked writerIndex is 0.

flush

default ByteBuf flush()
               throws IOException

same as markWriter()

抛出:

IOException

clear

default void clear()

reset the markWriter, and skip all readable data

resetReader

ByteBuf resetReader()

Repositions the current readerIndex to the marked readerIndex in this buffer.

抛出:

IndexOutOfBoundsException - if the current writerIndex is less than the marked readerIndex

resetWriter

ByteBuf resetWriter()

Repositions the current writerIndex to the marked writerIndex in this buffer.

抛出:

IndexOutOfBoundsException - if the current readerIndex is greater than the marked writerIndex

skipReadableBytes

ByteBuf skipReadableBytes(int length)

skipWritableBytes

ByteBuf skipWritableBytes(int length)

writeByte

void writeByte(byte n)

写入 1 字节的 byte，写入后 writerIndex 会 + 1。 如果 writerIndex + 1 > capacity 则会引发 IndexOutOfBoundsException 异常

writeBytes

default void writeBytes(byte[] b)

数据写入，写入后 writerIndex 会增加 b.length。 如果 writerIndex + b.length > capacity 则会引发 IndexOutOfBoundsException 异常

writeBytes

void writeBytes(byte[] b,
                int off,
                int len)

数据写入，写入后 writerIndex 会增加 len。 如果 writerIndex + len > capacity 则会引发 IndexOutOfBoundsException 异常

writeInt16

void writeInt16(short n)

写入 2 字节的 sort（大端字节序），写入后 writerIndex 会 + 2。 如果 writerIndex + 2 > capacity 则会引发 IndexOutOfBoundsException 异常

writeInt24

void writeInt24(int n)

写入 3 字节的 int（大端字节序），写入后 writerIndex 会 + 3。 如果 writerIndex + 3 > capacity 则会引发 IndexOutOfBoundsException 异常

writeInt32

void writeInt32(int n)

写入 4 字节的 int（大端字节序），写入后 writerIndex 会 + 4。 如果 writerIndex + 4 > capacity 则会引发 IndexOutOfBoundsException 异常

writeUInt32

void writeUInt32(long n)

写入 4 字节的无符号 int（大端字节序），写入后 writerIndex 会 + 4。 如果 writerIndex + 4 > capacity 则会引发 IndexOutOfBoundsException 异常

writeInt64

void writeInt64(long n)

写入 8 字节的 long（大端字节序），写入后 writerIndex 会 + 8。 如果 writerIndex + 8 > capacity 则会引发 IndexOutOfBoundsException 异常

writeFloat32

default void writeFloat32(float n)

写入 4 字节的 float（大端字节序），写入后 writerIndex 会 + 4。 如果 writerIndex + 4 > capacity 则会引发 IndexOutOfBoundsException 异常

writeFloat64

default void writeFloat64(double n)

写入 8 字节的 double（大端字节序），写入后 writerIndex 会 + 8。 如果 writerIndex + 8 > capacity 则会引发 IndexOutOfBoundsException 异常

writeInt16LE

void writeInt16LE(short n)

写入 2 字节的 sort（小端字节序），写入后 writerIndex 会 + 2。 如果 writerIndex + 2 > capacity 则会引发 IndexOutOfBoundsException 异常

writeInt24LE

void writeInt24LE(int n)

写入 3 字节的 int（小端字节序），写入后 writerIndex 会 + 3。 如果 writerIndex + 3 > capacity 则会引发 IndexOutOfBoundsException 异常

writeInt32LE

void writeInt32LE(int n)

写入 4 字节的 int（小端字节序），写入后 writerIndex 会 + 4。 如果 writerIndex + 4 > capacity 则会引发 IndexOutOfBoundsException 异常

writeUInt32LE

void writeUInt32LE(long n)

写入 4 字节的无符号 int（小端字节序），写入后 writerIndex 会 + 4。 如果 writerIndex + 4 > capacity 则会引发 IndexOutOfBoundsException 异常

writeInt64LE

void writeInt64LE(long n)

写入 8 字节的 int（小端字节序），写入后 writerIndex 会 + 8。 如果 writerIndex + 8 > capacity 则会引发 IndexOutOfBoundsException 异常

writeFloat32LE

default void writeFloat32LE(float n)

写入 4 字节的 float（小端字节序），写入后 writerIndex 会 + 4。 如果 writerIndex + 4 > capacity 则会引发 IndexOutOfBoundsException 异常

writeFloat64LE

default void writeFloat64LE(double n)

写入 8 字节的 double（小端字节序），写入后 writerIndex 会 + 8。 如果 writerIndex + 8 > capacity 则会引发 IndexOutOfBoundsException 异常

write

int write(ByteBuffer src)

use copy form src ByteBuffer

指定者:

write 在接口中 WritableByteChannel

write

int write(ByteBuf src)

use copy form src ByteBuffer

writeString

default int writeString(String string,
                        Charset charset)

字符串会以 str.getBytes(charset) 方式转换为字节数组并写入缓存。返回值是写入的字节数。 如果 writerIndex + [string 字节数组长度] > capacity 则会引发 IndexOutOfBoundsException 异常

setByte

void setByte(int offset,
             byte n)

在 offset 偏移量的位置上向后覆盖方式写入 1 字节的 byte，该方法不会更新 writerIndex 值。 参数 offset + 1 必须要小于 writerIndex，否则会引发 IndexOutOfBoundsException 异常

setBytes

void setBytes(int offset,
              byte[] b)

在 offset 偏移量的位置上向后覆盖方式写入 b 数组的数据，该方法不会更新 writerIndex 值。 参数 offset + b.length 必须要小于 writerIndex，否则会引发 IndexOutOfBoundsException 异常

setBytes

void setBytes(int offset,
              byte[] b,
              int off,
              int len)

在 offset 偏移量的位置上向后覆盖方式写入 b 数组的数据，该方法不会更新 writerIndex 值。 参数 offset + len 必须要小于 writerIndex，否则会引发 IndexOutOfBoundsException 异常

setInt16

void setInt16(int offset,
              short n)

在 offset 偏移量的位置上向后覆盖方式写入 2 字节长度的 sort（大端字节序），该方法不会更新 writerIndex 值。 参数 offset + 2 必须要小于 writerIndex，否则会引发 IndexOutOfBoundsException 异常

setInt24

void setInt24(int offset,
              int n)

在 offset 偏移量的位置上向后覆盖方式写入 3 字节长度的 int（大端字节序），该方法不会更新 writerIndex 值。 参数 offset + 3 必须要小于 writerIndex，否则会引发 IndexOutOfBoundsException 异常

setInt32

void setInt32(int offset,
              int n)

在 offset 偏移量的位置上向后覆盖方式写入 4 字节长度的 int（大端字节序），该方法不会更新 writerIndex 值。 参数 offset + 4 必须要小于 writerIndex，否则会引发 IndexOutOfBoundsException 异常

setInt64

void setInt64(int offset,
              long n)

在 offset 偏移量的位置上向后覆盖方式写入 8 字节长度的 long（大端字节序），该方法不会更新 writerIndex 值。 参数 offset + 8 必须要小于 writerIndex，否则会引发 IndexOutOfBoundsException 异常

setFloat32

default void setFloat32(int offset,
                        float n)

在 offset 偏移量的位置上向后覆盖方式写入 4 字节长度的 float（大端字节序），该方法不会更新 writerIndex 值。 参数 offset + 4 必须要小于 writerIndex，否则会引发 IndexOutOfBoundsException 异常

setFloat64

default void setFloat64(int offset,
                        double n)

在 offset 偏移量的位置上向后覆盖方式写入 8 字节长度的 float（大端字节序），该方法不会更新 writerIndex 值。 参数 offset + 8 必须要小于 writerIndex，否则会引发 IndexOutOfBoundsException 异常

setInt16LE

void setInt16LE(int offset,
                short n)

在 offset 偏移量的位置上向后覆盖方式写入 2 字节长度的 sort（小端字节序），该方法不会更新 writerIndex 值。 参数 offset + 2 必须要小于 writerIndex，否则会引发 IndexOutOfBoundsException 异常

setInt24LE

void setInt24LE(int offset,
                int n)

在 offset 偏移量的位置上向后覆盖方式写入 3 字节长度的 int（小端字节序），该方法不会更新 writerIndex 值。 参数 offset + 3 必须要小于 writerIndex，否则会引发 IndexOutOfBoundsException 异常

setInt32LE

void setInt32LE(int offset,
                int n)

在 offset 偏移量的位置上向后覆盖方式写入 4 字节长度的 int（小端字节序），该方法不会更新 writerIndex 值。 参数 offset + 4 必须要小于 writerIndex，否则会引发 IndexOutOfBoundsException 异常

setInt64LE

void setInt64LE(int offset,
                long n)

在 offset 偏移量的位置上向后覆盖方式写入 8 字节长度的 long（小端字节序），该方法不会更新 writerIndex 值。 参数 offset + 8 必须要小于 writerIndex，否则会引发 IndexOutOfBoundsException 异常

setFloat32LE

default void setFloat32LE(int offset,
                          float n)

在 offset 偏移量的位置上向后覆盖方式写入 4 字节长度的 float（小端字节序），该方法不会更新 writerIndex 值。 参数 offset + 4 必须要小于 writerIndex，否则会引发 IndexOutOfBoundsException 异常

setFloat64LE

default void setFloat64LE(int offset,
                          double n)

在 offset 偏移量的位置上向后覆盖方式写入 8 字节长度的 float（小端字节序），该方法不会更新 writerIndex 值。 参数 offset + 8 必须要小于 writerIndex，否则会引发 IndexOutOfBoundsException 异常

setString

default int setString(int offset,
                      String string,
                      Charset charset)

在 offset 偏移量的位置上向后覆盖方式写入字符串，字符串会通过 str.getBytes(charset) 方式转换为字节数组，该方法不会更新 writerIndex 值。返回值是写入了多少个字节。 参数 offset + [string 字节数组长度] 必须要小于 writerIndex，否则会引发 IndexOutOfBoundsException 异常

readByte

byte readByte()

读取 1 字节。 如果 readableBytes() < 1 则会引发 IndexOutOfBoundsException 异常

readBytes

default int readBytes(byte[] b)

读取一定数量的字节，并将它们存储到缓冲区数组 b 中。实际读取的字节数以整数形式返回。如果读取到末尾或者没有可读的数据将会返回 -1。

readBytes

int readBytes(byte[] b,
              int off,
              int len)

读取 len 数量的字节，并将它们存储到 off 位置开始的缓冲区数组 b 中。实际读取的字节数以整数形式返回。如果读取到末尾或者没有可读的数据将会返回 -1。

readInt16

short readInt16()

读取 2 字节的 short（大端字节序），读取后 readerIndex 会增加 2。 如果 readableBytes() < 2 则会引发 IndexOutOfBoundsException 异常

readInt24

int readInt24()

读取 3 字节的 int（大端字节序），读取后 readerIndex 会增加 3。 如果 readableBytes() < 3 则会引发 IndexOutOfBoundsException 异常

readInt32

int readInt32()

读取 4 字节的 int（大端字节序），读取后 readerIndex 会增加 4。 如果 readableBytes() < 4 则会引发 IndexOutOfBoundsException 异常

readInt64

long readInt64()

读取 8 字节的 long（大端字节序），读取后 readerIndex 会增加 8。 如果 readableBytes() < 8 则会引发 IndexOutOfBoundsException 异常

readFloat32

default float readFloat32()

读取 4 字节的 float（大端字节序），读取后 readerIndex 会增加 4。 如果 readableBytes() < 4 则会引发 IndexOutOfBoundsException 异常

readFloat64

default double readFloat64()

读取 8 字节的 double（大端字节序），读取后 readerIndex 会增加 8。 如果 readableBytes() < 8 则会引发 IndexOutOfBoundsException 异常

readInt16LE

short readInt16LE()

读取 2 字节的 short（小端字节序），读取后 readerIndex 会增加 2。 如果 readableBytes() < 2 则会引发 IndexOutOfBoundsException 异常

readInt24LE

int readInt24LE()

读取 3 字节的 int（小端字节序），读取后 readerIndex 会增加 3。 如果 readableBytes() < 3 则会引发 IndexOutOfBoundsException 异常

readInt32LE

int readInt32LE()

读取 4 字节的 int（小端字节序），读取后 readerIndex 会增加 4。 如果 readableBytes() < 4 则会引发 IndexOutOfBoundsException 异常

readInt64LE

long readInt64LE()

读取 8 字节的 long（小端字节序），读取后 readerIndex 会增加 8。 如果 readableBytes() < 8 则会引发 IndexOutOfBoundsException 异常

readFloat32LE

default float readFloat32LE()

读取 4 字节的 float（小端字节序），读取后 readerIndex 会增加 4。 如果 readableBytes() < 4 则会引发 IndexOutOfBoundsException 异常

readFloat64LE

default double readFloat64LE()

读取 8 字节的 double（小端字节序），读取后 readerIndex 会增加 8。 如果 readableBytes() < 8 则会引发 IndexOutOfBoundsException 异常

read

int read(ByteBuffer dst)

use copy to dst

指定者:

read 在接口中 ReadableByteChannel

read

default int read(ByteBuf dst)

use copy to dst

read

int read(ByteBuf dst,
         int len)

use copy to dst

参数:

dst - dst ByteBuf

len - max copy Size

返回:

return real copy size.

readString

default String readString(int len,
                          Charset charset)

读取 len 字节并将其构造成 String，读取后 readerIndex 会增加 len。 如果 readableBytes() < len 则会引发 IndexOutOfBoundsException 异常

getByte

byte getByte(int offset)

从 offset 偏移量的位置上开始读取 1 字节。 若 offset + 1 > readableBytes() 那么将会引发 IndexOutOfBoundsException 异常

getBytes

default int getBytes(int offset,
                     byte[] b)

从 offset 偏移量的位置上开始读取一定数量的字节，并将它们存储到缓冲区数组 b 中。实际读取的字节数以整数形式返回。如果读取到末尾或者没有可读的数据将会返回 -1

getBytes

int getBytes(int offset,
             byte[] b,
             int off,
             int len)

从 offset 偏移量的位置上开始读取 len 数量的字节，并将它们存储到 off 位置开始的缓冲区数组 b 中。实际读取的字节数以整数形式返回。如果读取到末尾或者没有可读的数据将会返回 -1

getInt16

short getInt16(int offset)

读取 2 字节的 short（大端字节序），该方法不会更新 readerIndex 值。 若 offset + 2 > readableBytes() 那么将会引发 IndexOutOfBoundsException 异常

getInt24

int getInt24(int offset)

读取 3 字节的 int（大端字节序），该方法不会更新 readerIndex 值。 若 offset + 3 > readableBytes() 那么将会引发 IndexOutOfBoundsException 异常

getInt32

int getInt32(int offset)

读取 4 字节的 int（大端字节序），该方法不会更新 readerIndex 值。 若 offset + 4 > readableBytes() 那么将会引发 IndexOutOfBoundsException 异常

getInt64

long getInt64(int offset)

读取 8 字节的 long（大端字节序），该方法不会更新 readerIndex 值。 若 offset + 8 > readableBytes() 那么将会引发 IndexOutOfBoundsException 异常

getFloat32

default float getFloat32(int offset)

读取 4 字节的 float（大端字节序），该方法不会更新 readerIndex 值。 若 offset + 4 > readableBytes() 那么将会引发 IndexOutOfBoundsException 异常

getFloat64

default double getFloat64(int offset)

读取 8 字节的 double（大端字节序），该方法不会更新 readerIndex 值。 若 offset + 8 > readableBytes() 那么将会引发 IndexOutOfBoundsException 异常

getInt16LE

short getInt16LE(int offset)

读取 2 字节的 short（小端字节序），该方法不会更新 readerIndex 值。 若 offset + 2 > readableBytes() 那么将会引发 IndexOutOfBoundsException 异常

getInt24LE

int getInt24LE(int offset)

读取 3 字节的 int（小端字节序），该方法不会更新 readerIndex 值。 若 offset + 3 > readableBytes() 那么将会引发 IndexOutOfBoundsException 异常

getInt32LE

int getInt32LE(int offset)

读取 4 字节的 int（小端字节序），该方法不会更新 readerIndex 值。 若 offset + 4 > readableBytes() 那么将会引发 IndexOutOfBoundsException 异常

getInt64LE

long getInt64LE(int offset)

读取 8 字节的 long（小端字节序），该方法不会更新 readerIndex 值。 若 offset + 8 > readableBytes() 那么将会引发 IndexOutOfBoundsException 异常

getFloat32LE

default float getFloat32LE(int offset)

读取 4 字节的 float（小端字节序），该方法不会更新 readerIndex 值。 若 offset + 4 > readableBytes() 那么将会引发 IndexOutOfBoundsException 异常

getFloat64LE

default double getFloat64LE(int offset)

读取 8 字节的 double（小端字节序），该方法不会更新 readerIndex 值。 若 offset + 8 > readableBytes() 那么将会引发 IndexOutOfBoundsException 异常

getString

default String getString(int offset,
                         int len,
                         Charset charset)

从 offset 开始读取 len 个字节，并构造一个 String，该方法不会更新 readerIndex 值。 若 offset + len > readableBytes() 那么将会引发 IndexOutOfBoundsException 异常

readUInt8

short readUInt8()

读取 1 字节的 byte 返回 0～255 之间的一个数（大端字节序），读取后 readerIndex 会增加 1。 如果 readableBytes() < 1 则会引发 IndexOutOfBoundsException 异常

readUInt16

int readUInt16()

读取 2 字节的 无符号 sort（大端字节序），读取后 readerIndex 会增加 2。 如果 readableBytes() < 2 则会引发 IndexOutOfBoundsException 异常

readUInt24

int readUInt24()

读取 3 字节的 无符号 int（大端字节序），读取后 readerIndex 会增加 3。 如果 readableBytes() < 3 则会引发 IndexOutOfBoundsException 异常

readUInt32

long readUInt32()

读取 4 字节的 无符号 int（大端字节序），读取后 readerIndex 会增加 4。 如果 readableBytes() < 4 则会引发 IndexOutOfBoundsException 异常

readUInt16LE

int readUInt16LE()

读取 2 字节的 无符号 sort（小端字节序），读取后 readerIndex 会增加 2。 如果 readableBytes() < 2 则会引发 IndexOutOfBoundsException 异常

readUInt24LE

int readUInt24LE()

读取 3 字节的 无符号 int（小端字节序），读取后 readerIndex 会增加 3。 如果 readableBytes() < 3 则会引发 IndexOutOfBoundsException 异常

readUInt32LE

long readUInt32LE()

读取 4 字节的 无符号 int（小端字节序），读取后 readerIndex 会增加 4。 如果 readableBytes() < 4 则会引发 IndexOutOfBoundsException 异常

getUInt8

short getUInt8(int offset)

读取 1 字节的 byte 返回 0～255 之间的一个数（小端字节序），该方法不会更新 readerIndex 值。 若 offset + 1 > readableBytes() 那么将会引发 IndexOutOfBoundsException 异常

getUInt16

int getUInt16(int offset)

读取 2 字节的 无符号 sort（小端字节序），该方法不会更新 readerIndex 值。 若 offset + 2 > readableBytes() 那么将会引发 IndexOutOfBoundsException 异常

getUInt24

int getUInt24(int offset)

读取 3 字节的 无符号 int（小端字节序），该方法不会更新 readerIndex 值。 若 offset + 3 > readableBytes() 那么将会引发 IndexOutOfBoundsException 异常

getUInt32

long getUInt32(int offset)

读取 4 字节的 无符号 int（小端字节序），该方法不会更新 readerIndex 值。 若 offset + 4 > readableBytes() 那么将会引发 IndexOutOfBoundsException 异常

getUInt16LE

int getUInt16LE(int offset)

读取 2 字节的 无符号 sort（小端字节序），该方法不会更新 readerIndex 值。 若 offset + 2 > readableBytes() 那么将会引发 IndexOutOfBoundsException 异常

getUInt24LE

int getUInt24LE(int offset)

读取 3 字节的 无符号 int（小端字节序），该方法不会更新 readerIndex 值。 若 offset + 3 > readableBytes() 那么将会引发 IndexOutOfBoundsException 异常

getUInt32LE

long getUInt32LE(int offset)

读取 4 字节的 无符号 int（小端字节序），该方法不会更新 readerIndex 值。 若 offset + 4 > readableBytes() 那么将会引发 IndexOutOfBoundsException 异常

expect

default int expect(String expect,
                   Charset charset)

查找下一个 expect 字符串的出现的位置（使用指定的编码），该方法不会更新 readerIndex 值。如果不存在期待的字符串，那么返回 -1。

expectLine

default int expectLine()

查找最近的一个 '\n'，该方法不会更新 readerIndex 值。如果不存在期待的字符串，那么返回 -1

hasLine

default boolean hasLine()

具有行结尾

readLine

default String readLine()

读一整行

readLine

default String readLine(Charset charset)

读一整行

expect

default int expect(char expect,
                   Charset charset)

查找下一个 expect 字符的出现的位置（使用指定的编码），该方法不会更新 readerIndex 值。如果不存在期待的字符，那么返回 -1。

readExpect

default String readExpect(String expect,
                          Charset charset)

从当前位置开始读取，直到遇到第一个 expect 字符串读完。如果没有期待的 expect 字符串那么返回 null。 比如：readLine 可以写作 readExpectString("\n", StandardCharsets.US_ASCII)

readExpect

default String readExpect(char expect,
                          Charset charset)

从当前位置开始读取，直到遇到第一个 expect 字符串读完。如果没有期待的 expect 字符串那么返回 null。 比如：readLine 可以写作 readExpectString('\n', StandardCharsets.US_ASCII)

expectLast

default int expectLast(String expect,
                       Charset charset)

查找最后一个 expect 字符串的出现的位置（使用指定的编码），该方法不会更新 readerIndex 值。如果不存在期待的字符串，那么返回 -1。

expectLast

default int expectLast(char expect,
                       Charset charset)

查找最后一个 expect 字符的出现的位置（使用指定的编码），该方法不会更新 readerIndex 值。如果不存在期待的字符，那么返回 -1。

readExpectLast

default String readExpectLast(String expect,
                              Charset charset)

从当前位置开始读取，直到遇到最后一个 expect 字符串读完。如果没有期待的 expect 字符串那么返回 null。 比如：readLine 可以写作 readExpectString("\n", StandardCharsets.US_ASCII)

readExpectLast

default String readExpectLast(char expect,
                              Charset charset)

从当前位置开始读取，直到遇到最后一个 expect 字符串读完。如果没有期待的 expect 字符串那么返回 null。 比如：readLine 可以写作 readExpectString('\n', StandardCharsets.US_ASCII)