ByteUtil (java-common 2.1.1a API)

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

public class ByteUtil
extends java.lang.Object

字段概要

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

static byte[] EMPTY_BYTE_ARRAY

static byte[] ZERO_BYTE_ARRAY

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

构造器概要

构造器
构造器和说明

ByteUtil()

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

方法概要

所有方法静态方法具体方法
限定符和类型	方法和说明
`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)` Omitting sign indication byte.
`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 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 java.math.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(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 byte[]`	`encodeValFor32Bits(java.lang.Object arg)`
`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
`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`	`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[]`	`setBit(byte[] data, int pos, int val)`
`static byte[]`	`shortToBytes(short n)`
`static byte[]`	`stripLeadingZeroes(byte[] data)`
`static java.lang.String`	`toHexString(byte[] data)` Convert a byte-array into a hex String.
`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
```
- 构造器详细资料
  - ByteUtil
```
public ByteUtil()
```
- 方法详细资料
  - appendByte
```
public static byte[] appendByte(byte[] bytes,
                                byte b)
```
    Creates a copy of bytes and appends b to the end of it
    
    参数:
    
    bytes - bytes data
    
    b - append byte
    
    返回:
    
    appended byte[]
  - 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.
  - bigIntegerToBytesSigned
```
public static byte[] bigIntegerToBytesSigned(java.math.BigInteger b,
                                             int numBytes)
```
  - bigIntegerToBytes
```
public static byte[] bigIntegerToBytes(java.math.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
    
    参数:
    
    value - any big integer number. A null-value will return null
    
    返回:
    
    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 java.math.BigInteger bytesToBigInteger(byte[] bb)
```
    参数:
    
    bb - byte[]
    
    返回:
    
    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
    
    参数:
    
    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
  - toHexString
```
public static java.lang.String toHexString(byte[] data)
```
    Convert a byte-array into a hex String.
    Works similar to Hex.toHexString(byte[]) but allows for null
    
    参数:
    
    data - - byte-array to convert to a hex-string
    
    返回:
    
    hex representation of the data.
    Returns an empty String if the input is null
    
    另请参阅:
    
    Hex.toHexString(byte[])
  - 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 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 int Limited to Integer.MAX_VALUE: 2^32-1 (4 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
  - encodeValFor32Bits
```
public static byte[] encodeValFor32Bits(java.lang.Object arg)
```
    参数:
    
    arg - - not more that 32 bits
    
    返回:
    
    - bytes of the value pad with complete to 32 zeroes
  - 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 - b1
    
    b2 - b2
    
    返回:
    
    xorAlignRight
  - 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)
```
  - 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(java.lang.String data)
```
    Converts string hex representation to data bytes
    
    参数:
    
    data - String like '0xa5e..' or just 'a5e..'
    
    返回:
    
    decoded bytes array

类 ByteUtil

字段概要

构造器概要

方法概要

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

字段详细资料

EMPTY_BYTE_ARRAY

ZERO_BYTE_ARRAY

构造器详细资料

ByteUtil

方法详细资料

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