ByteUtils (Bouncy Castle Library 1.52 API Specification)

org.bouncycastle.pqc.math.linearalgebra

## Class ByteUtils

- java.lang.Object
- - org.bouncycastle.pqc.math.linearalgebra.ByteUtils

-     public final class ByteUtils
      extends java.lang.Object

  This class is a utility class for manipulating byte arrays.

- - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `static byte[]` | `clone(byte[] array)` Return a clone of the given byte array (performs null check beforehand).
    `static byte[]` | `concatenate(byte[][] array)` Convert a 2-dimensional byte array into a 1-dimensional byte array by concatenating all entries.
    `static byte[]` | `concatenate(byte[] x1, byte[] x2)` Concatenate two byte arrays.
    `static int` | `deepHashCode(byte[] array)` Computes a hashcode based on the contents of a one-dimensional byte array rather than its identity.
    `static int` | `deepHashCode(byte[][] array)` Computes a hashcode based on the contents of a two-dimensional byte array rather than its identity.
    `static int` | `deepHashCode(byte[][][] array)` Computes a hashcode based on the contents of a three-dimensional byte array rather than its identity.
    `static boolean` | `equals(byte[][][] left, byte[][][] right)` Compare two three-dimensional byte arrays.
    `static boolean` | `equals(byte[][] left, byte[][] right)` Compare two two-dimensional byte arrays.
    `static boolean` | `equals(byte[] left, byte[] right)` Compare two byte arrays (perform null checks beforehand).
    `static byte[]` | `fromHexString(java.lang.String s)` Convert a string containing hexadecimal characters to a byte-array.
    `static byte[][]` | `split(byte[] input, int index)` Split a byte array `input` into two arrays at `index`, i.e. the first array will have the lower `index` bytes, the second one the higher `input.length - index` bytes.
    `static byte[]` | `subArray(byte[] input, int start)` Generate a subarray of a given byte array.
    `static byte[]` | `subArray(byte[] input, int start, int end)` Generate a subarray of a given byte array.
    `static java.lang.String` | `toBinaryString(byte[] input)` Convert a byte array to the corresponding bit string.
    `static char[]` | `toCharArray(byte[] input)` Rewrite a byte array as a char array
    `static java.lang.String` | `toHexString(byte[] input)` Convert a byte array to the corresponding hexstring.
    `static java.lang.String` | `toHexString(byte[] input, java.lang.String prefix, java.lang.String seperator)` Convert a byte array to the corresponding hex string.
    `static byte[]` | `xor(byte[] x1, byte[] x2)` Compute the bitwise XOR of two arrays of bytes.

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

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

- - ### Method Detail

    - #### equals

          public static boolean equals(byte[] left,
                       byte[] right)

      Compare two byte arrays (perform null checks beforehand).
      Parameters:
        `left` - the first byte array
        `right` - the second byte array
      Returns:
        the result of the comparison

    - #### equals

          public static boolean equals(byte[][] left,
                       byte[][] right)

      Compare two two-dimensional byte arrays. No null checks are performed.
      Parameters:
        `left` - the first byte array
        `right` - the second byte array
      Returns:
        the result of the comparison

    - #### equals

          public static boolean equals(byte[][][] left,
                       byte[][][] right)

      Compare two three-dimensional byte arrays. No null checks are performed.
      Parameters:
        `left` - the first byte array
        `right` - the second byte array
      Returns:
        the result of the comparison

    - #### deepHashCode

          public static int deepHashCode(byte[] array)

      Computes a hashcode based on the contents of a one-dimensional byte array rather than its identity.
      Parameters:
        `array` - the array to compute the hashcode of
      Returns:
        the hashcode

    - #### deepHashCode

          public static int deepHashCode(byte[][] array)

      Computes a hashcode based on the contents of a two-dimensional byte array rather than its identity.
      Parameters:
        `array` - the array to compute the hashcode of
      Returns:
        the hashcode

    - #### deepHashCode

          public static int deepHashCode(byte[][][] array)

      Computes a hashcode based on the contents of a three-dimensional byte array rather than its identity.
      Parameters:
        `array` - the array to compute the hashcode of
      Returns:
        the hashcode

    - #### clone

          public static byte[] clone(byte[] array)

      Return a clone of the given byte array (performs null check beforehand).
      Parameters:
        `array` - the array to clone
      Returns:
        the clone of the given array, or `null` if the array is `null`

    - #### fromHexString

          public static byte[] fromHexString(java.lang.String s)

      Convert a string containing hexadecimal characters to a byte-array.
      Parameters:
        `s` - a hex string
      Returns:
        a byte array with the corresponding value

    - #### toHexString

          public static java.lang.String toHexString(byte[] input)

      Convert a byte array to the corresponding hexstring.
      Parameters:
        `input` - the byte array to be converted
      Returns:
        the corresponding hexstring

    - #### toHexString

          public static java.lang.String toHexString(byte[] input,
                                     java.lang.String prefix,
                                     java.lang.String seperator)

      Convert a byte array to the corresponding hex string.
      Parameters:
        `input` - the byte array to be converted
        `prefix` - the prefix to put at the beginning of the hex string
        `seperator` - a separator string
      Returns:
        the corresponding hex string

    - #### toBinaryString

          public static java.lang.String toBinaryString(byte[] input)

      Convert a byte array to the corresponding bit string.
      Parameters:
        `input` - the byte array to be converted
      Returns:
        the corresponding bit string

    - #### xor

          public static byte[] xor(byte[] x1,
                   byte[] x2)

      Compute the bitwise XOR of two arrays of bytes. The arrays have to be of same length. No length checking is performed.
      Parameters:
        `x1` - the first array
        `x2` - the second array
      Returns:
        x1 XOR x2

    - #### concatenate

          public static byte[] concatenate(byte[] x1,
                           byte[] x2)

      Concatenate two byte arrays. No null checks are performed.
      Parameters:
        `x1` - the first array
        `x2` - the second array
      Returns:
        (x2||x1) (little-endian order, i.e. x1 is at lower memory addresses)

    - #### concatenate

          public static byte[] concatenate(byte[][] array)

      Convert a 2-dimensional byte array into a 1-dimensional byte array by concatenating all entries.
      Parameters:
        `array` - a 2-dimensional byte array
      Returns:
        the concatenated input array

    - #### split

          public static byte[][] split(byte[] input,
                       int index)
                                throws java.lang.ArrayIndexOutOfBoundsException

      Split a byte array `input` into two arrays at `index`, i.e. the first array will have the lower `index` bytes, the second one the higher `input.length - index` bytes.
      Parameters:
        `input` - the byte array to be split
        `index` - the index where the byte array is split
      Returns:
        the splitted input array as an array of two byte arrays
      Throws:
        `java.lang.ArrayIndexOutOfBoundsException` - if `index` is out of bounds

    - #### subArray

          public static byte[] subArray(byte[] input,
                        int start,
                        int end)

      Generate a subarray of a given byte array.
      Parameters:
        `input` - the input byte array
        `start` - the start index
        `end` - the end index
      Returns:
        a subarray of `input`, ranging from `start` (inclusively) to `end` (exclusively)

    - #### subArray

          public static byte[] subArray(byte[] input,
                        int start)

      Generate a subarray of a given byte array.
      Parameters:
        `input` - the input byte array
        `start` - the start index
      Returns:
        a subarray of `input`, ranging from `start` to the end of the array

    - #### toCharArray

          public static char[] toCharArray(byte[] input)

      Rewrite a byte array as a char array
      Parameters:
        `input` - - the byte array
      Returns:
        char array