ByteUtil (java-common 3.0 API)

java.lang.Object
- com.arxanfintech.common.util.ByteUtil

```
public class ByteUtil
extends Object
```

Field Summary

Fields
Modifier and Type Field and Description

static byte[] EMPTY_BYTE_ARRAY

static byte[] ZERO_BYTE_ARRAY

Fields
Modifier and Type	Field and Description
`static byte[]`	`EMPTY_BYTE_ARRAY`
`static byte[]`	`ZERO_BYTE_ARRAY`

Constructor Summary

Constructors
Constructor and Description

ByteUtil()

Constructors
Constructor and Description
`ByteUtil()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`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(BigInteger value)` Omitting sign indication byte.
`static byte[]`	`bigIntegerToBytes(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(BigInteger b, int numBytes)`
`static int`	`byteArrayToInt(byte[] b)` Cast hex encoded value from byte[] to int Limited to Integer.MAX_VALUE: 2^32-1 (4 bytes)
`static long`	`byteArrayToLong(byte[] b)` Cast hex encoded value from byte[] to int Limited to Integer.MAX_VALUE: 2^32-1 (4 bytes)
`static BigInteger`	`bytesToBigInteger(byte[] bb)`
`static int[]`	`bytesToInts(byte[] arr, boolean bigEndian)`
`static void`	`bytesToInts(byte[] b, int[] arr, boolean bigEndian)`
`static byte[]`	`calcPacketLength(byte[] msg)` Calculate packet length
`static byte[]`	`copyToArray(BigInteger value)` Utility function to copy a byte array into a new byte array with given size.
`static Set<byte[]>`	`difference(Set<byte[]> setA, Set<byte[]> setB)`
`static byte[]`	`encodeDataList(Object... args)` encode the values and concatenate together
`static byte[]`	`encodeValFor32Bits(Object arg)`
`static int`	`firstNonZeroByte(byte[] data)`
`static int`	`getBit(byte[] data, int pos)`
`static byte[]`	`hexStringToBytes(String data)` Converts string hex representation to data bytes
`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 ...
`static byte[]`	`merge(byte[]... arrays)`
`static String`	`nibblesToPrettyString(byte[] nibbles)` Turn nibbles to a pretty looking output string Example.
`static int`	`numBytes(String val)` Calculate the number of bytes need to encode the number
`static String`	`oneByteToHexString(byte value)`
`static byte[]`	`or(byte[] b1, byte[] b2)`
`static byte[]`	`setBit(byte[] data, int pos, int val)`
`static byte[]`	`shortToBytes(short n)`
`static byte[]`	`stripLeadingZeroes(byte[] data)`
`static String`	`toHexString(byte[] data)` Convert a byte-array into a hex String. Works similar to `Hex.toHexString(byte[])` but allows for `null`
`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

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

- Field Detail
  - EMPTY_BYTE_ARRAY
```
public static final byte[] EMPTY_BYTE_ARRAY
```
  - ZERO_BYTE_ARRAY
```
public static final byte[] ZERO_BYTE_ARRAY
```
- Constructor Detail
  - ByteUtil
```
public ByteUtil()
```
- Method Detail
  - appendByte
```
public static byte[] appendByte(byte[] bytes,
                                byte b)
```
    Creates a copy of bytes and appends b to the end of it
    
    Parameters:
    
    bytes - bytes data
    
    b - append byte
    
    Returns:
    
    appended byte[]
  - bigIntegerToBytes
```
public static byte[] bigIntegerToBytes(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.
    
    Parameters:
    
    b - the integer to format into a byte array
    
    numBytes - the desired size of the resulting byte array
    
    Returns:
    
    numBytes byte long array.
  - bigIntegerToBytesSigned
```
public static byte[] bigIntegerToBytesSigned(BigInteger b,
                                             int numBytes)
```
  - bigIntegerToBytes
```
public static byte[] bigIntegerToBytes(BigInteger value)
```
    Omitting sign indication byte.
    
    Instead of BigIntegers.asUnsignedByteArray(BigInteger)
    we use this custom method to avoid an empty array in case of BigInteger.ZERO
    
    Parameters:
    
    value - any big integer number. A null-value will return null
    
    Returns:
    
    A byte array without a leading zero byte if present in the signed encoding. BigInteger.ZERO will return an array with length 1 and byte-value 0.
  - bytesToBigInteger
```
public static BigInteger bytesToBigInteger(byte[] bb)
```
    Parameters:
    
    bb - byte[]
    
    Returns:
    
    big integer
  - 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
    
    Parameters:
    
    a - first input
    
    b - second input
    
    Returns:
    
    Number of bytes that match
  - longToBytes
```
public static byte[] longToBytes(long val)
```
    Converts a long value into a byte array.
    
    Parameters:
    
    val - - long value to convert
    
    Returns:
    
    byte[] of length 8, representing the long value
  - longToBytesNoLeadZeroes
```
public static byte[] longToBytesNoLeadZeroes(long val)
```
    Converts a long value into a byte array.
    
    Parameters:
    
    val - - long value to convert
    
    Returns:
    
    decimal value with leading byte that are zeroes striped
  - intToBytes
```
public static byte[] intToBytes(int val)
```
    Converts int value into a byte array.
    
    Parameters:
    
    val - - int value to convert
    
    Returns:
    
    byte[] of length 4, representing the int value
  - intToBytesNoLeadZeroes
```
public static byte[] intToBytesNoLeadZeroes(int val)
```
    Converts a int value into a byte array.
    
    Parameters:
    
    val - - int value to convert
    
    Returns:
    
    value with leading byte that are zeroes striped
  - toHexString
```
public static String toHexString(byte[] data)
```
    Convert a byte-array into a hex String.
    Works similar to Hex.toHexString(byte[]) but allows for null
    
    Parameters:
    
    data - - byte-array to convert to a hex-string
    
    Returns:
    
    hex representation of the data.
    Returns an empty String if the input is null
    
    See Also:
    
    Hex.toHexString(byte[])
  - calcPacketLength
```
public static byte[] calcPacketLength(byte[] msg)
```
    Calculate packet length
    
    Parameters:
    
    msg - byte[]
    
    Returns:
    
    byte-array with 4 elements
  - byteArrayToInt
```
public static int byteArrayToInt(byte[] b)
```
    Cast hex encoded value from byte[] to int Limited to Integer.MAX_VALUE: 2^32-1 (4 bytes)
    
    Parameters:
    
    b - array contains the values
    
    Returns:
    
    unsigned positive int value.
  - byteArrayToLong
```
public static long byteArrayToLong(byte[] b)
```
    Cast hex encoded value from byte[] to int Limited to Integer.MAX_VALUE: 2^32-1 (4 bytes)
    
    Parameters:
    
    b - array contains the values
    
    Returns:
    
    unsigned positive long value.
  - nibblesToPrettyString
```
public static String nibblesToPrettyString(byte[] nibbles)
```
    Turn nibbles to a pretty looking output string Example. [ 1, 2, 3, 4, 5 ] becomes '\x11\x23\x45'
    
    Parameters:
    
    nibbles - - getting byte of data [ 04 ] and turning it to a '\x04' representation
    
    Returns:
    
    pretty string of nibbles
  - oneByteToHexString
```
public static String oneByteToHexString(byte value)
```
  - numBytes
```
public static int numBytes(String val)
```
    Calculate the number of bytes need to encode the number
    
    Parameters:
    
    val - - number
    
    Returns:
    
    number of min bytes used to encode the number
  - encodeValFor32Bits
```
public static byte[] encodeValFor32Bits(Object arg)
```
    Parameters:
    
    arg - - not more that 32 bits
    
    Returns:
    
    - bytes of the value pad with complete to 32 zeroes
  - encodeDataList
```
public static byte[] encodeDataList(Object... args)
```
    encode the values and concatenate together
    
    Parameters:
    
    args - Object
    
    Returns:
    
    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
    
    Parameters:
    
    bytes - byte[]
    
    Returns:
    
    boolean
  - copyToArray
```
public static byte[] copyToArray(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.
    
    Parameters:
    
    value - - a BigInteger with a maximum value of 2^256-1
    
    Returns:
    
    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
    
    Parameters:
    
    b1 - b1
    
    b2 - b2
    
    Returns:
    
    xorAlignRight
  - merge
```
public static byte[] merge(byte[]... arrays)
```
    Parameters:
    
    arrays - - arrays to merge
    
    Returns:
    
    - merged array
  - isNullOrZeroArray
```
public static boolean isNullOrZeroArray(byte[] array)
```
  - isSingleZero
```
public static boolean isSingleZero(byte[] array)
```
  - difference
```
public static Set<byte[]> difference(Set<byte[]> setA,
                                     Set<byte[]> setB)
```
  - length
```
public static int length(byte[]... bytes)
```
  - intsToBytes
```
public static byte[] intsToBytes(int[] arr,
                                 boolean bigEndian)
```
  - bytesToInts
```
public static int[] bytesToInts(byte[] arr,
                                boolean bigEndian)
```
  - bytesToInts
```
public static void bytesToInts(byte[] b,
                               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(String data)
```
    Converts string hex representation to data bytes
    
    Parameters:
    
    data - String like '0xa5e..' or just 'a5e..'
    
    Returns:
    
    decoded bytes array

Class ByteUtil

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

EMPTY_BYTE_ARRAY

ZERO_BYTE_ARRAY

Constructor Detail

ByteUtil

Method Detail

appendByte

bigIntegerToBytes

bigIntegerToBytesSigned

bigIntegerToBytes

bytesToBigInteger

matchingNibbleLength

longToBytes

longToBytesNoLeadZeroes

intToBytes

intToBytesNoLeadZeroes

toHexString

calcPacketLength

byteArrayToInt

byteArrayToLong

nibblesToPrettyString

oneByteToHexString

numBytes

encodeValFor32Bits

encodeDataList

firstNonZeroByte

stripLeadingZeroes

increment

copyToArray

setBit

getBit

and

or

xor

xorAlignRight

merge

isNullOrZeroArray

isSingleZero

difference

length

intsToBytes

bytesToInts

bytesToInts

intsToBytes

bigEndianToShort

bigEndianToShort

shortToBytes

hexStringToBytes