ByteUtils (java-sdk 1.0.0 API)

java.lang.Object
- io.github.alleriawindrunner.sdk.v3.utils.ByteUtils

public class ByteUtils
extends java.lang.Object

字段概要

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

static byte[] EMPTY_BYTE_ARRAY

static byte[] ZERO_BYTE_ARRAY

字段
限定符和类型	字段和说明
`static byte[]`	`EMPTY_BYTE_ARRAY`
`static byte[]`	`ZERO_BYTE_ARRAY`

构造器概要

构造器
构造器和说明

ByteUtils()

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

方法概要

所有方法静态方法具体方法
限定符和类型	方法和说明
`static byte[]`	`and(byte[] b1, byte[] b2)`
`static byte[]`	`appendByte(byte[] bytes, byte b)` Creates a copy of bytes and appends b to the end of it
`static short`	`bigEndianToShort(byte[] bs)`
`static short`	`bigEndianToShort(byte[] bs, int off)`
`static byte[]`	`bigIntegerToBytes(java.math.BigInteger value)`
`static byte[]`	`bigIntegerToBytes(java.math.BigInteger b, int numBytes)` The regular `BigInteger.toByteArray()` method isn't quite what we often need: it appends a leading zero to indicate that the number is positive and may need padding.
`static byte[]`	`bigIntegerToBytesSigned(java.math.BigInteger b, int numBytes)`
`static int`	`byteArrayToInt(byte[] b)` Cast hex encoded value from byte[] to int null is parsed like byte[0] Limited to Integer.MAX_VALUE: 2^32-1 (4 bytes)
`static long`	`byteArrayToLong(byte[] b)` Cast hex encoded value from byte[] to long null is parsed like byte[0] Limited to Long.MAX_VALUE: 2⁶³-1 (8 bytes)
`static java.math.BigInteger`	`bytesToBigInteger(byte[] bb)` Cast hex encoded value from byte[] to BigInteger null is parsed like byte[0]
`static int[]`	`bytesToInts(byte[] arr, boolean bigEndian)`
`static void`	`bytesToInts(byte[] b, int[] arr, boolean bigEndian)`
`static java.lang.String`	`bytesToIp(byte[] bytesIp)` Converts 4 bytes IPv4 IP to String representation
`static byte[]`	`calcPacketLength(byte[] msg)` Calculate packet length
`static byte[]`	`copyToArray(java.math.BigInteger value)` Utility function to copy a byte array into a new byte array with given size.
`static java.util.Set<byte[]>`	`difference(java.util.Set<byte[]> setA, java.util.Set<byte[]> setB)`
`static byte[]`	`encodeDataList(java.lang.Object... args)` encode the values and concatenate together
`static int`	`firstNonZeroByte(byte[] data)`
`static int`	`getBit(byte[] data, int pos)`
`static byte[]`	`hexStringToBytes(java.lang.String data)` Converts string hex representation to data bytes Accepts following hex: - with or without 0x prefix
`static byte[]`	`hostToBytes(java.lang.String ip)` Converts string representation of host/ip to 4-bytes byte[] IPv4
`static boolean`	`increment(byte[] bytes)` increment byte array as a number until max is reached
`static byte[]`	`intsToBytes(int[] arr, boolean bigEndian)`
`static void`	`intsToBytes(int[] arr, byte[] b, boolean bigEndian)`
`static byte[]`	`intToBytes(int val)` Converts int value into a byte array.
`static byte[]`	`intToBytesNoLeadZeroes(int val)` Converts a int value into a byte array.
`static boolean`	`isNullOrZeroArray(byte[] array)`
`static boolean`	`isSingleZero(byte[] array)`
`static int`	`length(byte[]... bytes)`
`static byte[]`	`longToBytes(long val)` Converts a long value into a byte array.
`static byte[]`	`longToBytesNoLeadZeroes(long val)` Converts a long value into a byte array.
`static int`	`matchingNibbleLength(byte[] a, byte[] b)` Returns the amount of nibbles that match each other from 0 ... amount will never be larger than smallest input
`static byte[]`	`merge(byte[]... arrays)`
`static java.lang.String`	`nibblesToPrettyString(byte[] nibbles)` Turn nibbles to a pretty looking output string Example. [ 1, 2, 3, 4, 5 ] becomes '\x11\x23\x45'
`static int`	`numberOfLeadingZeros(byte[] bytes)` Returns a number of zero bits preceding the highest-order ("leftmost") one-bit interpreting input array as a big-endian integer value
`static int`	`numBytes(java.lang.String val)` Calculate the number of bytes need to encode the number
`static java.lang.String`	`oneByteToHexString(byte value)`
`static byte[]`	`or(byte[] b1, byte[] b2)`
`static byte[]`	`parseBytes(byte[] input, int offset, int len)` Parses fixed number of bytes starting from `offset` in `input` array.
`static byte[]`	`parseWord(byte[] input, int idx)` Parses 32-bytes word from given input.
`static byte[]`	`parseWord(byte[] input, int offset, int idx)` Parses 32-bytes word from given input.
`static byte[]`	`setBit(byte[] data, int pos, int val)`
`static byte[]`	`shortToBytes(short n)`
`static byte[]`	`stripLeadingZeroes(byte[] data)`
`static byte[]`	`trimLeadingBytes(byte[] bytes, byte b)`
`static byte[]`	`trimLeadingZeroes(byte[] bytes)`
`static byte[]`	`xor(byte[] b1, byte[] b2)`
`static byte[]`	`xorAlignRight(byte[] b1, byte[] b2)` XORs byte arrays of different lengths by aligning length of the shortest via adding zeros at beginning

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

- 字段详细资料
  - EMPTY_BYTE_ARRAY
```
public static final byte[] EMPTY_BYTE_ARRAY
```
  - ZERO_BYTE_ARRAY
```
public static final byte[] ZERO_BYTE_ARRAY
```
- 构造器详细资料
  - ByteUtils
```
public ByteUtils()
```
- 方法详细资料
  - appendByte
```
public static byte[] appendByte(byte[] bytes,
                                byte b)
```
    Creates a copy of bytes and appends b to the end of it
    
    参数:
    
    bytes - the original bytes
    
    b - the appended byte
    
    返回:
    
    a appended bytes @
  - bigIntegerToBytes
```
public static byte[] bigIntegerToBytes(java.math.BigInteger b,
                                       int numBytes)
```
    The regular BigInteger.toByteArray() method isn't quite what we often need: it appends a leading zero to indicate that the number is positive and may need padding.
    
    参数:
    
    b - the integer to format into a byte array
    
    numBytes - the desired size of the resulting byte array
    
    返回:
    
    numBytes byte long array.
  - bigIntegerToBytes
```
public static byte[] bigIntegerToBytes(java.math.BigInteger value)
```
  - bigIntegerToBytesSigned
```
public static byte[] bigIntegerToBytesSigned(java.math.BigInteger b,
                                             int numBytes)
```
  - bytesToBigInteger
```
public static java.math.BigInteger bytesToBigInteger(byte[] bb)
```
    Cast hex encoded value from byte[] to BigInteger null is parsed like byte[0]
    
    参数:
    
    bb - byte array contains the values
    
    返回:
    
    unsigned positive BigInteger value.
  - matchingNibbleLength
```
public static int matchingNibbleLength(byte[] a,
                                       byte[] b)
```
    Returns the amount of nibbles that match each other from 0 ... amount will never be larger than smallest input
    
    参数:
    
    a - - first input
    
    b - - second input
    
    返回:
    
    Number of bytes that match
  - longToBytes
```
public static byte[] longToBytes(long val)
```
    Converts a long value into a byte array.
    
    参数:
    
    val - - long value to convert
    
    返回:
    
    byte[] of length 8, representing the long value
  - longToBytesNoLeadZeroes
```
public static byte[] longToBytesNoLeadZeroes(long val)
```
    Converts a long value into a byte array.
    
    参数:
    
    val - - long value to convert
    
    返回:
    
    decimal value with leading byte that are zeroes striped
  - intToBytes
```
public static byte[] intToBytes(int val)
```
    Converts int value into a byte array.
    
    参数:
    
    val - - int value to convert
    
    返回:
    
    byte[] of length 4, representing the int value
  - intToBytesNoLeadZeroes
```
public static byte[] intToBytesNoLeadZeroes(int val)
```
    Converts a int value into a byte array.
    
    参数:
    
    val - - int value to convert
    
    返回:
    
    value with leading byte that are zeroes striped
  - calcPacketLength
```
public static byte[] calcPacketLength(byte[] msg)
```
    Calculate packet length
    
    参数:
    
    msg - byte[]
    
    返回:
    
    byte-array with 4 elements
  - byteArrayToInt
```
public static int byteArrayToInt(byte[] b)
```
    Cast hex encoded value from byte[] to int null is parsed like byte[0]
    Limited to Integer.MAX_VALUE: 2^32-1 (4 bytes)
    
    参数:
    
    b - array contains the values
    
    返回:
    
    unsigned positive int value.
  - byteArrayToLong
```
public static long byteArrayToLong(byte[] b)
```
    Cast hex encoded value from byte[] to long null is parsed like byte[0]
    Limited to Long.MAX_VALUE: 2⁶³-1 (8 bytes)
    
    参数:
    
    b - array contains the values
    
    返回:
    
    unsigned positive long value.
  - nibblesToPrettyString
```
public static java.lang.String nibblesToPrettyString(byte[] nibbles)
```
    Turn nibbles to a pretty looking output string
    Example. [ 1, 2, 3, 4, 5 ] becomes '\x11\x23\x45'
    
    参数:
    
    nibbles - - getting byte of data [ 04 ] and turning it to a '\x04' representation
    
    返回:
    
    pretty string of nibbles
  - oneByteToHexString
```
public static java.lang.String oneByteToHexString(byte value)
```
  - numBytes
```
public static int numBytes(java.lang.String val)
```
    Calculate the number of bytes need to encode the number
    
    参数:
    
    val - - number
    
    返回:
    
    number of min bytes used to encode the number
  - encodeDataList
```
public static byte[] encodeDataList(java.lang.Object... args)
```
    encode the values and concatenate together
    
    参数:
    
    args - Object
    
    返回:
    
    byte[]
  - firstNonZeroByte
```
public static int firstNonZeroByte(byte[] data)
```
  - stripLeadingZeroes
```
public static byte[] stripLeadingZeroes(byte[] data)
```
  - increment
```
public static boolean increment(byte[] bytes)
```
    increment byte array as a number until max is reached
    
    参数:
    
    bytes - byte[]
    
    返回:
    
    boolean
  - copyToArray
```
public static byte[] copyToArray(java.math.BigInteger value)
```
    Utility function to copy a byte array into a new byte array with given size. If the src length is smaller than the given size, the result will be left-padded with zeros.
    
    参数:
    
    value - - a BigInteger with a maximum value of 2^256-1
    
    返回:
    
    Byte array of given size with a copy of the src
  - setBit
```
public static byte[] setBit(byte[] data,
                            int pos,
                            int val)
```
  - getBit
```
public static int getBit(byte[] data,
                         int pos)
```
  - and
```
public static byte[] and(byte[] b1,
                         byte[] b2)
```
  - or
```
public static byte[] or(byte[] b1,
                        byte[] b2)
```
  - xor
```
public static byte[] xor(byte[] b1,
                         byte[] b2)
```
  - xorAlignRight
```
public static byte[] xorAlignRight(byte[] b1,
                                   byte[] b2)
```
    XORs byte arrays of different lengths by aligning length of the shortest via adding zeros at beginning
    
    参数:
    
    b1 - the first byte array
    
    b2 - the second byte array
    
    返回:
    
    a byte array contains XORS of b1 and b2
  - merge
```
public static byte[] merge(byte[]... arrays)
```
    参数:
    
    arrays - - arrays to merge
    
    返回:
    
    - merged array
  - isNullOrZeroArray
```
public static boolean isNullOrZeroArray(byte[] array)
```
  - isSingleZero
```
public static boolean isSingleZero(byte[] array)
```
  - difference
```
public static java.util.Set<byte[]> difference(java.util.Set<byte[]> setA,
                                               java.util.Set<byte[]> setB)
```
  - length
```
public static int length(byte[]... bytes)
```
  - bytesToInts
```
public static int[] bytesToInts(byte[] arr,
                                boolean bigEndian)
```
  - bytesToInts
```
public static void bytesToInts(byte[] b,
                               int[] arr,
                               boolean bigEndian)
```
  - intsToBytes
```
public static byte[] intsToBytes(int[] arr,
                                 boolean bigEndian)
```
  - intsToBytes
```
public static void intsToBytes(int[] arr,
                               byte[] b,
                               boolean bigEndian)
```
  - bigEndianToShort
```
public static short bigEndianToShort(byte[] bs)
```
  - bigEndianToShort
```
public static short bigEndianToShort(byte[] bs,
                                     int off)
```
  - shortToBytes
```
public static byte[] shortToBytes(short n)
```
  - hexStringToBytes
```
public static byte[] hexStringToBytes(java.lang.String data)
```
    Converts string hex representation to data bytes Accepts following hex: - with or without 0x prefix
    
    参数:
    
    data - String like '0xa5e..' or just 'a5e..'
    
    返回:
    
    decoded bytes array
  - hostToBytes
```
public static byte[] hostToBytes(java.lang.String ip)
```
    Converts string representation of host/ip to 4-bytes byte[] IPv4
    
    参数:
    
    ip - the ip string of host
    
    返回:
    
    a 4-bytes byte[] IPv4
  - bytesToIp
```
public static java.lang.String bytesToIp(byte[] bytesIp)
```
    Converts 4 bytes IPv4 IP to String representation
    
    参数:
    
    bytesIp - the 4 bytes IPv4 IP
    
    返回:
    
    a String representation of the IP
  - numberOfLeadingZeros
```
public static int numberOfLeadingZeros(byte[] bytes)
```
    Returns a number of zero bits preceding the highest-order ("leftmost") one-bit interpreting input array as a big-endian integer value
    
    参数:
    
    bytes - the byte array
    
    返回:
    
    the number of leading zeros
  - parseBytes
```
public static byte[] parseBytes(byte[] input,
                                int offset,
                                int len)
```
    Parses fixed number of bytes starting from offset in input array. If input has not enough bytes return array will be right padded with zero bytes. I.e. if offset is higher than input.length then zero byte array of length len will be returned
    
    参数:
    
    input - the input bytes array
    
    offset - an offset in input array to start parsing from
    
    len - the length of zero byte array
    
    返回:
    
    a fixed bytes array
  - parseWord
```
public static byte[] parseWord(byte[] input,
                               int idx)
```
    Parses 32-bytes word from given input. Uses parseBytes(byte[], int, int) method, thus, result will be right-padded with zero bytes if there is not enough bytes in input
    
    参数:
    
    input - the input bytes array
    
    idx - an index of the word starting from 0
    
    返回:
    
    a fixed bytes array
  - parseWord
```
public static byte[] parseWord(byte[] input,
                               int offset,
                               int idx)
```
    Parses 32-bytes word from given input. Uses parseBytes(byte[], int, int) method, thus, result will be right-padded with zero bytes if there is not enough bytes in input
    
    参数:
    
    input - the input bytes array
    
    idx - an index of the word starting from 0
    
    offset - an offset in input array to start parsing from
    
    返回:
    
    a fixed bytes array
  - trimLeadingBytes
```
public static byte[] trimLeadingBytes(byte[] bytes,
                                      byte b)
```
  - trimLeadingZeroes
```
public static byte[] trimLeadingZeroes(byte[] bytes)
```

类 ByteUtils

字段概要

构造器概要

方法概要

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

字段详细资料

EMPTY_BYTE_ARRAY

ZERO_BYTE_ARRAY

构造器详细资料

ByteUtils

方法详细资料

appendByte

bigIntegerToBytes

bigIntegerToBytes

bigIntegerToBytesSigned

bytesToBigInteger

matchingNibbleLength

longToBytes

longToBytesNoLeadZeroes

intToBytes

intToBytesNoLeadZeroes

calcPacketLength

byteArrayToInt

byteArrayToLong

nibblesToPrettyString

oneByteToHexString

numBytes

encodeDataList

firstNonZeroByte

stripLeadingZeroes

increment

copyToArray

setBit

getBit

and

or

xor

xorAlignRight

merge

isNullOrZeroArray

isSingleZero

difference

length

bytesToInts

bytesToInts

intsToBytes

intsToBytes

bigEndianToShort

bigEndianToShort

shortToBytes

hexStringToBytes

hostToBytes

bytesToIp

numberOfLeadingZeros

parseBytes

parseWord

parseWord

trimLeadingBytes

trimLeadingZeroes