Bytes (Cask Common Libraries: Core 0.8.0 API)

java.lang.Object
- co.cask.common.Bytes

```
public class Bytes
extends Object
```
Utility class that handles byte arrays, conversions to/from other types, comparisons, hash code generation, manufacturing keys for HashMaps or HashSets, etc.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class Bytes.ByteArrayComparator
Byte array comparator class.

Nested Classes
Modifier and Type	Class and Description
`static class`	`Bytes.ByteArrayComparator` Byte array comparator class.

Field Summary

Fields
Modifier and Type	Field and Description
`static Comparator<byte[]>`	`BYTES_COMPARATOR` Pass this to TreeMaps where byte [] are keys.
`static byte[]`	`EMPTY_BYTE_ARRAY` Byte array of size zero.
`static int`	`SIZEOF_BOOLEAN` Size of boolean in bytes.
`static int`	`SIZEOF_BYTE` Size of byte in bytes.
`static int`	`SIZEOF_CHAR` Size of char in bytes.
`static int`	`SIZEOF_DOUBLE` Size of double in bytes.
`static int`	`SIZEOF_FLOAT` Size of float in bytes.
`static int`	`SIZEOF_INT` Size of int in bytes.
`static int`	`SIZEOF_LONG` Size of long in bytes.
`static int`	`SIZEOF_SHORT` Size of short in bytes.
`static String`	`UTF8_ENCODING` When we encode strings, we always specify UTF8 encoding.

Constructor Summary

Constructors
Constructor and Description

Bytes()

Constructors
Constructor and Description
`Bytes()`

Method Summary

Methods
Modifier and Type	Method and Description
`static byte[]`	`add(byte[] a, byte[] b)` Concatenate two byte arrays.
`static byte[]`	`add(byte[] a, byte[] b, byte[] c)` Concatenate three byte arrays.
`static int`	`compareTo(byte[] left, byte[] right)` Lexicographically compare two arrays.
`static int`	`compareTo(byte[] buffer1, int offset1, int length1, byte[] buffer2, int offset2, int length2)` Lexicographically compare two arrays.
`static byte[]`	`concat(byte[]... arrays)` Returns the values from each provided array combined into a single array.
`static boolean`	`equals(byte[] left, byte[] right)` Checks two byte arrays for equality.
`static boolean`	`equals(byte[] left, int leftOffset, int leftLen, byte[] right, int rightOffset, int rightLen)` Checks segments of two byte arrays for equality.
`static byte[]`	`getBytes(ByteBuffer buf)` This method will get a sequence of bytes from pos -> limit, but will restore pos after.
`static int`	`hashBytes(byte[] bytes, int length)` Compute hash for binary data.
`static int`	`hashBytes(byte[] bytes, int offset, int length)` Compute hash for binary data.
`static int`	`hashCode(byte[] b)` Compute hash for binary data.
`static int`	`hashCode(byte[] b, int length)` Compute hash for binary data.
`static int`	`hashCode(byte[] bytes, int offset, int length)`
`static byte[]`	`head(byte[] a, int length)` Returns first `length` bytes from byte array.
`static <T> NavigableMap<byte[],T>`	`immutableSortedMapOf(byte[] key, T value)` Creates immutable sorted map with one entry with given key and value.
`static <T> NavigableMap<byte[],T>`	`immutableSortedMapOf(byte[] key1, T value1, byte[] key2, T value2)` Creates immutable sorted map with two entries with given keys and values.
`static byte[]`	`incrementBytes(byte[] value, long amount)` Bytewise binary increment/deincrement of long contained in byte array on given amount.
`static Iterable<byte[]>`	`iterateOnSplits(byte[] a, byte[] b, boolean inclusive, int num)` Iterate over keys within the passed range.
`static Iterable<byte[]>`	`iterateOnSplits(byte[] a, byte[] b, int num)` Iterate over keys within the passed range, splitting at an [a,b) boundary.
`static Integer`	`mapKey(byte[] b)` Returns a hash of a byte array as an Integer that can be used as key in Maps.
`static Integer`	`mapKey(byte[] b, int length)` Returns a hash of a byte array segment as an Integer that can be used as key in Maps.
`static byte[]`	`padHead(byte[] a, int length)` Return a byte array with value in `a` plus `length` prepended 0 bytes.
`static byte[]`	`padTail(byte[] a, int length)` Return a byte array with value in `a` plus `length` appended 0 bytes.
`static int`	`putBigDecimal(byte[] bytes, int offset, BigDecimal val)` Put a BigDecimal value out to the specified byte array position.
`static int`	`putByte(byte[] bytes, int offset, byte b)` Write a single byte out to the specified byte array position.
`static int`	`putBytes(byte[] tgtBytes, int tgtOffset, byte[] srcBytes, int srcOffset, int srcLength)` Put bytes at the specified byte array position.
`static int`	`putDouble(byte[] bytes, int offset, double d)` Put a double value out to the specified byte array position.
`static int`	`putFloat(byte[] bytes, int offset, float f)` Put a float value out to the specified byte array position.
`static int`	`putInt(byte[] bytes, int offset, int val)` Put an int value out to the specified byte array position.
`static int`	`putLong(byte[] bytes, int offset, long val)` Put a long value out to the specified byte array position.
`static int`	`putShort(byte[] bytes, int offset, short val)` Put a short value out to the specified byte array position.
`static byte[][]`	`split(byte[] a, byte[] b, boolean inclusive, int num)` Split passed range.
`static byte[][]`	`split(byte[] a, byte[] b, int num)` Split passed range.
`static boolean`	`startsWith(byte[] bytes, byte[] prefix)` Return true if the byte array on the right is a prefix of the byte array on the left.
`static byte[]`	`stopKeyForPrefix(byte[] prefix)` Returns the given prefix, incremented by one, in the form that will be suitable for prefix matching.
`static byte[]`	`tail(byte[] a, int length)` Returns last `length` bytes from byte array.
`static BigDecimal`	`toBigDecimal(byte[] bytes)` Converts a byte array to a BigDecimal.
`static BigDecimal`	`toBigDecimal(byte[] bytes, int offset, int length)` Converts a byte array to a BigDecimal value.
`static byte`	`toBinaryFromHex(byte ch)` Takes a ASCII digit in the range A-F0-9 and returns the corresponding integer/ordinal value.
`static boolean`	`toBoolean(byte[] b)` Reverses `toBytes(boolean)`.
`static byte[][]`	`toByteArrays(byte[] column)` Returns an array of byte arrays where first and only entry is.
`static byte[][]`	`toByteArrays(String column)` Returns an array of byte arrays where first and only entry is.
`static byte[][]`	`toByteArrays(String[] t)` Returns an array of byte arrays made from passed array of Text.
`static byte[]`	`toBytes(BigDecimal val)` Convert a BigDecimal value to a byte array.
`static byte[]`	`toBytes(boolean b)` Convert a boolean to a byte array.
`static byte[]`	`toBytes(ByteBuffer bb)` Returns a new byte array, copied from the passed ByteBuffer.
`static byte[]`	`toBytes(double d)` Serialize a double as the IEEE 754 double format output.
`static byte[]`	`toBytes(float f)`
`static byte[]`	`toBytes(int val)` Convert an int value to a byte array.
`static byte[]`	`toBytes(long val)` Convert a long value to a byte array using big-endian.
`static byte[]`	`toBytes(short val)` Convert a short value to a byte array of `SIZEOF_SHORT` bytes long.
`static byte[]`	`toBytes(String s)` Converts a string to a UTF-8 byte array.
`static byte[]`	`toBytesBinary(String in)`
`static double`	`toDouble(byte[] bytes)` Return double made from passed bytes.
`static double`	`toDouble(byte[] bytes, int offset)` Return double made from passed bytes.
`static float`	`toFloat(byte[] bytes)` Presumes float encoded as IEEE 754 floating-point "single format".
`static float`	`toFloat(byte[] bytes, int offset)` Presumes float encoded as IEEE 754 floating-point "single format".
`static String`	`toHexString(byte[] bytes)` Returns a string containing each byte, in order, as a two-digit unsigned hexadecimal number in lower case.
`static int`	`toInt(byte[] bytes)` Converts a byte array to an int value.
`static int`	`toInt(byte[] bytes, int offset)` Converts a byte array to an int value.
`static int`	`toInt(byte[] bytes, int offset, int length)` Converts a byte array to an int value.
`static long`	`toLong(byte[] bytes)` Converts a byte array to a long value.
`static long`	`toLong(byte[] bytes, int offset)` Converts a byte array to a long value.
`static long`	`toLong(byte[] bytes, int offset, int length)` Converts a byte array to a long value.
`static short`	`toShort(byte[] bytes)` Converts a byte array to a short value.
`static short`	`toShort(byte[] bytes, int offset)` Converts a byte array to a short value.
`static short`	`toShort(byte[] bytes, int offset, int length)` Converts a byte array to a short value.
`static String`	`toString(byte[] b)` This method will convert utf8 encoded bytes into a string.
`static String`	`toString(byte[] b, int off, int len)` This method will convert utf8 encoded bytes into a string.
`static String`	`toString(byte[] b1, String sep, byte[] b2)` Joins two byte arrays together using a separator.
`static String`	`toString(ByteBuffer buf)` This method will convert the remaining bytes of a UTF8 encoded byte buffer into a string.
`static String`	`toStringBinary(byte[] b)` Write a printable representation of a byte array.
`static String`	`toStringBinary(byte[] b, int off, int len)` Write a printable representation of a byte array.
`static String`	`toStringBinary(ByteBuffer buf)` Converts the given byte buffer, from its array offset to its limit, to a string.
`static void`	`writeStringFixedSize(DataOutput out, String s, int size)` Writes a string as a fixed-size field, padded with zeros.

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

- Field Detail
  - SIZEOF_BOOLEAN
```
public static final int SIZEOF_BOOLEAN
```
    Size of boolean in bytes.
    
    See Also:
    Constant Field Values
  - SIZEOF_BYTE
```
public static final int SIZEOF_BYTE
```
    Size of byte in bytes.
    
    See Also:
    Constant Field Values
  - SIZEOF_CHAR
```
public static final int SIZEOF_CHAR
```
    Size of char in bytes.
    
    See Also:
    Constant Field Values
  - SIZEOF_DOUBLE
```
public static final int SIZEOF_DOUBLE
```
    Size of double in bytes.
    
    See Also:
    Constant Field Values
  - SIZEOF_FLOAT
```
public static final int SIZEOF_FLOAT
```
    Size of float in bytes.
    
    See Also:
    Constant Field Values
  - SIZEOF_INT
```
public static final int SIZEOF_INT
```
    Size of int in bytes.
    
    See Also:
    Constant Field Values
  - SIZEOF_LONG
```
public static final int SIZEOF_LONG
```
    Size of long in bytes.
    
    See Also:
    Constant Field Values
  - SIZEOF_SHORT
```
public static final int SIZEOF_SHORT
```
    Size of short in bytes.
    
    See Also:
    Constant Field Values
  - BYTES_COMPARATOR
```
public static final Comparator<byte[]> BYTES_COMPARATOR
```
    Pass this to TreeMaps where byte [] are keys.
  - UTF8_ENCODING
```
public static final String UTF8_ENCODING
```
    When we encode strings, we always specify UTF8 encoding.
    
    See Also:
    Constant Field Values
  - EMPTY_BYTE_ARRAY
```
public static final byte[] EMPTY_BYTE_ARRAY
```
    Byte array of size zero.
- Constructor Detail
  - Bytes
```
public Bytes()
```
- Method Detail
  - putBytes
```
public static int putBytes(byte[] tgtBytes,
           int tgtOffset,
           byte[] srcBytes,
           int srcOffset,
           int srcLength)
```
    Put bytes at the specified byte array position.
    
    Parameters:
    tgtBytes - the byte array
    tgtOffset - position in the array
    srcBytes - array to write out
    srcOffset - source offset
    srcLength - source length
    
    Returns:
    incremented offset
  - putByte
```
public static int putByte(byte[] bytes,
          int offset,
          byte b)
```
    Write a single byte out to the specified byte array position.
    
    Parameters:
    bytes - the byte array
    offset - position in the array
    b - byte to write out
    
    Returns:
    incremented offset
  - toBytes
```
public static byte[] toBytes(ByteBuffer bb)
```
    Returns a new byte array, copied from the passed ByteBuffer.
    
    Parameters:
    bb - A ByteBuffer
    
    Returns:
    the byte array
  - toString
```
public static String toString(byte[] b)
```
    This method will convert utf8 encoded bytes into a string. If an UnsupportedEncodingException occurs, this method will eat it and return null instead.
    
    Parameters:
    b - Presumed UTF-8 encoded byte array.
    
    Returns:
    String made from b
  - toString
```
public static String toString(byte[] b1,
              String sep,
              byte[] b2)
```
    Joins two byte arrays together using a separator.
    
    Parameters:
    b1 - The first byte array.
    sep - The separator to use.
    b2 - The second byte array.
  - toString
```
public static String toString(byte[] b,
              int off,
              int len)
```
    This method will convert utf8 encoded bytes into a string. If an UnsupportedEncodingException occurs, this method will eat it and return null instead.
    
    Parameters:
    b - Presumed UTF-8 encoded byte array.
    off - offset into array
    len - length of utf-8 sequence
    
    Returns:
    String made from b or null
  - toString
```
public static String toString(ByteBuffer buf)
```
    This method will convert the remaining bytes of a UTF8 encoded byte buffer into a string.
    
    Parameters:
    buf - Presumed UTF-8 encoded byte buffer.
    
    Returns:
    String made from buf or null
  - toStringBinary
```
public static String toStringBinary(byte[] b)
```
    Write a printable representation of a byte array.
    
    Parameters:
    b - byte array
    
    Returns:
    string
    See Also:
    toStringBinary(byte[], int, int)
  - toHexString
```
public static String toHexString(byte[] bytes)
```
    Returns a string containing each byte, in order, as a two-digit unsigned hexadecimal number in lower case.
  - toStringBinary
```
public static String toStringBinary(ByteBuffer buf)
```
    Converts the given byte buffer, from its array offset to its limit, to a string. The position and the mark are ignored.
    
    Parameters:
    buf - a byte buffer
    
    Returns:
    a string representation of the buffer's binary contents
  - toStringBinary
```
public static String toStringBinary(byte[] b,
                    int off,
                    int len)
```
    Write a printable representation of a byte array. Non-printable characters are hex escaped in the format \\x%02X, eg: \x00 \x05 etc
    
    Parameters:
    b - array to write out
    off - offset to start at
    len - length to write
    
    Returns:
    string output
  - toBinaryFromHex
```
public static byte toBinaryFromHex(byte ch)
```
    Takes a ASCII digit in the range A-F0-9 and returns the corresponding integer/ordinal value.
    
    Parameters:
    ch - The hex digit.
    
    Returns:
    The converted hex value as a byte.
  - toBytesBinary
```
public static byte[] toBytesBinary(String in)
```
  - toBytes
```
public static byte[] toBytes(String s)
```
    Converts a string to a UTF-8 byte array.
    
    Parameters:
    s - string
    
    Returns:
    the byte array
  - toBytes
```
public static byte[] toBytes(boolean b)
```
    Convert a boolean to a byte array. True becomes -1 and false becomes 0.
    
    Parameters:
    b - value
    
    Returns:
    b encoded in a byte array.
  - toBoolean
```
public static boolean toBoolean(byte[] b)
```
    Reverses toBytes(boolean).
    
    Parameters:
    b - array
    
    Returns:
    True or false.
  - toBytes
```
public static byte[] toBytes(long val)
```
    Convert a long value to a byte array using big-endian.
    
    Parameters:
    val - value to convert
    
    Returns:
    the byte array
  - toLong
```
public static long toLong(byte[] bytes)
```
    Converts a byte array to a long value. Reverses toBytes(long)
    
    Parameters:
    bytes - array
    
    Returns:
    the long value
  - toLong
```
public static long toLong(byte[] bytes,
          int offset)
```
    Converts a byte array to a long value. Assumes there will be SIZEOF_LONG bytes available.
    
    Parameters:
    bytes - bytes
    offset - offset
    
    Returns:
    the long value
  - toLong
```
public static long toLong(byte[] bytes,
          int offset,
          int length)
```
    Converts a byte array to a long value.
    
    Parameters:
    bytes - array of bytes
    offset - offset into array
    length - length of data (must be SIZEOF_LONG)
    
    Returns:
    the long value
    
    Throws:
    
    IllegalArgumentException - if length is not SIZEOF_LONG or if there's not enough room in the array at the offset indicated.
  - putLong
```
public static int putLong(byte[] bytes,
          int offset,
          long val)
```
    Put a long value out to the specified byte array position.
    
    Parameters:
    bytes - the byte array
    offset - position in the array
    val - long to write out
    
    Returns:
    incremented offset
    
    Throws:
    
    IllegalArgumentException - if the byte array given doesn't have enough room at the offset specified.
  - toFloat
```
public static float toFloat(byte[] bytes)
```
    Presumes float encoded as IEEE 754 floating-point "single format".
    
    Parameters:
    bytes - byte array
    
    Returns:
    Float made from passed byte array.
  - toFloat
```
public static float toFloat(byte[] bytes,
            int offset)
```
    Presumes float encoded as IEEE 754 floating-point "single format".
    
    Parameters:
    bytes - array to convert
    offset - offset into array
    
    Returns:
    Float made from passed byte array.
  - putFloat
```
public static int putFloat(byte[] bytes,
           int offset,
           float f)
```
    Put a float value out to the specified byte array position.
    
    Parameters:
    bytes - byte array
    offset - offset to write to
    f - float value
    
    Returns:
    New offset in bytes
  - toBytes
```
public static byte[] toBytes(float f)
```
    Parameters:
    f - float value
    
    Returns:
    the float represented as byte []
  - toDouble
```
public static double toDouble(byte[] bytes)
```
    Return double made from passed bytes.
    
    Parameters:
    bytes - byte array
    
    Returns:
    Return double made from passed bytes.
  - toDouble
```
public static double toDouble(byte[] bytes,
              int offset)
```
    Return double made from passed bytes.
    
    Parameters:
    bytes - byte array
    offset - offset where double is
    
    Returns:
    Return double made from passed bytes.
  - putDouble
```
public static int putDouble(byte[] bytes,
            int offset,
            double d)
```
    Put a double value out to the specified byte array position.
    
    Parameters:
    bytes - byte array
    offset - offset to write to
    d - value
    
    Returns:
    New offset into array bytes
  - toBytes
```
public static byte[] toBytes(double d)
```
    Serialize a double as the IEEE 754 double format output. The resultant array will be 8 bytes long.
    
    Parameters:
    d - value
    
    Returns:
    the double represented as byte []
  - toBytes
```
public static byte[] toBytes(int val)
```
    Convert an int value to a byte array.
    
    Parameters:
    val - value
    
    Returns:
    the byte array
  - toInt
```
public static int toInt(byte[] bytes)
```
    Converts a byte array to an int value.
    
    Parameters:
    bytes - byte array
    
    Returns:
    the int value
  - toInt
```
public static int toInt(byte[] bytes,
        int offset)
```
    Converts a byte array to an int value.
    
    Parameters:
    bytes - byte array
    offset - offset into array
    
    Returns:
    the int value
  - toInt
```
public static int toInt(byte[] bytes,
        int offset,
        int length)
```
    Converts a byte array to an int value.
    
    Parameters:
    bytes - byte array
    offset - offset into array
    length - length of int (has to be SIZEOF_INT)
    
    Returns:
    the int value
    
    Throws:
    
    IllegalArgumentException - if length is not SIZEOF_INT or if there's not enough room in the array at the offset indicated.
  - putInt
```
public static int putInt(byte[] bytes,
         int offset,
         int val)
```
    Put an int value out to the specified byte array position.
    
    Parameters:
    bytes - the byte array
    offset - position in the array
    val - int to write out
    
    Returns:
    incremented offset
    
    Throws:
    
    IllegalArgumentException - if the byte array given doesn't have enough room at the offset specified.
  - toBytes
```
public static byte[] toBytes(short val)
```
    Convert a short value to a byte array of SIZEOF_SHORT bytes long.
    
    Parameters:
    val - value
    
    Returns:
    the byte array
  - toShort
```
public static short toShort(byte[] bytes)
```
    Converts a byte array to a short value.
    
    Parameters:
    bytes - byte array
    
    Returns:
    the short value
  - toShort
```
public static short toShort(byte[] bytes,
            int offset)
```
    Converts a byte array to a short value.
    
    Parameters:
    bytes - byte array
    offset - offset into array
    
    Returns:
    the short value
  - toShort
```
public static short toShort(byte[] bytes,
            int offset,
            int length)
```
    Converts a byte array to a short value.
    
    Parameters:
    bytes - byte array
    offset - offset into array
    length - length, has to be SIZEOF_SHORT
    
    Returns:
    the short value
    
    Throws:
    
    IllegalArgumentException - if length is not SIZEOF_SHORT or if there's not enough room in the array at the offset indicated.
  - getBytes
```
public static byte[] getBytes(ByteBuffer buf)
```
    This method will get a sequence of bytes from pos -> limit, but will restore pos after.
    
    Parameters:
    buf -
    
    Returns:
    byte array
  - putShort
```
public static int putShort(byte[] bytes,
           int offset,
           short val)
```
    Put a short value out to the specified byte array position.
    
    Parameters:
    bytes - the byte array
    offset - position in the array
    val - short to write out
    
    Returns:
    incremented offset
    
    Throws:
    
    IllegalArgumentException - if the byte array given doesn't have enough room at the offset specified.
  - toBytes
```
public static byte[] toBytes(BigDecimal val)
```
    Convert a BigDecimal value to a byte array.
    
    Parameters:
    val -
    
    Returns:
    the byte array
  - toBigDecimal
```
public static BigDecimal toBigDecimal(byte[] bytes)
```
    Converts a byte array to a BigDecimal.
    
    Parameters:
    bytes -
    
    Returns:
    the char value
  - toBigDecimal
```
public static BigDecimal toBigDecimal(byte[] bytes,
                      int offset,
                      int length)
```
    Converts a byte array to a BigDecimal value.
    
    Parameters:
    bytes -
    offset -
    length -
    
    Returns:
    the char value
  - putBigDecimal
```
public static int putBigDecimal(byte[] bytes,
                int offset,
                BigDecimal val)
```
    Put a BigDecimal value out to the specified byte array position.
    
    Parameters:
    bytes - the byte array
    offset - position in the array
    val - BigDecimal to write out
    
    Returns:
    incremented offset
  - compareTo
```
public static int compareTo(byte[] left,
            byte[] right)
```
    Lexicographically compare two arrays.
    
    Parameters:
    left - left operand
    right - right operand
    
    Returns:
    0 if equal, < 0 if left is less than right, etc.
  - compareTo
```
public static int compareTo(byte[] buffer1,
            int offset1,
            int length1,
            byte[] buffer2,
            int offset2,
            int length2)
```
    Lexicographically compare two arrays.
    
    Parameters:
    buffer1 - left operand
    buffer2 - right operand
    offset1 - Where to start comparing in the left buffer
    offset2 - Where to start comparing in the right buffer
    length1 - How much to compare from the left buffer
    length2 - How much to compare from the right buffer
    
    Returns:
    0 if equal, < 0 if left is less than right, etc.
  - equals
```
public static boolean equals(byte[] left,
             byte[] right)
```
    Checks two byte arrays for equality.
    
    Parameters:
    left - left operand
    right - right operand
    
    Returns:
    True if equal
  - equals
```
public static boolean equals(byte[] left,
             int leftOffset,
             int leftLen,
             byte[] right,
             int rightOffset,
             int rightLen)
```
    Checks segments of two byte arrays for equality.
    
    Parameters:
    left - left operand
    leftOffset - offset from which to start comparison
    leftLen - length of left segment
    right - right operand
    rightOffset - offset from which to start comparison
    rightLen - length of right segment
    
    Returns:
    True if two segments are equal
  - startsWith
```
public static boolean startsWith(byte[] bytes,
                 byte[] prefix)
```
    Return true if the byte array on the right is a prefix of the byte array on the left.
  - hashCode
```
public static int hashCode(byte[] b)
```
    Compute hash for binary data.
    
    Parameters:
    b - bytes to hash
    
    Returns:
    Runs hashBytes(byte[], int) on the passed in array.
  - hashCode
```
public static int hashCode(byte[] b,
           int length)
```
    Compute hash for binary data.
    
    Parameters:
    b - value
    length - length of the value
    
    Returns:
    Runs hashBytes(byte[], int) on the passed in array.
  - hashBytes
```
public static int hashBytes(byte[] bytes,
            int offset,
            int length)
```
    Compute hash for binary data.
  - hashBytes
```
public static int hashBytes(byte[] bytes,
            int length)
```
    Compute hash for binary data.
  - mapKey
```
public static Integer mapKey(byte[] b)
```
    Returns a hash of a byte array as an Integer that can be used as key in Maps.
    
    Parameters:
    b - bytes to hash
    
    Returns:
    A hash of b as an Integer that can be used as key in Maps.
  - mapKey
```
public static Integer mapKey(byte[] b,
             int length)
```
    Returns a hash of a byte array segment as an Integer that can be used as key in Maps.
    
    Parameters:
    b - bytes to hash
    length - length to hash
    
    Returns:
    A hash of b as an Integer that can be used as key in Maps.
  - add
```
public static byte[] add(byte[] a,
         byte[] b)
```
    Concatenate two byte arrays.
    
    Parameters:
    a - lower half
    b - upper half
    
    Returns:
    New array that has a in lower half and b in upper half.
  - add
```
public static byte[] add(byte[] a,
         byte[] b,
         byte[] c)
```
    Concatenate three byte arrays.
    
    Parameters:
    a - first third
    b - second third
    c - third third
    
    Returns:
    New array made from a, b and c
  - concat
```
public static byte[] concat(byte[]... arrays)
```
    Returns the values from each provided array combined into a single array. For example, concat(new byte[] {a, b}, new byte[] {}, new byte[] {c} returns the array {a, b, c}. This method is copied from google guava library.
    
    Parameters:
    arrays - zero or more byte arrays
    
    Returns:
    a single array containing all the values from the source arrays, in order
  - head
```
public static byte[] head(byte[] a,
          int length)
```
    Returns first length bytes from byte array.
    
    Parameters:
    a - array
    length - amount of bytes to grab
    
    Returns:
    First length bytes from a
  - tail
```
public static byte[] tail(byte[] a,
          int length)
```
    Returns last length bytes from byte array.
    
    Parameters:
    a - array
    length - amount of bytes to snarf
    
    Returns:
    Last length bytes from a
  - padHead
```
public static byte[] padHead(byte[] a,
             int length)
```
    Return a byte array with value in a plus length prepended 0 bytes.
    
    Parameters:
    a - array
    length - new array size
    
    Returns:
    Value in a plus length prepended 0 bytes
  - padTail
```
public static byte[] padTail(byte[] a,
             int length)
```
    Return a byte array with value in a plus length appended 0 bytes.
    
    Parameters:
    a - array
    length - new array size
    
    Returns:
    Value in a plus length appended 0 bytes
  - split
```
public static byte[][] split(byte[] a,
             byte[] b,
             int num)
```
    Split passed range. Expensive operation relatively. Uses BigInteger math. Useful splitting ranges for MapReduce jobs.
    
    Parameters:
    a - Beginning of range
    b - End of range
    num - Number of times to split range. Pass 1 if you want to split the range in two; i.e. one split.
    
    Returns:
    Array of dividing values
  - split
```
public static byte[][] split(byte[] a,
             byte[] b,
             boolean inclusive,
             int num)
```
    Split passed range. Expensive operation relatively. Uses BigInteger math. Useful splitting ranges for MapReduce jobs.
    
    Parameters:
    a - Beginning of range
    b - End of range
    inclusive - Whether the end of range is prefix-inclusive or is considered an exclusive boundary. Automatic splits are generally exclusive and manual splits with an explicit range utilize an inclusive end of range.
    num - Number of times to split range. Pass 1 if you want to split the range in two; i.e. one split.
    
    Returns:
    Array of dividing values
  - iterateOnSplits
```
public static Iterable<byte[]> iterateOnSplits(byte[] a,
                               byte[] b,
                               int num)
```
    Iterate over keys within the passed range, splitting at an [a,b) boundary.
  - iterateOnSplits
```
public static Iterable<byte[]> iterateOnSplits(byte[] a,
                               byte[] b,
                               boolean inclusive,
                               int num)
```
    Iterate over keys within the passed range.
  - hashCode
```
public static int hashCode(byte[] bytes,
           int offset,
           int length)
```
    Parameters:
    bytes - array to hash
    offset - offset to start from
    length - length to hash
  - toByteArrays
```
public static byte[][] toByteArrays(String[] t)
```
    Returns an array of byte arrays made from passed array of Text.
    
    Parameters:
    t - operands
    
    Returns:
    Array of byte arrays made from passed array of Text
  - toByteArrays
```
public static byte[][] toByteArrays(String column)
```
    Returns an array of byte arrays where first and only entry is. column
    
    Parameters:
    column - operand
    
    Returns:
    An array of byte arrays where first and only entry is column
  - toByteArrays
```
public static byte[][] toByteArrays(byte[] column)
```
    Returns an array of byte arrays where first and only entry is. column
    
    Parameters:
    column - operand
    
    Returns:
    An array of byte arrays where first and only entry is column
  - incrementBytes
```
public static byte[] incrementBytes(byte[] value,
                    long amount)
```
    Bytewise binary increment/deincrement of long contained in byte array on given amount.
    
    Parameters:
    value - - array of bytes containing long (length <= SIZEOF_LONG)
    amount - value will be incremented on (deincremented if negative)
    
    Returns:
    array of bytes containing incremented long (length == SIZEOF_LONG)
  - writeStringFixedSize
```
public static void writeStringFixedSize(DataOutput out,
                        String s,
                        int size)
                                 throws IOException
```
    Writes a string as a fixed-size field, padded with zeros.
    
    Throws:
    
    IOException
  - stopKeyForPrefix
```
@Nullable
public static byte[] stopKeyForPrefix(byte[] prefix)
```
    Returns the given prefix, incremented by one, in the form that will be suitable for prefix matching.
    
    Parameters:
    prefix - the prefix to increment for the stop key
    
    Returns:
    the stop key to use (may be null if the prefix cannot be incremented)
  - immutableSortedMapOf
```
public static <T> NavigableMap<byte[],T> immutableSortedMapOf(byte[] key,
                                              T value)
```
    Creates immutable sorted map with one entry with given key and value.
    
    Parameters:
    key - key of the entry
    value - value of the entry
    
    Returns:
    instance of NavigableMap
  - immutableSortedMapOf
```
public static <T> NavigableMap<byte[],T> immutableSortedMapOf(byte[] key1,
                                              T value1,
                                              byte[] key2,
                                              T value2)
```
    Creates immutable sorted map with two entries with given keys and values.
    
    Parameters:
    key1 - key of the first entry
    value1 - value of the first entry
    key2 - key of the second entry
    value2 - value of the second entry
    
    Returns:
    instance of NavigableMap

Class Bytes

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

SIZEOF_BOOLEAN

SIZEOF_BYTE

SIZEOF_CHAR

SIZEOF_DOUBLE

SIZEOF_FLOAT

SIZEOF_INT

SIZEOF_LONG

SIZEOF_SHORT

BYTES_COMPARATOR

UTF8_ENCODING

EMPTY_BYTE_ARRAY

Constructor Detail

Bytes

Method Detail

putBytes

putByte

toBytes

toString

toString

toString

toString

toStringBinary

toHexString

toStringBinary

toStringBinary

toBinaryFromHex

toBytesBinary

toBytes

toBytes

toBoolean

toBytes

toLong

toLong

toLong

putLong

toFloat

toFloat

putFloat

toBytes

toDouble

toDouble

putDouble

toBytes

toBytes

toInt

toInt

toInt

putInt

toBytes

toShort

toShort

toShort

getBytes

putShort

toBytes

toBigDecimal

toBigDecimal

putBigDecimal

compareTo

compareTo

equals

equals

startsWith

hashCode

hashCode

hashBytes

hashBytes

mapKey

mapKey

add

add

concat

head