Bytes (polaris-core 3.2.39 API)

java.lang.Object
- io.polaris.core.lang.primitive.Bytes

```
public class Bytes
extends Object
```
字节操作工具类

可对数字和字节进行转换。假设数据存储是以大端模式存储的：
- byte: 字节类型占8位二进制 00000000
- char: 字符类型占2个字节 16位二进制 byte[0] byte[1]
- int : 整数类型占4个字节 32位二进制 byte[0] byte[1] byte[2] byte[3]
- long: 长整数类型占8个字节 64位二进制 byte[0] byte[1] byte[2] byte[3] byte[4] byte[5]
- long: 长整数类型占8个字节 64位二进制 byte[0] byte[1] byte[2] byte[3] byte[4] byte[5] byte[6] byte[7]
- float: 浮点数(小数) 占4个字节 32位二进制 byte[0] byte[1] byte[2] byte[3]
- double: 双精度浮点数(小数) 占8个字节 64位二进制 byte[0] byte[1] byte[2] byte[3] byte[4]byte[5] byte[6] byte[7]
从以下版本开始:

1.8

作者:

Qt

字段概要

字段
限定符和类型字段和说明

static ByteOrder CPU_ENDIAN
CPU的字节序

static ByteOrder DEFAULT_ORDER

字段
限定符和类型	字段和说明
`static ByteOrder`	`CPU_ENDIAN` CPU的字节序
`static ByteOrder`	`DEFAULT_ORDER`

构造器概要

构造器
构造器和说明

Bytes()

构造器
构造器和说明
`Bytes()`

方法概要

所有方法静态方法具体方法
限定符和类型	方法和说明
`static byte[]`	`bytes(CharSequence str)`
`static byte[]`	`bytes(String str)`
`static double`	`bytesToDouble(byte[] bytes)` byte数组转Double 默认以大端序转换
`static double`	`bytesToDouble(byte[] bytes, ByteOrder byteOrder)` byte数组转double 自定义端序
`static float`	`bytesToFloat(byte[] bytes)` byte数组转float 默认以大端序转换
`static float`	`bytesToFloat(byte[] bytes, ByteOrder byteOrder)` byte数组转float 自定义端序
`static int`	`bytesToInt(byte[] bytes)` byte[]转int值默认以大端序转换
`static int`	`bytesToInt(byte[] bytes, ByteOrder byteOrder)` byte[]转int值自定义端序
`static int`	`bytesToInt(byte[] bytes, int start, ByteOrder byteOrder)` byte[]转int值自定义端序
`static long`	`bytesToLong(byte[] bytes)` byte数组转long 默认以大端序转换 from: https://stackoverflow.com/questions/4485128/how-do-i-convert-long-to-byte-and-back-in-java
`static long`	`bytesToLong(byte[] bytes, ByteOrder byteOrder)` byte数组转long 自定义端序 from: https://stackoverflow.com/questions/4485128/how-do-i-convert-long-to-byte-and-back-in-java
`static long`	`bytesToLong(byte[] bytes, int start, ByteOrder byteOrder)` byte数组转long 自定义端序 from: https://stackoverflow.com/questions/4485128/how-do-i-convert-long-to-byte-and-back-in-java
`static <T extends Number> T`	`bytesToNumber(byte[] bytes, Class<T> targetClass, ByteOrder byteOrder)` byte数组转换为指定类型数字
`static short`	`bytesToShort(byte[] bytes)` byte数组转short 默认以大端序转换
`static short`	`bytesToShort(byte[] bytes, ByteOrder byteOrder)` byte数组转short 自定义端序
`static short`	`bytesToShort(byte[] bytes, int start, ByteOrder byteOrder)` byte数组转short 自定义端序
`static int`	`byteToUnsignedInt(byte byteValue)` byte转无符号int
`static byte[]`	`concat(byte[] byteArray, byte[]... byteArrays)`
`static boolean`	`contains(byte[] array, byte value)` 数组中是否包含元素
`static byte[]`	`copy(byte[] array, int length)`
`static byte[]`	`copy(byte[] array, int from, int to)`
`static byte[]`	`doubleToBytes(double doubleValue)` double转byte数组默认以大端序转换
`static byte[]`	`doubleToBytes(double doubleValue, ByteOrder byteOrder)` double转byte数组自定义端序 from: https://stackoverflow.com/questions/4485128/how-do-i-convert-long-to-byte-and-back-in-java
`static byte[]`	`floatToBytes(float floatValue)` float转byte数组，默认以大端序转换
`static byte[]`	`floatToBytes(float floatValue, ByteOrder byteOrder)` float转byte数组，自定义端序
`static int`	`indexOf(byte[] array, byte value)`
`static int`	`indexOf(byte[] array, byte[] target)`
`static byte`	`intToByte(int intValue)` int转byte
`static byte[]`	`intToBytes(int intValue)` int转byte数组默认以大端序转换
`static byte[]`	`intToBytes(int intValue, ByteOrder byteOrder)` int转byte数组自定义端序
`static boolean`	`isEmpty(byte[] array)` 数组是否为空
`static boolean`	`isNotEmpty(byte[] array)` 数组是否为非空
`static boolean`	`isSorted(byte[] array)` 检查数组是否升序，即array[i] <= array[i+1]，若传入空数组，则返回false
`static boolean`	`isSortedAsc(byte[] array)` 检查数组是否升序，即array[i] <= array[i+1]，若传入空数组，则返回false
`static boolean`	`isSortedDesc(byte[] array)` 检查数组是否降序，即array[i] >= array[i+1]，若传入空数组，则返回false
`static byte[]`	`join(byte[]... arrays)` 将多个数组合并在一起忽略null的数组
`static int`	`lastIndexOf(byte[] array, byte value)` 返回数组中指定元素所在最后的位置，未找到返回 -1
`static byte[]`	`longToBytes(long longValue)` long转byte数组默认以大端序转换 from: https://stackoverflow.com/questions/4485128/how-do-i-convert-long-to-byte-and-back-in-java
`static byte[]`	`longToBytes(long longValue, ByteOrder byteOrder)` long转byte数组自定义端序 from: https://stackoverflow.com/questions/4485128/how-do-i-convert-long-to-byte-and-back-in-java
`static byte`	`max(byte... numberArray)` 取最大值
`static byte`	`min(byte... numberArray)` 取最小值
`static byte[]`	`numberToBytes(Number number)` 将`Number`转换为
`static byte[]`	`numberToBytes(Number number, ByteOrder byteOrder)` 将`Number`转换为
`static byte`	`parse(String text, int radix)`
`static byte[]`	`parseBase32Bytes(String text)`
`static byte[]`	`parseBase64Bytes(String text)`
`static byte`	`parseBin(String text)`
`static byte`	`parseHex(String text)`
`static byte[]`	`parseHexBytes(String text)`
`static byte`	`parseOct(String text)`
`static byte[]`	`remove(byte[] array, int index)` 移除数组中对应位置的元素 copy from commons-lang
`static byte[]`	`removeElement(byte[] array, byte element)` 移除数组中指定的元素只会移除匹配到的第一个元素 copy from commons-lang
`static byte[]`	`resize(byte[] bytes, int newSize)` 生成一个新的重新设置大小的数组调整大小后拷贝原数组到新数组下。
`static byte[]`	`reverse(byte[] array)` 反转数组，会变更原数组
`static byte[]`	`reverse(byte[] array, int startIndexInclusive, int endIndexExclusive)` 反转数组，会变更原数组
`static byte[]`	`shortToBytes(short shortValue)` short转byte数组默认以大端序转换
`static byte[]`	`shortToBytes(short shortValue, ByteOrder byteOrder)` short转byte数组自定义端序
`static byte[]`	`shuffle(byte[] array)` 打乱数组顺序，会变更原数组
`static byte[]`	`shuffle(byte[] array, Random random)` 打乱数组顺序，会变更原数组
`static byte[][]`	`split(byte[] array, int len)` 拆分byte数组为几个等份（最后一份按照剩余长度分配空间）
`static byte[]`	`sub(byte[] array, int start, int end)` 获取子数组
`static byte[]`	`swap(byte[] array, int index1, int index2)` 交换数组中两个位置的值
`static String`	`toBase32String(byte[] bytes)`
`static String`	`toBase64String(byte[] bytes)`
`static String`	`toBinString(byte num)`
`static String`	`toHexString(byte num)`
`static String`	`toHexString(byte[] bytes)`
`static String`	`toOctString(byte num)`
`static byte[]`	`unwrap(Byte... values)` 包装类数组转为原始类型数组
`static byte[]`	`utf8Bytes(CharSequence str)`
`static byte[]`	`utf8Bytes(String str)`
`static Byte[]`	`wrap(byte... values)` 将原始类型数组包装为包装类型

从类继承的方法 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- 字段详细资料
  - DEFAULT_ORDER
```
public static final ByteOrder DEFAULT_ORDER
```
  - CPU_ENDIAN
```
public static final ByteOrder CPU_ENDIAN
```
    CPU的字节序
- 构造器详细资料
  - Bytes
```
public Bytes()
```
- 方法详细资料
  - toHexString
```
public static String toHexString(byte[] bytes)
```
  - parseHexBytes
```
public static byte[] parseHexBytes(String text)
```
  - toBase32String
```
public static String toBase32String(byte[] bytes)
```
  - parseBase32Bytes
```
public static byte[] parseBase32Bytes(String text)
```
  - toBase64String
```
public static String toBase64String(byte[] bytes)
```
  - parseBase64Bytes
```
public static byte[] parseBase64Bytes(String text)
```
  - toBinString
```
public static String toBinString(byte num)
```
  - toOctString
```
public static String toOctString(byte num)
```
  - toHexString
```
public static String toHexString(byte num)
```
  - parseBin
```
public static byte parseBin(String text)
```
  - parseOct
```
public static byte parseOct(String text)
```
  - parseHex
```
public static byte parseHex(String text)
```
  - parse
```
public static byte parse(String text,
                         int radix)
```
  - resize
```
public static byte[] resize(byte[] bytes,
                            int newSize)
```
    生成一个新的重新设置大小的数组
    调整大小后拷贝原数组到新数组下。扩大则占位前N个位置，其它位置补充0，缩小则截断
    
    参数:
    
    bytes - 原数组
    
    newSize - 新的数组大小
    
    返回:
    
    调整后的新数组
  - join
```
public static byte[] join(byte[]... arrays)
```
    将多个数组合并在一起
    忽略null的数组
    
    参数:
    
    arrays - 数组集合
    
    返回:
    
    合并后的数组
  - split
```
public static byte[][] split(byte[] array,
                             int len)
```
    拆分byte数组为几个等份（最后一份按照剩余长度分配空间）
    
    参数:
    
    array - 数组
    
    len - 每个小节的长度
    
    返回:
    
    拆分后的数组
  - wrap
```
public static Byte[] wrap(byte... values)
```
    将原始类型数组包装为包装类型
    
    参数:
    
    values - 原始类型数组
    
    返回:
    
    包装类型数组
  - unwrap
```
public static byte[] unwrap(Byte... values)
```
    包装类数组转为原始类型数组
    
    参数:
    
    values - 包装类型数组
    
    返回:
    
    原始类型数组
  - sub
```
public static byte[] sub(byte[] array,
                         int start,
                         int end)
```
    获取子数组
    
    参数:
    
    array - 数组
    
    start - 开始位置（包括）
    
    end - 结束位置（不包括）
    
    返回:
    
    新的数组
    
    另请参阅:
    
    Arrays.copyOfRange(Object[], int, int)
  - remove
```
public static byte[] remove(byte[] array,
                            int index)
                     throws IllegalArgumentException
```
    移除数组中对应位置的元素
    copy from commons-lang
    
    参数:
    
    array - 数组对象，可以是对象数组，也可以原始类型数组
    
    index - 位置，如果位置小于0或者大于长度，返回原数组
    
    返回:
    
    去掉指定元素后的新数组或原数组
    
    抛出:
    
    IllegalArgumentException - 参数对象不为数组对象
  - removeElement
```
public static byte[] removeElement(byte[] array,
                                   byte element)
                            throws IllegalArgumentException
```
    移除数组中指定的元素
    只会移除匹配到的第一个元素 copy from commons-lang
    
    参数:
    
    array - 数组对象，可以是对象数组，也可以原始类型数组
    
    element - 要移除的元素
    
    返回:
    
    去掉指定元素后的新数组或原数组
    
    抛出:
    
    IllegalArgumentException - 参数对象不为数组对象
  - reverse
```
public static byte[] reverse(byte[] array,
                             int startIndexInclusive,
                             int endIndexExclusive)
```
    反转数组，会变更原数组
    
    参数:
    
    array - 数组，会变更
    
    startIndexInclusive - 起始位置（包含）
    
    endIndexExclusive - 结束位置（不包含）
    
    返回:
    
    变更后的原数组
  - reverse
```
public static byte[] reverse(byte[] array)
```
    反转数组，会变更原数组
    
    参数:
    
    array - 数组，会变更
    
    返回:
    
    变更后的原数组
  - min
```
public static byte min(byte... numberArray)
```
    取最小值
    
    参数:
    
    numberArray - 数字数组
    
    返回:
    
    最小值
  - max
```
public static byte max(byte... numberArray)
```
    取最大值
    
    参数:
    
    numberArray - 数字数组
    
    返回:
    
    最大值
  - shuffle
```
public static byte[] shuffle(byte[] array)
```
    打乱数组顺序，会变更原数组
    
    参数:
    
    array - 数组，会变更
    
    返回:
    
    打乱后的数组
  - shuffle
```
public static byte[] shuffle(byte[] array,
                             Random random)
```
    打乱数组顺序，会变更原数组
    
    参数:
    
    array - 数组，会变更
    
    random - 随机数生成器
    
    返回:
    
    打乱后的数组
  - swap
```
public static byte[] swap(byte[] array,
                          int index1,
                          int index2)
```
    交换数组中两个位置的值
    
    参数:
    
    array - 数组
    
    index1 - 位置1
    
    index2 - 位置2
    
    返回:
    
    交换后的数组，与传入数组为同一对象
  - isSorted
```
public static boolean isSorted(byte[] array)
```
    检查数组是否升序，即array[i] <= array[i+1]，若传入空数组，则返回false
    
    参数:
    
    array - 数组
    
    返回:
    
    数组是否升序
  - isSortedAsc
```
public static boolean isSortedAsc(byte[] array)
```
    检查数组是否升序，即array[i] <= array[i+1]，若传入空数组，则返回false
    
    参数:
    
    array - 数组
    
    返回:
    
    数组是否升序
  - isSortedDesc
```
public static boolean isSortedDesc(byte[] array)
```
    检查数组是否降序，即array[i] >= array[i+1]，若传入空数组，则返回false
    
    参数:
    
    array - 数组
    
    返回:
    
    数组是否降序
  - copy
```
public static byte[] copy(byte[] array,
                          int length)
```
  - copy
```
public static byte[] copy(byte[] array,
                          int from,
                          int to)
```
  - concat
```
public static byte[] concat(@Nonnull
                            byte[] byteArray,
                            byte[]... byteArrays)
```
  - indexOf
```
public static int indexOf(byte[] array,
                          byte[] target)
```
  - indexOf
```
public static int indexOf(byte[] array,
                          byte value)
```
  - lastIndexOf
```
public static int lastIndexOf(byte[] array,
                              byte value)
```
    返回数组中指定元素所在最后的位置，未找到返回 -1
    
    参数:
    
    array - 数组
    
    value - 被检查的元素
    
    返回:
    
    数组中指定元素所在位置，未找到返回 -1
  - contains
```
public static boolean contains(byte[] array,
                               byte value)
```
    数组中是否包含元素
    
    参数:
    
    array - 数组
    
    value - 被检查的元素
    
    返回:
    
    是否包含
  - isEmpty
```
public static boolean isEmpty(byte[] array)
```
    数组是否为空
    
    参数:
    
    array - 数组
    
    返回:
    
    是否为空
  - isNotEmpty
```
public static boolean isNotEmpty(byte[] array)
```
    数组是否为非空
    
    参数:
    
    array - 数组
    
    返回:
    
    是否为非空
  - utf8Bytes
```
public static byte[] utf8Bytes(CharSequence str)
```
  - utf8Bytes
```
public static byte[] utf8Bytes(String str)
```
  - bytes
```
public static byte[] bytes(CharSequence str)
```
  - bytes
```
public static byte[] bytes(String str)
```
  - intToByte
```
public static byte intToByte(int intValue)
```
    int转byte
    
    参数:
    
    intValue - int值
    
    返回:
    
    byte值
  - byteToUnsignedInt
```
public static int byteToUnsignedInt(byte byteValue)
```
    byte转无符号int
    
    参数:
    
    byteValue - byte值
    
    返回:
    
    无符号int值
  - bytesToShort
```
public static short bytesToShort(byte[] bytes)
```
    byte数组转short
    默认以大端序转换
    
    参数:
    
    bytes - byte数组
    
    返回:
    
    short值
  - bytesToShort
```
public static short bytesToShort(byte[] bytes,
                                 ByteOrder byteOrder)
```
    byte数组转short
    自定义端序
    
    参数:
    
    bytes - byte数组，长度必须为2
    
    byteOrder - 端序
    
    返回:
    
    short值
  - bytesToShort
```
public static short bytesToShort(byte[] bytes,
                                 int start,
                                 ByteOrder byteOrder)
```
    byte数组转short
    自定义端序
    
    参数:
    
    bytes - byte数组，长度必须大于2
    
    start - 开始位置
    
    byteOrder - 端序
    
    返回:
    
    short值
  - shortToBytes
```
public static byte[] shortToBytes(short shortValue)
```
    short转byte数组
    默认以大端序转换
    
    参数:
    
    shortValue - short值
    
    返回:
    
    byte数组
  - shortToBytes
```
public static byte[] shortToBytes(short shortValue,
                                  ByteOrder byteOrder)
```
    short转byte数组
    自定义端序
    
    参数:
    
    shortValue - short值
    
    byteOrder - 端序
    
    返回:
    
    byte数组
  - bytesToInt
```
public static int bytesToInt(byte[] bytes)
```
    byte[]转int值
    默认以大端序转换
    
    参数:
    
    bytes - byte数组
    
    返回:
    
    int值
  - bytesToInt
```
public static int bytesToInt(byte[] bytes,
                             ByteOrder byteOrder)
```
    byte[]转int值
    自定义端序
    
    参数:
    
    bytes - byte数组
    
    byteOrder - 端序
    
    返回:
    
    int值
  - bytesToInt
```
public static int bytesToInt(byte[] bytes,
                             int start,
                             ByteOrder byteOrder)
```
    byte[]转int值
    自定义端序
    
    参数:
    
    bytes - byte数组
    
    start - 开始位置（包含）
    
    byteOrder - 端序
    
    返回:
    
    int值
  - intToBytes
```
public static byte[] intToBytes(int intValue)
```
    int转byte数组
    默认以大端序转换
    
    参数:
    
    intValue - int值
    
    返回:
    
    byte数组
  - intToBytes
```
public static byte[] intToBytes(int intValue,
                                ByteOrder byteOrder)
```
    int转byte数组
    自定义端序
    
    参数:
    
    intValue - int值
    
    byteOrder - 端序
    
    返回:
    
    byte数组
  - longToBytes
```
public static byte[] longToBytes(long longValue)
```
    long转byte数组
    默认以大端序转换
    from: https://stackoverflow.com/questions/4485128/how-do-i-convert-long-to-byte-and-back-in-java
    
    参数:
    
    longValue - long值
    
    返回:
    
    byte数组
  - longToBytes
```
public static byte[] longToBytes(long longValue,
                                 ByteOrder byteOrder)
```
    long转byte数组
    自定义端序
    from: https://stackoverflow.com/questions/4485128/how-do-i-convert-long-to-byte-and-back-in-java
    
    参数:
    
    longValue - long值
    
    byteOrder - 端序
    
    返回:
    
    byte数组
  - bytesToLong
```
public static long bytesToLong(byte[] bytes)
```
    byte数组转long
    默认以大端序转换
    from: https://stackoverflow.com/questions/4485128/how-do-i-convert-long-to-byte-and-back-in-java
    
    参数:
    
    bytes - byte数组
    
    返回:
    
    long值
  - bytesToLong
```
public static long bytesToLong(byte[] bytes,
                               ByteOrder byteOrder)
```
    byte数组转long
    自定义端序
    from: https://stackoverflow.com/questions/4485128/how-do-i-convert-long-to-byte-and-back-in-java
    
    参数:
    
    bytes - byte数组
    
    byteOrder - 端序
    
    返回:
    
    long值
  - bytesToLong
```
public static long bytesToLong(byte[] bytes,
                               int start,
                               ByteOrder byteOrder)
```
    byte数组转long
    自定义端序
    from: https://stackoverflow.com/questions/4485128/how-do-i-convert-long-to-byte-and-back-in-java
    
    参数:
    
    bytes - byte数组
    
    start - 计算数组开始位置
    
    byteOrder - 端序
    
    返回:
    
    long值
  - floatToBytes
```
public static byte[] floatToBytes(float floatValue)
```
    float转byte数组，默认以大端序转换
    
    参数:
    
    floatValue - float值
    
    返回:
    
    byte数组
  - floatToBytes
```
public static byte[] floatToBytes(float floatValue,
                                  ByteOrder byteOrder)
```
    float转byte数组，自定义端序
    
    参数:
    
    floatValue - float值
    
    byteOrder - 端序
    
    返回:
    
    byte数组
  - bytesToFloat
```
public static float bytesToFloat(byte[] bytes)
```
    byte数组转float
    默认以大端序转换
    
    参数:
    
    bytes - byte数组
    
    返回:
    
    float值
  - bytesToFloat
```
public static float bytesToFloat(byte[] bytes,
                                 ByteOrder byteOrder)
```
    byte数组转float
    自定义端序
    
    参数:
    
    bytes - byte数组
    
    byteOrder - 端序
    
    返回:
    
    float值
  - doubleToBytes
```
public static byte[] doubleToBytes(double doubleValue)
```
    double转byte数组
    默认以大端序转换
    
    参数:
    
    doubleValue - double值
    
    返回:
    
    byte数组
  - doubleToBytes
```
public static byte[] doubleToBytes(double doubleValue,
                                   ByteOrder byteOrder)
```
    double转byte数组
    自定义端序
    from: https://stackoverflow.com/questions/4485128/how-do-i-convert-long-to-byte-and-back-in-java
    
    参数:
    
    doubleValue - double值
    
    byteOrder - 端序
    
    返回:
    
    byte数组
  - bytesToDouble
```
public static double bytesToDouble(byte[] bytes)
```
    byte数组转Double
    默认以大端序转换
    
    参数:
    
    bytes - byte数组
    
    返回:
    
    long值
  - bytesToDouble
```
public static double bytesToDouble(byte[] bytes,
                                   ByteOrder byteOrder)
```
    byte数组转double
    自定义端序
    
    参数:
    
    bytes - byte数组
    
    byteOrder - 端序
    
    返回:
    
    long值
  - numberToBytes
```
public static byte[] numberToBytes(Number number)
```
    将Number转换为
    
    参数:
    
    number - 数字
    
    返回:
    
    bytes
  - numberToBytes
```
public static byte[] numberToBytes(Number number,
                                   ByteOrder byteOrder)
```
    将Number转换为
    
    参数:
    
    number - 数字
    
    byteOrder - 端序
    
    返回:
    
    bytes
  - bytesToNumber
```
public static <T extends Number> T bytesToNumber(byte[] bytes,
                                                 Class<T> targetClass,
                                                 ByteOrder byteOrder)
                                          throws IllegalArgumentException
```
    byte数组转换为指定类型数字
    
    类型参数:
    
    T - 数字类型
    
    参数:
    
    bytes - byte数组
    
    targetClass - 目标数字类型
    
    byteOrder - 端序
    
    返回:
    
    转换后的数字
    
    抛出:
    
    IllegalArgumentException - 不支持的数字类型，如用户自定义数字类型

类 Bytes

字段概要

构造器概要

方法概要

从类继承的方法 java.lang.Object

字段详细资料

DEFAULT_ORDER

CPU_ENDIAN

构造器详细资料

Bytes

方法详细资料

toHexString

parseHexBytes

toBase32String

parseBase32Bytes

toBase64String

parseBase64Bytes

toBinString

toOctString

toHexString

parseBin

parseOct

parseHex

parse

resize

join

split

wrap

unwrap

sub

remove

removeElement

reverse

reverse

min

max

shuffle

shuffle

swap

isSorted

isSortedAsc

isSortedDesc

copy

copy

concat

indexOf

indexOf

lastIndexOf

contains

isEmpty

isNotEmpty

utf8Bytes

utf8Bytes

bytes

bytes

intToByte

byteToUnsignedInt

bytesToShort

bytesToShort

bytesToShort

shortToBytes

shortToBytes

bytesToInt

bytesToInt

bytesToInt

intToBytes

intToBytes

longToBytes

longToBytes

bytesToLong

bytesToLong

bytesToLong

floatToBytes

floatToBytes

bytesToFloat

bytesToFloat

doubleToBytes

doubleToBytes

bytesToDouble

bytesToDouble