org.bouncycastle.util

Class Arrays

java.lang.Object

org.bouncycastle.util.Arrays

public final class Arrays
extends java.lang.Object

General array utilities.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	Arrays.Iterator<T> Iterator backed by a specific array.

Method Summary

Modifier and Type	Method and Description
static byte[]	append(byte[] a, byte b)
static int[]	append(int[] a, int b)
static short[]	append(short[] a, short b)
static java.lang.String[]	append(java.lang.String[] a, java.lang.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(java.lang.Object[] a, java.lang.Object[] b)
static boolean	areEqual(short[] a, short[] b)
static void	clear(byte[] array) Fill input array by zeros
static java.math.BigInteger[]	clone(java.math.BigInteger[] data)
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 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 java.math.BigInteger[]	copyOf(java.math.BigInteger[] data, int newLength)
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 java.math.BigInteger[]	copyOfRange(java.math.BigInteger[] data, int from, int to)
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 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(java.lang.Object[] data)
static int	hashCode(short[] data)
static int	hashCode(short[][] shorts)
static int	hashCode(short[][][] shorts)
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 Detail

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(java.lang.Object[] a,
                               java.lang.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(java.lang.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 java.math.BigInteger[] clone(java.math.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 java.math.BigInteger[] copyOf(java.math.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 java.math.BigInteger[] copyOfRange(java.math.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 java.lang.String[] append(java.lang.String[] a,
                                        java.lang.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