org.eclipse.rdf4j.common.io

## Class ByteArrayUtil

- java.lang.Object
- - org.eclipse.rdf4j.common.io.ByteArrayUtil

-     public class ByteArrayUtil
      extends Object

  Class providing utility methods for handling byte arrays.

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `ByteArrayUtil()`

  - ### Method Summary

    All Methods Static Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `static int` | `compareRegion(byte[] array1, int startIdx1, byte[] array2, int startIdx2, int length)` Compares two regions of bytes, indicating whether one is larger than the other.
    `static int` | `find(byte[] a, int fromIndex, int toIndex, byte key)` Retrieve a byte from a byte array.
    `static int` | `find(byte[] a, int fromIndex, int toIndex, byte[] key)` Look for a sequence of bytes in a byte array.
    `static byte[]` | `get(byte[] array, int offset)` Gets the subarray from `array` that starts at `offset`.
    `static byte[]` | `get(byte[] array, int offset, int length)` Gets the subarray of length `length` from `array` that starts at `offset`.
    `static int` | `getInt(byte[] array, int offset)` Get an integer value from a byte array at a specific offset.
    `static long` | `getLong(byte[] array, int offset)` Get a long value from a byte array at a specific offset.
    `static boolean` | `matchesPattern(byte[] value, byte[] mask, byte[] pattern)` Checks whether `value` matches `pattern` with respect to the bits specified by `mask`.
    `static void` | `put(byte[] source, byte[] target, int offset)` Puts the entire `source` array in the `target` array at offset `offset`.
    `static void` | `putInt(int value, byte[] array, int offset)` Put an integer value (padded) in a byte array at a specific offset.
    `static void` | `putLong(long value, byte[] array, int offset)` Put a long value (padded) in a byte array at a specific offset.
    `static boolean` | `regionMatches(byte[] subValue, byte[] superValue, int offset)` Checks whether `subValue` matches the region in `superValue` starting at offset `offset`.
    `static BitSet` | `toBitSet(byte[] array)` Convert a byte array to a vector of bits.
    `static byte[]` | `toByteArray(BitSet bitSet)` Convert a bitset to a byte array.
    `static String` | `toHexString(byte[] array)` Returns the hexadecimal value of the supplied byte array.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### ByteArrayUtil

          public ByteArrayUtil()

  - ### Method Detail

    - #### put

          public static void put(byte[] source,
                                 byte[] target,
                                 int offset)

      Puts the entire `source` array in the `target` array at offset `offset`.
      Parameters:
        `source` - source array
        `target` - target array
        `offset` - non-negative offset

    - #### get

          public static byte[] get(byte[] array,
                                   int offset)

      Gets the subarray from `array` that starts at `offset`.
      Parameters:
        `array` - source array
        `offset` - non-negative offset
      Returns:
        byte array

    - #### get

          public static byte[] get(byte[] array,
                                   int offset,
                                   int length)

      Gets the subarray of length `length` from `array` that starts at `offset`.
      Parameters:
        `array` - byte array
        `offset` - non-negative offset
        `length` - length
      Returns:
        byte array

    - #### putInt

          public static void putInt(int value,
                                    byte[] array,
                                    int offset)

      Put an integer value (padded) in a byte array at a specific offset.
      Parameters:
        `value` - integer value
        `array` - byte array
        `offset` - non-negative offset

    - #### getInt

          public static int getInt(byte[] array,
                                   int offset)

      Get an integer value from a byte array at a specific offset.
      Parameters:
        `array` - byte array
        `offset` - non-negative offset
      Returns:
        integer value

    - #### putLong

          public static void putLong(long value,
                                     byte[] array,
                                     int offset)

      Put a long value (padded) in a byte array at a specific offset.
      Parameters:
        `value` - long value
        `array` - byte array
        `offset` - non-negative offset

    - #### getLong

          public static long getLong(byte[] array,
                                     int offset)

      Get a long value from a byte array at a specific offset.
      Parameters:
        `array` - byte array
        `offset` - offset
      Returns:
        long value

    - #### find

          public static int find(byte[] a,
                                 int fromIndex,
                                 int toIndex,
                                 byte key)

      Retrieve a byte from a byte array.
      Parameters:
        `a` - the byte array to look in
        `fromIndex` - the position from which to start looking
        `toIndex` - the position up to which to look
        `key` - the byte to find
      Returns:
        the position of the byte in the array, or -1 if the byte was not found in the array

    - #### find

          public static int find(byte[] a,
                                 int fromIndex,
                                 int toIndex,
                                 byte[] key)

      Look for a sequence of bytes in a byte array.
      Parameters:
        `a` - the byte array to look in
        `fromIndex` - the position from which to start looking
        `toIndex` - the position up to which to look
        `key` - the bytes to find
      Returns:
        the position of the bytes in the array, or -1 if the bytes were not found in the array

    - #### matchesPattern

          public static boolean matchesPattern(byte[] value,
                                               byte[] mask,
                                               byte[] pattern)

      Checks whether `value` matches `pattern` with respect to the bits specified by `mask`. In other words: this method returns true if `(value[i] ^ pattern[i]) & mask[i] == 0` for all i.
      Parameters:
        `value` - byte array
        `mask` -
        `pattern` - pattern
      Returns:
        true if pattern was found

    - #### regionMatches

          public static boolean regionMatches(byte[] subValue,
                                              byte[] superValue,
                                              int offset)

      Checks whether `subValue` matches the region in `superValue` starting at offset `offset`.
      Parameters:
        `subValue` - value to search for
        `superValue` - byte array
        `offset` - non-negative offset
      Returns:
        true upon exact match, false otherwise

    - #### compareRegion

          public static int compareRegion(byte[] array1,
                                          int startIdx1,
                                          byte[] array2,
                                          int startIdx2,
                                          int length)

      Compares two regions of bytes, indicating whether one is larger than the other.
      Parameters:
        `array1` - The first byte array.
        `startIdx1` - The start of the region in the first array.
        `array2` - The second byte array.
        `startIdx2` - The start of the region in the second array.
        `length` - The length of the region that should be compared.
      Returns:
        A negative number when the first region is smaller than the second, a positive number when the first region is larger than the second, or 0 if the regions are equal.

    - #### toBitSet

          public static BitSet toBitSet(byte[] array)

      Convert a byte array to a vector of bits.
      Parameters:
        `array` - byte array
      Returns:
        bitset

    - #### toByteArray

          public static byte[] toByteArray(BitSet bitSet)

      Convert a bitset to a byte array.
      Parameters:
        `bitSet` - bitset (should not be null)
      Returns:
        byte array

    - #### toHexString

          public static String toHexString(byte[] array)

      Returns the hexadecimal value of the supplied byte array. The resulting string always uses two hexadecimals per byte. As a result, the length of the resulting string is guaranteed to be twice the length of the supplied byte array.
      Parameters:
        `array` - byte array
      Returns:
        hexadecimal string

Copyright © 2015-2020 Eclipse Foundation. All Rights Reserved.