Bytes (Bytes Java Primitive Tools 0.2.0 API)

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

All Implemented Interfaces:

Comparable<Bytes>

Direct Known Subclasses:

MutableBytes
```
public class Bytes
extends Object
implements Comparable<Bytes>
```
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, ...
- Making it mutable
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);
     b.negate();
     System.out.println(b.encodeHex());
 
```

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`static Bytes`	`allocate(int length)` Creates a new instance with an empty array filled 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 with the provided data (ie.
`Bytes`	`append(byte[] secondArray)` Creates a new instance with the current array appended with the provided data (ie.
`Bytes`	`append(Bytes bytes)` Creates a new instance with the current array appended with the provided data (ie.
`Bytes`	`append(char char2Bytes)` Creates a new instance with the current array appended with the provided data (ie.
`Bytes`	`append(int integer4Bytes)` Creates a new instance with the current array appended with the provided data (ie.
`Bytes`	`append(long long8Bytes)` Creates a new instance with the current array appended with the provided data (ie.
`Bytes`	`append(short short2Bytes)` Creates a new instance with the current array appended with the provided data (ie.
`byte[]`	`array()` The reference of te internal byte-array.
`BigInteger`	`bigInteger()` The internal byte array wrapped in a `BigInteger` instance.
`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 or endianness.
`Bytes`	`byteOrder(ByteOrder byteOrder)` Set the byte order or endianness of this instance.
`int`	`compareTo(Bytes o)` Compares this bytes instance to another.
`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.
`Bytes`	`duplicate()` Create a new instance which shares the same underlying array
`String`	`encode(BinaryToTextEncoding.Encoder encoder)` Encode the internal byte-array with given encoder.
`String`	`encodeBase36()` Base36 (aka Hexatrigesimal) representation.
`String`	`encodeBase64()` Base64 representation with padding.
`String`	`encodeBinary()` Binary (aka "1" and "0") representation.
`String`	`encodeCharset(Charset charset)` String 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`	`encodeUtf8()` UTF-8 representation of this byte array
`double`	`entropy()` Calculates the entropy of the internal byte array.
`boolean`	`equals(Object o)`
`boolean`	`equalsContent(byte[] array)` Checks only for internal array content
`boolean`	`equalsContent(Bytes other)` Checks only for internal array content
`static Bytes`	`from(BitSet set)` Creates a new instance from given BitSet.
`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[] 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(char char2Byte)` Creates a new instance from given unsigned 2 byte char.
`static Bytes`	`from(Collection<Byte> bytesCollection)` Creates a new instance from given collections.
`static Bytes`	`from(InputStream stream)` Reads given input stream and creates a new instance from read data
`static Bytes`	`from(int integer4byte)` Creates a new instance from given 4 byte integer.
`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(String utf8String)` Creates a new instance from given utf-8 encoded string
`static Bytes`	`from(String string, Charset charset)` Creates a new instance from given string
`int`	`hashCode()`
`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.
`InputStream`	`inputStream()` Creates an input stream with the same backing data as the intern array of this instance
`boolean`	`isEmpty()` Checks the internal array for emptiness.
`boolean`	`isReadOnly()` Check if this instance is read only
`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.
`int`	`length()` The byte length of the underlying byte array.
`int`	`lengthBit()` The bit length of the underlying byte array.
`MutableBytes`	`mutable()` Returns a mutable version of this instance with sharing the same underlying byte-array.
`Bytes`	`negate()` Bitwise negate 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(String encoded, BinaryToTextEncoding.Decoder decoder)` Parsing of arbitrary encoded format
`static Bytes`	`parseBase36(String base36String)` Parsing of base36 encoded byte arrays.
`static Bytes`	`parseBase64(String base64String)` Parsing of base64 encoded byte arrays.
`static Bytes`	`parseDec(String decString)` Parsing of decimal encoded byte arrays.
`static Bytes`	`parseHex(String hexString)` Parsing of base16/HEX encoded byte arrays.
`static Bytes`	`parseOctal(String octalString)` Parsing of octal encoded byte arrays.
`static Bytes`	`random(int length)` A new instance with random bytes.
`static Bytes`	`random(int length, Random random)` A new instance with random bytes.
`Bytes`	`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`	`reverse()` Reverses the internal byte array.
`Bytes`	`rightShift(int shiftCount)` Bitwise right shifting of internal byte array.
`Bytes`	`shuffle()` Shuffles the internal byte array with a new `SecureRandom` instance.
`Bytes`	`shuffle(Random random)` Shuffles the internal byte array
`Bytes`	`sort()` Sorts the internal byte array with it's natural ordering
`Bytes`	`sort(Comparator<Byte> comparator)` Sorts the internal byte array according to given comparator.
`BitSet`	`toBitSet()` Returns a copy of the internal byte-array as `BitSet` type
`byte`	`toByte()` If the underlying byte array is smaller than 1 byte / 8 bit returns unsigned two-complement representation for a Java byte value.
`char`	`toChar()` If the underlying byte array is smaller than 2 byte / 16 bit returns unsigned two-complement representation for a Java char integer value.
`int`	`toInt()` If the underlying byte array is smaller than 4 byte / 32 bit returns signed two-complement representation for a Java signed integer value.
`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 smaller than 8 byte / 64 bit returns signed two-complement representation for a Java signed long integer value.
`Byte[]`	`toObjectArray()` Returns a copy of the internal byte-array as boxed primitive array.
`short`	`toShort()` If the underlying byte array is smaller than 2 byte / 16 bit returns signed two-complement representation for a Java short integer value.
`String`	`toString()` A memory safe toString implementation, which only shows the byte length and at most 8 bytes preview in hex representation.
`Bytes`	`transform(BytesTransformer transformer)` Generic transformation of this instance.
`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.
`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

- Method Detail
  - allocate
```
public static Bytes allocate(int length)
```
    Creates a new instance with an empty array filled 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
  - 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
  - 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[] array,
                         int offset,
                         int length)
```
    Creates a new instance from a slice of given array
    
    Parameters:
    
    array - to slice
    
    offset - stat 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(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 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[] 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
  - 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(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(long long8byte)
```
    Creates a new instance from given 8 byte long.
    
    Parameters:
    
    long8byte - 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
    
    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(InputStream stream)
```
    Reads given input stream and creates a new instance from read data
    
    Parameters:
    
    stream - to read from
    
    Returns:
    
    new instance
  - from
```
public static Bytes from(String 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(String 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
  - parseOctal
```
public static Bytes parseOctal(String octalString)
```
    Parsing of octal encoded byte arrays.
    
    Parameters:
    
    octalString - the encoded string
    
    Returns:
    
    decoded instance
  - parseDec
```
public static Bytes parseDec(String decString)
```
    Parsing of decimal encoded byte arrays.
    
    Parameters:
    
    decString - the encoded string
    
    Returns:
    
    decoded instance
  - parseHex
```
public static Bytes parseHex(String hexString)
```
    Parsing of base16/HEX encoded byte arrays. Will accept upper- and lowercase variant and ignores possible "0x" prefix.
    
    Parameters:
    
    hexString - the encoded string
    
    Returns:
    
    decoded instance
  - parseBase36
```
public static Bytes parseBase36(String base36String)
```
    Parsing of base36 encoded byte arrays.
    
    Parameters:
    
    base36String - the encoded string
    
    Returns:
    
    decoded instance
  - parseBase64
```
public static Bytes parseBase64(String base64String)
```
    Parsing of base64 encoded byte arrays.
    
    Parameters:
    
    base64String - the encoded string
    
    Returns:
    
    decoded instance
  - parse
```
public static Bytes parse(String 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
  - 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 with the provided data (ie. append at the end)
    
    Parameters:
    
    bytes - to append
    
    Returns:
    
    appended instance
  - append
```
public Bytes append(byte singleByte)
```
    Creates a new instance with the current array appended with 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 with 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 with 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 with 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 with the provided data (ie. append at the end)
    
    Parameters:
    
    long8Bytes - to append
    
    Returns:
    
    appended instance
  - append
```
public Bytes append(byte[] secondArray)
```
    Creates a new instance with the current array appended with the provided data (ie. append at the end)
    
    Parameters:
    
    secondArray - to append
    
    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
  - negate
```
public Bytes negate()
```
    Bitwise negate 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.
    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 right shifting of internal byte array.
    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
  - 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 byte array.
    See the considerations about possible in-place operation in transform(BytesTransformer).
    
    Returns:
    
    reversed instance
  - sort
```
public Bytes sort(Comparator<Byte> comparator)
```
    Sorts the internal byte array according to given comparator.
    See the considerations about possible in-place operation in transform(BytesTransformer).
    
    Parameters:
    
    comparator - to sort the bytes
    
    Returns:
    
    sorted instance
  - sort
```
public Bytes sort()
```
    Sorts the internal byte array with it's natural ordering
    See the considerations about possible in-place operation in transform(BytesTransformer).
    
    Returns:
    
    sorted instance
  - shuffle
```
public Bytes shuffle(Random random)
```
    Shuffles the internal byte array
    See the considerations about possible in-place operation in transform(BytesTransformer).
    
    Parameters:
    
    random - used to create entropy for the shuffle
    
    Returns:
    
    a shuffled instance
  - shuffle
```
public Bytes shuffle()
```
    Shuffles the internal byte array with a new SecureRandom instance.
    See the considerations about possible in-place operation in transform(BytesTransformer).
    
    Returns:
    
    a shuffled instance
  - 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 prefered, 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)
  - 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.
    If if the internal array will be grown, zero bytes will be added on the left, keeping the value the same.
    
    Parameters:
    
    newByteLength - the length of the copy to be returned
    
    Returns:
    
    a copy with the desired size or "this" instance if newByteLength == current length
  - 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 or endianness. Default in Java is ByteOrder.BIG_ENDIAN.
    
    Returns:
    
    either ByteOrder.BIG_ENDIAN or ByteOrder.LITTLE_ENDIAN
    
    See Also:
    
    Endianness
  - isReadOnly
```
public boolean isReadOnly()
```
    Check if this instance is read only
    
    Returns:
    
    true if read only
  - indexOf
```
public int indexOf(byte target)
```
    Returns the index of the first appearance of the value target in array.
    
    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[] 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.
  - 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.
  - 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 string.
  - 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
  - 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 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 Bytes 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 (ie. immutable)
    
    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
  - bigInteger
```
public BigInteger bigInteger()
```
    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
    
    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
  - 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
  - encodeBase36
```
public String encodeBase36()
```
    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%.
    Example: SpT9/x6v7Q==
    
    Returns:
    
    base64 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
  - 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
  - toObjectArray
```
public Byte[] toObjectArray()
```
    Returns a copy of the internal byte-array as boxed primitive array. This requires a time and space complexity of O(n).
    
    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
  - toByte
```
public byte toByte()
```
    If the underlying byte array is smaller than 1 byte / 8 bit returns unsigned two-complement representation for a Java byte value.
    
    Returns:
    
    the byte representation
    
    Throws:
    
    UnsupportedOperationException - if byte array is longer than 1 byte
    
    See Also:
    
    Primitive Types
  - toChar
```
public char toChar()
```
    If the underlying byte array is smaller than 2 byte / 16 bit returns unsigned two-complement representation for a Java char integer value. The output is dependent on the set byteOrder().
    
    Returns:
    
    the int representation
    
    Throws:
    
    UnsupportedOperationException - if byte array is longer than 2 byte
    
    See Also:
    
    Primitive Types
  - toShort
```
public short toShort()
```
    If the underlying byte array is smaller than 2 byte / 16 bit returns signed two-complement representation for a Java short integer value. The output is dependent on the set byteOrder().
    
    Returns:
    
    the int representation
    
    Throws:
    
    UnsupportedOperationException - if byte array is longer than 2 byte
    
    See Also:
    
    Primitive Types
  - toInt
```
public int toInt()
```
    If the underlying byte array is smaller than 4 byte / 32 bit returns signed two-complement representation for a Java signed integer value. The output is dependent on the set byteOrder().
    
    Returns:
    
    the int representation
    
    Throws:
    
    UnsupportedOperationException - if byte array is longer than 4 byte
    
    See Also:
    
    Primitive Types
  - toLong
```
public long toLong()
```
    If the underlying byte array is smaller than 8 byte / 64 bit returns signed two-complement representation for a Java signed long integer value. The output is dependent on the set byteOrder().
    
    Returns:
    
    the long representation
    
    Throws:
    
    UnsupportedOperationException - if byte array is longer than 8 byte
    
    See Also:
    
    Primitive Types
  - 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)
```
    Overrides:
    
    equals in class Object
  - 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[]))
  - equalsContent
```
public boolean equalsContent(byte[] array)
```
    Checks only for internal array content
    
    Parameters:
    
    array - 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 memory safe 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

Class Bytes

Method Summary

Methods inherited from class java.lang.Object

Method Detail

allocate

allocate

wrap

wrap

wrap

from

from

from

from

from

from

from

from

from

from

from

from

from

from

from

parseOctal

parseDec

parseHex

parseBase36

parseBase64

parse

random

random

append

append

append

append

append

append

append

xor

xor

and

and

or

or

negate

leftShift

rightShift

copy

copy

reverse

sort

sort

shuffle

shuffle

transform

resize

length

lengthBit

isEmpty

byteOrder

isReadOnly

indexOf

indexOf

lastIndexOf

byteAt

count

entropy

duplicate

byteOrder

readOnly

buffer

bigInteger

mutable

inputStream

array

encodeBinary

encodeOctal

encodeDec

encodeHex