ByteUtils

java.lang.Object
- org.zoolu.util.ByteUtils

```
public class ByteUtils
extends java.lang.Object
```
Class that collects static methods for dealing with binary materials.

Constructor Summary

Constructors
Constructor and Description

ByteUtils()

Constructors
Constructor and Description
`ByteUtils()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static java.lang.String`	`asAscii(byte[] data)` Gets an ASCII representation of an array of bytes.
`static java.lang.String`	`asAscii(byte[] buf, int off, int len)` Gets an ASCII representation of an array of bytes.
`static java.lang.String`	`asBinary(byte[] data)` Gets a binary representation of an array of bytes.
`static java.lang.String`	`asBinary(byte[] buf, int off, int len)` Gets a binary representation of an array of bytes.
`static java.lang.String`	`asHex(byte[] data)` Gets a hexadecimal representation of an array of bytes.
`static java.lang.String`	`asHex(byte[] buf, int off, int len)` Gets a hexadecimal representation of an array of bytes.
`static java.lang.String`	`bytesToAsciiString(byte[] data)` Gets an ASCII representation of an array of bytes.
`static java.lang.String`	`bytesToAsciiString(byte[] buf, int off, int len)` Gets an ASCII representation of an array of bytes.
`static java.lang.String`	`bytesToBinString(byte[] data)` Converts a byte array into a binary string.
`static java.lang.String`	`bytesToBinString(byte[] buf, int off, int len)` Converts a byte array into a binary string.
`static java.lang.String`	`bytesToFormattedHexString(byte[] data, char c, int num)` Gets a formatted (e.g. colon-separated) hexadecimal representation of an array of bytes.
`static java.lang.String`	`bytesToFormattedHexString(byte[] buf, int off, int len, char c, int num)` Gets a formatted (e.g. colon-separated) hexadecimal representation of an array of bytes.
`static java.lang.String`	`bytesToHexString(byte[] data)` Gets a hexadecimal representation of an array of bytes.
`static java.lang.String`	`bytesToHexString(byte[] buf, int off, int len)` Gets a hexadecimal representation of an array of bytes.
`static int`	`compare(byte[] a1, byte[] a2)` Compares two arrays of bytes.
`static int`	`compare(byte[] buf1, int off1, int len1, byte[] buf2, int off2, int len2)` Compares two arrays of bytes.
`static byte[]`	`concat(byte[] src1, byte[] src2)` Concatenates two arrays of bytes.
`static int`	`concat(byte[] src1, byte[] src2, byte[] dst3)` Concatenates two arrays of bytes.
`static byte[]`	`concat(byte[] src1, int off1, int len1, byte[] src2, int off2, int len2)` Concatenates two arrays of bytes.
`static int`	`concat(byte[] src1, int off1, int len1, byte[] src2, int off2, int len2, byte[] dst3, int off3)` Concatenates two arrays of bytes.
`static byte[]`	`copy(byte[] src)` Gets a new array containing a copy of an array of bytes.
`static void`	`copy(byte[] src, byte[] dst)` Copies an array of bytes into another array.
`static void`	`copy(byte[] src, byte[] dst, int dst_off)` Copies an array of bytes into another array.
`static void`	`copy(byte[] src, int src_off, byte[] dst, int dst_off, int len)` Copies an array of bytes into another array.
`static byte[]`	`copy(byte[] src, int off, int len)` Gets a new array containing a copy of an array of bytes.
`static long`	`eightBytesToInt(byte[] src)` Transforms a 8-byte array into a 64-bit integer; the 8-byte array is in big-endian byte order (the big end, most significant byte, is stored first, at the lowest storage address).
`static long`	`eightBytesToInt(byte[] src, int off)` Transforms a 8-byte array into a 64-bit integer; the 8-byte array is in big-endian byte order (the big end, most significant byte, is stored first, at the lowest storage address).
`static void`	`fill(byte[] a, byte val)` Assigns the specified byte value to each element of the array of bytes.
`static void`	`fill(byte[] buf, int off, int len, byte val)` Assigns the specified byte value to each element of an array of bytes.
`static byte[]`	`formattedHexStringToBytes(java.lang.String str, char c)` Converts a formatted hexadecimal string into an array of bytes.
`static int`	`formattedHexStringToBytes(java.lang.String str, char c, byte[] buf, int off)` Converts a formatted hexadecimal string into an array of bytes.
`static byte[]`	`formattedHexStringToBytes(java.lang.String str, char c, int len)` Converts a formatted hexadecimal string into an array of bytes.
`static long`	`fourBytesToInt(byte[] src)` Transforms a 4-byte array into a 32-bit integer; the 4-byte array is in big-endian byte order (the big end, most significant byte, is stored first, at the lowest storage address).
`static long`	`fourBytesToInt(byte[] src, int off)` Transforms a 4-byte array into a 32-bit integer; the 4-byte array is in big-endian byte order (the big end, most significant byte, is stored first, at the lowest storage address).
`static long`	`fourBytesToIntLittleEndian(byte[] src)` Transforms a four-byte array into a 32-bit integer; the four-byte array is in little-endian byte order (the little end, least significant byte, is stored first, at the lowest storage address).
`static long`	`fourBytesToIntLittleEndian(byte[] src, int off)` Transforms a four-byte array into a 32-bit integer; the four-byte array is in little-endian byte order (the little end, least significant byte, is stored first, at the lowest storage address).
`static long`	`fourBytesToLong(byte b3, byte b2, byte b1, byte b0)` Gets a 32-bit integer (as long) from four bytes.
`static byte[]`	`hexStringToBytes(java.lang.String str)` Converts a hexadecimal string into an array of bytes.
`static int`	`hexStringToBytes(java.lang.String str, byte[] buf, int off)` Converts a hexadecimal string into an array of bytes.
`static byte[]`	`hexToBytes(java.lang.String str)` Converts a hexadecimal string into an array of bytes.
`static int`	`hexToBytes(java.lang.String str, byte[] buf, int off)` Converts a hexadecimal string into an array of bytes.
`static byte[]`	`hexToBytes(java.lang.String str, int len)` Converts a hexadecimal string into an array of bytes.
`static void`	`inc(byte[] buf)` Adds 1 to the number represented by the given array of bytes, module 2^n, where n is the length (in bits) of the array.
`static int`	`indexOf(byte[] a1, byte[] buf2, int off2, int len2)` Finds the first occurrence of one array of bytes within a second array of bytes.
`static int`	`indexOf(byte[] buf1, int off1, int len1, byte[] buf2, int off2, int len2)` Finds the first occurrence of one array of bytes within a second array of bytes.
`static byte[]`	`intToEightBytes(long val)` Transforms a 64-bit signed integer (as long) into an eight-byte array in big-endian byte order (the big end, most significant byte, is stored first, at the lowest storage address).
`static void`	`intToEightBytes(long val, byte[] dst, int off)` Transforms a 64-bit signed integer (as long) into an eight-byte array in big-endian byte order (the big end, most significant byte, is stored first, at the lowest storage address).
`static byte[]`	`intToFourBytes(long val)` Transforms a 32-bit integer into a four-byte array in big-endian byte order (the big end, most significant byte, is stored first, at the lowest storage address).
`static void`	`intToFourBytes(long val, byte[] dst, int off)` Transforms a 32-bit integer into a four-byte array in big-endian byte order (the big end, most significant byte, is stored first, at the lowest storage address).
`static byte[]`	`intToFourBytesLittleEndian(long n)` Transforms a 32-bit integer into a four-byte array in little-endian byte order (the little end, least significant byte, is stored first, at the lowest storage address).
`static void`	`intToFourBytesLittleEndian(long n, byte[] dst, int off)` Transforms a 32-bit integer into a four-byte array copied into a given buffer; the 4-bytes array is in little-endian byte order (the little end, least significant byte, is stored first, at the lowest storage address).
`static void`	`intToNBytes(long val, byte[] dst, int off, int len)` Transforms an integer into an n-byte array in big-endian byte order (the big end, most significant byte, is stored first, at the lowest storage address).
`static byte[]`	`intToNBytes(long val, int len)` Transforms an integer into an n-byte array in big-endian byte order (the big end, most significant byte, is stored first, at the lowest storage address).
`static byte[]`	`intToSixBytes(long val)` Transforms a 48-bit integer into a six-byte array in big-endian byte order (the big end, most significant byte, is stored first, at the lowest storage address).
`static void`	`intToSixBytes(long val, byte[] dst, int off)` Transforms a 48-bit integer into a six-byte array in big-endian byte order (the big end, most significant byte, is stored first, at the lowest storage address).
`static byte[]`	`intToTwoBytes(int val)` Transforms a 16-bit integer into a two-byte array in big-endian byte order (the big end, most significant byte, is stored first, at the lowest storage address).
`static void`	`intToTwoBytes(int val, byte[] dst, int off)` Writes a 16-bit integer into a two-byte array in big-endian byte order (the big end, most significant byte, is stored first, at the lowest storage address).
`static void`	`invertByteOrder(byte[] buf)` Modifies the given array inverting the byte order.
`static boolean`	`match(byte[] a1, byte[] a2)` Compares two arrays of bytes.
`static boolean`	`match(byte[] buf1, int off1, int len1, byte[] buf2, int off2, int len2)` Compares two arrays of bytes.
`static long`	`nBytesToInt(byte[] src)` Transforms a n-byte array into an integer; the n-byte array is in big-endian byte order (the big end, most significant byte, is stored first, at the lowest storage address).
`static long`	`nBytesToInt(byte[] src, int off, int len)` Transforms a n-byte array into an integer; the n-byte array is in big-endian byte order (the big end, most significant byte, is stored first, at the lowest storage address).
`static java.lang.String`	`trimHexString(java.lang.String str)` Gets an unformatted hexadecimal string.
`static int`	`twoBytesToInt(byte[] src)` Transforms a two-byte array into a 16-bit integer; the 2-byte array is in big-endian byte order (the big end, most significant byte, is stored first, at the lowest storage address).
`static int`	`twoBytesToInt(byte[] src, int off)` Reads a 16-bit integer from a two-byte array; the two-byte array is in big-endian byte order (the big end, most significant byte, is stored first, at the lowest storage address).
`static int`	`twoBytesToInt(byte b_high, byte b_low)` Gets a 16-bit integer from two bytes.
`static short`	`uByte(byte b)` Gets the unsigned representation of a byte, returned as a short.
`static long`	`uInt(int n)` Gets the unsigned representation of a 32-bit integer, returned as a long.

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

- Constructor Detail
  - ByteUtils
```
public ByteUtils()
```
- Method Detail
  - copy
```
public static void copy(byte[] src,
                        byte[] dst)
```
    Copies an array of bytes into another array.
    
    Parameters:
    
    src - the source array to be copied
    
    dst - the destination array
  - copy
```
public static void copy(byte[] src,
                        byte[] dst,
                        int dst_off)
```
    Copies an array of bytes into another array.
    
    Parameters:
    
    src - the source array to be copied
    
    dst - the destination buffer where the array has to be copied
    
    dst_off - the offset within the buffer
  - copy
```
public static void copy(byte[] src,
                        int src_off,
                        byte[] dst,
                        int dst_off,
                        int len)
```
    Copies an array of bytes into another array.
    
    Parameters:
    
    src - the buffer containing the source array to be copied
    
    src_off - the offset within the buffer
    
    dst - the destination buffer where the array has to be copied
    
    dst_off - the offset within the buffer
    
    len - the number of bytes to be copied
  - copy
```
public static byte[] copy(byte[] src)
```
    Gets a new array containing a copy of an array of bytes.
    
    Parameters:
    
    src - the array to be copied
    
    Returns:
    
    a copy of the original array
  - copy
```
public static byte[] copy(byte[] src,
                          int off,
                          int len)
```
    Gets a new array containing a copy of an array of bytes.
    
    Parameters:
    
    src - the buffer containing the array to be copied
    
    off - the offset within the buffer
    
    len - the length of the array
    
    Returns:
    
    a copy of the original array
  - match
```
public static boolean match(byte[] a1,
                            byte[] a2)
```
    Compares two arrays of bytes.
    
    Parameters:
    
    a1 - one array
    
    a2 - the other array
    
    Returns:
    
    true if the two arrays are equal
  - match
```
public static boolean match(byte[] buf1,
                            int off1,
                            int len1,
                            byte[] buf2,
                            int off2,
                            int len2)
```
    Compares two arrays of bytes.
    
    Parameters:
    
    buf1 - the buffer containing the first array
    
    off1 - the offset within the buffer
    
    len1 - the length of the first array
    
    buf2 - the buffer containing the second array
    
    off2 - the offset within the buffer
    
    len2 - the length of the second array
    
    Returns:
    
    true if the two arrays are equal
  - compare
```
public static int compare(byte[] a1,
                          byte[] a2)
```
    Compares two arrays of bytes.
    Parameters:
    
    a1 - one array
    
    a2 - the other array
    
    Returns:
    0 if the two arrays are equal;
    1 if they are different and, starting from left, all bits are equal and the length of the first array is greater than than the second, or the first bit that differs has value '1' in the first array (and '0' in the second one);
    -1 if they are different and, starting from left, all bits are equal and the length of the first array is lesser than than the second, or the first bit that differs has value '0' in the first array (and '1' in the second one)
  - compare
```
public static int compare(byte[] buf1,
                          int off1,
                          int len1,
                          byte[] buf2,
                          int off2,
                          int len2)
```
    Compares two arrays of bytes.
    Parameters:
    
    buf1 - the buffer containing the first array
    
    off1 - the offset within the buffer
    
    len1 - the length of the first array
    
    buf2 - the buffer containing the second array
    
    off2 - the offset within the buffer
    
    len2 - the length of the second array
    
    Returns:
    0 if the two arrays are equal;
    1 if they are different and, starting from left, all bits are equal and the length of the first array is greater than than the second, or the first bit that differs has value '1' in the first array (and '0' in the second one);
    -1 if they are different and, starting from left, all bits are equal and the length of the first array is lesser than than the second, or the first bit that differs has value '0' in the first array (and '1' in the second one)
  - indexOf
```
public static int indexOf(byte[] a1,
                          byte[] buf2,
                          int off2,
                          int len2)
```
    Finds the first occurrence of one array of bytes within a second array of bytes.
    
    Parameters:
    
    a1 - the array to be searched
    
    buf2 - the buffer containing the second array
    
    off2 - the offset within the second array
    
    len2 - the length of the second array
    
    Returns:
    
    the index within the second array of the first occurrence of the first array, or -1 if not found.
  - indexOf
```
public static int indexOf(byte[] buf1,
                          int off1,
                          int len1,
                          byte[] buf2,
                          int off2,
                          int len2)
```
    Finds the first occurrence of one array of bytes within a second array of bytes.
    
    Parameters:
    
    buf1 - the buffer containing the array to be searched
    
    off1 - the offset within the buffer
    
    len1 - the length of the array to be searched
    
    buf2 - the buffer containing the second array
    
    off2 - the offset within the buffer
    
    len2 - the length of the second array
    
    Returns:
    
    the index within the second array of the first occurrence of the first array, or -1 if not found.
  - fill
```
public static void fill(byte[] a,
                        byte val)
```
    Assigns the specified byte value to each element of the array of bytes.
    
    Parameters:
    
    a - the array of bytes
    
    val - the value to be assigned
  - fill
```
public static void fill(byte[] buf,
                        int off,
                        int len,
                        byte val)
```
    Assigns the specified byte value to each element of an array of bytes.
    
    Parameters:
    
    buf - the buffer containing the array
    
    off - the offset within the buffer
    
    len - the length of the array
    
    val - the value to be assigned
  - concat
```
public static byte[] concat(byte[] src1,
                            byte[] src2)
```
    Concatenates two arrays of bytes.
    
    Parameters:
    
    src1 - buffer containing the 1st array
    
    src2 - buffer containing the 2nd array
    
    Returns:
    
    a new byte array containing the concatenation of the two arrays.
  - concat
```
public static int concat(byte[] src1,
                         byte[] src2,
                         byte[] dst3)
```
    Concatenates two arrays of bytes.
    
    Parameters:
    
    src1 - buffer containing the first array
    
    src2 - buffer containing the second array
    
    dst3 - buffer for the resulting concatenation array
    
    Returns:
    
    the length of the concatenation of the two arrays.
  - concat
```
public static byte[] concat(byte[] src1,
                            int off1,
                            int len1,
                            byte[] src2,
                            int off2,
                            int len2)
```
    Concatenates two arrays of bytes.
    
    Parameters:
    
    src1 - buffer containing the first array
    
    off1 - offset of the first array
    
    len1 - length of the first array
    
    src2 - buffer containing the second array
    
    off2 - offset of the second array
    
    len2 - length of the second array
    
    Returns:
    
    a new byte array containing the concatenation of the two arrays.
  - concat
```
public static int concat(byte[] src1,
                         int off1,
                         int len1,
                         byte[] src2,
                         int off2,
                         int len2,
                         byte[] dst3,
                         int off3)
```
    Concatenates two arrays of bytes.
    
    Parameters:
    
    src1 - buffer containing the first array
    
    off1 - offset of the first array
    
    len1 - length of the first array
    
    src2 - buffer containing the second array
    
    off2 - offset of the second array
    
    len2 - length of the second array
    
    dst3 - buffer for the resulting concatenation array
    
    off3 - offset of the resulting array
    
    Returns:
    
    the length of the concatenation of the two arrays.
  - uByte
```
public static short uByte(byte b)
```
    Gets the unsigned representation of a byte, returned as a short. The same as getting (short)(b&0xFF).
    
    Parameters:
    
    b - the byte value
    
    Returns:
    
    the unsigned integer value (as short) of the given byte.
  - uInt
```
public static long uInt(int n)
```
    Gets the unsigned representation of a 32-bit integer, returned as a long. The same as getting (long)n&0x00000000FFFFFFFF.
    
    Parameters:
    
    n - the integer value
    
    Returns:
    
    the unsigned integer value (as long) of the given integer.
  - bytesToHexString
```
public static java.lang.String bytesToHexString(byte[] data)
```
    Gets a hexadecimal representation of an array of bytes.
    
    Parameters:
    
    data - the byte array
    
    Returns:
    
    the hexadecimal string
  - bytesToHexString
```
public static java.lang.String bytesToHexString(byte[] buf,
                                                int off,
                                                int len)
```
    Gets a hexadecimal representation of an array of bytes.
    
    Parameters:
    
    buf - buffer containing the byte array
    
    off - the offset within the array
    
    len - the number of bytes
    
    Returns:
    
    the hexadecimal string
  - bytesToFormattedHexString
```
public static java.lang.String bytesToFormattedHexString(byte[] data,
                                                         char c,
                                                         int num)
```
    Gets a formatted (e.g. colon-separated) hexadecimal representation of an array of bytes. The hexadecimal values are formatted in blocks of a given size, separated by a given symbol. Example, in case of two-byte blocks (block size = 2) separated by colons, the string will be formatted as "aabb:ccdd:..:eeff".
    
    Parameters:
    
    data - the byte array
    
    c - the block separator
    
    num - the number of bytes within each block
    
    Returns:
    
    the hexadecimal string
  - bytesToFormattedHexString
```
public static java.lang.String bytesToFormattedHexString(byte[] buf,
                                                         int off,
                                                         int len,
                                                         char c,
                                                         int num)
```
    Gets a formatted (e.g. colon-separated) hexadecimal representation of an array of bytes. The hexadecimal values are formatted in blocks of a given size, separatedby a given symbol. Example, in case of two-byte blocks (block size = 2) separated by colons, the string will be formatted as "aabb:ccdd:..:eeff".
    
    Parameters:
    
    buf - the buffer containing the byte array
    
    off - the offset within the array
    
    len - the length of the array
    
    c - the block separator
    
    num - the number of bytes within each block
    
    Returns:
    
    the hexadecimal string
  - trimHexString
```
public static java.lang.String trimHexString(java.lang.String str)
```
    Gets an unformatted hexadecimal string. It removes any non-hexadecimal character from the string.
    
    Parameters:
    
    str - the formatted hexadecimal string
    
    Returns:
    
    the unformatted hexadecimal string
  - hexStringToBytes
```
public static byte[] hexStringToBytes(java.lang.String str)
```
    Converts a hexadecimal string into an array of bytes.
    
    Parameters:
    
    str - the hexadecimal string
    
    Returns:
    
    the array of bytes
  - hexStringToBytes
```
public static int hexStringToBytes(java.lang.String str,
                                   byte[] buf,
                                   int off)
```
    Converts a hexadecimal string into an array of bytes.
    
    Parameters:
    
    str - the hexadecimal string
    
    buf - the buffer where the array of bytes will be written
    
    off - the offset within the buffer
    
    Returns:
    
    the length of the array
  - formattedHexStringToBytes
```
public static byte[] formattedHexStringToBytes(java.lang.String str,
                                               char c)
```
    Converts a formatted hexadecimal string into an array of bytes.
    
    Parameters:
    
    str - the string with hexadecimal characters possibly separated by the given character
    
    c - the separator character
    
    Returns:
    
    the array of bytes
  - formattedHexStringToBytes
```
public static byte[] formattedHexStringToBytes(java.lang.String str,
                                               char c,
                                               int len)
```
    Converts a formatted hexadecimal string into an array of bytes.
    
    Parameters:
    
    str - the string with hexadecimal characters possibly separated by the given character
    
    c - the separator character
    
    len - the length of the array of bytes, or -1 if unknown
    
    Returns:
    
    the array of bytes
  - formattedHexStringToBytes
```
public static int formattedHexStringToBytes(java.lang.String str,
                                            char c,
                                            byte[] buf,
                                            int off)
```
    Converts a formatted hexadecimal string into an array of bytes.
    
    Parameters:
    
    str - the string with hexadecimal characters possibly separated by the given character
    
    c - the separator character
    
    buf - the buffer where the array of bytes will be written
    
    off - the offset within the buffer
    
    Returns:
    
    the length of the array of bytes
  - asHex
```
public static java.lang.String asHex(byte[] data)
```
    Gets a hexadecimal representation of an array of bytes.
    The same as bytesToHexString(byte[])
    
    Parameters:
    
    data - the byte array
    
    Returns:
    
    the hexadecimal string
  - asHex
```
public static java.lang.String asHex(byte[] buf,
                                     int off,
                                     int len)
```
    Gets a hexadecimal representation of an array of bytes.
    The same as bytesToHexString(byte[], int, int)
    
    Parameters:
    
    buf - buffer containing the byte array
    
    off - the offset within the array
    
    len - the number of bytes
    
    Returns:
    
    the hexadecimal string
  - hexToBytes
```
public static byte[] hexToBytes(java.lang.String str)
```
    Converts a hexadecimal string into an array of bytes. The string may also include colon ':' characters that separate blocks of hexadecimal values (e.g. aa:bb:cc:dd:..:ff).
    The same as formattedHexStringToBytes(String, char, int) with c=':' and len=-1
    
    Parameters:
    
    str - the string with hexadecimal characters possibly separated by colon
    
    Returns:
    
    the array of bytes
  - hexToBytes
```
public static byte[] hexToBytes(java.lang.String str,
                                int len)
```
    Converts a hexadecimal string into an array of bytes. The string may also include colon ':' characters that separate blocks of hexadecimal values (e.g. aa:bb:cc:dd:..:ff).
    The same as formattedHexStringToBytes(String, char, int) with c=':'
    
    Parameters:
    
    str - the string with hexadecimal characters possibly separated by colon
    
    len - the length of the array of bytes, or -1 if unknown
    
    Returns:
    
    the array of bytes
  - hexToBytes
```
public static int hexToBytes(java.lang.String str,
                             byte[] buf,
                             int off)
```
    Converts a hexadecimal string into an array of bytes. The string may also include colon ':' characters that separate blocks of hexadecimal values (e.g. aa:bb:cc:dd:..:ff).
    The same as formattedHexStringToBytes(String, char, byte[], int) with c=':'
    
    Parameters:
    
    str - the string with hexadecimal characters possibly separated by colon
    
    buf - the buffer where the array of bytes will be written
    
    off - the offset within the buffer
    
    Returns:
    
    the length of the array of bytes
  - bytesToAsciiString
```
public static java.lang.String bytesToAsciiString(byte[] data)
```
    Gets an ASCII representation of an array of bytes. Non-ASCII bytes are encoded as '.'.
    
    Parameters:
    
    data - the array of bytes
    
    Returns:
    
    the ASCII string
  - bytesToAsciiString
```
public static java.lang.String bytesToAsciiString(byte[] buf,
                                                  int off,
                                                  int len)
```
    Gets an ASCII representation of an array of bytes. Non-ASCII bytes are encoded as '.'.
    
    Parameters:
    
    buf - buffer containing the array of bytes
    
    off - the offset within the buffer
    
    len - the number of bytes
    
    Returns:
    
    the ASCII string
  - asAscii
```
public static java.lang.String asAscii(byte[] data)
```
    Gets an ASCII representation of an array of bytes. Non-ASCII bytes are encoded as '.'.
    The same as bytesToAsciiString(byte[])
    
    Parameters:
    
    data - the array of bytes
    
    Returns:
    
    the ASCII string
  - asAscii
```
public static java.lang.String asAscii(byte[] buf,
                                       int off,
                                       int len)
```
    Gets an ASCII representation of an array of bytes. Non-ASCII bytes are encoded as '.'.
    The same as bytesToAsciiString(byte[], int, int)
    
    Parameters:
    
    buf - buffer containing the array of bytes
    
    off - the offset within the buffer
    
    len - the number of bytes
    
    Returns:
    
    the ASCII string
  - bytesToBinString
```
public static java.lang.String bytesToBinString(byte[] data)
```
    Converts a byte array into a binary string.
    
    Parameters:
    
    data - the byte array
    
    Returns:
    
    the binary string
  - bytesToBinString
```
public static java.lang.String bytesToBinString(byte[] buf,
                                                int off,
                                                int len)
```
    Converts a byte array into a binary string.
    
    Parameters:
    
    buf - buffer containing the byte array
    
    off - the offset within the buffer
    
    len - the length of the array
    
    Returns:
    
    the binary string
  - asBinary
```
public static java.lang.String asBinary(byte[] data)
```
    Gets a binary representation of an array of bytes.
    The same as bytesToBinString(byte[])
    
    Parameters:
    
    data - the array of bytes
    
    Returns:
    
    the binary string
  - asBinary
```
public static java.lang.String asBinary(byte[] buf,
                                        int off,
                                        int len)
```
    Gets a binary representation of an array of bytes.
    The same as bytesToBinString(byte[], int, int)
    
    Parameters:
    
    buf - buffer containing the array of bytes
    
    off - the offset within the buffer
    
    len - the number of bytes
    
    Returns:
    
    the binary string
  - twoBytesToInt
```
public static int twoBytesToInt(byte[] src)
```
    Transforms a two-byte array into a 16-bit integer; the 2-byte array is in big-endian byte order (the big end, most significant byte, is stored first, at the lowest storage address).
    
    Parameters:
    
    src - the two-byte array representing an integer in big-endian byte order
    
    Returns:
    
    the 16-bit integer
  - twoBytesToInt
```
public static int twoBytesToInt(byte[] src,
                                int off)
```
    Reads a 16-bit integer from a two-byte array; the two-byte array is in big-endian byte order (the big end, most significant byte, is stored first, at the lowest storage address).
    
    Parameters:
    
    src - a buffer containing the two-byte array representing an integer in big-endian byte order
    
    off - the offset within the buffer
    
    Returns:
    
    the 16-bit integer
  - fourBytesToInt
```
public static long fourBytesToInt(byte[] src)
```
    Transforms a 4-byte array into a 32-bit integer; the 4-byte array is in big-endian byte order (the big end, most significant byte, is stored first, at the lowest storage address).
    
    Parameters:
    
    src - the 4-byte array representing an integer in big-endian byte order
    
    Returns:
    
    the 32-bit integer
  - fourBytesToInt
```
public static long fourBytesToInt(byte[] src,
                                  int off)
```
    Transforms a 4-byte array into a 32-bit integer; the 4-byte array is in big-endian byte order (the big end, most significant byte, is stored first, at the lowest storage address).
    
    Parameters:
    
    src - a buffer containing the 4-byte array representing an integer in big-endian byte order
    
    off - the offset within the buffer
    
    Returns:
    
    the 32-bit integer
  - eightBytesToInt
```
public static long eightBytesToInt(byte[] src)
```
    Transforms a 8-byte array into a 64-bit integer; the 8-byte array is in big-endian byte order (the big end, most significant byte, is stored first, at the lowest storage address).
    
    Parameters:
    
    src - the 8-byte array representing an integer in big-endian byte order
    
    Returns:
    
    the 64-bit integer
  - eightBytesToInt
```
public static long eightBytesToInt(byte[] src,
                                   int off)
```
    Transforms a 8-byte array into a 64-bit integer; the 8-byte array is in big-endian byte order (the big end, most significant byte, is stored first, at the lowest storage address).
    
    Parameters:
    
    src - a buffer containing the 8-byte array representing an integer in big-endian byte order
    
    off - the offset within the buffer
    
    Returns:
    
    the 64-bit integer
  - nBytesToInt
```
public static long nBytesToInt(byte[] src)
```
    Transforms a n-byte array into an integer; the n-byte array is in big-endian byte order (the big end, most significant byte, is stored first, at the lowest storage address).
    
    Parameters:
    
    src - the n-byte array representing an integer in big-endian byte order
    
    Returns:
    
    the integer
  - nBytesToInt
```
public static long nBytesToInt(byte[] src,
                               int off,
                               int len)
```
    Transforms a n-byte array into an integer; the n-byte array is in big-endian byte order (the big end, most significant byte, is stored first, at the lowest storage address).
    
    Parameters:
    
    src - a buffer containing the n-byte array representing an integer in big-endian byte order
    
    off - the offset within the buffer
    
    len - the number of bytes
    
    Returns:
    
    the integer
  - intToTwoBytes
```
public static byte[] intToTwoBytes(int val)
```
    Transforms a 16-bit integer into a two-byte array in big-endian byte order (the big end, most significant byte, is stored first, at the lowest storage address).
    
    Parameters:
    
    val - the 16-bit integer
    
    Returns:
    
    a two-byte array representing the given integer, in big-endian byte order
  - intToTwoBytes
```
public static void intToTwoBytes(int val,
                                 byte[] dst,
                                 int off)
```
    Writes a 16-bit integer into a two-byte array in big-endian byte order (the big end, most significant byte, is stored first, at the lowest storage address).
    
    Parameters:
    
    val - the 16-bit integer
    
    dst - a buffer for the two-byte big-endian representation of the given integer
    
    off - the offset within the buffer
  - intToFourBytes
```
public static byte[] intToFourBytes(long val)
```
    Transforms a 32-bit integer into a four-byte array in big-endian byte order (the big end, most significant byte, is stored first, at the lowest storage address).
    
    Parameters:
    
    val - the 32-bit integer
    
    Returns:
    
    a four-byte array representing the given integer, in big-endian byte order
  - intToFourBytes
```
public static void intToFourBytes(long val,
                                  byte[] dst,
                                  int off)
```
    Transforms a 32-bit integer into a four-byte array in big-endian byte order (the big end, most significant byte, is stored first, at the lowest storage address).
    
    Parameters:
    
    val - the 32-bit integer
    
    dst - a buffer for the four-byte big-endian representation of the given integer
    
    off - the offset within the buffer
  - intToSixBytes
```
public static byte[] intToSixBytes(long val)
```
    Transforms a 48-bit integer into a six-byte array in big-endian byte order (the big end, most significant byte, is stored first, at the lowest storage address).
    
    Parameters:
    
    val - the 48-bit integer
    
    Returns:
    
    a six-byte array representing the given integer, in big-endian byte order
  - intToSixBytes
```
public static void intToSixBytes(long val,
                                 byte[] dst,
                                 int off)
```
    Transforms a 48-bit integer into a six-byte array in big-endian byte order (the big end, most significant byte, is stored first, at the lowest storage address).
    
    Parameters:
    
    val - the 48-bit integer
    
    dst - a buffer for the six-byte big-endian representation of the given integer
    
    off - the offset within the buffer
  - intToEightBytes
```
public static byte[] intToEightBytes(long val)
```
    Transforms a 64-bit signed integer (as long) into an eight-byte array in big-endian byte order (the big end, most significant byte, is stored first, at the lowest storage address).
    
    Parameters:
    
    val - the 64-bit integer
    
    Returns:
    
    an eight-byte array representing the given integer, in big-endian byte order
  - intToEightBytes
```
public static void intToEightBytes(long val,
                                   byte[] dst,
                                   int off)
```
    Transforms a 64-bit signed integer (as long) into an eight-byte array in big-endian byte order (the big end, most significant byte, is stored first, at the lowest storage address).
    
    Parameters:
    
    val - the 64-bit integer
    
    dst - a buffer for the eight-byte big-endian representation of the given integer
    
    off - the offset within the buffer
  - intToNBytes
```
public static byte[] intToNBytes(long val,
                                 int len)
```
    Transforms an integer into an n-byte array in big-endian byte order (the big end, most significant byte, is stored first, at the lowest storage address).
    
    Parameters:
    
    val - the integer
    
    len - the number of bytes
    
    Returns:
    
    an n-byte array representing the given integer, in big-endian byte order
  - intToNBytes
```
public static void intToNBytes(long val,
                               byte[] dst,
                               int off,
                               int len)
```
    Transforms an integer into an n-byte array in big-endian byte order (the big end, most significant byte, is stored first, at the lowest storage address).
    
    Parameters:
    
    val - the integer
    
    dst - a buffer for the n-byte big-endian representation of the given integer
    
    off - the offset within the buffer
    
    len - the number of bytes
  - fourBytesToIntLittleEndian
```
public static long fourBytesToIntLittleEndian(byte[] src)
```
    Transforms a four-byte array into a 32-bit integer; the four-byte array is in little-endian byte order (the little end, least significant byte, is stored first, at the lowest storage address).
    
    Parameters:
    
    src - the four-byte array representing an integer in little-endian byte order
    
    Returns:
    
    the 32-bit integer
  - fourBytesToIntLittleEndian
```
public static long fourBytesToIntLittleEndian(byte[] src,
                                              int off)
```
    Transforms a four-byte array into a 32-bit integer; the four-byte array is in little-endian byte order (the little end, least significant byte, is stored first, at the lowest storage address).
    
    Parameters:
    
    src - a buffer containing the four-byte array representing an integer in little-endian byte order
    
    off - the offset within the buffer
    
    Returns:
    
    the 32-bit integer
  - intToFourBytesLittleEndian
```
public static byte[] intToFourBytesLittleEndian(long n)
```
    Transforms a 32-bit integer into a four-byte array in little-endian byte order (the little end, least significant byte, is stored first, at the lowest storage address).
    
    Parameters:
    
    n - the 32-bit integer
    
    Returns:
    
    a four-byte array representing the given integer, in little-endian byte order
  - intToFourBytesLittleEndian
```
public static void intToFourBytesLittleEndian(long n,
                                              byte[] dst,
                                              int off)
```
    Transforms a 32-bit integer into a four-byte array copied into a given buffer; the 4-bytes array is in little-endian byte order (the little end, least significant byte, is stored first, at the lowest storage address).
    
    Parameters:
    
    n - the 32-bit integer
    
    dst - a buffer for the four-byte little-endian representation of the given integer
    
    off - the offset within the buffer
  - invertByteOrder
```
public static void invertByteOrder(byte[] buf)
```
    Modifies the given array inverting the byte order. It transforms little-endian to big-endian n-bytes array (and vice versa).
    
    Parameters:
    
    buf - the buffer containing the array
  - inc
```
public static void inc(byte[] buf)
```
    Adds 1 to the number represented by the given array of bytes, module 2^n, where n is the length (in bits) of the array.
    
    Parameters:
    
    buf - the buffer containing the array
  - twoBytesToInt
```
public static int twoBytesToInt(byte b_high,
                                byte b_low)
```
    Gets a 16-bit integer from two bytes.
    
    Parameters:
    
    b_high - high byte
    
    b_low - low byte
    
    Returns:
    
    the 16-bit integer value
  - fourBytesToLong
```
public static long fourBytesToLong(byte b3,
                                   byte b2,
                                   byte b1,
                                   byte b0)
```
    Gets a 32-bit integer (as long) from four bytes.
    
    Parameters:
    
    b3 - the fourth byte
    
    b2 - the third byte
    
    b1 - the second byte
    
    b0 - the first byte
    
    Returns:
    
    the 32-bit integer value

Class ByteUtils

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

ByteUtils

Method Detail

copy

copy

copy

copy

copy

match

match

compare

compare

indexOf

indexOf

fill

fill

concat

concat

concat

concat

uByte

uInt

bytesToHexString

bytesToHexString

bytesToFormattedHexString

bytesToFormattedHexString

trimHexString

hexStringToBytes

hexStringToBytes

formattedHexStringToBytes

formattedHexStringToBytes

formattedHexStringToBytes

asHex

asHex

hexToBytes

hexToBytes

hexToBytes

bytesToAsciiString

bytesToAsciiString

asAscii

asAscii

bytesToBinString

bytesToBinString

asBinary

asBinary

twoBytesToInt

twoBytesToInt

fourBytesToInt

fourBytesToInt

eightBytesToInt

eightBytesToInt

nBytesToInt

nBytesToInt

intToTwoBytes

intToTwoBytes

intToFourBytes

intToFourBytes

intToSixBytes

intToSixBytes

intToEightBytes

intToEightBytes

intToNBytes

intToNBytes

fourBytesToIntLittleEndian

fourBytesToIntLittleEndian

intToFourBytesLittleEndian

intToFourBytesLittleEndian

invertByteOrder

inc

twoBytesToInt

fourBytesToLong