net.lecousin.framework.collections

Class ArrayUtil

java.lang.Object

net.lecousin.framework.collections.ArrayUtil

public final class ArrayUtil
extends Object

Utility methods for arrays.

Method Summary

Modifier and Type	Method and Description
static <T> T[]	add(T[] a, Collection<T> toAdd) Create a new array with new elements appended at the end.
static <T> T[]	add(T[] a, T elem) Create a new array with one more element appended at the end.
static <T> T[]	add(T[] a, T elem, int pos) Create a new array with one more element inserted at the given position.
static int	compare(byte[] b1, byte[] b2) Compare 2 byte arrays.
static int	compare(byte[] b1, int off1, byte[] b2, int off2, int len) Compare 2 byte arrays.
static <T> T[]	concatenate(T[] a, T[] b) Create a new array concatenating first array with second array.
static boolean	contains(byte[] array, byte value) Return true if the array contains the value.
static boolean	contains(char[] array, char value) Return true if the array contains the value.
static boolean	contains(int[] array, int value) Return true if the array contains the value.
static boolean	contains(long[] array, long value) Return true if the array contains the value.
static boolean	contains(short[] array, short value) Return true if the array contains the value.
static <T> boolean	contains(T[] array, T value) Return true if the array contains the value.
static byte[]	copy(byte[] a) Create a copy of the array.
static <T> T[]	createGenericArray(Class<T[]> clazz, int size) Creates an array of the given type and size.
static <T> T[]	createGenericArray(Class<T[]> clazz, Object[] content) Creates an array of the given type, and put the given elements inside.
static <T> T[]	createGenericArrayOf(int size, Class<T> type) Creates an array of the given type and size.
static boolean	equals(byte[] a1, byte[] a2) Return true if the 2 arrays are identical.
static boolean	equals(byte[] a1, int off1, byte[] a2, int off2, int len) Return true if the 2 specified parts of the arrays are identical.
static boolean	equals(char[] a1, char[] a2) Return true if the 2 arrays are identical.
static boolean	equals(char[] a1, int off1, char[] a2, int off2, int len) Return true if the 2 specified parts of the arrays are identical.
static boolean	equals(int[] a1, int[] a2) Return true if the 2 arrays are identical.
static boolean	equals(int[] a1, int off1, int[] a2, int off2, int len) Return true if the 2 specified parts of the arrays are identical.
static boolean	equals(long[] a1, int off1, long[] a2, int off2, int len) Return true if the 2 specified parts of the arrays are identical.
static boolean	equals(long[] a1, long[] a2) Return true if the 2 arrays are identical.
static boolean	equals(short[] a1, int off1, short[] a2, int off2, int len) Return true if the 2 specified parts of the arrays are identical.
static boolean	equals(short[] a1, short[] a2) Return true if the 2 arrays are identical.
static <T> boolean	equals(T[] a1, int off1, T[] a2, int off2, int len) Return true if the portions of the arrays are equal.
static <T> boolean	equals(T[] a1, T[] a2) Return true if the 2 arrays are identical.
static int	indexOf(byte element, byte[] array) Return the index of the element in the array, or -1 if not found.
static int	indexOf(char element, char[] array) Return the index of the element in the array, or -1 if not found.
static int	indexOf(int element, int[] array) Return the index of the element in the array, or -1 if not found.
static int	indexOf(long element, long[] array) Return the index of the element in the array, or -1 if not found.
static int	indexOf(short element, short[] array) Return the index of the element in the array, or -1 if not found.
static <T> int	indexOf(T element, T[] array) Return the index of the element in the array, or -1 if not found.
static <T> int	indexOfInstance(T element, T[] array) Return the index of the element in the array, or -1 if not found.
static <T> List<T>	intersectionIdentity(T[] a1, T[] a2) Creates a List containing instances of elements present in both arrays.
static <T> Iterator<T>	iterator(T[] a) Instantiate an ArrayIterator on the given array.
static byte[]	merge(List<byte[]> arrays) Create a single byte array from the given arrays.
static <T> ArrayList<T>	newArrayList(T[] items) Create an ArrayList from the array.
static <T> T[]	remove(T[] a, T elem) Remove an element from an array.
static <T> T[]	removeAt(T[] a, int i) Create a new array with the element at the given position removed from it.
static int	search(byte[] toFind, byte[] array) Search a sequence of bytes.
static int	search(byte[] toFind, byte[] array, int start) Search a sequence of bytes.
static int	search(byte[] toFind, byte[] array, int start, int len) Search a sequence of bytes.
static int[]	toArray(Collection<Integer> col) Create an array from the collection.

Methods inherited from class java.lang.Object

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

Method Detail

contains

public static <T> boolean contains(T[] array,
                                   T value)

Return true if the array contains the value. Comparison is done using the equals method. The array must not contain null values.

contains

public static boolean contains(char[] array,
                               char value)

Return true if the array contains the value.

contains

public static boolean contains(byte[] array,
                               byte value)

Return true if the array contains the value.

contains

public static boolean contains(short[] array,
                               short value)

Return true if the array contains the value.

contains

public static boolean contains(int[] array,
                               int value)

Return true if the array contains the value.

contains

public static boolean contains(long[] array,
                               long value)

Return true if the array contains the value.

indexOf

public static <T> int indexOf(T element,
                              T[] array)

Return the index of the element in the array, or -1 if not found. Comparison is done using the equals method. The array must not contain null values.

indexOf

public static int indexOf(byte element,
                          byte[] array)

Return the index of the element in the array, or -1 if not found.

indexOf

public static int indexOf(short element,
                          short[] array)

Return the index of the element in the array, or -1 if not found.

indexOf

public static int indexOf(int element,
                          int[] array)

Return the index of the element in the array, or -1 if not found.

indexOf

public static int indexOf(long element,
                          long[] array)

Return the index of the element in the array, or -1 if not found.

indexOf

public static int indexOf(char element,
                          char[] array)

Return the index of the element in the array, or -1 if not found.

indexOfInstance

public static <T> int indexOfInstance(T element,
                                      T[] array)

Return the index of the element in the array, or -1 if not found. Comparison is done using the == operator. The array may contain null values.

equals

public static <T> boolean equals(T[] a1,
                                 T[] a2)

Return true if the 2 arrays are identical. The are identical if both are null or

• They have the same length
• The elements are the same (using equals method) in the same order

equals

public static <T> boolean equals(T[] a1,
                                 int off1,
                                 T[] a2,
                                 int off2,
                                 int len)

Return true if the portions of the arrays are equal.

equals

public static boolean equals(byte[] a1,
                             byte[] a2)

Return true if the 2 arrays are identical. The are identical if both are null or

• They have the same length
• The values are the same in the same order

equals

public static boolean equals(byte[] a1,
                             int off1,
                             byte[] a2,
                             int off2,
                             int len)

Return true if the 2 specified parts of the arrays are identical. The are identical if both array are null or if the values are the same and in the same order starting at their respective offset.

equals

public static boolean equals(short[] a1,
                             short[] a2)

Return true if the 2 arrays are identical. The are identical if both are null or

• They have the same length
• The values are the same in the same order

equals

public static boolean equals(short[] a1,
                             int off1,
                             short[] a2,
                             int off2,
                             int len)

Return true if the 2 specified parts of the arrays are identical. The are identical if both array are null or if the values are the same and in the same order starting at their respective offset.

equals

public static boolean equals(int[] a1,
                             int[] a2)

Return true if the 2 arrays are identical. The are identical if both are null or

• They have the same length
• The values are the same in the same order

equals

public static boolean equals(int[] a1,
                             int off1,
                             int[] a2,
                             int off2,
                             int len)

Return true if the 2 specified parts of the arrays are identical. The are identical if both array are null or if the values are the same and in the same order starting at their respective offset.

equals

public static boolean equals(long[] a1,
                             long[] a2)

Return true if the 2 arrays are identical. The are identical if both are null or

• They have the same length
• The values are the same in the same order

equals

public static boolean equals(long[] a1,
                             int off1,
                             long[] a2,
                             int off2,
                             int len)

Return true if the 2 specified parts of the arrays are identical. The are identical if both array are null or if the values are the same and in the same order starting at their respective offset.

equals

public static boolean equals(char[] a1,
                             char[] a2)

Return true if the 2 arrays are identical. The are identical if both are null or

• They have the same length
• The values are the same in the same order

equals

public static boolean equals(char[] a1,
                             int off1,
                             char[] a2,
                             int off2,
                             int len)

Return true if the 2 specified parts of the arrays are identical. The are identical if both array are null or if the values are the same and in the same order starting at their respective offset.

createGenericArray

public static <T> T[] createGenericArray(Class<T[]> clazz,
                                         int size)

Creates an array of the given type and size.

createGenericArray

public static <T> T[] createGenericArray(Class<T[]> clazz,
                                         Object[] content)

Creates an array of the given type, and put the given elements inside.

createGenericArrayOf

public static <T> T[] createGenericArrayOf(int size,
                                           Class<T> type)

Creates an array of the given type and size.

intersectionIdentity

public static <T> List<T> intersectionIdentity(T[] a1,
                                               T[] a2)

Creates a List containing instances of elements present in both arrays.

concatenate

public static <T> T[] concatenate(T[] a,
                                  T[] b)

Create a new array concatenating first array with second array.

merge

public static byte[] merge(List<byte[]> arrays)

Create a single byte array from the given arrays.

compare

public static int compare(byte[] b1,
                          byte[] b2)

Compare 2 byte arrays. Comparison is done byte by byte. On the first different byte, if the value of the byte on the first array is lower than the second array -1 is returned, else 1 is returned. If the first array contains less elements than the second, and the bytes are the same, -1 is returned. If the first array contains more elements than the second, and the bytes are the same, 1 is returned.

compare

public static int compare(byte[] b1,
                          int off1,
                          byte[] b2,
                          int off2,
                          int len)

Compare 2 byte arrays. If both contain the same values, starting at their respective offset, 0 is returned. Else the first different byte is compared: if the value of the byte on the first array is lower than the second array -1 is returned, else 1 is returned.

add

public static <T> T[] add(T[] a,
                          T elem)

Create a new array with one more element appended at the end.

add

public static <T> T[] add(T[] a,
                          T elem,
                          int pos)

Create a new array with one more element inserted at the given position.

add

public static <T> T[] add(T[] a,
                          Collection<T> toAdd)

Create a new array with new elements appended at the end.

remove

public static <T> T[] remove(T[] a,
                             T elem)

Remove an element from an array. If the element is not found, the original array is returned. If the element is found, a new array is created with the first occurence of the element removed from it.

removeAt

public static <T> T[] removeAt(T[] a,
                               int i)

Create a new array with the element at the given position removed from it.

iterator

public static <T> Iterator<T> iterator(T[] a)

Instantiate an ArrayIterator on the given array.

copy

public static byte[] copy(byte[] a)

Create a copy of the array.

toArray

public static int[] toArray(Collection<Integer> col)

Create an array from the collection.

newArrayList

public static <T> ArrayList<T> newArrayList(T[] items)

Create an ArrayList from the array.

search

public static int search(byte[] toFind,
                         byte[] array)

Search a sequence of bytes.

search

public static int search(byte[] toFind,
                         byte[] array,
                         int start)

Search a sequence of bytes.

search

public static int search(byte[] toFind,
                         byte[] array,
                         int start,
                         int len)

Search a sequence of bytes.