org.apache.lucene.util

Class ArrayUtil

java.lang.Object

org.apache.lucene.util.ArrayUtil

public final class ArrayUtil
extends Object

Methods for manipulating arrays.

NOTE: This API is for internal purposes only and might change in incompatible ways in the next release.

Field Summary

Fields

Modifier and Type	Field and Description
static int	MAX_ARRAY_LENGTH Maximum length for an array (Integer.MAX_VALUE - RamUsageEstimator.NUM_BYTES_ARRAY_HEADER).

Method Summary

Modifier and Type	Method and Description
static byte[]	grow(byte[] array)
static byte[]	grow(byte[] array, int minSize)
static char[]	grow(char[] array)
static char[]	grow(char[] array, int minSize)
static double[]	grow(double[] array)
static double[]	grow(double[] array, int minSize)
static float[]	grow(float[] array)
static float[]	grow(float[] array, int minSize)
static int[]	grow(int[] array)
static int[]	grow(int[] array, int minSize)
static long[]	grow(long[] array)
static long[]	grow(long[] array, int minSize)
static short[]	grow(short[] array)
static short[]	grow(short[] array, int minSize)
static <T> T[]	grow(T[] array, int minSize)
static int	hashCode(char[] array, int start, int end) Returns hash of chars in range start (inclusive) to end (inclusive)
static <T extends Comparable<? super T>> void	introSort(T[] a) Sorts the given array in natural order.
static <T> void	introSort(T[] a, Comparator<? super T> comp) Sorts the given array using the Comparator.
static <T extends Comparable<? super T>> void	introSort(T[] a, int fromIndex, int toIndex) Sorts the given array slice in natural order.
static <T> void	introSort(T[] a, int fromIndex, int toIndex, Comparator<? super T> comp) Sorts the given array slice using the Comparator.
static int	oversize(int minTargetSize, int bytesPerElement) Returns an array size >= minTargetSize, generally over-allocating exponentially to achieve amortized linear-time cost as the array grows.
static int	parseInt(char[] chars, int offset, int len) Parses a char array into an int.
static int	parseInt(char[] chars, int offset, int len, int radix) Parses the string argument as if it was an int value and returns the result.
static <T> void	select(T[] arr, int from, int to, int k, Comparator<? super T> comparator) Reorganize arr[from:to[ so that the element at offset k is at the same position as if arr[from:to[ was sorted, and all elements on its left are less than or equal to it, and all elements on its right are greater than or equal to it.
static <T> void	swap(T[] arr, int i, int j) Swap values stored in slots i and j
static <T extends Comparable<? super T>> void	timSort(T[] a) Sorts the given array in natural order.
static <T> void	timSort(T[] a, Comparator<? super T> comp) Sorts the given array using the Comparator.
static <T extends Comparable<? super T>> void	timSort(T[] a, int fromIndex, int toIndex) Sorts the given array slice in natural order.
static <T> void	timSort(T[] a, int fromIndex, int toIndex, Comparator<? super T> comp) Sorts the given array slice using the Comparator.

Methods inherited from class java.lang.Object

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

Field Detail

MAX_ARRAY_LENGTH

public static final int MAX_ARRAY_LENGTH

Maximum length for an array (Integer.MAX_VALUE - RamUsageEstimator.NUM_BYTES_ARRAY_HEADER).

Method Detail

parseInt

public static int parseInt(char[] chars,
                           int offset,
                           int len)
                    throws NumberFormatException

Parses a char array into an int.

Parameters:

chars - the character array

offset - The offset into the array

len - The length

Returns:

the int

Throws:

NumberFormatException - if it can't parse

parseInt

public static int parseInt(char[] chars,
                           int offset,
                           int len,
                           int radix)
                    throws NumberFormatException

Parses the string argument as if it was an int value and returns the result. Throws NumberFormatException if the string does not represent an int quantity. The second argument specifies the radix to use when parsing the value.

Parameters:

chars - a string representation of an int quantity.

radix - the base to use for conversion.

Returns:

int the value represented by the argument

Throws:

NumberFormatException - if the argument could not be parsed as an int quantity.

oversize

public static int oversize(int minTargetSize,
                           int bytesPerElement)

Returns an array size >= minTargetSize, generally over-allocating exponentially to achieve amortized linear-time cost as the array grows. NOTE: this was originally borrowed from Python 2.4.2 listobject.c sources (attribution in LICENSE.txt), but has now been substantially changed based on discussions from java-dev thread with subject "Dynamic array reallocation algorithms", started on Jan 12 2010.

Parameters:

minTargetSize - Minimum required value to be returned.

bytesPerElement - Bytes used by each element of the array. See constants in RamUsageEstimator.

NOTE: This API is for internal purposes only and might change in incompatible ways in the next release.

grow

public static <T> T[] grow(T[] array,
                           int minSize)

grow

public static short[] grow(short[] array,
                           int minSize)

grow

public static short[] grow(short[] array)

grow

public static float[] grow(float[] array,
                           int minSize)

grow

public static float[] grow(float[] array)

grow

public static double[] grow(double[] array,
                            int minSize)

grow

public static double[] grow(double[] array)

grow

public static int[] grow(int[] array,
                         int minSize)

grow

public static int[] grow(int[] array)

grow

public static long[] grow(long[] array,
                          int minSize)

grow

public static long[] grow(long[] array)

grow

public static byte[] grow(byte[] array,
                          int minSize)

grow

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

grow

public static char[] grow(char[] array,
                          int minSize)

grow

public static char[] grow(char[] array)

hashCode

public static int hashCode(char[] array,
                           int start,
                           int end)

Returns hash of chars in range start (inclusive) to end (inclusive)

swap

public static <T> void swap(T[] arr,
                            int i,
                            int j)

Swap values stored in slots i and j

introSort

public static <T> void introSort(T[] a,
                                 int fromIndex,
                                 int toIndex,
                                 Comparator<? super T> comp)

Sorts the given array slice using the Comparator. This method uses the intro sort algorithm, but falls back to insertion sort for small arrays.

Parameters:

fromIndex - start index (inclusive)

toIndex - end index (exclusive)

introSort

public static <T> void introSort(T[] a,
                                 Comparator<? super T> comp)

Sorts the given array using the Comparator. This method uses the intro sort algorithm, but falls back to insertion sort for small arrays.

introSort

public static <T extends Comparable<? super T>> void introSort(T[] a,
                                                               int fromIndex,
                                                               int toIndex)

Sorts the given array slice in natural order. This method uses the intro sort algorithm, but falls back to insertion sort for small arrays.

Parameters:

fromIndex - start index (inclusive)

toIndex - end index (exclusive)

introSort

public static <T extends Comparable<? super T>> void introSort(T[] a)

Sorts the given array in natural order. This method uses the intro sort algorithm, but falls back to insertion sort for small arrays.

timSort

public static <T> void timSort(T[] a,
                               int fromIndex,
                               int toIndex,
                               Comparator<? super T> comp)

Sorts the given array slice using the Comparator. This method uses the Tim sort algorithm, but falls back to binary sort for small arrays.

Parameters:

fromIndex - start index (inclusive)

toIndex - end index (exclusive)

timSort

public static <T> void timSort(T[] a,
                               Comparator<? super T> comp)

Sorts the given array using the Comparator. This method uses the Tim sort algorithm, but falls back to binary sort for small arrays.

timSort

public static <T extends Comparable<? super T>> void timSort(T[] a,
                                                             int fromIndex,
                                                             int toIndex)

Sorts the given array slice in natural order. This method uses the Tim sort algorithm, but falls back to binary sort for small arrays.

Parameters:

fromIndex - start index (inclusive)

toIndex - end index (exclusive)

timSort

public static <T extends Comparable<? super T>> void timSort(T[] a)

Sorts the given array in natural order. This method uses the Tim sort algorithm, but falls back to binary sort for small arrays.

select

public static <T> void select(T[] arr,
                              int from,
                              int to,
                              int k,
                              Comparator<? super T> comparator)

Reorganize arr[from:to[ so that the element at offset k is at the same position as if arr[from:to[ was sorted, and all elements on its left are less than or equal to it, and all elements on its right are greater than or equal to it. This runs in linear time on average and in n log(n) time in the worst case.