Bytes (Bytes Utility Library 1.3.0 API)

java.lang.Object
- at.favre.lib.bytes.Bytes

All Implemented Interfaces:

Serializable, Comparable<Bytes>, Iterable<Byte>

Direct Known Subclasses:

MutableBytes, ReadOnlyBytes
```
public class Bytes
extends Object
implements Comparable<Bytes>, Serializable, Iterable<Byte>
```
Bytes is wrapper class for an byte-array that allows a lot of convenience operations on it:
- Creation from various source: arrays, primitives, parsed or random
- Encoding in many formats: hex, base64, etc.
- Helper functions like: indexOf, count, entropy
- Transformations like: append, reverse, xor, and, resize, ...
- Conversation to other types: primitives, List, object array, ByteBuffer, BigInteger, ...
- Validation: built-in or provided
- Making it mutable or read-only
It supports byte ordering (little/big endianness).
This class is immutable as long as the internal array is not changed from outside (which can't be assured, when using using wrap()). It is possible to create a mutable version (see MutableBytes).
Example:
```
     Bytes b = Bytes.from(array).mutable();
     b.not();
     System.out.println(b.encodeHex());
 
```
Comparable
The implemented comparator treats the bytes as signed bytes. If you want to sort, treating each byte as unsigned, use BytesTransformers.sortUnsigned().
See Also:

Serialized Form

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static Bytes`	`allocate(int length)` Creates a new instance with an empty array filled with zeros.
`static Bytes`	`allocate(int length, byte defaultValue)` Creates a new instance with an empty array filled with given defaultValue
`Bytes`	`and(byte[] secondArray)` Bitwise AND operation on the whole internal byte array.
`Bytes`	`and(Bytes bytes)` Bitwise AND operation on the whole internal byte array.
`Bytes`	`append(byte singleByte)` Creates a new instance with the current array appended to the provided data (ie.
`Bytes`	`append(byte[]... arrays)` Creates a new instance with the current array appended to the provided data (ie.
`Bytes`	`append(byte[] secondArray)` Creates a new instance with the current array appended to the provided data (ie.
`Bytes`	`append(Bytes bytes)` Creates a new instance with the current array appended to the provided data (ie.
`Bytes`	`append(char char2Bytes)` Creates a new instance with the current array appended to the provided data (ie.
`Bytes`	`append(CharSequence stringUtf8)` Creates a new instance with the current array appended to the provided utf-8 encoded representation of this string
`Bytes`	`append(CharSequence string, Charset charset)` Creates a new instance with the current array appended to the provided string with provided encoding
`Bytes`	`append(int integer4Bytes)` Creates a new instance with the current array appended to the provided data (ie.
`Bytes`	`append(long long8Bytes)` Creates a new instance with the current array appended to the provided data (ie.
`Bytes`	`append(short short2Bytes)` Creates a new instance with the current array appended to the provided data (ie.
`Bytes`	`appendNullSafe(byte[] secondArrayNullable)` Creates a new instance with the current array appended to the provided data (ie.
`byte[]`	`array()` The reference of te internal byte-array.
`boolean`	`bitAt(int bitIndex)` Returns the `bit` value as boolean at the specified index.
`ByteBuffer`	`buffer()` The internal byte array wrapped in a `ByteBuffer` instance.
`byte`	`byteAt(int index)` Returns the `byte` value at the specified index.
`ByteOrder`	`byteOrder()` Get the set byte order/endianness.
`Bytes`	`byteOrder(ByteOrder byteOrder)` Set the byte order or endianness of this instance.
`char`	`charAt(int index)` Returns the `char` value at the specified index.
`int`	`compareTo(Bytes o)` Compares this bytes instance to another.
`boolean`	`contains(byte target)` Checks if given byte value is contained in internal array
`Bytes`	`copy()` Creates a new instance with a copy of the internal byte array and all other attributes.
`Bytes`	`copy(int offset, int length)` Creates a new instance with a copy of the internal byte array and all other attributes.
`int`	`count(byte target)` Traverses the internal byte array counts the occurrences of given byte.
`int`	`count(byte[] pattern)` Traverses the internal byte array counts the occurrences of given pattern array.
`Bytes`	`duplicate()` Create a new instance which shares the same underlying array
`static Bytes`	`empty()` Creates an Byte instance with an internal empty byte array.
`String`	`encode(BinaryToTextEncoding.Encoder encoder)` Encode the internal byte-array with given encoder.
`String`	`encodeBase32()` Base32 RFC4648 string representation of the internal byte array (not Base32 hex alphabet extension)
`String`	`encodeBase36()` Deprecated. use `encodeRadix(int)` instead; will be removed in v1.0+
`String`	`encodeBase64()` Base64 representation with padding.
`String`	`encodeBase64(boolean urlSafe, boolean withPadding)` Base64 representation with either padding or without and with or without URL and filename safe alphabet.
`String`	`encodeBase64Url()` Base64 representation with padding.
`String`	`encodeBinary()` Binary (aka "1" and "0") representation.
`String`	`encodeCharset(Charset charset)` String representation with given charset encoding
`byte[]`	`encodeCharsetToBytes(Charset charset)` Byte array representation with given charset encoding.
`String`	`encodeDec()` Decimal (0-9) representation.
`String`	`encodeHex()` Base16 or Hex representation in lowercase.
`String`	`encodeHex(boolean upperCase)` Base16 or Hex representation.
`String`	`encodeOctal()` Octal (0-7) representation.
`String`	`encodeRadix(int radix)` Encodes the internal array in given radix representation (e.g.
`String`	`encodeUtf8()` UTF-8 representation of this byte array
`byte[]`	`encodeUtf8ToBytes()` UTF-8 representation of this byte array as byte array
`boolean`	`endsWith(byte[] subArray)` Checks if the given sub array is equal to the end of given array.
`double`	`entropy()` Calculates the entropy of the internal byte array.
`boolean`	`equals(byte[] anotherArray)` Compares the inner array with given array
`boolean`	`equals(Byte[] anotherArray)` Compares the inner array with given array.
`boolean`	`equals(ByteBuffer buffer)` Compares the inner array with the inner array of given ByteBuffer.
`boolean`	`equals(Object o)` Checks if this instance is equal to given other instance o
`boolean`	`equalsConstantTime(byte[] anotherArray)` Compares the inner array with given array.
`boolean`	`equalsContent(Bytes other)` Checks only for internal array content
`static Bytes`	`from(BigInteger bigInteger)` Creates a new instance from given `BigInteger`.
`static Bytes`	`from(BitSet set)` Creates a new instance from given `BitSet`.
`static Bytes`	`from(boolean booleanValue)` Creates a new instance from given boolean.
`static Bytes`	`from(byte singleByte)` Creates a new single array element array instance from given byte
`static Bytes`	`from(byte[]... moreArrays)` Creates a new instance from given array of byte arrays
`static Bytes`	`from(byte[] byteArrayToCopy)` Creates a new instance from given collections of single bytes.
`static Bytes`	`from(Byte[] boxedObjectArray)` Creates a new instance from given object byte array.
`static Bytes`	`from(byte[] array, int offset, int length)` Creates a new instance from a slice of given array
`static Bytes`	`from(ByteBuffer buffer)` Creates a new instance from given `ByteBuffer`.
`static Bytes`	`from(byte firstByte, byte... moreBytes)` Creates a new instance from given collections of single bytes.
`static Bytes`	`from(Bytes... moreBytes)` Creates a new instance from given array of byte arrays
`static Bytes`	`from(char char2Byte)` Creates a new instance from given unsigned 2 byte char.
`static Bytes`	`from(char[] charArray)` Creates a new instance from given char array using utf-8 encoding
`static Bytes`	`from(char[] charArray, Charset charset)` Creates a new instance from given char array.
`static Bytes`	`from(char[] charArray, Charset charset, int offset, int length)` Creates a new instance from given char array with given range.
`static Bytes`	`from(CharBuffer buffer)` Creates a new instance from given `CharBuffer`.
`static Bytes`	`from(CharSequence utf8String)` Creates a new instance from given utf-8 encoded string
`static Bytes`	`from(CharSequence string, Charset charset)` Creates a new instance from given string
`static Bytes`	`from(CharSequence utf8String, Normalizer.Form form)` Creates a new instance from normalized form of given utf-8 encoded string
`static Bytes`	`from(Collection<Byte> bytesCollection)` Creates a new instance from given collections.
`static Bytes`	`from(DataInput dataInput, int length)` Reads given `DataInput` and creates a new instance from read data
`static Bytes`	`from(double double8Byte)` Creates a new instance from given 8 byte floating point number (double).
`static Bytes`	`from(File file)` Reads given file and returns the byte content.
`static Bytes`	`from(File file, int offset, int length)` Reads given file and returns the byte content.
`static Bytes`	`from(float float4byte)` Creates a new instance from given 4 byte floating point number (float).
`static Bytes`	`from(InputStream stream)` Reads given whole input stream and creates a new instance from read data
`static Bytes`	`from(InputStream stream, int maxLength)` Reads given input stream up to maxLength and creates a new instance from read data.
`static Bytes`	`from(int... intArray)` Creates a new instance from given 4 byte integer array.
`static Bytes`	`from(int integer4byte)` Creates a new instance from given 4 byte integer.
`static Bytes`	`from(IntBuffer buffer)` Creates a new instance from given `IntBuffer`.
`static Bytes`	`from(long... longArray)` Creates a new instance from given 8 byte long array.
`static Bytes`	`from(long long8byte)` Creates a new instance from given 8 byte long.
`static Bytes`	`from(short short2Byte)` Creates a new instance from given 2 byte short.
`static Bytes`	`from(UUID uuid)` Convert UUID to a newly generated 16 byte long array representation.
`static Bytes`	`fromNullSafe(byte[] byteArrayToCopy)` Creates a new instance from given collections of single bytes.
`Bytes`	`hash(String algorithm)` Calculates hash with provided algorithm on the underlying byte array and returns a byte instance containing the hash.
`int`	`hashCode()`
`Bytes`	`hashMd5()` Calculates md5 on the underlying byte array and returns a byte instance containing the hash.
`Bytes`	`hashSha1()` Calculates sha1 on the underlying byte array and returns a byte instance containing the hash.
`Bytes`	`hashSha256()` Calculates sha256 on the underlying byte array and returns a byte instance containing the hash.
`int`	`indexOf(byte target)` Returns the index of the first appearance of the value `target` in `array`.
`int`	`indexOf(byte[] subArray)` Returns the start position of the first occurrence of the specified `target` within `array`, or `-1` if there is no such occurrence.
`int`	`indexOf(byte[] subArray, int fromIndex)` Returns the start position of the first occurrence of the specified `target` within `array` from given start index 'fromIndex', or `-1` if there is no such occurrence.
`int`	`indexOf(byte target, int fromIndex)` Returns the index of the first appearance of the value `target` in `array` from given start index 'fromIndex'.
`InputStream`	`inputStream()` Creates an input stream with the same backing data as the intern array of this instance
`int`	`intAt(int index)` Returns the `int` value at the specified index.
`boolean`	`isEmpty()` Checks the internal array for emptiness.
`boolean`	`isMutable()` Checks if instance is mutable
`boolean`	`isReadOnly()` Check if this instance is read only
`Iterator<Byte>`	`iterator()`
`int`	`lastIndexOf(byte target)` Returns the index of the last appearance of the value `target` in `array`.
`Bytes`	`leftShift(int shiftCount)` Bitwise left shifting of internal byte array (i.e.
`int`	`length()` The byte length of the underlying byte array.
`int`	`lengthBit()` The bit length of the underlying byte array.
`long`	`longAt(int index)` Returns the `long` value at the specified index.
`MutableBytes`	`mutable()` Returns a mutable version of this instance with sharing the same underlying byte-array.
`Bytes`	`not()` Bitwise not operation on the whole internal byte array.
`Bytes`	`or(byte[] secondArray)` Bitwise OR operation on the whole internal byte array.
`Bytes`	`or(Bytes bytes)` Bitwise OR operation on the whole internal byte array.
`static Bytes`	`parse(CharSequence encoded, BinaryToTextEncoding.Decoder decoder)` Parsing of arbitrary encoded format
`static Bytes`	`parseBase32(CharSequence base32Rfc4648String)` Parsing of base32/RFC 4648 encoded byte arrays.
`static Bytes`	`parseBase36(CharSequence base36String)` Deprecated. use `parseRadix(CharSequence, int)` with 36 instead; will be removed in v1.0+
`static Bytes`	`parseBase64(CharSequence base64String)` Parsing of base64 encoded byte arrays.
`static Bytes`	`parseBinary(CharSequence binaryString)` Parses a big endian binary string (e.g.
`static Bytes`	`parseDec(CharSequence decString)` Parsing of decimal encoded byte arrays.
`static Bytes`	`parseHex(CharSequence hexString)` Parsing of base16/HEX encoded byte arrays.
`static Bytes`	`parseOctal(CharSequence octalString)` Parsing of octal encoded byte arrays.
`static Bytes`	`parseRadix(CharSequence radixNumberString, int radix)` Encodes with given radix string representation (e.g.
`static Bytes`	`random(int length)` A new instance with random bytes.
`static Bytes`	`random(int length, Random random)` A new instance with random bytes.
`ReadOnlyBytes`	`readOnly()` Returns a new read-only byte instance.
`Bytes`	`resize(int newByteLength)` Copies the specified array, truncating or padding with zeros (if necessary) so the copy has the specified length.
`Bytes`	`resize(int newByteLength, BytesTransformer.ResizeTransformer.Mode mode)` Copies the specified array, truncating or padding with zeros (if necessary) so the copy has the specified length.
`Bytes`	`reverse()` Reverses the internal bytes in the array (not bits in each byte)
`Bytes`	`rightShift(int shiftCount)` Bitwise unsigned/logical right shifting of internal byte array (i.e.
`short`	`shortAt(int index)` Returns the `short` value at the specified index.
`boolean`	`startsWith(byte[] subArray)` Checks if the given sub array is equal to the start of given array.
`Bytes`	`switchBit(int bitPosition)` Returns a Byte whose value is equivalent to this Byte with the designated bit switched.
`Bytes`	`switchBit(int bitPosition, boolean newBitValue)` Returns a Byte whose value is equivalent to this Byte with the designated bit set to newBitValue.
`BigInteger`	`toBigInteger()` The internal byte array wrapped in a `BigInteger` instance.
`BitSet`	`toBitSet()` Returns a copy of the internal byte-array as `BitSet` type
`Byte[]`	`toBoxedArray()` Returns a copy of the internal byte-array as boxed primitive array.
`byte`	`toByte()` If the underlying byte array is exactly 1 byte / 8 bit long, returns signed two-complement representation for a Java byte value.
`char`	`toChar()` If the underlying byte array is exactly 2 byte / 16 bit long, return unsigned two-complement representation for a Java char integer value.
`char[]`	`toCharArray()` Decodes the internal byte array to UTF-8 char array.
`char[]`	`toCharArray(Charset charset)` Decodes the internal byte array with given charset to a char array.
`double`	`toDouble()` If the underlying byte array is exactly 8 byte / 64 bit long, return the representation for a Java double value.
`double[]`	`toDoubleArray()` Converts the internal byte array to an double array, that is, every 8 bytes will be packed into a single double.
`float`	`toFloat()` If the underlying byte array is exactly 4 byte / 32 bit long, return the representation for a Java float value.
`float[]`	`toFloatArray()` Converts the internal byte array to an float array, that is, every 4 bytes will be packed into a single float.
`int`	`toInt()` If the underlying byte array is exactly 4 byte / 32 bit long, return signed two-complement representation for a Java signed integer value.
`int[]`	`toIntArray()` Converts the internal byte array to an int array, that is, every 4 bytes will be packed into a single int.
`List<Byte>`	`toList()` Returns a copy of the internal byte-array as `List` collection type This requires a time and space complexity of O(n).
`long`	`toLong()` If the underlying byte array is exactly 8 byte / 64 bit long, return signed two-complement representation for a Java signed long integer value.
`long[]`	`toLongArray()` Converts the internal byte array to an long array, that is, every 8 bytes will be packed into a single long.
`short`	`toShort()` If the underlying byte array is exactly 2 byte / 16 bit long, return signed two-complement representation for a Java short integer value.
`String`	`toString()` A constant length output toString() implementation, which only shows the byte length and at most 8 bytes preview in hex representation.
`int`	`toUnsignedByte()` If the underlying byte array is exactly 1 byte / 8 bit long, returns unsigned two-complement representation for a Java byte value wrapped in an 4 byte int.
`UUID`	`toUUID()` Creates a `UUID` instance of the internal byte array.
`Bytes`	`transform(BytesTransformer transformer)` Generic transformation of this instance.
`static Bytes`	`unsecureRandom(int length)` A new instance with pseudo random bytes using an unsecure random number generator.
`static Bytes`	`unsecureRandom(int length, long seed)` A new instance with pseudo random bytes using an unsecure random number generator.
`int`	`unsignedByteAt(int index)` Returns the unsigned `byte` value at the specified index as an int.
`boolean`	`validate(BytesValidator... bytesValidators)` Applies all given validators and returns true if all of them return true (default AND concatenation).
`boolean`	`validateNotOnlyZeros()` Checks the content of each byte for 0 values
`static Bytes`	`wrap(byte[] array)` Creates a new instance with given byte array.
`static Bytes`	`wrap(byte[] array, ByteOrder byteOrder)` Creates a new instance with given byte array.
`static Bytes`	`wrap(Bytes bytes)` Creates a new reference backed by the same byte array.
`static Bytes`	`wrapNullSafe(byte[] array)` Creates a new instance with given byte array.
`Bytes`	`xor(byte[] secondArray)` Bitwise XOR operation on the whole internal byte array.
`Bytes`	`xor(Bytes bytes)` Bitwise XOR operation on the whole internal byte array.

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

Methods inherited from interface java.lang.Iterable
forEach, spliterator

- Method Detail
  - allocate
```
public static Bytes allocate(int length)
```
    Creates a new instance with an empty array filled with zeros.
    
    Parameters:
    
    length - of the internal array
    
    Returns:
    
    new instance
  - allocate
```
public static Bytes allocate(int length,
                             byte defaultValue)
```
    Creates a new instance with an empty array filled with given defaultValue
    
    Parameters:
    
    length - of the internal array
    
    defaultValue - to fill with
    
    Returns:
    
    new instance
  - empty
```
public static Bytes empty()
```
    Creates an Byte instance with an internal empty byte array. Same as calling allocate(int) with 0.
    
    Returns:
    
    the empty instance (always the same reference
  - wrap
```
public static Bytes wrap(Bytes bytes)
```
    Creates a new reference backed by the same byte array. Inherits all attributes (readonly, etc.)
    
    Parameters:
    
    bytes - to use as template
    
    Returns:
    
    new instance
  - wrapNullSafe
```
public static Bytes wrapNullSafe(byte[] array)
```
    Creates a new instance with given byte array.
    The new instance will be backed by the given byte array; that is, modifications to the bytes will cause the array to be modified and vice versa.
    If given array is null, a zero length byte array will be created and used instead.
    
    Parameters:
    
    array - to use directly or zero length byte array
    
    Returns:
    
    new instance
  - wrap
```
public static Bytes wrap(byte[] array)
```
    Creates a new instance with given byte array.
    The new instance will be backed by the given byte array; that is, modifications to the bytes will cause the array to be modified and vice versa.
    
    Parameters:
    
    array - to use directly
    
    Returns:
    
    new instance
  - wrap
```
public static Bytes wrap(byte[] array,
                         ByteOrder byteOrder)
```
    Creates a new instance with given byte array.
    The new instance will be backed by the given byte array; that is, modifications to the bytes will cause the array to be modified and vice versa.
    
    Parameters:
    
    array - to use directly
    
    byteOrder - the byte order of passed array
    
    Returns:
    
    new instance
  - from
```
public static Bytes from(byte[] byteArrayToCopy)
```
    Creates a new instance from given collections of single bytes. This will create a copy of given bytes and will not directly use given bytes or byte array.
    
    Parameters:
    
    byteArrayToCopy - must not be null and will not be used directly, but a copy
    
    Returns:
    
    new instance
  - fromNullSafe
```
public static Bytes fromNullSafe(byte[] byteArrayToCopy)
```
    Creates a new instance from given collections of single bytes. This will create a copy of given bytes and will not directly use given bytes or byte array.
    If given array is null, a zero length byte array will be created and used instead.
    
    Parameters:
    
    byteArrayToCopy - will not be used directly, but a copy; may be null
    
    Returns:
    
    new instance
  - from
```
public static Bytes from(byte[] array,
                         int offset,
                         int length)
```
    Creates a new instance from a slice of given array
    
    Parameters:
    
    array - to slice
    
    offset - start position
    
    length - length
    
    Returns:
    
    new instance
  - from
```
public static Bytes from(byte[]... moreArrays)
```
    Creates a new instance from given array of byte arrays
    
    Parameters:
    
    moreArrays - must not be null
    
    Returns:
    
    new instance
  - from
```
public static Bytes from(Bytes... moreBytes)
```
    Creates a new instance from given array of byte arrays
    
    Parameters:
    
    moreBytes - must not be null
    
    Returns:
    
    new instance
  - from
```
public static Bytes from(Collection<Byte> bytesCollection)
```
    Creates a new instance from given collections. This will create a lot of auto-unboxing events, so use with care with bigger lists.
    
    Parameters:
    
    bytesCollection - to create from
    
    Returns:
    
    new instance
  - from
```
public static Bytes from(Byte[] boxedObjectArray)
```
    Creates a new instance from given object byte array. Will copy and unbox every element.
    
    Parameters:
    
    boxedObjectArray - to create from
    
    Returns:
    
    new instance
  - from
```
public static Bytes from(byte singleByte)
```
    Creates a new single array element array instance from given byte
    
    Parameters:
    
    singleByte - to create from
    
    Returns:
    
    new instance
  - from
```
public static Bytes from(byte firstByte,
                         byte... moreBytes)
```
    Creates a new instance from given collections of single bytes. This will create a copy of given bytes and will not directly use given bytes or byte array.
    
    Parameters:
    
    firstByte - must not be null and will not be used directly, but a copy
    
    moreBytes - more bytes vararg
    
    Returns:
    
    new instance
  - from
```
public static Bytes from(boolean booleanValue)
```
    Creates a new instance from given boolean. This will create a new single array element array instance using the convention that false is zero. E.g. Creates array new byte[] {1} if booleanValue is true and new byte[] {0} if booleanValue is false.
    
    Parameters:
    
    booleanValue - to convert (false is zero, true is one)
    
    Returns:
    
    new instance
  - from
```
public static Bytes from(char char2Byte)
```
    Creates a new instance from given unsigned 2 byte char.
    
    Parameters:
    
    char2Byte - to create from
    
    Returns:
    
    new instance
  - from
```
public static Bytes from(short short2Byte)
```
    Creates a new instance from given 2 byte short.
    
    Parameters:
    
    short2Byte - to create from
    
    Returns:
    
    new instance
  - from
```
public static Bytes from(int integer4byte)
```
    Creates a new instance from given 4 byte integer.
    
    Parameters:
    
    integer4byte - to create from
    
    Returns:
    
    new instance
  - from
```
public static Bytes from(int... intArray)
```
    Creates a new instance from given 4 byte integer array.
    
    Parameters:
    
    intArray - to create from
    
    Returns:
    
    new instance
  - from
```
public static Bytes from(long long8byte)
```
    Creates a new instance from given 8 byte long.
    
    Parameters:
    
    long8byte - to create from
    
    Returns:
    
    new instance
  - from
```
public static Bytes from(long... longArray)
```
    Creates a new instance from given 8 byte long array.
    
    Parameters:
    
    longArray - to create from
    
    Returns:
    
    new instance
  - from
```
public static Bytes from(float float4byte)
```
    Creates a new instance from given 4 byte floating point number (float).
    
    Parameters:
    
    float4byte - to create from
    
    Returns:
    
    new instance
  - from
```
public static Bytes from(double double8Byte)
```
    Creates a new instance from given 8 byte floating point number (double).
    
    Parameters:
    
    double8Byte - to create from
    
    Returns:
    
    new instance
  - from
```
public static Bytes from(ByteBuffer buffer)
```
    Creates a new instance from given ByteBuffer. Will use the same backing byte array and honour the buffer's byte order.
    
    Parameters:
    
    buffer - to get the byte array from (must not be null)
    
    Returns:
    
    new instance
  - from
```
public static Bytes from(CharBuffer buffer)
```
    Creates a new instance from given CharBuffer. Will ignore buffer's byte order and use ByteOrder.BIG_ENDIAN
    
    Parameters:
    
    buffer - to get the char array from (must not be null)
    
    Returns:
    
    new instance
  - from
```
public static Bytes from(IntBuffer buffer)
```
    Creates a new instance from given IntBuffer. Will ignore buffer's byte order and use ByteOrder.BIG_ENDIAN
    
    Parameters:
    
    buffer - to get the int array from (must not be null)
    
    Returns:
    
    new instance
  - from
```
public static Bytes from(BitSet set)
```
    Creates a new instance from given BitSet.
    
    Parameters:
    
    set - to get the byte array from
    
    Returns:
    
    new instance
  - from
```
public static Bytes from(BigInteger bigInteger)
```
    Creates a new instance from given BigInteger.
    
    Parameters:
    
    bigInteger - to get the byte array from
    
    Returns:
    
    new instance
  - from
```
public static Bytes from(InputStream stream)
```
    Reads given whole input stream and creates a new instance from read data
    
    Parameters:
    
    stream - to read from
    
    Returns:
    
    new instance
  - from
```
public static Bytes from(InputStream stream,
                         int maxLength)
```
    Reads given input stream up to maxLength and creates a new instance from read data. Read maxLength is never longer than stream size (ie. maxLength is only limiting, not assuring maxLength)
    
    Parameters:
    
    stream - to read from
    
    maxLength - read to this maxLength or end of stream
    
    Returns:
    
    new instance
  - from
```
public static Bytes from(DataInput dataInput,
                         int length)
```
    Reads given DataInput and creates a new instance from read data
    
    Parameters:
    
    dataInput - to read from
    
    length - how many bytes should be read
    
    Returns:
    
    new instance
  - from
```
public static Bytes from(File file)
```
    Reads given file and returns the byte content. Be aware that the whole file content will be loaded to memory, so be careful what to read in.
    
    Parameters:
    
    file - to read from
    
    Returns:
    
    new instance
    
    Throws:
    
    IllegalArgumentException - if file does not exist
    
    IllegalStateException - if file could not be read
  - from
```
public static Bytes from(File file,
                         int offset,
                         int length)
```
    Reads given file and returns the byte content. Be aware that the whole defined file content will be loaded to memory, so be careful what to read in. This uses RandomAccessFile under the hood.
    
    Parameters:
    
    file - to read from
    
    offset - byte offset from zero position of the file
    
    length - to read from offset
    
    Returns:
    
    new instance
    
    Throws:
    
    IllegalArgumentException - if file does not exist
    
    IllegalStateException - if file could not be read
  - from
```
public static Bytes from(CharSequence utf8String)
```
    Creates a new instance from given utf-8 encoded string
    
    Parameters:
    
    utf8String - to get the internal byte array from
    
    Returns:
    
    new instance
  - from
```
public static Bytes from(CharSequence utf8String,
                         Normalizer.Form form)
```
    Creates a new instance from normalized form of given utf-8 encoded string
    
    Parameters:
    
    utf8String - to get the internal byte array from
    
    form - to normalize, usually you want Normalizer.Form.NFKD for compatibility
    
    Returns:
    
    new instance
  - from
```
public static Bytes from(CharSequence string,
                         Charset charset)
```
    Creates a new instance from given string
    
    Parameters:
    
    string - to get the internal byte array from
    
    charset - used to decode the string
    
    Returns:
    
    new instance
  - from
```
public static Bytes from(char[] charArray)
```
    Creates a new instance from given char array using utf-8 encoding
    
    Parameters:
    
    charArray - to get the internal byte array from
    
    Returns:
    
    new instance
  - from
```
public static Bytes from(char[] charArray,
                         Charset charset)
```
    Creates a new instance from given char array. The array will be handles like an encoded string
    
    Parameters:
    
    charArray - to get the internal byte array from
    
    charset - charset to be used to decode the char array
    
    Returns:
    
    new instance
  - from
```
public static Bytes from(char[] charArray,
                         Charset charset,
                         int offset,
                         int length)
```
    Creates a new instance from given char array with given range. The array will be handles like an encoded string
    
    Parameters:
    
    charArray - to get the internal byte array from
    
    charset - charset to be used to decode the char array
    
    offset - start position (from given char array not encoded byte array out)
    
    length - length in relation to offset (from given char array not encoded byte array out)
    
    Returns:
    
    new instance
  - from
```
public static Bytes from(UUID uuid)
```
    Convert UUID to a newly generated 16 byte long array representation. Puts the 8 byte most significant bits and 8 byte least significant bits into an byte array.
    
    Parameters:
    
    uuid - to convert to array
    
    Returns:
    
    new instance
  - parseBinary
```
public static Bytes parseBinary(CharSequence binaryString)
```
    Parses a big endian binary string (e.g. 10010001)
    
    Parameters:
    
    binaryString - the encoded string
    
    Returns:
    
    decoded instance
  - parseOctal
```
public static Bytes parseOctal(CharSequence octalString)
```
    Parsing of octal encoded byte arrays.
    
    Parameters:
    
    octalString - the encoded string
    
    Returns:
    
    decoded instance
  - parseDec
```
public static Bytes parseDec(CharSequence decString)
```
    Parsing of decimal encoded byte arrays.
    
    Parameters:
    
    decString - the encoded string
    
    Returns:
    
    decoded instance
  - parseRadix
```
public static Bytes parseRadix(CharSequence radixNumberString,
                               int radix)
```
    Encodes with given radix string representation (e.g. radix 16 would be hex). See also BigInteger.toString(int).
    This is usually a number encoding, not a data encoding (ie. leading zeros are not preserved), but this implementation tries to preserve the leading zeros, to keep the in/output byte length size the same, but use at your own risk!
    
    Parameters:
    
    radixNumberString - the encoded string
    
    radix - radix of the String representation (supported are 2-36)
    
    Returns:
    
    decoded instance
  - parseHex
```
public static Bytes parseHex(CharSequence hexString)
```
    Parsing of base16/HEX encoded byte arrays. This is by design a very flexible decoder accepting the following cases:
    - Upper- and lowercase a-f (also mixed case)
    - Prefix with 0x which will be ignored
    - Even and odd number of string length with auto zero padding (ie. 'E3F' is same as '0E3F')
    Parameters:
    
    hexString - the encoded string
    
    Returns:
    
    decoded instance
    
    Throws:
    
    IllegalArgumentException - if string contains something else than [0-9a-fA-F]
  - parseBase32
```
public static Bytes parseBase32(CharSequence base32Rfc4648String)
```
    Parsing of base32/RFC 4648 encoded byte arrays.
    Uses the RFC 4648 non-hex alphabet, see Base32 alphabet.
    
    Parameters:
    
    base32Rfc4648String - the encoded string
    
    Returns:
    
    decoded instance
  - parseBase36
```
@Deprecated
public static Bytes parseBase36(CharSequence base36String)
```
    Deprecated. use parseRadix(CharSequence, int) with 36 instead; will be removed in v1.0+
    
    Parsing of base36 encoded byte arrays.
    This is usually a number encoding, not a data encoding (ie. leading zeros are not preserved), but this implementation tries to preserve the leading zeros, to keep the in/output byte length size the same.
    
    Parameters:
    
    base36String - the encoded string
    
    Returns:
    
    decoded instance
  - parseBase64
```
public static Bytes parseBase64(CharSequence base64String)
```
    Parsing of base64 encoded byte arrays. Supporting RFC 4648 normal and url safe encoding, with or without padding.
    
    Parameters:
    
    base64String - the encoded string
    
    Returns:
    
    decoded instance
  - parse
```
public static Bytes parse(CharSequence encoded,
                          BinaryToTextEncoding.Decoder decoder)
```
    Parsing of arbitrary encoded format
    
    Parameters:
    
    encoded - the encoded string
    
    decoder - the decoder used to decode the string
    
    Returns:
    
    decoded instance
  - random
```
public static Bytes random(int length)
```
    A new instance with random bytes. Uses a cryptographically secure SecureRandom instance.
    
    Parameters:
    
    length - desired array length
    
    Returns:
    
    random instance
  - unsecureRandom
```
public static Bytes unsecureRandom(int length)
```
    A new instance with pseudo random bytes using an unsecure random number generator. This may be used in e.g. tests. In production code use random(int) per default.
    ONLY USE IN NON-SECURITY RELEVANT CONTEXT!
    
    Parameters:
    
    length - desired array length
    
    Returns:
    
    random instance
  - unsecureRandom
```
public static Bytes unsecureRandom(int length,
                                   long seed)
```
    A new instance with pseudo random bytes using an unsecure random number generator. This may be used in e.g. tests to create predictable numbers.
    In production code use random(int) per default.
    ONLY USE IN NON-SECURITY RELEVANT CONTEXT!
    
    Parameters:
    
    length - desired array length
    
    seed - used to seed random number generator - using same seed will generate same numbers
    
    Returns:
    
    random instance
  - random
```
public static Bytes random(int length,
                           Random random)
```
    A new instance with random bytes.
    
    Parameters:
    
    length - desired array length
    
    random - to create the entropy for the random bytes
    
    Returns:
    
    random instance
  - append
```
public Bytes append(Bytes bytes)
```
    Creates a new instance with the current array appended to the provided data (ie. append at the end).
    This will create a new byte array internally, so it is not suitable to use as extensive builder pattern - use ByteBuffer or ByteArrayOutputStream for that.
    
    Parameters:
    
    bytes - to append
    
    Returns:
    
    appended instance
  - append
```
public Bytes append(byte singleByte)
```
    Creates a new instance with the current array appended to the provided data (ie. append at the end)
    
    Parameters:
    
    singleByte - to append
    
    Returns:
    
    appended instance
  - append
```
public Bytes append(char char2Bytes)
```
    Creates a new instance with the current array appended to the provided data (ie. append at the end)
    
    Parameters:
    
    char2Bytes - to append
    
    Returns:
    
    appended instance
  - append
```
public Bytes append(short short2Bytes)
```
    Creates a new instance with the current array appended to the provided data (ie. append at the end)
    
    Parameters:
    
    short2Bytes - to append
    
    Returns:
    
    appended instance
  - append
```
public Bytes append(int integer4Bytes)
```
    Creates a new instance with the current array appended to the provided data (ie. append at the end)
    
    Parameters:
    
    integer4Bytes - to append
    
    Returns:
    
    appended instance
  - append
```
public Bytes append(long long8Bytes)
```
    Creates a new instance with the current array appended to the provided data (ie. append at the end)
    
    Parameters:
    
    long8Bytes - to append
    
    Returns:
    
    appended instance
  - append
```
public Bytes append(byte[]... arrays)
```
    Creates a new instance with the current array appended to the provided data (ie. append at the end). You may use this to append multiple byte arrays without the need for chaining the append(byte[]) call and therefore generating intermediate copies of the byte array, making this approach use less memory.
    
    Parameters:
    
    arrays - to append
    
    Returns:
    
    appended instance
  - append
```
public Bytes append(byte[] secondArray)
```
    Creates a new instance with the current array appended to the provided data (ie. append at the end)
    
    Parameters:
    
    secondArray - to append
    
    Returns:
    
    appended instance
  - appendNullSafe
```
public Bytes appendNullSafe(byte[] secondArrayNullable)
```
    Creates a new instance with the current array appended to the provided data (ie. append at the end)
    If given array is null, the nothing will be appended.
    
    Parameters:
    
    secondArrayNullable - to append, may be null
    
    Returns:
    
    appended instance or same if passed array is null
  - append
```
public Bytes append(CharSequence stringUtf8)
```
    Creates a new instance with the current array appended to the provided utf-8 encoded representation of this string
    
    Parameters:
    
    stringUtf8 - string used to get utf-8 bytes from
    
    Returns:
    
    appended instance
  - append
```
public Bytes append(CharSequence string,
                    Charset charset)
```
    Creates a new instance with the current array appended to the provided string with provided encoding
    
    Parameters:
    
    string - string used to get bytes from
    
    charset - encoding of provided string
    
    Returns:
    
    appended instance
  - xor
```
public Bytes xor(Bytes bytes)
```
    Bitwise XOR operation on the whole internal byte array. See the considerations about possible in-place operation in transform(BytesTransformer).
    
    Parameters:
    
    bytes - must be of same length as this instance
    
    Returns:
    
    xor'ed instance
    
    See Also:
    
    Bitwise operators: XOR
  - xor
```
public Bytes xor(byte[] secondArray)
```
    Bitwise XOR operation on the whole internal byte array. See the considerations about possible in-place operation in transform(BytesTransformer).
    
    Parameters:
    
    secondArray - must be of same length as this instance
    
    Returns:
    
    xor'ed instance
    
    See Also:
    
    Bitwise operators: XOR
  - and
```
public Bytes and(Bytes bytes)
```
    Bitwise AND operation on the whole internal byte array. See the considerations about possible in-place operation in transform(BytesTransformer).
    
    Parameters:
    
    bytes - must be of same length as this instance
    
    Returns:
    
    and'ed instance
    
    See Also:
    
    Bitwise operators: AND
  - and
```
public Bytes and(byte[] secondArray)
```
    Bitwise AND operation on the whole internal byte array. See the considerations about possible in-place operation in transform(BytesTransformer).
    
    Parameters:
    
    secondArray - must be of same length as this instance
    
    Returns:
    
    and'ed instance
    
    See Also:
    
    Bitwise operators: AND
  - or
```
public Bytes or(Bytes bytes)
```
    Bitwise OR operation on the whole internal byte array. See the considerations about possible in-place operation in transform(BytesTransformer).
    
    Parameters:
    
    bytes - must be of same length as this instance
    
    Returns:
    
    or'ed instance
    
    See Also:
    
    Bitwise operators: OR
  - or
```
public Bytes or(byte[] secondArray)
```
    Bitwise OR operation on the whole internal byte array. See the considerations about possible in-place operation in transform(BytesTransformer).
    
    Parameters:
    
    secondArray - must be of same length as this instance
    
    Returns:
    
    or'ed instance
    
    See Also:
    
    Bitwise operators: OR
  - not
```
public Bytes not()
```
    Bitwise not operation on the whole internal byte array. See the considerations about possible in-place operation in transform(BytesTransformer).
    
    Returns:
    
    negated instance
    
    See Also:
    
    Bitwise operators: NOT
  - leftShift
```
public Bytes leftShift(int shiftCount)
```
    Bitwise left shifting of internal byte array (i.e. <<). Unlike BigInteger's implementation, this one will never grow or shrink the underlying array. Either a bit is pushed out of the array or a zero is pushed in.
    See the considerations about possible in-place operation in transform(BytesTransformer).
    
    Parameters:
    
    shiftCount - how many bits (not bytes)
    
    Returns:
    
    shifted instance
    
    See Also:
    
    Bit shifts
  - rightShift
```
public Bytes rightShift(int shiftCount)
```
    Bitwise unsigned/logical right shifting of internal byte array (i.e. >>>). Unlike BigInteger's implementation, this one will never grow or shrink the underlying array. Either a bit is pushed out of the array or a zero is pushed in.
    See the considerations about possible in-place operation in transform(BytesTransformer).
    
    Parameters:
    
    shiftCount - how many bits (not bytes)
    
    Returns:
    
    shifted instance
    
    See Also:
    
    Bit shifts
  - switchBit
```
public Bytes switchBit(int bitPosition,
                       boolean newBitValue)
```
    Returns a Byte whose value is equivalent to this Byte with the designated bit set to newBitValue. Bits start to count from the LSB (ie. Bytes.from(0).switchBit(0,true) == 1)
    
    Parameters:
    
    bitPosition - not to confuse with byte position
    
    newBitValue - if true set to 1, 0 otherwise
    
    Returns:
    
    instance with bit switched
  - switchBit
```
public Bytes switchBit(int bitPosition)
```
    Returns a Byte whose value is equivalent to this Byte with the designated bit switched.
    
    Parameters:
    
    bitPosition - not to confuse with byte position
    
    Returns:
    
    instance with bit switched
  - copy
```
public Bytes copy()
```
    Creates a new instance with a copy of the internal byte array and all other attributes.
    
    Returns:
    
    copied instance
  - copy
```
public Bytes copy(int offset,
                  int length)
```
    Creates a new instance with a copy of the internal byte array and all other attributes.
    
    Parameters:
    
    offset - starting position in the source array
    
    length - of the new instance
    
    Returns:
    
    copied instance
  - reverse
```
public Bytes reverse()
```
    Reverses the internal bytes in the array (not bits in each byte)
    See the considerations about possible in-place operation in transform(BytesTransformer).
    
    Returns:
    
    reversed instance
  - resize
```
public Bytes resize(int newByteLength)
```
    Copies the specified array, truncating or padding with zeros (if necessary) so the copy has the specified length. For all indices that are valid in both the original array and the copy, the two arrays will contain identical values. For any indices that are valid in the copy but not the original, the copy will contain (byte)0.
    Resize from LSB or length, so an array [0,1,2,3] resized to 3 will result in [1,2,3] or resized to 5 [0,0,1,2,3]. So when a 8 byte value resized to 4 byte will result in the same 32 bit integer value
    
    Parameters:
    
    newByteLength - the length of the copy to be returned
    
    Returns:
    
    a copy with the desired size or "this" instance if newByteLength == current length
  - resize
```
public Bytes resize(int newByteLength,
                    BytesTransformer.ResizeTransformer.Mode mode)
```
    Copies the specified array, truncating or padding with zeros (if necessary) so the copy has the specified length. For all indices that are valid in both the original array and the copy, the two arrays will contain identical values. For any indices that are valid in the copy but not the original, the copy will contain (byte)0.
    Modes:
    - BytesTransformer.ResizeTransformer.Mode.RESIZE_KEEP_FROM_ZERO_INDEX: Resize from MSB or index 0; so an array [0,1,2,3] resized to 3 will result in [0,1,2] or resized to 5 [0,1,2,3,0]
    - BytesTransformer.ResizeTransformer.Mode.RESIZE_KEEP_FROM_MAX_LENGTH: Resize from LSB or length; so an array [0,1,2,3] resized to 3 will result in [1,2,3] or resized to 5 [0,0,1,2,3]
    Parameters:
    
    newByteLength - the length of the copy to be returned
    
    mode - from which end the length will start to count (either index 0 or length())
    
    Returns:
    
    a copy with the desired size or "this" instance if newByteLength == current length
  - hashMd5
```
public Bytes hashMd5()
```
    Calculates md5 on the underlying byte array and returns a byte instance containing the hash. This hash algorithm SHOULD be supported by every JVM implementation (see Javadoc for MessageDigest) Do not use this algorithm in security relevant applications.
    
    Returns:
    
    md5 (16 bytes) hash of internal byte array
    
    Throws:
    
    IllegalArgumentException - if the message digest algorithm can not be found in the security providers
    
    See Also:
    
    MD5
  - hashSha1
```
public Bytes hashSha1()
```
    Calculates sha1 on the underlying byte array and returns a byte instance containing the hash. This hash algorithm SHOULD be supported by every JVM implementation (see Javadoc for MessageDigest) Do not use this algorithm in security relevant applications.
    
    Returns:
    
    sha1 (20 bytes) hash of internal byte array
    
    Throws:
    
    IllegalArgumentException - if the message digest algorithm can not be found in the security providers
    
    See Also:
    
    Secure Hash Algorithm 1
  - hashSha256
```
public Bytes hashSha256()
```
    Calculates sha256 on the underlying byte array and returns a byte instance containing the hash.
    
    Returns:
    
    sha256 (32 bytes) hash of internal byte array
    
    Throws:
    
    IllegalArgumentException - if the message digest algorithm can not be found in the security providers
    
    See Also:
    
    Secure Hash Algorithms
  - hash
```
public Bytes hash(String algorithm)
```
    Calculates hash with provided algorithm on the underlying byte array and returns a byte instance containing the hash.
    
    Parameters:
    
    algorithm - same format as passed to MessageDigest.getInstance(String)
    
    Returns:
    
    hash of internal byte array
    
    Throws:
    
    IllegalArgumentException - if the message digest algorithm can not be found in the security providers
  - transform
```
public Bytes transform(BytesTransformer transformer)
```
    Generic transformation of this instance.
    This transformation might be done in-place (ie. without copying the internal array and overwriting its old state), or on a copy of the internal data, depending on the type (e.g. MutableBytes) and if the operation can be done in-place. Therefore the caller has to ensure that certain side-effects, which occur due to the changing of the internal data, do not create bugs in his/her code. Usually immutability is preferred, but when handling many or big byte arrays, mutability enables drastically better performance.
    
    Parameters:
    
    transformer - used to transform this instance
    
    Returns:
    
    the transformed instance (might be the same, or a new one)
  - validateNotOnlyZeros
```
public boolean validateNotOnlyZeros()
```
    Checks the content of each byte for 0 values
    
    Returns:
    
    true if not empty and only contains zero byte values
  - validate
```
public boolean validate(BytesValidator... bytesValidators)
```
    Applies all given validators and returns true if all of them return true (default AND concatenation).
    
    Parameters:
    
    bytesValidators - array of validators to check against the byte array
    
    Returns:
    
    true if all validators return true
  - length
```
public int length()
```
    The byte length of the underlying byte array.
    
    Returns:
    
    byte length
  - lengthBit
```
public int lengthBit()
```
    The bit length of the underlying byte array.
    
    Returns:
    
    bit length
  - isEmpty
```
public boolean isEmpty()
```
    Checks the internal array for emptiness.
    
    Returns:
    
    if the underlying byte array has a length of 0
  - byteOrder
```
public ByteOrder byteOrder()
```
    Get the set byte order/endianness. Default in Java is ByteOrder.BIG_ENDIAN.
    
    Returns:
    
    either ByteOrder.BIG_ENDIAN or ByteOrder.LITTLE_ENDIAN
    
    See Also:
    
    Endianness
  - isMutable
```
public boolean isMutable()
```
    Checks if instance is mutable
    
    Returns:
    
    true if mutable, ie. transformers will change internal array
  - isReadOnly
```
public boolean isReadOnly()
```
    Check if this instance is read only
    
    Returns:
    
    true if read only
  - contains
```
public boolean contains(byte target)
```
    Checks if given byte value is contained in internal array
    
    Parameters:
    
    target - a primitive byte value
    
    Returns:
    
    true if this Bytes instance contains the specified element
  - indexOf
```
public int indexOf(byte target)
```
    Returns the index of the first appearance of the value target in array. Same as calling indexOf(byte, int) with fromIndex '0'.
    
    Parameters:
    
    target - a primitive byte value
    
    Returns:
    
    the least index i for which array[i] == target, or -1 if no such index exists.
  - indexOf
```
public int indexOf(byte target,
                   int fromIndex)
```
    Returns the index of the first appearance of the value target in array from given start index 'fromIndex'.
    
    Parameters:
    
    target - a primitive byte value
    
    fromIndex - search from this index
    
    Returns:
    
    the least index i for which array[i] == target, or -1 if no such index exists or fromIndex is gt target length.
  - indexOf
```
public int indexOf(byte[] subArray)
```
    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:
    
    subArray - the array to search for as a sub-sequence of array
    
    Returns:
    
    the least index i for which array[i] == target, or -1 if no such index exists.
  - indexOf
```
public int indexOf(byte[] subArray,
                   int fromIndex)
```
    Returns the start position of the first occurrence of the specified target within array from given start index 'fromIndex', 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:
    
    subArray - the array to search for as a sub-sequence of array
    
    fromIndex - search from this index
    
    Returns:
    
    the least index i for which array[i] == target, or -1 if no such index exists.
  - startsWith
```
public boolean startsWith(byte[] subArray)
```
    Checks if the given sub array is equal to the start of given array. That is, sub array must be gt or eq to the length of the internal array and internal[i] == subArray[i] for i=0..subArray.length-1
    
    Parameters:
    
    subArray - to check against the start of the internal array
    
    Returns:
    
    true if the start of the internal array is eq to given sub array
  - lastIndexOf
```
public int lastIndexOf(byte target)
```
    Returns the index of the last appearance of the value target in array.
    
    Parameters:
    
    target - a primitive byte value
    
    Returns:
    
    the greatest index i for which array[i] == target, or -1 if no such index exists.
  - endsWith
```
public boolean endsWith(byte[] subArray)
```
    Checks if the given sub array is equal to the end of given array. That is, sub array must be gt or eq to the length of the internal array and internal[i] == subArray[i] for i=subArray.length...internal.length
    
    Parameters:
    
    subArray - to check against the end of the internal array
    
    Returns:
    
    true if the end of the internal array is eq to given sub array
  - bitAt
```
public boolean bitAt(int bitIndex)
```
    Returns the bit value as boolean at the specified index. Bit index 0 is the LSB, so for example byte word 1000 0000 has bitAt(0) == false and bitAt(7) == true.
    
    Parameters:
    
    bitIndex - the index of the bit value.
    
    Returns:
    
    true if bit at given index is set, false otherwise
    
    Throws:
    
    IndexOutOfBoundsException - if the bitIndex argument is negative or not less than the length of this array in bits.
  - byteAt
```
public byte byteAt(int index)
```
    Returns the byte value at the specified index. An index ranges from 0 to length() - 1. The first char value of the sequence is at index 0, the next at index 1, and so on, as for array indexing.
    
    Parameters:
    
    index - the index of the byte value.
    
    Returns:
    
    the byte value at the specified index of the underlying byte array.
    
    Throws:
    
    IndexOutOfBoundsException - if the index argument is negative or not less than the length of this array.
  - unsignedByteAt
```
public int unsignedByteAt(int index)
```
    Returns the unsigned byte value at the specified index as an int. An index ranges from 0 to length() - 1. The first char value of the sequence is at index 0, the next at index 1, and so on, as for array indexing.
    
    Parameters:
    
    index - the index of the unsigned byte value.
    
    Returns:
    
    the unsigned byte value at the specified index of the underlying byte array as type 4 byte integer
    
    Throws:
    
    IndexOutOfBoundsException - if the index argument is negative or not less than the length of this array.
  - charAt
```
public char charAt(int index)
```
    Returns the char value at the specified index. Reads the primitive from given index and the following byte and interprets it according to byte order.
    
    Parameters:
    
    index - the index of the char value.
    
    Returns:
    
    the char value at the specified index of the underlying byte array.
    
    Throws:
    
    IndexOutOfBoundsException - if the index argument is negative or length is greater than index - 2
  - shortAt
```
public short shortAt(int index)
```
    Returns the short value at the specified index. Reads the primitive from given index and the following byte and interprets it according to byte order.
    
    Parameters:
    
    index - the index of the short value.
    
    Returns:
    
    the short value at the specified index of the underlying byte array.
    
    Throws:
    
    IndexOutOfBoundsException - if the index argument is negative or length is greater than index - 2
  - intAt
```
public int intAt(int index)
```
    Returns the int value at the specified index. Reads the primitive from given index and the following 3 bytes and interprets it according to byte order.
    
    Parameters:
    
    index - the index of the int value.
    
    Returns:
    
    the int value at the specified index of the underlying byte array.
    
    Throws:
    
    IndexOutOfBoundsException - if the int argument is negative or length is greater than index - 4
  - longAt
```
public long longAt(int index)
```
    Returns the long value at the specified index. Reads the primitive from given index and the following 7 bytes and interprets it according to byte order.
    
    Parameters:
    
    index - the index of the long value.
    
    Returns:
    
    the long value at the specified index of the underlying byte array.
    
    Throws:
    
    IndexOutOfBoundsException - if the long argument is negative or length is greater than index - 8
  - count
```
public int count(byte target)
```
    Traverses the internal byte array counts the occurrences of given byte. This has a time complexity of O(n).
    
    Parameters:
    
    target - byte to count
    
    Returns:
    
    the count of given target in the byte array
  - count
```
public int count(byte[] pattern)
```
    Traverses the internal byte array counts the occurrences of given pattern array. This has a time complexity of O(n).
    Example:
    - Internal Array: [0, 1, 2, 0, 1, 0]
    - Pattern Array: [0, 1]
    - Count: 2
    Parameters:
    
    pattern - byte array to count
    
    Returns:
    
    the count of given target in the byte array
  - entropy
```
public double entropy()
```
    Calculates the entropy of the internal byte array. This might be useful for judging the internal data for using e.g. in security relevant use case. In statistical mechanics, entropy is related to the number of microscopic configurations Ω that a thermodynamic system can have when in a state as specified by some macroscopic variables. Specifically, assuming for simplicity that each of the microscopic configurations is equally probable, the entropy of the system is the natural logarithm of that number of configurations, multiplied by the Boltzmann constant kB.
    This implementation requires O(n) time and O(1) space complexity.
    
    Returns:
    
    entropy value; higher is more entropy (simply: more different values)
    
    See Also:
    
    Entropy
  - duplicate
```
public Bytes duplicate()
```
    Create a new instance which shares the same underlying array
    
    Returns:
    
    new instance backed by the same data
  - byteOrder
```
public Bytes byteOrder(ByteOrder byteOrder)
```
    Set the byte order or endianness of this instance. Default in Java is ByteOrder.BIG_ENDIAN.
    This option is important for all encoding and conversation methods.
    
    Parameters:
    
    byteOrder - new byteOrder
    
    Returns:
    
    a new instance with the same underlying array and new order, or "this" if order is the same
    
    See Also:
    
    Endianness
  - readOnly
```
public ReadOnlyBytes readOnly()
```
    Returns a new read-only byte instance. Read-only means, that there is no direct access to the underlying byte array and all transformers will create a copy.
    
    Returns:
    
    a new instance if not already readonly, or "this" otherwise
  - buffer
```
public ByteBuffer buffer()
```
    The internal byte array wrapped in a ByteBuffer instance. Changes to it will be directly mirrored in this Bytes instance.
    This will honor the set byteOrder().
    
    Returns:
    
    byte buffer
    
    Throws:
    
    ReadOnlyBufferException - if this is a read-only instance
  - mutable
```
public MutableBytes mutable()
```
    Returns a mutable version of this instance with sharing the same underlying byte-array. If you want the mutable version to be a copy, call copy() first.
    
    Returns:
    
    new mutable instance with same reference to internal byte array, or "this" if this is already of type MutableBytes
    
    Throws:
    
    ReadOnlyBufferException - if this is a read-only instance
  - inputStream
```
public InputStream inputStream()
```
    Creates an input stream with the same backing data as the intern array of this instance
    
    Returns:
    
    new input stream
  - array
```
public byte[] array()
```
    The reference of te internal byte-array. This call requires no conversation or additional memory allocation.
    Modifications to this bytes's content will cause the returned array's content to be modified, and vice versa.
    
    Returns:
    
    the direct reference of the internal byte array
    
    Throws:
    
    ReadOnlyBufferException - if this is a read-only instance
  - encodeBinary
```
public String encodeBinary()
```
    Binary (aka "1" and "0") representation. This is especially useful for debugging purposes. Binary has a space efficiency of 12.5%.
    Example: 10011100
    
    Returns:
    
    binary string
    
    See Also:
    
    Binary number
  - encodeOctal
```
public String encodeOctal()
```
    Octal (0-7) representation. Octal has a space efficiency of 37.5%.
    Example: 1124517677707527755
    
    Returns:
    
    octal number as string
    
    See Also:
    
    Octal
  - encodeDec
```
public String encodeDec()
```
    Decimal (0-9) representation. It has a space efficiency of 41.5%.
    Example: 20992966904426477
    
    Returns:
    
    decimal number as string
    
    See Also:
    
    Decimal
  - encodeRadix
```
public String encodeRadix(int radix)
```
    Encodes the internal array in given radix representation (e.g. 2 = binary, 10 = decimal, 16 = hex).
    This is usually a number encoding, not a data encoding (ie. leading zeros are not preserved), but this implementation tries to preserve the leading zeros, to keep the in/output byte length size the same. To preserve the length padding would be required, but is not supported in this implementation.
    But still full disclaimer: This is NOT recommended for data encoding, only for number encoding
    See Radix Economy and BigInteger.toString(int).
    
    Parameters:
    
    radix - of the String representation (supported are 2-36)
    
    Returns:
    
    string in given radix representation
  - encodeHex
```
public String encodeHex()
```
    Base16 or Hex representation in lowercase. 2 characters represent a single byte, it therefore has an efficiency of 50%.
    Example: 4a94fdff1eafed
    
    Returns:
    
    hex string
    
    See Also:
    
    Hexadecimal
  - encodeHex
```
public String encodeHex(boolean upperCase)
```
    Base16 or Hex representation. See encodeHex().
    Example: 4A94FDFF1EAFED
    
    Parameters:
    
    upperCase - if the output character should be in uppercase
    
    Returns:
    
    hex string
  - encodeBase32
```
public String encodeBase32()
```
    Base32 RFC4648 string representation of the internal byte array (not Base32 hex alphabet extension)
    Example: MZXW6YQ=
    See RFC 4648
    
    Returns:
    
    base32 string
  - encodeBase36
```
@Deprecated
public String encodeBase36()
```
    Deprecated. use encodeRadix(int) instead; will be removed in v1.0+
    
    DO NOT USE AS DATA ENCODING, ONLY FOR NUMBERS!
    Base36 (aka Hexatrigesimal) representation. The choice of 36 is convenient in that the digits can be represented using the Arabic numerals 0–9 and the Latin letters A–Z. This encoding has a space efficiency of 64.6%.
    Example: 5qpdvuwjvu5
    
    Returns:
    
    base36 string
    
    See Also:
    
    Base36
  - encodeBase64
```
public String encodeBase64()
```
    Base64 representation with padding. This is *NOT* the url safe variation. This encoding has a space efficiency of 75%.
    This encoding is RFC 4648 compatible.
    Example: SpT9/x6v7Q==
    
    Returns:
    
    base64 string
    
    See Also:
    
    Base64
  - encodeBase64Url
```
public String encodeBase64Url()
```
    Base64 representation with padding. This is the url safe variation substitution '+' and '/' with '-' and '_' respectively. This encoding has a space efficiency of 75%.
    This encoding is RFC 4648 compatible.
    Example: SpT9_x6v7Q==
    
    Returns:
    
    base64 url safe string
    
    See Also:
    
    Base64
  - encodeBase64
```
public String encodeBase64(boolean urlSafe,
                           boolean withPadding)
```
    Base64 representation with either padding or without and with or without URL and filename safe alphabet. This encoding is RFC 4648 compatible.
    Example: SpT9/x6v7Q==
    
    Parameters:
    
    urlSafe - if true will substitute '+' and '/' with '-' and '_'
    
    withPadding - if true will add padding the next full byte with '='
    
    Returns:
    
    base64 url safe string
    
    See Also:
    
    Base64
  - encodeUtf8
```
public String encodeUtf8()
```
    UTF-8 representation of this byte array
    
    Returns:
    
    utf-8 encoded string
    
    See Also:
    
    UTF-8
  - encodeCharset
```
public String encodeCharset(Charset charset)
```
    String representation with given charset encoding
    
    Parameters:
    
    charset - the charset the return will be encoded
    
    Returns:
    
    encoded string
  - encodeUtf8ToBytes
```
public byte[] encodeUtf8ToBytes()
```
    UTF-8 representation of this byte array as byte array
    Similar to encodeUtf8().getBytes(StandardCharsets.UTF_8).
    
    Returns:
    
    utf-8 encoded byte array
    
    See Also:
    
    UTF-8
  - encodeCharsetToBytes
```
public byte[] encodeCharsetToBytes(Charset charset)
```
    Byte array representation with given charset encoding.
    Similar to encodeCharset(charset).getBytes(charset).
    
    Parameters:
    
    charset - the charset the return will be encoded
    
    Returns:
    
    encoded byte array
  - encode
```
public String encode(BinaryToTextEncoding.Encoder encoder)
```
    Encode the internal byte-array with given encoder.
    
    Parameters:
    
    encoder - the encoder implementation
    
    Returns:
    
    byte-to-text representation
  - toList
```
public List<Byte> toList()
```
    Returns a copy of the internal byte-array as List collection type This requires a time and space complexity of O(n).
    
    Returns:
    
    copy of internal array as list
  - toBoxedArray
```
public Byte[] toBoxedArray()
```
    Returns a copy of the internal byte-array as boxed primitive array. This requires a time and space complexity of O(n).
    Note: this method was previously called toObjectArray()
    
    Returns:
    
    copy of internal array as object array
  - toBitSet
```
public BitSet toBitSet()
```
    Returns a copy of the internal byte-array as BitSet type
    
    Returns:
    
    bit set with the content of the internal array
  - toBigInteger
```
public BigInteger toBigInteger()
```
    The internal byte array wrapped in a BigInteger instance.
    If the internal byte order is ByteOrder.LITTLE_ENDIAN, a copy of the internal array will be reversed and used as backing array with the big integer. Otherwise the internal array will be used directly.
    
    Returns:
    
    big integer
  - toUUID
```
public UUID toUUID()
```
    Creates a UUID instance of the internal byte array. This requires the internal array to be exactly 16 bytes. Takes the first 8 byte as mostSigBits and the last 8 byte as leastSigBits. There is no validation of version/type, just passes the raw bytes to a UUID constructor.
    
    Returns:
    
    newly created UUID
  - toByte
```
public byte toByte()
```
    If the underlying byte array is exactly 1 byte / 8 bit long, returns signed two-complement representation for a Java byte value.
    If you just want to get the first element as byte, see byteAt(int), using index zero.
    
    Returns:
    
    the byte representation
    
    Throws:
    
    IllegalStateException - if byte array has length not equal to 1
    
    See Also:
    
    Primitive Types
  - toUnsignedByte
```
public int toUnsignedByte()
```
    If the underlying byte array is exactly 1 byte / 8 bit long, returns unsigned two-complement representation for a Java byte value wrapped in an 4 byte int.
    If you just want to get the first element as byte, see byteAt(int), using index zero.
    
    Returns:
    
    the unsigned byte representation wrapped in an int
    
    Throws:
    
    IllegalStateException - if byte array has length not equal to 1
    
    See Also:
    
    Primitive Types
  - toChar
```
public char toChar()
```
    If the underlying byte array is exactly 2 byte / 16 bit long, return unsigned two-complement representation for a Java char integer value. The output is dependent on the set byteOrder().
    If you just want to get the first 2 bytes as char, see charAt(int) using index zero.
    
    Returns:
    
    the int representation
    
    Throws:
    
    IllegalStateException - if byte array has length not equal to 2
    
    See Also:
    
    Primitive Types
  - toShort
```
public short toShort()
```
    If the underlying byte array is exactly 2 byte / 16 bit long, return signed two-complement representation for a Java short integer value. The output is dependent on the set byteOrder().
    If you just want to get the first 2 bytes as short, see shortAt(int) using index zero.
    
    Returns:
    
    the int representation
    
    Throws:
    
    IllegalStateException - if byte array has length not equal to 2
    
    See Also:
    
    Primitive Types
  - toInt
```
public int toInt()
```
    If the underlying byte array is exactly 4 byte / 32 bit long, return signed two-complement representation for a Java signed integer value. The output is dependent on the set byteOrder().
    If you just want to get the first 4 bytes as int, see intAt(int) using index zero.
    
    Returns:
    
    the int representation
    
    Throws:
    
    IllegalStateException - if byte array has length not equal to 4
    
    See Also:
    
    Primitive Types
  - toIntArray
```
public int[] toIntArray()
```
    Converts the internal byte array to an int array, that is, every 4 bytes will be packed into a single int.
    E.g. 4 bytes will be packed to a length 1 int array:
```
  [b1, b2, b3, b4] = [int1]
 
```
    This conversion respects the internal byte order. Will only work if all bytes can be directly mapped to int, which means the byte array length must be dividable by 4 without rest.
    Returns:
    
    new int[] instance representing this byte array
    
    Throws:
    
    IllegalArgumentException - if internal byte length mod 4 != 0
  - toLong
```
public long toLong()
```
    If the underlying byte array is exactly 8 byte / 64 bit long, return signed two-complement representation for a Java signed long integer value. The output is dependent on the set byteOrder().
    If you just want to get the first 4 bytes as long, see longAt(int) using index zero.
    
    Returns:
    
    the long representation
    
    Throws:
    
    IllegalStateException - if byte array has length not equal to 8
    
    See Also:
    
    Primitive Types
  - toLongArray
```
public long[] toLongArray()
```
    Converts the internal byte array to an long array, that is, every 8 bytes will be packed into a single long.
    E.g. 8 bytes will be packed to a length 1 long array:
```
  [b1, b2, b3, b4, b5, b6, b7, b8] = [int1]
 
```
    This conversion respects the internal byte order. Will only work if all bytes can be directly mapped to long, which means the byte array length must be dividable by 8 without rest.
    Returns:
    
    new long[] instance representing this byte array
    
    Throws:
    
    IllegalArgumentException - if internal byte length mod 8 != 0
  - toFloat
```
public float toFloat()
```
    If the underlying byte array is exactly 4 byte / 32 bit long, return the representation for a Java float value. The output is dependent on the set byteOrder().
    
    Returns:
    
    the float representation
    
    Throws:
    
    IllegalStateException - if byte array has length not equal to 4
    
    See Also:
    
    Primitive Types
  - toFloatArray
```
public float[] toFloatArray()
```
    Converts the internal byte array to an float array, that is, every 4 bytes will be packed into a single float.
    E.g. 4 bytes will be packed to a length 1 float array:
```
  [b1, b2, b3, b4] = [float1]
 
```
    This conversion respects the internal byte order. Will only work if all bytes can be directly mapped to float, which means the byte array length must be dividable by 4 without rest.
    Returns:
    
    new float[] instance representing this byte array
    
    Throws:
    
    IllegalArgumentException - if internal byte length mod 4 != 0
  - toDouble
```
public double toDouble()
```
    If the underlying byte array is exactly 8 byte / 64 bit long, return the representation for a Java double value. The output is dependent on the set byteOrder().
    
    Returns:
    
    the double representation
    
    Throws:
    
    IllegalStateException - if byte array has length not equal to 8
    
    See Also:
    
    Primitive Types
  - toDoubleArray
```
public double[] toDoubleArray()
```
    Converts the internal byte array to an double array, that is, every 8 bytes will be packed into a single double.
    E.g. 8 bytes will be packed to a length 1 double array:
```
  [b1, b2, b3, b4, b5, b6, b7, b8] = [double1]
 
```
    This conversion respects the internal byte order. Will only work if all bytes can be directly mapped to double, which means the byte array length must be dividable by 8 without rest.
    Returns:
    
    new double[] instance representing this byte array
    
    Throws:
    
    IllegalArgumentException - if internal byte length mod 8 != 0
  - toCharArray
```
public char[] toCharArray()
```
    Decodes the internal byte array to UTF-8 char array. This implementation will not internally create a String.
    
    Returns:
    
    char array
  - toCharArray
```
public char[] toCharArray(Charset charset)
```
    Decodes the internal byte array with given charset to a char array. This implementation will not internally create a String.
    
    Parameters:
    
    charset - to use for decoding
    
    Returns:
    
    char array
  - compareTo
```
public int compareTo(Bytes o)
```
    Compares this bytes instance to another.
    Two byte bytes are compared by comparing their sequences of remaining elements lexicographically, without regard to the starting position of each sequence within its corresponding buffer. Pairs of byte elements are compared as if by invoking Byte.compare(byte, byte).
    Uses ByteBuffer.compareTo(Object) internally.
    
    Specified by:
    
    compareTo in interface Comparable<Bytes>
    
    Returns:
    
    A negative integer, zero, or a positive integer as this buffer is less than, equal to, or greater than the given buffer
  - equals
```
public boolean equals(Object o)
```
    Checks if this instance is equal to given other instance o
    
    Overrides:
    
    equals in class Object
    
    Parameters:
    
    o - other instance
    
    Returns:
    
    if the instance are equal
  - equals
```
public boolean equals(byte[] anotherArray)
```
    Compares the inner array with given array
    
    Parameters:
    
    anotherArray - to compare with
    
    Returns:
    
    true if Arrays.equals(byte[], byte[]) returns true on given and internal array
  - equalsConstantTime
```
public boolean equalsConstantTime(byte[] anotherArray)
```
    Compares the inner array with given array. The comparison is done in constant time, therefore will not break on the first mismatch. This method is useful to prevent some side-channel attacks, but is slower on average.
    This implementation uses the algorithm suggested in https://codahale.com/a-lesson-in-timing-attacks/
    
    Parameters:
    
    anotherArray - to compare with
    
    Returns:
    
    true if Arrays.equals(byte[], byte[]) returns true on given and internal array
  - equals
```
public boolean equals(Byte[] anotherArray)
```
    Compares the inner array with given array. Note: a null Byte will not be equal to a 0 byte
    
    Parameters:
    
    anotherArray - to compare with
    
    Returns:
    
    true if both array have same length and every byte element is the same
  - equals
```
public boolean equals(ByteBuffer buffer)
```
    Compares the inner array with the inner array of given ByteBuffer. Will check for internal array and byte order.
    
    Parameters:
    
    buffer - to compare with
    
    Returns:
    
    true if both array have same length and every byte element is the same
  - equalsContent
```
public boolean equalsContent(Bytes other)
```
    Checks only for internal array content
    
    Parameters:
    
    other - to compare to
    
    Returns:
    
    true if the internal array are equals (see Arrays.equals(byte[], byte[]))
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - toString
```
public String toString()
```
    A constant length output toString() implementation, which only shows the byte length and at most 8 bytes preview in hex representation.
    
    Overrides:
    
    toString in class Object
    
    Returns:
    
    string representation
  - iterator
```
public Iterator<Byte> iterator()
```
    Specified by:
    
    iterator in interface Iterable<Byte>

Class Bytes

Comparable

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.lang.Iterable

Method Detail

allocate

allocate

empty

wrap

wrapNullSafe

wrap

wrap

from

fromNullSafe

from

from

from

from

from

from

from

from

from

from

from

from

from

from

from

from

from

from

from

from

from

from

from

from

from

from

from

from

from

from

from

from

from

parseBinary

parseOctal

parseDec

parseRadix

parseHex

parseBase32

parseBase36

parseBase64

parse

random

unsecureRandom

unsecureRandom

random

append

append

append

append

append

append

append

append

appendNullSafe

append

append

xor

xor

and

and

or

or

not

leftShift