java.lang.Object
- com.mapr.org.apache.hadoop.hbase.util.Bytes

```
public class Bytes
extends java.lang.Object
```
Utility class that handles byte arrays, conversions to/from other types, comparisons, hash code generation, manufacturing keys for HashMaps or HashSets, etc. Use this instead of the HBase class when we can not have dependency on HBase artifacts.

Nested Class Summary

Nested Classes
Modifier and Type	Class	Description
`static class`	`Bytes.ByteArrayComparator`	Byte array comparator class.
`static class`	`Bytes.RowEndKeyComparator`	A `Bytes.ByteArrayComparator` that treats the empty array as the largest value.

Field Summary

Fields
Modifier and Type	Field	Description
`static java.util.Comparator<byte[]>`	`BYTES_COMPARATOR`	Pass this to TreeMaps where byte [] are keys.
`static byte[]`	`EMPTY_BYTE_ARRAY`
`static int`	`ESTIMATED_HEAP_TAX`	Estimate of size cost to pay beyond payload in jvm for instance of byte [].
`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

Constructor Summary

Constructors
Constructor Description

Bytes()

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method	Description
`static byte[]`	`add(byte[] a, byte[] b)`
`static byte[]`	`add(byte[] a, byte[] b, byte[] c)`
`static byte[]`	`appendZeroByte(byte[] input)`	Treat the byte[] as an unsigned series of bytes, most significant bits first.
`static int`	`compareTo(byte[] left, byte[] right)`
`static int`	`compareTo(byte[] buffer1, int offset1, int length1, byte[] buffer2, int offset2, int length2)`	Lexicographically compare two arrays.
`static byte[]`	`concatenate(byte[] a, byte[] b)`
`static boolean`	`contains(byte[] array, byte target)`
`static boolean`	`contains(byte[] array, byte[] target)`
`static byte[]`	`copy(byte[] bytes)`	Copy the byte array given in parameter and return an instance of a new byte array with the same length and the same content.
`static byte[]`	`copy(byte[] bytes, int offset, int length)`	Copy the byte array given in parameter and return an instance of a new byte array with the same length and the same content.
`static java.nio.ByteBuffer`	`copyToByteBuffer(java.nio.ByteBuffer bb)`	Copies a direct bytebuffer to a non-direct byte buffer.
`static java.nio.ByteBuffer`	`copyToDirectByteBuffer(java.nio.ByteBuffer bb)`	Copies a non-direct bytebuffer to a direct byte buffer.
`static byte[]`	`createMaxByteArray(int maxByteCount)`	Create a max byte array with the specified max byte count
`static byte[]`	`createStopKeyForPrefix(byte[] prefix)`	Returns the Stop Key for the given physical row key prefix
`static boolean`	`equals(byte[] left, byte[] right)`
`static boolean`	`equals(byte[] left, int leftOffset, int leftLen, byte[] right, int rightOffset, int rightLen)`
`static boolean`	`equals(byte[] a, java.nio.ByteBuffer buf)`
`static boolean`	`equals(java.util.List<byte[]> a, java.util.List<byte[]> b)`
`static byte[]`	`fromHex(java.lang.String hex)`	Create a byte array from a string of hash digits.
`static byte[]`	`getBytes(java.nio.ByteBuffer buf)`	Returns a new byte array, copied from the given `buf`, from the position (inclusive) to the limit (exclusive).
`static int`	`hashCode(byte[] b)`
`static int`	`hashCode(byte[] bytes, int offset, int length)`
`static byte[]`	`head(byte[] a, int length)`
`static int`	`indexOf(byte[] array, byte target)`	Returns the index of the first appearance of the value `target` in `array`.
`static int`	`indexOf(byte[] array, byte[] target)`	Returns the start position of the first occurrence of the specified `target` within `array`, or `-1` if there is no such occurrence.
`static int`	`len(byte[] b)`	Returns length of the byte array, returning 0 if the array is null.
`static byte[]`	`maxOfStartRows(byte[] left, byte[] right)`
`static byte[]`	`maxOfStopRows(byte[] left, byte[] right)`
`static byte[]`	`minOfStartRows(byte[] left, byte[] right)`
`static byte[]`	`minOfStopRows(byte[] left, byte[] right)`
`static byte[]`	`multiple(byte[] srcBytes, int multiNum)`	Create a byte array which is multiple given bytes
`static byte[]`	`padHead(byte[] a, int length)`
`static byte[]`	`padTail(byte[] a, int length)`
`static int`	`putAsShort(byte[] bytes, int offset, int val)`	Put an int value as short out to the specified byte array position.
`static int`	`putBigDecimal(byte[] bytes, int offset, java.math.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`	`putByteBuffer(byte[] bytes, int offset, java.nio.ByteBuffer buf)`	Add the whole content of the ByteBuffer to the bytes arrays.
`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)`
`static int`	`putFloat(byte[] bytes, int offset, float f)`
`static int`	`putInt(byte[] bytes, int offset, int val)`	Put an int value out to the specified byte array position.
`static int`	`putIntUnsafe(byte[] bytes, int offset, int val)`	Put an int value out to the specified byte array position (Unsafe).
`static int`	`putLong(byte[] bytes, int offset, long val)`	Put a long value out to the specified byte array position.
`static int`	`putLongUnsafe(byte[] bytes, int offset, long val)`	Put a long value out to the specified byte array position (Unsafe).
`static int`	`putShort(byte[] bytes, int offset, short val)`	Put a short value out to the specified byte array position.
`static int`	`putShortUnsafe(byte[] bytes, int offset, short val)`	Put a short value out to the specified byte array position (Unsafe).
`static void`	`random(byte[] b)`	Fill given array with random bytes.
`static void`	`random(byte[] b, int offset, int length)`	Fill given array with random bytes at the specified position.
`static int`	`readAsInt(byte[] bytes, int offset, int length)`	Converts a byte array to an int value
`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[]`	`tail(byte[] a, int length)`
`static java.lang.String`	`toBase64(byte[] b)`	Encodes the specified byte array to a base-64 String.
`static java.math.BigDecimal`	`toBigDecimal(byte[] bytes)`	Converts a byte array to a BigDecimal
`static java.math.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)`
`static byte[][]`	`toByteArrays(java.lang.String column)`
`static byte[][]`	`toByteArrays(java.lang.String[] t)`
`static java.nio.ByteBuffer`	`toByteBuffer(java.lang.String s)`	Converts a string to a UTF-8 ByteBuffer.
`static byte[]`	`toBytes(boolean b)`	Convert a boolean to a byte array.
`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(java.lang.String s)`	Converts a string to a UTF-8 byte array.
`static byte[]`	`toBytes(java.math.BigDecimal val)`	Convert a BigDecimal value to a byte array
`static byte[]`	`toBytes(java.nio.ByteBuffer buf)`	Returns a new byte array, copied from the given `buf`, from the index 0 (inclusive) to the limit (exclusive), regardless of the current position.
`static byte[]`	`toBytesBinary(java.lang.String in)`
`static java.nio.ByteBuffer`	`toDirectByteBuffer(java.lang.String s)`	Converts a string to a UTF-8 DirectByteBuffer.
`static double`	`toDouble(byte[] bytes)`
`static double`	`toDouble(byte[] bytes, int offset)`
`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 java.lang.String`	`toHex(byte[] b)`	Convert a byte array into a hex string
`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 int`	`toIntUnsafe(byte[] bytes, int offset)`	Converts a byte array to an int value (Unsafe version)
`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 long`	`toLongUnsafe(byte[] bytes, int offset)`	Converts a byte array to an long value (Unsafe version)
`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 short`	`toShortUnsafe(byte[] bytes, int offset)`	Converts a byte array to an short value (Unsafe version)
`static java.lang.String`	`toString(byte[] b)`
`static java.lang.String`	`toString(byte[] b, int off, int len)`	This method will convert utf8 encoded bytes into a string.
`static java.lang.String`	`toString(byte[] b1, java.lang.String sep, byte[] b2)`	Joins two byte arrays together using a separator.
`static java.lang.String`	`toString(java.nio.ByteBuffer b)`
`static java.lang.String`	`toString(java.nio.ByteBuffer b, int len)`
`static java.lang.String`	`toString(java.nio.ByteBuffer b, int offset, int len)`
`static java.lang.String`	`toStringBinary(byte[] b)`	Write a printable representation of a byte array.
`static java.lang.String`	`toStringBinary(byte[] b, int off, int len)`	Write a printable representation of a byte array.
`static java.lang.String`	`toStringBinary(java.nio.ByteBuffer buf)`	Converts the given byte buffer to a printable representation, from the index 0 (inclusive) to the limit (exclusive), regardless of the current position.
`static java.lang.String`	`toStringBinary2(java.nio.ByteBuffer buf)`	Converts the given byte buffer to a printable representation, from the position (inclusive) to the limit (exclusive).
`static int`	`unsignedBinarySearch(byte[] a, int fromIndex, int toIndex, byte key)`	Search sorted array "a" for byte "key".
`static byte[]`	`unsignedCopyAndIncrement(byte[] input)`	Treat the byte[] as an unsigned series of bytes, most significant bits first.
`static void`	`zero(byte[] b)`	Fill given array with zeros.
`static void`	`zero(byte[] b, int offset, int length)`	Fill given array with zeros at the specified position.

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
```
  - 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
  - ESTIMATED_HEAP_TAX
```
public static final int ESTIMATED_HEAP_TAX
```
    Estimate of size cost to pay beyond payload in jvm for instance of byte []. Estimate based on study of jhat and jprofiler numbers.
    
    See Also:
    
    Constant Field Values
  - BYTES_COMPARATOR
```
public static final java.util.Comparator<byte[]> BYTES_COMPARATOR
```
    Pass this to TreeMaps where byte [] are keys.
- Constructor Detail
  - Bytes
```
public Bytes()
```
- Method Detail
  - len
```
public static final int len(byte[] b)
```
    Returns length of the byte array, returning 0 if the array is null. Useful for calculating sizes.
    
    Parameters:
    
    b - byte array, which can be null
    
    Returns:
    
    0 if b is null, otherwise returns length
  - 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
  - putByteBuffer
```
public static int putByteBuffer(byte[] bytes,
                                int offset,
                                java.nio.ByteBuffer buf)
```
    Add the whole content of the ByteBuffer to the bytes arrays. The ByteBuffer is modified.
    
    Parameters:
    
    bytes - the byte array
    
    offset - position in the array
    
    buf - ByteBuffer to write out
    
    Returns:
    
    incremented offset
  - toBytes
```
public static byte[] toBytes(java.nio.ByteBuffer buf)
```
    Returns a new byte array, copied from the given buf, from the index 0 (inclusive) to the limit (exclusive), regardless of the current position. The position and the other index parameters are not changed.
    
    Parameters:
    
    buf - a byte buffer
    
    Returns:
    
    the byte array
    
    See Also:
    
    getBytes(ByteBuffer)
  - toString
```
public static java.lang.String toString(java.nio.ByteBuffer b)
```
  - toString
```
public static java.lang.String toString(java.nio.ByteBuffer b,
                                        int len)
```
  - toString
```
public static java.lang.String toString(java.nio.ByteBuffer b,
                                        int offset,
                                        int len)
```
  - toString
```
public static java.lang.String toString(byte[] b)
```
    Parameters:
    
    b - Presumed UTF-8 encoded byte array.
    
    Returns:
    
    String made from b
  - toString
```
public static java.lang.String toString(byte[] b1,
                                        java.lang.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 java.lang.String toString(byte[] b,
                                        int off,
                                        int len)
```
    This method will convert utf8 encoded bytes into a string. If the given byte array is null, this method will return null.
    
    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
  - toBase64
```
public static java.lang.String toBase64(byte[] b)
```
    Encodes the specified byte array to a base-64 String.
    
    Parameters:
    
    b - byte array
    
    Returns:
    
    base 64 encoded string
  - toStringBinary
```
public static java.lang.String toStringBinary(byte[] b)
```
    Write a printable representation of a byte array.
    
    Parameters:
    
    b - byte array
    
    Returns:
    
    string
    
    See Also:
    
    toStringBinary(byte[], int, int)
  - toStringBinary
```
public static java.lang.String toStringBinary(java.nio.ByteBuffer buf)
```
    Converts the given byte buffer to a printable representation, from the index 0 (inclusive) to the limit (exclusive), regardless of the current position. The position and the other index parameters are not changed.
    
    Parameters:
    
    buf - a byte buffer
    
    Returns:
    
    a string representation of the buffer's binary contents
    
    See Also:
    
    toBytes(ByteBuffer), getBytes(ByteBuffer)
  - toStringBinary2
```
public static java.lang.String toStringBinary2(java.nio.ByteBuffer buf)
```
    Converts the given byte buffer to a printable representation, from the position (inclusive) to the limit (exclusive). The position and the other index parameters are not changed.
    
    Parameters:
    
    buf - a byte buffer
    
    Returns:
    
    a string representation of the buffer's binary contents
    
    See Also:
    
    toBytes(ByteBuffer), getBytes(ByteBuffer)
  - toStringBinary
```
public static java.lang.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(java.lang.String in)
```
  - toDirectByteBuffer
```
public static java.nio.ByteBuffer toDirectByteBuffer(java.lang.String s)
```
    Converts a string to a UTF-8 DirectByteBuffer.
    
    Parameters:
    
    s - string
    
    Returns:
    
    the byte array
  - copyToByteBuffer
```
public static java.nio.ByteBuffer copyToByteBuffer(java.nio.ByteBuffer bb)
```
    Copies a direct bytebuffer to a non-direct byte buffer.
    
    Parameters:
    
    bb - input byte buffer, needs to be non-direct
    
    Returns:
    
    a new copy of the bytes in a direct byte buffer
  - copyToDirectByteBuffer
```
public static java.nio.ByteBuffer copyToDirectByteBuffer(java.nio.ByteBuffer bb)
```
    Copies a non-direct bytebuffer to a direct byte buffer.
    
    Parameters:
    
    bb - input byte buffer, needs to be non-direct
    
    Returns:
    
    a new copy of the bytes in a direct byte buffer
  - toByteBuffer
```
public static java.nio.ByteBuffer toByteBuffer(java.lang.String s)
```
    Converts a string to a UTF-8 ByteBuffer.
    
    Parameters:
    
    s - string
    
    Returns:
    
    the byte array
  - toBytes
```
public static byte[] toBytes(java.lang.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:
    
    java.lang.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:
    
    java.lang.IllegalArgumentException - if the byte array given doesn't have enough room at the offset specified.
  - putLongUnsafe
```
public static int putLongUnsafe(byte[] bytes,
                                int offset,
                                long val)
```
    Put a long value out to the specified byte array position (Unsafe).
    
    Parameters:
    
    bytes - the byte array
    
    offset - position in the array
    
    val - long to write out
    
    Returns:
    
    incremented offset
  - 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)
```
    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)
```
    Parameters:
    
    bytes - byte array
    
    Returns:
    
    Return double made from passed bytes.
  - toDouble
```
public static double toDouble(byte[] bytes,
                              int offset)
```
    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)
```
    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. Big-endian. Same as what DataOutputStream.writeInt does.
    
    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:
    
    java.lang.IllegalArgumentException - if length is not SIZEOF_INT or if there's not enough room in the array at the offset indicated.
  - toIntUnsafe
```
public static int toIntUnsafe(byte[] bytes,
                              int offset)
```
    Converts a byte array to an int value (Unsafe version)
    
    Parameters:
    
    bytes - byte array
    
    offset - offset into array
    
    Returns:
    
    the int value
  - toShortUnsafe
```
public static short toShortUnsafe(byte[] bytes,
                                  int offset)
```
    Converts a byte array to an short value (Unsafe version)
    
    Parameters:
    
    bytes - byte array
    
    offset - offset into array
    
    Returns:
    
    the short value
  - toLongUnsafe
```
public static long toLongUnsafe(byte[] bytes,
                                int offset)
```
    Converts a byte array to an long value (Unsafe version)
    
    Parameters:
    
    bytes - byte array
    
    offset - offset into array
    
    Returns:
    
    the long value
  - readAsInt
```
public static int readAsInt(byte[] bytes,
                            int offset,
                            int length)
```
    Converts a byte array to an int value
    
    Parameters:
    
    bytes - byte array
    
    offset - offset into array
    
    length - how many bytes should be considered for creating int
    
    Returns:
    
    the int value
    
    Throws:
    
    java.lang.IllegalArgumentException - 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:
    
    java.lang.IllegalArgumentException - if the byte array given doesn't have enough room at the offset specified.
  - putIntUnsafe
```
public static int putIntUnsafe(byte[] bytes,
                               int offset,
                               int val)
```
    Put an int value out to the specified byte array position (Unsafe).
    
    Parameters:
    
    bytes - the byte array
    
    offset - position in the array
    
    val - int to write out
    
    Returns:
    
    incremented offset
  - 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:
    
    java.lang.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(java.nio.ByteBuffer buf)
```
    Returns a new byte array, copied from the given buf, from the position (inclusive) to the limit (exclusive). The position and the other index parameters are not changed.
    
    Parameters:
    
    buf - a byte buffer
    
    Returns:
    
    the byte array
    
    See Also:
    
    toBytes(ByteBuffer)
  - 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:
    
    java.lang.IllegalArgumentException - if the byte array given doesn't have enough room at the offset specified.
  - putShortUnsafe
```
public static int putShortUnsafe(byte[] bytes,
                                 int offset,
                                 short val)
```
    Put a short value out to the specified byte array position (Unsafe).
    
    Parameters:
    
    bytes - the byte array
    
    offset - position in the array
    
    val - short to write out
    
    Returns:
    
    incremented offset
  - putAsShort
```
public static int putAsShort(byte[] bytes,
                             int offset,
                             int val)
```
    Put an int value as short out to the specified byte array position. Only the lower 2 bytes of the short will be put into the array. The caller of the API need to make sure they will not loose the value by doing so. This is useful to store an unsigned short which is represented as int in other parts.
    
    Parameters:
    
    bytes - the byte array
    
    offset - position in the array
    
    val - value to write out
    
    Returns:
    
    incremented offset
    
    Throws:
    
    java.lang.IllegalArgumentException - if the byte array given doesn't have enough room at the offset specified.
  - toBytes
```
public static byte[] toBytes(java.math.BigDecimal val)
```
    Convert a BigDecimal value to a byte array
    
    Parameters:
    
    val -
    
    Returns:
    
    the byte array
  - toBigDecimal
```
public static java.math.BigDecimal toBigDecimal(byte[] bytes)
```
    Converts a byte array to a BigDecimal
    
    Parameters:
    
    bytes -
    
    Returns:
    
    the char value
  - toBigDecimal
```
public static java.math.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,
                                java.math.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)
```
    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)
```
    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)
```
  - equals
```
public static boolean equals(byte[] a,
                             java.nio.ByteBuffer buf)
```
    Parameters:
    
    a - left operand
    
    buf - right operand
    
    Returns:
    
    True if 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)
```
    Parameters:
    
    b - bytes to hash
    
    Returns:
    
    Runs Arrays#hashCode(byte[], int) on the passed in array. This method is what org.apache.hadoop.io.Text and ImmutableBytesWritable use calculating hash code.
  - add
```
public static byte[] add(byte[] a,
                         byte[] b)
```
    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)
```
    Parameters:
    
    a - first third
    
    b - second third
    
    c - third third
    
    Returns:
    
    New array made from a, b and c
  - head
```
public static byte[] head(byte[] a,
                          int length)
```
    Parameters:
    
    a - array
    
    length - amount of bytes to grab
    
    Returns:
    
    First length bytes from a
  - tail
```
public static byte[] tail(byte[] a,
                          int length)
```
    Parameters:
    
    a - array
    
    length - amount of bytes to snarf
    
    Returns:
    
    Last length bytes from a
  - padHead
```
public static byte[] padHead(byte[] a,
                             int length)
```
    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)
```
    Parameters:
    
    a - array
    
    length - new array size
    
    Returns:
    
    Value in a plus length appended 0 bytes
  - 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(java.lang.String[] t)
```
    Parameters:
    
    t - operands
    
    Returns:
    
    Array of byte arrays made from passed array of Text
  - toByteArrays
```
public static byte[][] toByteArrays(java.lang.String column)
```
    Parameters:
    
    column - operand
    
    Returns:
    
    A byte array of a byte array where first and only entry is column
  - toByteArrays
```
public static byte[][] toByteArrays(byte[] column)
```
    Parameters:
    
    column - operand
    
    Returns:
    
    A byte array of a byte array where first and only entry is column
  - copy
```
public static byte[] copy(byte[] bytes)
```
    Copy the byte array given in parameter and return an instance of a new byte array with the same length and the same content.
    
    Parameters:
    
    bytes - the byte array to duplicate
    
    Returns:
    
    a copy of the given byte array
  - copy
```
public static byte[] copy(byte[] bytes,
                          int offset,
                          int length)
```
    Copy the byte array given in parameter and return an instance of a new byte array with the same length and the same content.
    
    Parameters:
    
    bytes - the byte array to copy from
    
    offset -
    
    length -
    
    Returns:
    
    a copy of the given designated byte array
  - unsignedBinarySearch
```
public static int unsignedBinarySearch(byte[] a,
                                       int fromIndex,
                                       int toIndex,
                                       byte key)
```
    Search sorted array "a" for byte "key". I can't remember if I wrote this or copied it from somewhere. (mcorgan)
    
    Parameters:
    
    a - Array to search. Entries must be sorted and unique.
    
    fromIndex - First index inclusive of "a" to include in the search.
    
    toIndex - Last index exclusive of "a" to include in the search.
    
    key - The byte to search for.
    
    Returns:
    
    The index of key if found. If not found, return -(index + 1), where negative indicates "not found" and the "index + 1" handles the "-0" case.
  - unsignedCopyAndIncrement
```
public static byte[] unsignedCopyAndIncrement(byte[] input)
```
    Treat the byte[] as an unsigned series of bytes, most significant bits first. Start by adding 1 to the rightmost bit/byte and carry over all overflows to the more significant bits/bytes.
    
    Parameters:
    
    input - The byte[] to increment.
    
    Returns:
    
    The incremented copy of "in". May be same length or 1 byte longer.
  - createStopKeyForPrefix
```
public static byte[] createStopKeyForPrefix(byte[] prefix)
```
    Returns the Stop Key for the given physical row key prefix
  - appendZeroByte
```
public static byte[] appendZeroByte(byte[] input)
```
    Treat the byte[] as an unsigned series of bytes, most significant bits first. Append \x00 to those series of bytes.
    
    Parameters:
    
    input - The byte[] to append to.
    
    Returns:
    
    The appended copy of "input". Will always by 1 byte longer.
  - equals
```
public static boolean equals(java.util.List<byte[]> a,
                             java.util.List<byte[]> b)
```
  - indexOf
```
public static int indexOf(byte[] array,
                          byte target)
```
    Returns the index of the first appearance of the value target in array.
    
    Parameters:
    
    array - an array of byte values, possibly empty
    
    target - a primitive byte value
    
    Returns:
    
    the least index i for which array[i] == target, or -1 if no such index exists.
  - indexOf
```
public static int indexOf(byte[] array,
                          byte[] target)
```
    Returns the start position of the first occurrence of the specified target within array, or -1 if there is no such occurrence.
    More formally, returns the lowest index i such that java.util.Arrays.copyOfRange(array, i, i + target.length) contains exactly the same elements as target.
    
    Parameters:
    
    array - the array to search for the sequence target
    
    target - the array to search for as a sub-sequence of array
  - contains
```
public static boolean contains(byte[] array,
                               byte target)
```
    Parameters:
    
    array - an array of byte values, possibly empty
    
    target - a primitive byte value
    
    Returns:
    
    true if target is present as an element anywhere in array.
  - contains
```
public static boolean contains(byte[] array,
                               byte[] target)
```
    Parameters:
    
    array - an array of byte values, possibly empty
    
    target - an array of byte
    
    Returns:
    
    true if target is present anywhere in array
  - zero
```
public static void zero(byte[] b)
```
    Fill given array with zeros.
    
    Parameters:
    
    b - array which needs to be filled with zeros
  - zero
```
public static void zero(byte[] b,
                        int offset,
                        int length)
```
    Fill given array with zeros at the specified position.
    
    Parameters:
    
    b -
    
    offset -
    
    length -
  - random
```
public static void random(byte[] b)
```
    Fill given array with random bytes.
    
    Parameters:
    
    b - array which needs to be filled with random bytes
  - random
```
public static void random(byte[] b,
                          int offset,
                          int length)
```
    Fill given array with random bytes at the specified position.
    
    Parameters:
    
    b -
    
    offset -
    
    length -
  - createMaxByteArray
```
public static byte[] createMaxByteArray(int maxByteCount)
```
    Create a max byte array with the specified max byte count
    
    Parameters:
    
    maxByteCount - the length of returned byte array
    
    Returns:
    
    the created max byte array
  - multiple
```
public static byte[] multiple(byte[] srcBytes,
                              int multiNum)
```
    Create a byte array which is multiple given bytes
    
    Parameters:
    
    srcBytes -
    
    multiNum -
    
    Returns:
    
    byte array
  - toHex
```
public static java.lang.String toHex(byte[] b)
```
    Convert a byte array into a hex string
    
    Parameters:
    
    b -
  - fromHex
```
public static byte[] fromHex(java.lang.String hex)
```
    Create a byte array from a string of hash digits. The length of the string must be a multiple of 2
    
    Parameters:
    
    hex -
  - maxOfStartRows
```
public static byte[] maxOfStartRows(byte[] left,
                                    byte[] right)
```
  - minOfStartRows
```
public static byte[] minOfStartRows(byte[] left,
                                    byte[] right)
```
  - maxOfStopRows
```
public static byte[] maxOfStopRows(byte[] left,
                                   byte[] right)
```
  - minOfStopRows
```
public static byte[] minOfStopRows(byte[] left,
                                   byte[] right)
```
  - concatenate
```
public static byte[] concatenate(byte[] a,
                                 byte[] b)
```

Class Bytes

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

EMPTY_BYTE_ARRAY

SIZEOF_BOOLEAN

SIZEOF_BYTE

SIZEOF_CHAR

SIZEOF_DOUBLE

SIZEOF_FLOAT

SIZEOF_INT

SIZEOF_LONG

SIZEOF_SHORT

ESTIMATED_HEAP_TAX

BYTES_COMPARATOR

Constructor Detail

Bytes

Method Detail

len

putBytes

putByte

putByteBuffer

toBytes

toString

toString

toString

toString

toString

toString

toBase64

toStringBinary

toStringBinary

toStringBinary2

toStringBinary

toBinaryFromHex

toBytesBinary

toDirectByteBuffer

copyToByteBuffer

copyToDirectByteBuffer

toByteBuffer

toBytes

toBytes

toBoolean

toBytes

toLong

toLong

toLong

putLong

putLongUnsafe

toFloat

toFloat

putFloat

toBytes

toDouble

toDouble

putDouble

toBytes

toBytes

toInt

toInt

toInt

toIntUnsafe

toShortUnsafe

toLongUnsafe

readAsInt

putInt

putIntUnsafe

toBytes

toShort

toShort

toShort

getBytes

putShort

putShortUnsafe

putAsShort

toBytes

toBigDecimal