ByteBufUtil (Netty API Reference (4.1.22.Final))

java.lang.Object
- io.netty.buffer.ByteBufUtil

```
public final class ByteBufUtil
extends java.lang.Object
```
与处理ByteBuf相关的实用程序方法的集合，例如生成十六进制转储和交换整数的字节顺序。

方法摘要

所有方法静态方法具体的方法
Modifier and Type	Method and Description
`static void`	`appendPrettyHexDump(java.lang.StringBuilder dump, ByteBuf buf)` 将指定的`ByteBuf`的美化多行十六进制转储附加到指定的`StringBuilder` ，这很容易被人读取。
`static void`	`appendPrettyHexDump(java.lang.StringBuilder dump, ByteBuf buf, int offset, int length)` 将指定的`ByteBuf`的美化多行十六进制转储追加到指定的`StringBuilder` ，这是人类易于阅读的，从给定的`offset`开始，使用给定的`length` 。
`static int`	`compare(ByteBuf bufferA, ByteBuf bufferB)` 按照 `ByteBuf.compareTo(ByteBuf)`中所述比较两个指定的缓冲区。
`static void`	`copy(AsciiString src, ByteBuf dst)` 使用`ByteBuf.writeBytes(byte[], int, int)`将src的全部内容`src`到`ByteBuf` 。
`static void`	`copy(AsciiString src, int srcIdx, ByteBuf dst, int length)` 副本的内容`src`到`ByteBuf`使用`ByteBuf.writeBytes(byte[], int, int)` 。
`static void`	`copy(AsciiString src, int srcIdx, ByteBuf dst, int dstIdx, int length)` 副本的内容`src`到`ByteBuf`使用`ByteBuf.setBytes(int, byte[], int, int)` 。
`static byte`	`decodeHexByte(java.lang.CharSequence s, int pos)` 解码一个字符串中的2位十六进制字节。
`static byte[]`	`decodeHexDump(java.lang.CharSequence hexDump)` 解码由 `hexDump(byte[])`生成的字符串
`static byte[]`	`decodeHexDump(java.lang.CharSequence hexDump, int fromIndex, int length)` 解码由 `hexDump(byte[])`生成的字符串的一部分
`static ByteBuf`	`encodeString(ByteBufAllocator alloc, java.nio.CharBuffer src, java.nio.charset.Charset charset)` 编码给定`CharBuffer`使用给定`Charset`到一个新`ByteBuf`这是通过分配`ByteBufAllocator` 。
`static ByteBuf`	`encodeString(ByteBufAllocator alloc, java.nio.CharBuffer src, java.nio.charset.Charset charset, int extraCapacity)` 编码给定`CharBuffer`使用给定`Charset`到一个新`ByteBuf`这是通过分配`ByteBufAllocator` 。
`static boolean`	`ensureWritableSuccess(int ensureWritableResult)` 用于确定 `ByteBuf.ensureWritable(int, boolean)`的返回值是否意味着有足够的空间并且写入操作会成功。
`static boolean`	`equals(ByteBuf bufferA, ByteBuf bufferB)` 返回 `true`当且仅当两个指定的缓冲区彼此相同时，如 `ByteBuf.equals(Object)`中所述。
`static boolean`	`equals(ByteBuf a, int aStartIndex, ByteBuf b, int bStartIndex, int length)` 返回 `true`当且仅当两个指定缓冲器彼此相同为 `length`开始于字节 `aStartIndex`指数为 `a`缓冲器和 `bStartIndex`指数为 `b`缓冲器。
`static byte[]`	`getBytes(ByteBuf buf)` 从 `buf`创建底层存储的 `buf`到一个字节数组中。
`static byte[]`	`getBytes(ByteBuf buf, int start, int length)` 从 `buf`创建底层存储的 `buf`到一个字节数组中。
`static byte[]`	`getBytes(ByteBuf buf, int start, int length, boolean copy)` 将来自 `buf`的底层存储阵列返回到字节数组中。
`static int`	`hashCode(ByteBuf buffer)` 计算指定缓冲区的哈希码。
`static java.lang.String`	`hexDump(byte[] array)` 返回指定字节数组的 hex dump 。
`static java.lang.String`	`hexDump(byte[] array, int fromIndex, int length)` 返回指定字节数组的子区域的 hex dump 。
`static java.lang.String`	`hexDump(ByteBuf buffer)` 返回指定缓冲区可读字节的 hex dump 。
`static java.lang.String`	`hexDump(ByteBuf buffer, int fromIndex, int length)` 返回指定缓冲区的子区域的 hex dump 。
`static int`	`indexOf(ByteBuf needle, ByteBuf haystack)` 返回干草堆中针的阅读器索引，如果针不在干草堆中，则返回-1。
`static int`	`indexOf(ByteBuf buffer, int fromIndex, int toIndex, byte value)` 默认实现 `ByteBuf.indexOf(int, int, byte)` 。
`static boolean`	`isText(ByteBuf buf, java.nio.charset.Charset charset)` 返回`true`如果给定`ByteBuf`是使用给定的有效文本`Charset` ，否则返回`false` 。
`static boolean`	`isText(ByteBuf buf, int index, int length, java.nio.charset.Charset charset)` 返回`true`如果指定的`ByteBuf`开始在`index`与`length`是使用给定的有效文本`Charset` ，否则返回`false` 。
`static java.lang.String`	`prettyHexDump(ByteBuf buffer)` 返回指定的`ByteBuf`的多行十六进制转储，易于人工读取。
`static java.lang.String`	`prettyHexDump(ByteBuf buffer, int offset, int length)` 返回指定的`ByteBuf`的多行十六进制转储，它很容易被人读取，从给定的`offset`开始，使用给定的`length` 。
`static ByteBuf`	`readBytes(ByteBufAllocator alloc, ByteBuf buffer, int length)` 阅读给定的字节量到一个新`ByteBuf`是从分配`ByteBufAllocator` 。
`static int`	`reserveAndWriteUtf8(ByteBuf buf, java.lang.CharSequence seq, int reserveBytes)` 在`CharSequence`中编码CharSequence并将其写入`reserveBytes`的reserveBytes 。
`static ByteBuf`	`setShortBE(ByteBuf buf, int index, int shortValue)` 将一个大端16位短整数设置为缓冲区。
`static int`	`swapInt(int value)` 切换指定的32位整数的字节顺序。
`static long`	`swapLong(long value)` 切换指定的64位长整数的字节序。
`static int`	`swapMedium(int value)` 切换指定的24位中等整数的字节顺序。
`static short`	`swapShort(short value)` 切换指定的16位短整数的字节序。
`static ByteBuf`	`threadLocalDirectBuffer()` 如果可用，则返回缓存的线程本地直接缓冲区。
`static int`	`utf8Bytes(java.lang.CharSequence seq)` 返回UTF8字符序列的确切字节长度。
`static int`	`utf8MaxBytes(java.lang.CharSequence seq)` 返回UTF8字符序列的最大字节长度。
`static int`	`utf8MaxBytes(int seqLength)` 返回给定长度的UTF8字符序列的最大字节长度。
`static ByteBuf`	`writeAscii(ByteBufAllocator alloc, java.lang.CharSequence seq)` 编码`CharSequence`在ASCII ，并将其写入到`ByteBuf`与分配`alloc` 。
`static int`	`writeAscii(ByteBuf buf, java.lang.CharSequence seq)` 编码`CharSequence`在ASCII ，并将其写入到`ByteBuf` 。
`static ByteBuf`	`writeMediumBE(ByteBuf buf, int mediumValue)` 将大端24位中等整数写入缓冲区。
`static ByteBuf`	`writeShortBE(ByteBuf buf, int shortValue)` 将一个大端16位短整数写入缓冲区。
`static ByteBuf`	`writeUtf8(ByteBufAllocator alloc, java.lang.CharSequence seq)` 编码`CharSequence`在UTF-8 ，并将其写入到`ByteBuf`与分配`alloc` 。
`static int`	`writeUtf8(ByteBuf buf, java.lang.CharSequence seq)` 在`CharSequence`中编码CharSequence并将其写入`ByteBuf` 。

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

- 方法详细信息
  - hexDump
```
public static java.lang.String hexDump(ByteBuf buffer)
```
    返回指定缓冲区可读字节的 hex dump 。
  - hexDump
```
public static java.lang.String hexDump(ByteBuf buffer,
                                       int fromIndex,
                                       int length)
```
    返回指定缓冲区的子区域的 hex dump 。
  - hexDump
```
public static java.lang.String hexDump(byte[] array)
```
    返回指定字节数组的 hex dump 。
  - hexDump
```
public static java.lang.String hexDump(byte[] array,
                                       int fromIndex,
                                       int length)
```
    返回指定字节数组的子区域的 hex dump 。
  - decodeHexByte
```
public static byte decodeHexByte(java.lang.CharSequence s,
                                 int pos)
```
    解码一个字符串中的2位十六进制字节。
  - decodeHexDump
```
public static byte[] decodeHexDump(java.lang.CharSequence hexDump)
```
    解码由 hexDump(byte[])生成的字符串
  - decodeHexDump
```
public static byte[] decodeHexDump(java.lang.CharSequence hexDump,
                                   int fromIndex,
                                   int length)
```
    解码由 hexDump(byte[])生成的字符串的一部分
  - ensureWritableSuccess
```
public static boolean ensureWritableSuccess(int ensureWritableResult)
```
    用于确定 ByteBuf.ensureWritable(int, boolean)的返回值是否意味着有足够的空间并且写操作会成功。
    
    参数
    
    ensureWritableResult -从返回值 ByteBuf.ensureWritable(int, boolean) 。
    
    结果
    
    true如果 ensureWritableResult表示有足够的空间并且写入操作会成功。
  - hashCode
```
public static int hashCode(ByteBuf buffer)
```
    计算指定缓冲区的哈希码。此方法在实现新的缓冲区类型时非常有用。
  - indexOf
```
public static int indexOf(ByteBuf needle,
                          ByteBuf haystack)
```
    返回干草堆中针的阅读器索引，如果针不在干草堆中，则返回-1。
  - equals
```
public static boolean equals(ByteBuf a,
                             int aStartIndex,
                             ByteBuf b,
                             int bStartIndex,
                             int length)
```
    返回true当且仅当两个指定缓冲区的length字节aStartIndex索引a缓冲区索引a缓冲区和bStartIndex缓冲区索引b 。更简洁的表达方式是：
    a[aStartIndex : aStartIndex + length] == b[bStartIndex : bStartIndex + length]
  - equals
```
public static boolean equals(ByteBuf bufferA,
                             ByteBuf bufferB)
```
    当且仅当两个指定的缓冲区彼此相同时才返回true ，如ByteBuf.equals(Object)中所述。此方法在实现新的缓冲区类型时非常有用。
  - compare
```
public static int compare(ByteBuf bufferA,
                          ByteBuf bufferB)
```
    按照ByteBuf.compareTo(ByteBuf)中所述比较两个指定的缓冲区。此方法在实现新的缓冲区类型时非常有用。
  - indexOf
```
public static int indexOf(ByteBuf buffer,
                          int fromIndex,
                          int toIndex,
                          byte value)
```
    默认实现ByteBuf.indexOf(int, int, byte) 。此方法在实现新的缓冲区类型时非常有用。
  - swapShort
```
public static short swapShort(short value)
```
    切换指定的16位短整数的字节序。
  - swapMedium
```
public static int swapMedium(int value)
```
    切换指定的24位中等整数的字节顺序。
  - swapInt
```
public static int swapInt(int value)
```
    切换指定的32位整数的字节顺序。
  - swapLong
```
public static long swapLong(long value)
```
    切换指定的64位长整数的字节序。
  - writeShortBE
```
public static ByteBuf writeShortBE(ByteBuf buf,
                                   int shortValue)
```
    将一个大端16位短整数写入缓冲区。
  - setShortBE
```
public static ByteBuf setShortBE(ByteBuf buf,
                                 int index,
                                 int shortValue)
```
    将一个大端16位短整数设置为缓冲区。
  - writeMediumBE
```
public static ByteBuf writeMediumBE(ByteBuf buf,
                                    int mediumValue)
```
    将大端24位中等整数写入缓冲区。
  - readBytes
```
public static ByteBuf readBytes(ByteBufAllocator alloc,
                                ByteBuf buffer,
                                int length)
```
    阅读给定的字节量到一个新ByteBuf是从分配ByteBufAllocator 。
  - writeUtf8
```
public static ByteBuf writeUtf8(ByteBufAllocator alloc,
                                java.lang.CharSequence seq)
```
    在CharSequence中编码CharSequence并将其写入alloc分配的alloc 。
    
    参数
    
    alloc - 分配器用于分配新的ByteBuf 。
    
    seq - 要写入缓冲区的字符。
    
    结果
    
    ByteBuf其中包含UTF-8编码结果。
  - writeUtf8
```
public static int writeUtf8(ByteBuf buf,
                            java.lang.CharSequence seq)
```
    编码CharSequence在UTF-8 ，并将其写入到ByteBuf 。
    它像reserveAndWriteUtf8(ByteBuf, CharSequence, int)与reserveBytes通过计算utf8MaxBytes(CharSequence) 。
    该方法返回写入的实际字节数。
  - reserveAndWriteUtf8
```
public static int reserveAndWriteUtf8(ByteBuf buf,
                                      java.lang.CharSequence seq,
                                      int reserveBytes)
```
    编码CharSequence在UTF-8并将其写入reserveBytes一个的ByteBuf 。
    必须计算reserveBytes （即急切地使用utf8MaxBytes(CharSequence)或准确使用utf8Bytes(CharSequence) ）以确保此方法不失败：出于性能原因，索引检查将仅使用reserveBytes执行。
    该方法返回写入的实际字节数。
  - utf8MaxBytes
```
public static int utf8MaxBytes(int seqLength)
```
    返回给定长度的UTF8字符序列的最大字节长度。
  - utf8MaxBytes
```
public static int utf8MaxBytes(java.lang.CharSequence seq)
```
    返回UTF8字符序列的最大字节长度。
    它像utf8MaxBytes(int)应用到seq CharSequence.length() 。
  - utf8Bytes
```
public static int utf8Bytes(java.lang.CharSequence seq)
```
    返回UTF8字符序列的确切字节长度。
    此方法正在按照writeUtf8(ByteBuf, CharSequence)生成确切的长度。
  - writeAscii
```
public static ByteBuf writeAscii(ByteBufAllocator alloc,
                                 java.lang.CharSequence seq)
```
    编码CharSequence在ASCII ，并将其写入到ByteBuf与分配alloc 。
    
    参数
    
    alloc - 分配器用于分配新的ByteBuf 。
    
    seq - 要写入缓冲区的字符。
    
    结果
    
    所述ByteBuf含有ASCII编码结果。
  - writeAscii
```
public static int writeAscii(ByteBuf buf,
                             java.lang.CharSequence seq)
```
    在CharSequence中编码CharSequence并将其写入ByteBuf 。该方法返回写入的实际字节数。
  - encodeString
```
public static ByteBuf encodeString(ByteBufAllocator alloc,
                                   java.nio.CharBuffer src,
                                   java.nio.charset.Charset charset)
```
    编码给定CharBuffer使用给定Charset到一个新ByteBuf这是通过分配ByteBufAllocator 。
  - encodeString
```
public static ByteBuf encodeString(ByteBufAllocator alloc,
                                   java.nio.CharBuffer src,
                                   java.nio.charset.Charset charset,
                                   int extraCapacity)
```
    编码给定CharBuffer使用给定Charset到一个新ByteBuf这是通过分配ByteBufAllocator 。
    
    参数
    
    alloc - ByteBufAllocator分配ByteBuf 。
    
    src - CharBuffer进行编码。
    
    charset - 指定的 Charset 。
    
    extraCapacity - 除解码空间外的额外 extraCapacity容量。
  - threadLocalDirectBuffer
```
public static ByteBuf threadLocalDirectBuffer()
```
    如果可用，则返回缓存的线程本地直接缓冲区。
    
    结果
    
    缓存的线程本地直接缓冲区（如果可用）。否则为null 。
  - getBytes
```
public static byte[] getBytes(ByteBuf buf)
```
    将底层存储的副本从buf为一个字节数组。该副本将从ByteBuf.readerIndex()开始并复制ByteBuf.readableBytes()字节。
  - getBytes
```
public static byte[] getBytes(ByteBuf buf,
                              int start,
                              int length)
```
    从buf创建底层存储的buf到一个字节数组中。该副本将从start开始并复制length个字节。
  - getBytes
```
public static byte[] getBytes(ByteBuf buf,
                              int start,
                              int length,
                              boolean copy)
```
    将来自buf的基础存储的数组返回到一个字节数组。该副本将从start开始并复制length字节。如果copy为真，则将复制内存。如果copy为false，则尽可能共享底层存储。
  - copy
```
public static void copy(AsciiString src,
                        ByteBuf dst)
```
    复制所有的内容src到ByteBuf使用ByteBuf.writeBytes(byte[], int, int) 。
    
    参数
    
    src - 要复制的源字符串
    
    dst - 目标缓冲区
  - copy
```
public static void copy(AsciiString src,
                        int srcIdx,
                        ByteBuf dst,
                        int dstIdx,
                        int length)
```
    副本的内容src到ByteBuf使用ByteBuf.setBytes(int, byte[], int, int) 。不像copy(AsciiString, ByteBuf)种copy(AsciiString, int, ByteBuf, int)方法，这种方法不增加writerIndex的dst缓冲区。
    
    参数
    
    src - 要复制的源字符串
    
    srcIdx - 要复制的字符的起始偏移量
    
    dst - 目标缓冲区
    
    dstIdx - 目标缓冲区中的起始偏移量
    
    length - 要复制的字符数
  - copy
```
public static void copy(AsciiString src,
                        int srcIdx,
                        ByteBuf dst,
                        int length)
```
    副本的内容src到ByteBuf使用ByteBuf.writeBytes(byte[], int, int) 。
    
    参数
    
    src - 要复制的源字符串
    
    srcIdx - 要复制的字符的起始偏移量
    
    dst - 目标缓冲区
    
    length - 要复制的字符数
  - prettyHexDump
```
public static java.lang.String prettyHexDump(ByteBuf buffer)
```
    返回指定的ByteBuf的多行十六进制转储，易于人读取。
  - prettyHexDump
```
public static java.lang.String prettyHexDump(ByteBuf buffer,
                                             int offset,
                                             int length)
```
    返回指定的ByteBuf的多行十六进制转储，它很容易被人读取，从给定的offset开始，使用给定的length 。
  - appendPrettyHexDump
```
public static void appendPrettyHexDump(java.lang.StringBuilder dump,
                                       ByteBuf buf)
```
    将指定的ByteBuf的美化多行十六进制转储追加到指定的StringBuilder ，这是人类易于阅读的。
  - appendPrettyHexDump
```
public static void appendPrettyHexDump(java.lang.StringBuilder dump,
                                       ByteBuf buf,
                                       int offset,
                                       int length)
```
    将指定的ByteBuf的美化多行十六进制转储附加到指定的StringBuilder ，这是人类易于阅读的，从给定的offset开始，使用给定的length 。
  - isText
```
public static boolean isText(ByteBuf buf,
                             java.nio.charset.Charset charset)
```
    返回true如果给定ByteBuf是使用给定的有效文本Charset ，否则返回false 。
    
    参数
    
    buf - 给出ByteBuf 。
    
    charset - 指定 Charset 。
  - isText
```
public static boolean isText(ByteBuf buf,
                             int index,
                             int length,
                             java.nio.charset.Charset charset)
```
    返回true如果指定的ByteBuf开始在index与length是使用给定的有效文本Charset ，否则返回false 。
    
    参数
    
    buf - 给出ByteBuf 。
    
    index - 指定缓冲区的开始索引。
    
    length - 指定缓冲区的长度。
    
    charset - 指定 Charset 。
    
    异常
    
    java.lang.IndexOutOfBoundsException - 如果 index + length大于 buf.readableBytes

Class ByteBufUtil

方法摘要

Methods inherited from class java.lang.Object

方法详细信息

hexDump

hexDump

hexDump

hexDump

decodeHexByte

decodeHexDump

decodeHexDump

ensureWritableSuccess

hashCode

indexOf

equals

equals

compare

indexOf

swapShort

swapMedium

swapInt

swapLong

writeShortBE

setShortBE

writeMediumBE

readBytes

writeUtf8

writeUtf8

reserveAndWriteUtf8

utf8MaxBytes

utf8MaxBytes

utf8Bytes

writeAscii

writeAscii

encodeString

encodeString

threadLocalDirectBuffer

getBytes

getBytes

getBytes

copy

copy

copy

prettyHexDump

prettyHexDump

appendPrettyHexDump

appendPrettyHexDump

isText

isText