Class Arrays

java.lang.Object
org.bouncycastle.util.Arrays

public final class Arrays extends Object
General array utilities.
  • Nested Class Summary

    Nested Classes
    Modifier and Type
    Class
    Description
    static class 
    Iterator backed by a specific array.
  • Method Summary

    Modifier and Type
    Method
    Description
    static byte[]
    append(byte[] a, byte b)
     
    static int[]
    append(int[] a, int b)
     
    static short[]
    append(short[] a, short b)
     
    static String[]
    append(String[] a, String b)
     
    static boolean
    areAllZeroes(byte[] buf, int off, int len)
     
    static boolean
    areEqual(boolean[] a, boolean[] b)
     
    static boolean
    areEqual(byte[] a, byte[] b)
     
    static boolean
    areEqual(char[] a, char[] b)
     
    static boolean
    areEqual(int[] a, int[] b)
     
    static boolean
    areEqual(long[] a, long[] b)
     
    static boolean
    areEqual(short[] a, short[] b)
     
    static boolean
    areEqual(Object[] a, Object[] b)
     
    static void
    clear(byte[] array)
    Fill input array by zeros
    static byte[]
    clone(byte[] data)
     
    static byte[][]
    clone(byte[][] data)
     
    static byte[][][]
    clone(byte[][][] data)
     
    static byte[]
    clone(byte[] data, byte[] existing)
     
    static char[]
    clone(char[] data)
     
    static int[]
    clone(int[] data)
     
    static long[]
    clone(long[] data)
     
    static long[]
    clone(long[] data, long[] existing)
     
    static short[]
    clone(short[] data)
     
    static BigInteger[]
    clone(BigInteger[] data)
     
    static int
    compareUnsigned(byte[] a, byte[] b)
     
    static byte[]
    concatenate(byte[][] arrays)
     
    static byte[]
    concatenate(byte[] a, byte[] b)
     
    static byte[]
    concatenate(byte[] a, byte[] b, byte[] c)
     
    static byte[]
    concatenate(byte[] a, byte[] b, byte[] c, byte[] d)
     
    static int[]
    concatenate(int[] a, int[] b)
     
    static boolean
    constantTimeAreEqual(byte[] expected, byte[] supplied)
    A constant time equals comparison - does not terminate early if test will fail.
    static boolean
    contains(int[] a, int n)
     
    static boolean
    contains(short[] a, short n)
     
    static byte[]
    copyOf(byte[] data, int newLength)
     
    static char[]
    copyOf(char[] data, int newLength)
     
    static int[]
    copyOf(int[] data, int newLength)
     
    static long[]
    copyOf(long[] data, int newLength)
     
    static BigInteger[]
    copyOf(BigInteger[] data, int newLength)
     
    static byte[]
    copyOfRange(byte[] data, int from, int to)
    Make a copy of a range of bytes from the passed in data array.
    static int[]
    copyOfRange(int[] data, int from, int to)
     
    static long[]
    copyOfRange(long[] data, int from, int to)
     
    static BigInteger[]
    copyOfRange(BigInteger[] data, int from, int to)
     
    static void
    fill(byte[] array, byte value)
     
    static void
    fill(byte[] array, int out, byte value)
     
    static void
    fill(byte[] array, int start, int finish, byte value)
     
    static void
    fill(char[] array, char value)
     
    static void
    fill(int[] array, int value)
     
    static void
    fill(int[] array, int out, int value)
     
    static void
    fill(long[] array, int out, long value)
     
    static void
    fill(long[] array, long value)
     
    static void
    fill(short[] array, int out, short value)
     
    static void
    fill(short[] array, short value)
     
    static int
    hashCode(byte[] data)
     
    static int
    hashCode(byte[] data, int off, int len)
     
    static int
    hashCode(char[] data)
     
    static int
    hashCode(int[] data)
     
    static int
    hashCode(int[][] ints)
     
    static int
    hashCode(int[] data, int off, int len)
     
    static int
    hashCode(long[] data)
     
    static int
    hashCode(long[] data, int off, int len)
     
    static int
    hashCode(short[] data)
     
    static int
    hashCode(short[][] shorts)
     
    static int
    hashCode(short[][][] shorts)
     
    static int
    hashCode(Object[] data)
     
    static byte[]
    prepend(byte[] a, byte b)
     
    static int[]
    prepend(int[] a, int b)
     
    static short[]
    prepend(short[] a, short b)
     
    static byte[]
    reverse(byte[] a)
     
    static int[]
    reverse(int[] a)
     

    Methods inherited from class java.lang.Object

    clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
  • Method Details

    • areAllZeroes

      public static boolean areAllZeroes(byte[] buf, int off, int len)
    • areEqual

      public static boolean areEqual(boolean[] a, boolean[] b)
    • areEqual

      public static boolean areEqual(char[] a, char[] b)
    • areEqual

      public static boolean areEqual(byte[] a, byte[] b)
    • areEqual

      public static boolean areEqual(short[] a, short[] b)
    • constantTimeAreEqual

      public static boolean constantTimeAreEqual(byte[] expected, byte[] supplied)
      A constant time equals comparison - does not terminate early if test will fail. For best results always pass the expected value as the first parameter.
      Parameters:
      expected - first array
      supplied - second array
      Returns:
      true if arrays equal, false otherwise.
    • areEqual

      public static boolean areEqual(int[] a, int[] b)
    • areEqual

      public static boolean areEqual(long[] a, long[] b)
    • areEqual

      public static boolean areEqual(Object[] a, Object[] b)
    • compareUnsigned

      public static int compareUnsigned(byte[] a, byte[] b)
    • contains

      public static boolean contains(short[] a, short n)
    • contains

      public static boolean contains(int[] a, int n)
    • fill

      public static void fill(byte[] array, byte value)
    • fill

      public static void fill(byte[] array, int start, int finish, byte value)
    • fill

      public static void fill(char[] array, char value)
    • fill

      public static void fill(long[] array, long value)
    • fill

      public static void fill(short[] array, short value)
    • fill

      public static void fill(int[] array, int value)
    • fill

      public static void fill(byte[] array, int out, byte value)
    • fill

      public static void fill(int[] array, int out, int value)
    • fill

      public static void fill(short[] array, int out, short value)
    • fill

      public static void fill(long[] array, int out, long value)
    • hashCode

      public static int hashCode(byte[] data)
    • hashCode

      public static int hashCode(byte[] data, int off, int len)
    • hashCode

      public static int hashCode(char[] data)
    • hashCode

      public static int hashCode(int[][] ints)
    • hashCode

      public static int hashCode(int[] data)
    • hashCode

      public static int hashCode(int[] data, int off, int len)
    • hashCode

      public static int hashCode(long[] data)
    • hashCode

      public static int hashCode(long[] data, int off, int len)
    • hashCode

      public static int hashCode(short[][][] shorts)
    • hashCode

      public static int hashCode(short[][] shorts)
    • hashCode

      public static int hashCode(short[] data)
    • hashCode

      public static int hashCode(Object[] data)
    • clone

      public static byte[] clone(byte[] data)
    • clone

      public static char[] clone(char[] data)
    • clone

      public static byte[] clone(byte[] data, byte[] existing)
    • clone

      public static byte[][] clone(byte[][] data)
    • clone

      public static byte[][][] clone(byte[][][] data)
    • clone

      public static int[] clone(int[] data)
    • clone

      public static long[] clone(long[] data)
    • clone

      public static long[] clone(long[] data, long[] existing)
    • clone

      public static short[] clone(short[] data)
    • clone

      public static BigInteger[] clone(BigInteger[] data)
    • copyOf

      public static byte[] copyOf(byte[] data, int newLength)
    • copyOf

      public static char[] copyOf(char[] data, int newLength)
    • copyOf

      public static int[] copyOf(int[] data, int newLength)
    • copyOf

      public static long[] copyOf(long[] data, int newLength)
    • copyOf

      public static BigInteger[] copyOf(BigInteger[] data, int newLength)
    • copyOfRange

      public static byte[] copyOfRange(byte[] data, int from, int to)
      Make a copy of a range of bytes from the passed in data array. The range can extend beyond the end of the input array, in which case the return array will be padded with zeroes.
      Parameters:
      data - the array from which the data is to be copied.
      from - the start index at which the copying should take place.
      to - the final index of the range (exclusive).
      Returns:
      a new byte array containing the range given.
    • copyOfRange

      public static int[] copyOfRange(int[] data, int from, int to)
    • copyOfRange

      public static long[] copyOfRange(long[] data, int from, int to)
    • copyOfRange

      public static BigInteger[] copyOfRange(BigInteger[] data, int from, int to)
    • append

      public static byte[] append(byte[] a, byte b)
    • append

      public static short[] append(short[] a, short b)
    • append

      public static int[] append(int[] a, int b)
    • append

      public static String[] append(String[] a, String b)
    • concatenate

      public static byte[] concatenate(byte[] a, byte[] b)
    • concatenate

      public static byte[] concatenate(byte[] a, byte[] b, byte[] c)
    • concatenate

      public static byte[] concatenate(byte[] a, byte[] b, byte[] c, byte[] d)
    • concatenate

      public static byte[] concatenate(byte[][] arrays)
    • concatenate

      public static int[] concatenate(int[] a, int[] b)
    • prepend

      public static byte[] prepend(byte[] a, byte b)
    • prepend

      public static short[] prepend(short[] a, short b)
    • prepend

      public static int[] prepend(int[] a, int b)
    • reverse

      public static byte[] reverse(byte[] a)
    • reverse

      public static int[] reverse(int[] a)
    • clear

      public static void clear(byte[] array)
      Fill input array by zeros
      Parameters:
      array - input array