Package com.intellij.util

Class ArrayUtil

java.lang.Object

com.intellij.util.ArrayUtilRt

com.intellij.util.ArrayUtil

public class ArrayUtil
extends ArrayUtilRt

Author: msk

Field Summary

Fields

Modifier and Type	Field	Description
static final boolean[]	EMPTY_BOOLEAN_ARRAY
static final byte[]	EMPTY_BYTE_ARRAY
static final char[]	EMPTY_CHAR_ARRAY
static final Class[]	EMPTY_CLASS_ARRAY
static final Collection[]	EMPTY_COLLECTION_ARRAY
static final File[]	EMPTY_FILE_ARRAY
static final int[]	EMPTY_INT_ARRAY
static final long[]	EMPTY_LONG_ARRAY
static final Object[]	EMPTY_OBJECT_ARRAY
static final Runnable[]	EMPTY_RUNNABLE_ARRAY
static final short[]	EMPTY_SHORT_ARRAY
static final String[]	EMPTY_STRING_ARRAY
static final ArrayFactory<Object>	OBJECT_ARRAY_FACTORY
static final ArrayFactory<String>	STRING_ARRAY_FACTORY

Method Summary

Modifier and Type	Method	Description
static boolean[]	append(boolean[] array, boolean value)
static byte[]	append(byte[] array, byte value)
static int[]	append(int[] array, int value)
static long[]	append(long[] array, long value)
static <T> T[]	append(T[] src, T element)	Appends element to the src array.
static <T> T[]	append(T[] src, T element, ArrayFactory<T> factory)
static <T> T[]	append(T[] src, T element, Class<T> componentType)
static long	averageAmongMedians(int[] time, int part)
static long	averageAmongMedians(long[] time, int part)
static boolean	contains(String s, String... strings)
static <T> boolean	contains(T o, T... objects)
static <T> void	copy(Collection<? extends T> src, T[] dst, int dstOffset)
static <E> E[]	ensureExactSize(int count, E[] sample)
static <T> boolean	equals(T[] a1, T[] a2, Equality<? super T> comparator)
static <T> boolean	equals(T[] a1, T[] a2, Comparator<? super T> comparator)
static int	find(int[] src, int obj)
static <T> int	find(T[] src, T obj)
static <T> T	getFirstElement(T[] array)
static <T> T	getLastElement(T[] array)
static int	indexOf(int[] ints, int value)
static int	indexOf(long[] ints, long value)
static int	indexOf(short[] ints, short value)
static int	indexOf(Object[] objects, Object object)
static int	indexOf(Object[] objects, Object object, int start, int end)
static <T> int	indexOf(List<T> objects, T object, Equality<T> comparator)
static <T> int	indexOf(List<T> objects, T object, Comparator<T> comparator)
static <T> int	indexOf(T[] objects, T object, Equality<T> comparator)
static int[]	insert(int[] array, int index, int value)
static <T> T[]	insert(T[] array, int index, T value)
static <T> boolean	isEmpty(T[] array)
static <T> int	lastIndexOf(int[] src, int obj)
static <T> int	lastIndexOf(List<T> src, T obj, Equality<? super T> comparator)
static <T> int	lastIndexOf(T[] src, T obj)
static <T> int	lastIndexOf(T[] src, T obj, Equality<? super T> comparator)
static int	lexicographicCompare(String[] obj1, String[] obj2)
static <T> int	lexicographicCompare(T[] obj1, T[] obj2)
static <T> T[]	mergeArrayAndCollection(T[] array, Collection<T> collection, ArrayFactory<T> factory)	Allocates new array of size array.length + collection.size() and copies elements of array and collection to it.
static byte[]	mergeArrays(byte[] a1, byte[] a2)
static int[]	mergeArrays(int[] a1, int[] a2)
static String[]	mergeArrays(String[] a1, String... a2)
static <T> T[]	mergeArrays(T[] a1, T[] a2)
static <T> T[]	mergeArrays(T[] a1, T[] a2, ArrayFactory<T> factory)
static <T> T[]	mergeCollections(Collection<? extends T> c1, Collection<? extends T> c2, ArrayFactory<T> factory)
static int	min(int[] values)
static int[]	newIntArray(int count)
static long[]	newLongArray(int count)
static Object[]	newObjectArray(int count)
static String[]	newStringArray(int count)
static byte[]	prepend(byte element, byte[] array)
static <T> T[]	prepend(T element, T[] array)
static <T> T[]	prepend(T element, T[] src, ArrayFactory<T> factory)
static <T> T[]	prepend(T element, T[] array, Class<T> type)
static boolean[]	realloc(boolean[] array, int newSize)
static byte[]	realloc(byte[] array, int newSize)
static char[]	realloc(char[] array, int newSize)
static int[]	realloc(int[] array, int newSize)
static long[]	realloc(long[] array, int newSize)
static <T> T[]	realloc(T[] array, int newSize, ArrayFactory<T> factory)
static int[]	remove(int[] src, int idx)
static short[]	remove(short[] src, int idx)
static <T> T[]	remove(T[] src, int idx)	Removes element with index idx from array src.
static <T> T[]	remove(T[] src, int idx, ArrayFactory<T> factory)
static <T> T[]	remove(T[] src, T element)
static <T> T[]	remove(T[] src, T element, ArrayFactory<T> factory)
static int[]	reverseArray(int[] array)
static <T> T[]	reverseArray(T[] array)
static <T> void	rotateLeft(T[] array, int i1, int i2)
static <T> void	rotateRight(T[] array, int i1, int i2)
static boolean	startsWith(byte[] array, byte[] prefix)
static boolean	startsWith(byte[] array, int start, byte[] subArray)
static <E> boolean	startsWith(E[] array, E[] subArray)
static <T> T[]	stripTrailingNulls(T[] array)
static void	swap(boolean[] array, int i1, int i2)
static void	swap(char[] array, int i1, int i2)
static void	swap(int[] array, int i1, int i2)
static <T> void	swap(T[] array, int i1, int i2)
static int[]	toIntArray(Collection<Integer> list)
static <T> T[]	toObjectArray(Class<T> aClass, Object... source)
static Object[]	toObjectArray(Collection<?> collection)
static <T> T[]	toObjectArray(Collection<T> collection, Class<T> aClass)
static String[]	toStringArray(Collection<String> collection)

Methods inherited from class java.lang.Object

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

Field Details

EMPTY_SHORT_ARRAY

public static final short[] EMPTY_SHORT_ARRAY

EMPTY_CHAR_ARRAY

public static final char[] EMPTY_CHAR_ARRAY

EMPTY_BYTE_ARRAY

public static final byte[] EMPTY_BYTE_ARRAY

EMPTY_INT_ARRAY

public static final int[] EMPTY_INT_ARRAY

EMPTY_BOOLEAN_ARRAY

public static final boolean[] EMPTY_BOOLEAN_ARRAY

EMPTY_OBJECT_ARRAY

public static final Object[] EMPTY_OBJECT_ARRAY

EMPTY_STRING_ARRAY

public static final String[] EMPTY_STRING_ARRAY

EMPTY_CLASS_ARRAY

public static final Class[] EMPTY_CLASS_ARRAY

EMPTY_LONG_ARRAY

public static final long[] EMPTY_LONG_ARRAY

EMPTY_COLLECTION_ARRAY

public static final Collection[] EMPTY_COLLECTION_ARRAY

EMPTY_FILE_ARRAY

public static final File[] EMPTY_FILE_ARRAY

EMPTY_RUNNABLE_ARRAY

public static final Runnable[] EMPTY_RUNNABLE_ARRAY

STRING_ARRAY_FACTORY

public static final ArrayFactory<String> STRING_ARRAY_FACTORY

OBJECT_ARRAY_FACTORY

public static final ArrayFactory<Object> OBJECT_ARRAY_FACTORY

Method Details

realloc

@NotNull
@Contract(pure=true)
public static byte[] realloc(@NotNull
 byte[] array,
 int newSize)

realloc

@NotNull
@Contract(pure=true)
public static boolean[] realloc(@NotNull
 boolean[] array,
 int newSize)

realloc

@NotNull
@Contract(pure=true)
public static long[] realloc(@NotNull
 long[] array,
 int newSize)

realloc

@NotNull
@Contract(pure=true)
public static int[] realloc(@NotNull
 int[] array,
 int newSize)

realloc

@NotNull
@Contract(pure=true)
public static <T> T[] realloc(@NotNull
 T[] array,
 int newSize,
 @NotNull
 ArrayFactory<T> factory)

append

@NotNull
@Contract(pure=true)
public static long[] append(@NotNull
 long[] array,
 long value)

append

@NotNull
@Contract(pure=true)
public static int[] append(@NotNull
 int[] array,
 int value)

insert

@NotNull
@Contract(pure=true)
public static <T> T[] insert(@NotNull
 T[] array,
 int index,
 T value)

insert

@NotNull
@Contract(pure=true)
public static int[] insert(@NotNull
 int[] array,
 int index,
 int value)

append

@NotNull
@Contract(pure=true)
public static byte[] append(@NotNull
 byte[] array,
 byte value)

append

@NotNull
@Contract(pure=true)
public static boolean[] append(@NotNull
 boolean[] array,
 boolean value)

realloc

@NotNull
@Contract(pure=true)
public static char[] realloc(@NotNull
 char[] array,
 int newSize)

toObjectArray

@NotNull
@Contract(pure=true)
public static <T> T[] toObjectArray(@NotNull
 Collection<T> collection,
 @NotNull
 Class<T> aClass)

toObjectArray

@NotNull
@Contract(pure=true)
public static <T> T[] toObjectArray(@NotNull
 Class<T> aClass,
 @NotNull
 Object... source)

toObjectArray

@NotNull
@Contract(pure=true)
public static Object[] toObjectArray(@NotNull
 Collection<?> collection)

toIntArray

@NotNull
@Contract(pure=true)
public static int[] toIntArray(@NotNull
 Collection<Integer> list)

mergeArrays

@NotNull
@Contract(pure=true)
public static <T> T[] mergeArrays(@NotNull
 T[] a1,
 @NotNull
 T[] a2)

mergeCollections

@NotNull
@Contract(pure=true)
public static <T> T[] mergeCollections(@NotNull
 Collection<? extends T> c1,
 @NotNull
 Collection<? extends T> c2,
 @NotNull
 ArrayFactory<T> factory)

mergeArrays

@NotNull
@Contract(pure=true)
public static <T> T[] mergeArrays(@NotNull
 T[] a1,
 @NotNull
 T[] a2,
 @NotNull
 ArrayFactory<T> factory)

mergeArrays

@NotNull
@Contract(pure=true)
public static String[] mergeArrays(@NotNull
 String[] a1,
 @NotNull
 String... a2)

mergeArrays

@NotNull
@Contract(pure=true)
public static int[] mergeArrays(@NotNull
 int[] a1,
 @NotNull
 int[] a2)

mergeArrays

@NotNull
@Contract(pure=true)
public static byte[] mergeArrays(@NotNull
 byte[] a1,
 @NotNull
 byte[] a2)

mergeArrayAndCollection

@NotNull
@Contract(pure=true)
public static <T> T[] mergeArrayAndCollection(@NotNull
 T[] array,
 @NotNull
 Collection<T> collection,
 @NotNull
 ArrayFactory<T> factory)

Allocates new array of size array.length + collection.size() and copies elements of array and collection to it.

Parameters:

array - source array

collection - source collection

factory - array factory used to create destination array of type T

Returns:

destination array

append

@NotNull
@Contract(pure=true)
public static <T> T[] append(@NotNull
 T[] src,
 @Nullable
 T element)

Appends element to the src array. As you can imagine the appended element will be the last one in the returned result.

Parameters:

src - array to which the element should be appended.

element - object to be appended to the end of src array.

Returns:

new array

prepend

@NotNull
@Contract(pure=true)
public static <T> T[] prepend(T element,
 @NotNull
 T[] array)

prepend

@NotNull
@Contract(pure=true)
public static <T> T[] prepend(T element,
 @NotNull
 T[] array,
 @NotNull
 Class<T> type)

prepend

@NotNull
@Contract(pure=true)
public static <T> T[] prepend(T element,
 @NotNull
 T[] src,
 @NotNull
 ArrayFactory<T> factory)

prepend

@NotNull
@Contract(pure=true)
public static byte[] prepend(byte element,
 @NotNull
 byte[] array)

append

@NotNull
@Contract(pure=true)
public static <T> T[] append(@NotNull
 T[] src,
 T element,
 @NotNull
 ArrayFactory<T> factory)

append

@NotNull
@Contract(pure=true)
public static <T> T[] append(@NotNull
 T[] src,
 @Nullable
 T element,
 @NotNull
 Class<T> componentType)

remove

@NotNull
@Contract(pure=true)
public static <T> T[] remove(@NotNull
 T[] src,
 int idx)

Removes element with index idx from array src.

Parameters:

src - array.

idx - index of element to be removed.

Returns:

modified array.

remove

@NotNull
@Contract(pure=true)
public static <T> T[] remove(@NotNull
 T[] src,
 int idx,
 @NotNull
 ArrayFactory<T> factory)

remove

@NotNull
@Contract(pure=true)
public static <T> T[] remove(@NotNull
 T[] src,
 T element)

remove

@NotNull
@Contract(pure=true)
public static <T> T[] remove(@NotNull
 T[] src,
 T element,
 @NotNull
 ArrayFactory<T> factory)

remove

@NotNull
@Contract(pure=true)
public static int[] remove(@NotNull
 int[] src,
 int idx)

remove

@NotNull
@Contract(pure=true)
public static short[] remove(@NotNull
 short[] src,
 int idx)

find

@Contract(pure=true)
public static int find(@NotNull
 int[] src,
 int obj)

find

@Contract(pure=true)
public static <T> int find(@NotNull
 T[] src,
 T obj)

startsWith

@Contract(pure=true)
public static boolean startsWith(@NotNull
 byte[] array,
 @NotNull
 byte[] prefix)

startsWith

@Contract(pure=true)
public static <E> boolean startsWith(@NotNull
 E[] array,
 @NotNull
 E[] subArray)

startsWith

@Contract(pure=true)
public static boolean startsWith(@NotNull
 byte[] array,
 int start,
 @NotNull
 byte[] subArray)

equals

@Contract(pure=true)
public static <T> boolean equals(@NotNull
 T[] a1,
 @NotNull
 T[] a2,
 @NotNull
 Equality<? super T> comparator)

equals

@Contract(pure=true)
public static <T> boolean equals(@NotNull
 T[] a1,
 @NotNull
 T[] a2,
 @NotNull
 Comparator<? super T> comparator)

reverseArray

@NotNull
@Contract(pure=true)
public static <T> T[] reverseArray(@NotNull
 T[] array)

reverseArray

@NotNull
@Contract(pure=true)
public static int[] reverseArray(@NotNull
 int[] array)

lexicographicCompare

@Contract(pure=true)
public static int lexicographicCompare(@NotNull
 String[] obj1,
 @NotNull
 String[] obj2)

lexicographicCompare

@Contract(pure=true)
public static <T> int lexicographicCompare(@NotNull
 T[] obj1,
 @NotNull
 T[] obj2)

swap

public static <T> void swap(@NotNull
 T[] array,
 int i1,
 int i2)

swap

public static void swap(@NotNull
 int[] array,
 int i1,
 int i2)

swap

public static void swap(@NotNull
 boolean[] array,
 int i1,
 int i2)

swap

public static void swap(@NotNull
 char[] array,
 int i1,
 int i2)

rotateLeft

public static <T> void rotateLeft(@NotNull
 T[] array,
 int i1,
 int i2)

rotateRight

public static <T> void rotateRight(@NotNull
 T[] array,
 int i1,
 int i2)

indexOf

@Contract(pure=true)
public static int indexOf(@NotNull
 Object[] objects,
 @Nullable
 Object object)

indexOf

@Contract(pure=true)
public static int indexOf(@NotNull
 Object[] objects,
 Object object,
 int start,
 int end)

indexOf

@Contract(pure=true)
public static <T> int indexOf(@NotNull
 List<T> objects,
 T object,
 @NotNull
 Equality<T> comparator)

indexOf

@Contract(pure=true)
public static <T> int indexOf(@NotNull
 List<T> objects,
 T object,
 @NotNull
 Comparator<T> comparator)

indexOf

@Contract(pure=true)
public static <T> int indexOf(@NotNull
 T[] objects,
 T object,
 @NotNull
 Equality<T> comparator)

indexOf

@Contract(pure=true)
public static int indexOf(@NotNull
 long[] ints,
 long value)

indexOf

@Contract(pure=true)
public static int indexOf(@NotNull
 int[] ints,
 int value)

indexOf

@Contract(pure=true)
public static int indexOf(@NotNull
 short[] ints,
 short value)

lastIndexOf

@Contract(pure=true)
public static <T> int lastIndexOf(@NotNull
 T[] src,
 T obj)

lastIndexOf

@Contract(pure=true)
public static <T> int lastIndexOf(@NotNull
 int[] src,
 int obj)

lastIndexOf

@Contract(pure=true)
public static <T> int lastIndexOf(@NotNull
 T[] src,
 T obj,
 @NotNull
 Equality<? super T> comparator)

lastIndexOf

@Contract(pure=true)
public static <T> int lastIndexOf(@NotNull
 List<T> src,
 T obj,
 @NotNull
 Equality<? super T> comparator)

contains

@Contract(pure=true)
public static <T> boolean contains(@Nullable
 T o,
 @NotNull
 T... objects)

contains

@Contract(pure=true)
public static boolean contains(@Nullable
 String s,
 @NotNull
 String... strings)

newIntArray

@NotNull
@Contract(pure=true)
public static int[] newIntArray(int count)

newLongArray

@NotNull
@Contract(pure=true)
public static long[] newLongArray(int count)

newStringArray

@NotNull
@Contract(pure=true)
public static String[] newStringArray(int count)

newObjectArray

@NotNull
@Contract(pure=true)
public static Object[] newObjectArray(int count)

ensureExactSize

@NotNull
@Contract(pure=true)
public static <E> E[] ensureExactSize(int count,
 @NotNull
 E[] sample)

getFirstElement

@Nullable
@Contract(pure=true)
public static <T> T getFirstElement(@Nullable
 T[] array)

getLastElement

@Nullable
@Contract(pure=true)
public static <T> T getLastElement(@Nullable
 T[] array)

isEmpty

@Contract(value="null -> true",
          pure=true)
public static <T> boolean isEmpty(@Nullable
 T[] array)

toStringArray

@NotNull
@Contract(pure=true)
public static String[] toStringArray(@Nullable
 Collection<String> collection)

copy

public static <T> void copy(@NotNull
 Collection<? extends T> src,
 @NotNull
 T[] dst,
 int dstOffset)

stripTrailingNulls

@NotNull
public static <T> T[] stripTrailingNulls(@NotNull
 T[] array)

averageAmongMedians

public static long averageAmongMedians(@NotNull
 long[] time,
 int part)

averageAmongMedians

public static long averageAmongMedians(@NotNull
 int[] time,
 int part)

min

public static int min(int[] values)