|
Préférences
Moteurs de recherche
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
JavaTM 2 Platform Std. Ed. v1.4.2
java.util
|
Method Summary | |
static List |
asList(Object[] a)
Returns a fixed-size list backed by the specified array. |
static int |
binarySearch(byte[] a,
byte key)
Searches the specified array of bytes for the specified value using the binary search algorithm. |
static int |
binarySearch(char[] a,
char key)
Searches the specified array of chars for the specified value using the binary search algorithm. |
static int |
binarySearch(double[] a,
double key)
Searches the specified array of doubles for the specified value using the binary search algorithm. |
static int |
binarySearch(float[] a,
float key)
Searches the specified array of floats for the specified value using the binary search algorithm. |
static int |
binarySearch(int[] a,
int key)
Searches the specified array of ints for the specified value using the binary search algorithm. |
static int |
binarySearch(long[] a,
long key)
Searches the specified array of longs for the specified value using the binary search algorithm. |
static int |
binarySearch(Object[] a,
Object key)
Searches the specified array for the specified object using the binary search algorithm. |
static int |
binarySearch(Object[] a,
Object key,
Comparator c)
Searches the specified array for the specified object using the binary search algorithm. |
static int |
binarySearch(short[] a,
short key)
Searches the specified array of shorts for the specified value using the binary search algorithm. |
static boolean |
equals(boolean[] a,
boolean[] a2)
Returns true if the two specified arrays of booleans are equal to one another. |
static boolean |
equals(byte[] a,
byte[] a2)
Returns true if the two specified arrays of bytes are equal to one another. |
static boolean |
equals(char[] a,
char[] a2)
Returns true if the two specified arrays of chars are equal to one another. |
static boolean |
equals(double[] a,
double[] a2)
Returns true if the two specified arrays of doubles are equal to one another. |
static boolean |
equals(float[] a,
float[] a2)
Returns true if the two specified arrays of floats are equal to one another. |
static boolean |
equals(int[] a,
int[] a2)
Returns true if the two specified arrays of ints are equal to one another. |
static boolean |
equals(long[] a,
long[] a2)
Returns true if the two specified arrays of longs are equal to one another. |
static boolean |
equals(Object[] a,
Object[] a2)
Returns true if the two specified arrays of Objects are equal to one another. |
static boolean |
equals(short[] a,
short[] a2)
Returns true if the two specified arrays of shorts are equal to one another. |
static void |
fill(boolean[] a,
boolean val)
Assigns the specified boolean value to each element of the specified array of booleans. |
static void |
fill(boolean[] a,
int fromIndex,
int toIndex,
boolean val)
Assigns the specified boolean value to each element of the specified range of the specified array of booleans. |
static void |
fill(byte[] a,
byte val)
Assigns the specified byte value to each element of the specified array of bytes. |
static void |
fill(byte[] a,
int fromIndex,
int toIndex,
byte val)
Assigns the specified byte value to each element of the specified range of the specified array of bytes. |
static void |
fill(char[] a,
char val)
Assigns the specified char value to each element of the specified array of chars. |
static void |
fill(char[] a,
int fromIndex,
int toIndex,
char val)
Assigns the specified char value to each element of the specified range of the specified array of chars. |
static void |
fill(double[] a,
double val)
Assigns the specified double value to each element of the specified array of doubles. |
static void |
fill(double[] a,
int fromIndex,
int toIndex,
double val)
Assigns the specified double value to each element of the specified range of the specified array of doubles. |
static void |
fill(float[] a,
float val)
Assigns the specified float value to each element of the specified array of floats. |
static void |
fill(float[] a,
int fromIndex,
int toIndex,
float val)
Assigns the specified float value to each element of the specified range of the specified array of floats. |
static void |
fill(int[] a,
int val)
Assigns the specified int value to each element of the specified array of ints. |
static void |
fill(int[] a,
int fromIndex,
int toIndex,
int val)
Assigns the specified int value to each element of the specified range of the specified array of ints. |
static void |
fill(long[] a,
int fromIndex,
int toIndex,
long val)
Assigns the specified long value to each element of the specified range of the specified array of longs. |
static void |
fill(long[] a,
long val)
Assigns the specified long value to each element of the specified array of longs. |
static void |
fill(Object[] a,
int fromIndex,
int toIndex,
Object val)
Assigns the specified Object reference to each element of the specified range of the specified array of Objects. |
static void |
fill(Object[] a,
Object val)
Assigns the specified Object reference to each element of the specified array of Objects. |
static void |
fill(short[] a,
int fromIndex,
int toIndex,
short val)
Assigns the specified short value to each element of the specified range of the specified array of shorts. |
static void |
fill(short[] a,
short val)
Assigns the specified short value to each element of the specified array of shorts. |
static void |
sort(byte[] a)
Sorts the specified array of bytes into ascending numerical order. |
static void |
sort(byte[] a,
int fromIndex,
int toIndex)
Sorts the specified range of the specified array of bytes into ascending numerical order. |
static void |
sort(char[] a)
Sorts the specified array of chars into ascending numerical order. |
static void |
sort(char[] a,
int fromIndex,
int toIndex)
Sorts the specified range of the specified array of chars into ascending numerical order. |
static void |
sort(double[] a)
Sorts the specified array of doubles into ascending numerical order. |
static void |
sort(double[] a,
int fromIndex,
int toIndex)
Sorts the specified range of the specified array of doubles into ascending numerical order. |
static void |
sort(float[] a)
Sorts the specified array of floats into ascending numerical order. |
static void |
sort(float[] a,
int fromIndex,
int toIndex)
Sorts the specified range of the specified array of floats into ascending numerical order. |
static void |
sort(int[] a)
Sorts the specified array of ints into ascending numerical order. |
static void |
sort(int[] a,
int fromIndex,
int toIndex)
Sorts the specified range of the specified array of ints into ascending numerical order. |
static void |
sort(long[] a)
Sorts the specified array of longs into ascending numerical order. |
static void |
sort(long[] a,
int fromIndex,
int toIndex)
Sorts the specified range of the specified array of longs into ascending numerical order. |
static void |
sort(Object[] a)
Sorts the specified array of objects into ascending order, according to the natural ordering of its elements. |
static void |
sort(Object[] a,
Comparator c)
Sorts the specified array of objects according to the order induced by the specified comparator. |
static void |
sort(Object[] a,
int fromIndex,
int toIndex)
Sorts the specified range of the specified array of objects into ascending order, according to the natural ordering of its elements. |
static void |
sort(Object[] a,
int fromIndex,
int toIndex,
Comparator c)
Sorts the specified range of the specified array of objects according to the order induced by the specified comparator. |
static void |
sort(short[] a)
Sorts the specified array of shorts into ascending numerical order. |
static void |
sort(short[] a,
int fromIndex,
int toIndex)
Sorts the specified range of the specified array of shorts into ascending numerical order. |
Methods inherited from class java.lang.Object |
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
Method Detail |
public static void sort(long[] a)
a
- the array to be sorted.public static void sort(long[] a, int fromIndex, int toIndex)
The sorting algorithm is a tuned quicksort, adapted from Jon L. Bentley and M. Douglas McIlroy's "Engineering a Sort Function", Software-Practice and Experience, Vol. 23(11) P. 1249-1265 (November 1993). This algorithm offers n*log(n) performance on many data sets that cause other quicksorts to degrade to quadratic performance.
a
- the array to be sorted.fromIndex
- the index of the first element (inclusive) to be
sorted.toIndex
- the index of the last element (exclusive) to be sorted.
IllegalArgumentException
- if fromIndex > toIndex
ArrayIndexOutOfBoundsException
- if fromIndex < 0 or
toIndex > a.lengthpublic static void sort(int[] a)
a
- the array to be sorted.public static void sort(int[] a, int fromIndex, int toIndex)
The sorting algorithm is a tuned quicksort, adapted from Jon L. Bentley and M. Douglas McIlroy's "Engineering a Sort Function", Software-Practice and Experience, Vol. 23(11) P. 1249-1265 (November 1993). This algorithm offers n*log(n) performance on many data sets that cause other quicksorts to degrade to quadratic performance.
a
- the array to be sorted.fromIndex
- the index of the first element (inclusive) to be
sorted.toIndex
- the index of the last element (exclusive) to be sorted.
IllegalArgumentException
- if fromIndex > toIndex
ArrayIndexOutOfBoundsException
- if fromIndex < 0 or
toIndex > a.lengthpublic static void sort(short[] a)
a
- the array to be sorted.public static void sort(short[] a, int fromIndex, int toIndex)
The sorting algorithm is a tuned quicksort, adapted from Jon L. Bentley and M. Douglas McIlroy's "Engineering a Sort Function", Software-Practice and Experience, Vol. 23(11) P. 1249-1265 (November 1993). This algorithm offers n*log(n) performance on many data sets that cause other quicksorts to degrade to quadratic performance.
a
- the array to be sorted.fromIndex
- the index of the first element (inclusive) to be
sorted.toIndex
- the index of the last element (exclusive) to be sorted.
IllegalArgumentException
- if fromIndex > toIndex
ArrayIndexOutOfBoundsException
- if fromIndex < 0 or
toIndex > a.lengthpublic static void sort(char[] a)
a
- the array to be sorted.public static void sort(char[] a, int fromIndex, int toIndex)
The sorting algorithm is a tuned quicksort, adapted from Jon L. Bentley and M. Douglas McIlroy's "Engineering a Sort Function", Software-Practice and Experience, Vol. 23(11) P. 1249-1265 (November 1993). This algorithm offers n*log(n) performance on many data sets that cause other quicksorts to degrade to quadratic performance.
a
- the array to be sorted.fromIndex
- the index of the first element (inclusive) to be
sorted.toIndex
- the index of the last element (exclusive) to be sorted.
IllegalArgumentException
- if fromIndex > toIndex
ArrayIndexOutOfBoundsException
- if fromIndex < 0 or
toIndex > a.lengthpublic static void sort(byte[] a)
a
- the array to be sorted.public static void sort(byte[] a, int fromIndex, int toIndex)
The sorting algorithm is a tuned quicksort, adapted from Jon L. Bentley and M. Douglas McIlroy's "Engineering a Sort Function", Software-Practice and Experience, Vol. 23(11) P. 1249-1265 (November 1993). This algorithm offers n*log(n) performance on many data sets that cause other quicksorts to degrade to quadratic performance.
a
- the array to be sorted.fromIndex
- the index of the first element (inclusive) to be
sorted.toIndex
- the index of the last element (exclusive) to be sorted.
IllegalArgumentException
- if fromIndex > toIndex
ArrayIndexOutOfBoundsException
- if fromIndex < 0 or
toIndex > a.lengthpublic static void sort(double[] a)
The <
relation does not provide a total order on
all floating-point values; although they are distinct numbers
-0.0 == 0.0
is true
and a NaN value
compares neither less than, greater than, nor equal to any
floating-point value, even itself. To allow the sort to
proceed, instead of using the <
relation to
determine ascending numerical order, this method uses the total
order imposed by Double.compareTo(java.lang.Double)
. This ordering
differs from the <
relation in that
-0.0
is treated as less than 0.0
and
NaN is considered greater than any other floating-point value.
For the purposes of sorting, all NaN values are considered
equivalent and equal.
The sorting algorithm is a tuned quicksort, adapted from Jon L. Bentley and M. Douglas McIlroy's "Engineering a Sort Function", Software-Practice and Experience, Vol. 23(11) P. 1249-1265 (November 1993). This algorithm offers n*log(n) performance on many data sets that cause other quicksorts to degrade to quadratic performance.
a
- the array to be sorted.public static void sort(double[] a, int fromIndex, int toIndex)
The <
relation does not provide a total order on
all floating-point values; although they are distinct numbers
-0.0 == 0.0
is true
and a NaN value
compares neither less than, greater than, nor equal to any
floating-point value, even itself. To allow the sort to
proceed, instead of using the <
relation to
determine ascending numerical order, this method uses the total
order imposed by Double.compareTo(java.lang.Double)
. This ordering
differs from the <
relation in that
-0.0
is treated as less than 0.0
and
NaN is considered greater than any other floating-point value.
For the purposes of sorting, all NaN values are considered
equivalent and equal.
The sorting algorithm is a tuned quicksort, adapted from Jon L. Bentley and M. Douglas McIlroy's "Engineering a Sort Function", Software-Practice and Experience, Vol. 23(11) P. 1249-1265 (November 1993). This algorithm offers n*log(n) performance on many data sets that cause other quicksorts to degrade to quadratic performance.
a
- the array to be sorted.fromIndex
- the index of the first element (inclusive) to be
sorted.toIndex
- the index of the last element (exclusive) to be sorted.
IllegalArgumentException
- if fromIndex > toIndex
ArrayIndexOutOfBoundsException
- if fromIndex < 0 or
toIndex > a.lengthpublic static void sort(float[] a)
The <
relation does not provide a total order on
all floating-point values; although they are distinct numbers
-0.0f == 0.0f
is true
and a NaN value
compares neither less than, greater than, nor equal to any
floating-point value, even itself. To allow the sort to
proceed, instead of using the <
relation to
determine ascending numerical order, this method uses the total
order imposed by Float.compareTo(java.lang.Float)
. This ordering
differs from the <
relation in that
-0.0f
is treated as less than 0.0f
and
NaN is considered greater than any other floating-point value.
For the purposes of sorting, all NaN values are considered
equivalent and equal.
The sorting algorithm is a tuned quicksort, adapted from Jon L. Bentley and M. Douglas McIlroy's "Engineering a Sort Function", Software-Practice and Experience, Vol. 23(11) P. 1249-1265 (November 1993). This algorithm offers n*log(n) performance on many data sets that cause other quicksorts to degrade to quadratic performance.
a
- the array to be sorted.public static void sort(float[] a, int fromIndex, int toIndex)
The <
relation does not provide a total order on
all floating-point values; although they are distinct numbers
-0.0f == 0.0f
is true
and a NaN value
compares neither less than, greater than, nor equal to any
floating-point value, even itself. To allow the sort to
proceed, instead of using the <
relation to
determine ascending numerical order, this method uses the total
order imposed by Float.compareTo(java.lang.Float)
. This ordering
differs from the <
relation in that
-0.0f
is treated as less than 0.0f
and
NaN is considered greater than any other floating-point value.
For the purposes of sorting, all NaN values are considered
equivalent and equal.
The sorting algorithm is a tuned quicksort, adapted from Jon L. Bentley and M. Douglas McIlroy's "Engineering a Sort Function", Software-Practice and Experience, Vol. 23(11) P. 1249-1265 (November 1993). This algorithm offers n*log(n) performance on many data sets that cause other quicksorts to degrade to quadratic performance.
a
- the array to be sorted.fromIndex
- the index of the first element (inclusive) to be
sorted.toIndex
- the index of the last element (exclusive) to be sorted.
IllegalArgumentException
- if fromIndex > toIndex
ArrayIndexOutOfBoundsException
- if fromIndex < 0 or
toIndex > a.lengthpublic static void sort(Object[] a)
This sort is guaranteed to be stable: equal elements will not be reordered as a result of the sort.
The sorting algorithm is a modified mergesort (in which the merge is omitted if the highest element in the low sublist is less than the lowest element in the high sublist). This algorithm offers guaranteed n*log(n) performance.
a
- the array to be sorted.
ClassCastException
- if the array contains elements that are not
mutually comparable (for example, strings and integers).Comparable
public static void sort(Object[] a, int fromIndex, int toIndex)
This sort is guaranteed to be stable: equal elements will not be reordered as a result of the sort.
The sorting algorithm is a modified mergesort (in which the merge is omitted if the highest element in the low sublist is less than the lowest element in the high sublist). This algorithm offers guaranteed n*log(n) performance.
a
- the array to be sorted.fromIndex
- the index of the first element (inclusive) to be
sorted.toIndex
- the index of the last element (exclusive) to be sorted.
IllegalArgumentException
- if fromIndex > toIndex
ArrayIndexOutOfBoundsException
- if fromIndex < 0 or
toIndex > a.length
ClassCastException
- if the array contains elements that are
not mutually comparable (for example, strings and
integers).Comparable
public static void sort(Object[] a, Comparator c)
This sort is guaranteed to be stable: equal elements will not be reordered as a result of the sort.
The sorting algorithm is a modified mergesort (in which the merge is omitted if the highest element in the low sublist is less than the lowest element in the high sublist). This algorithm offers guaranteed n*log(n) performance.
a
- the array to be sorted.c
- the comparator to determine the order of the array. A
null value indicates that the elements' natural
ordering should be used.
ClassCastException
- if the array contains elements that are
not mutually comparable using the specified comparator.Comparator
public static void sort(Object[] a, int fromIndex, int toIndex, Comparator c)
This sort is guaranteed to be stable: equal elements will not be reordered as a result of the sort.
The sorting algorithm is a modified mergesort (in which the merge is omitted if the highest element in the low sublist is less than the lowest element in the high sublist). This algorithm offers guaranteed n*log(n) performance.
a
- the array to be sorted.fromIndex
- the index of the first element (inclusive) to be
sorted.toIndex
- the index of the last element (exclusive) to be sorted.c
- the comparator to determine the order of the array. A
null value indicates that the elements' natural
ordering should be used.
ClassCastException
- if the array contains elements that are not
mutually comparable using the specified comparator.
IllegalArgumentException
- if fromIndex > toIndex
ArrayIndexOutOfBoundsException
- if fromIndex < 0 or
toIndex > a.lengthComparator
public static int binarySearch(long[] a, long key)
a
- the array to be searched.key
- the value to be searched for.
sort(long[])
public static int binarySearch(int[] a, int key)
a
- the array to be searched.key
- the value to be searched for.
sort(int[])
public static int binarySearch(short[] a, short key)
a
- the array to be searched.key
- the value to be searched for.
sort(short[])
public static int binarySearch(char[] a, char key)
a
- the array to be searched.key
- the value to be searched for.
sort(char[])
public static int binarySearch(byte[] a, byte key)
a
- the array to be searched.key
- the value to be searched for.
sort(byte[])
public static int binarySearch(double[] a, double key)
a
- the array to be searched.key
- the value to be searched for.
sort(double[])
public static int binarySearch(float[] a, float key)
a
- the array to be searched.key
- the value to be searched for.
sort(float[])
public static int binarySearch(Object[] a, Object key)
a
- the array to be searched.key
- the value to be searched for.
ClassCastException
- if the search key in not comparable to the
elements of the array.Comparable
,
sort(Object[])
public static int binarySearch(Object[] a, Object key, Comparator c)
a
- the array to be searched.key
- the value to be searched for.c
- the comparator by which the array is ordered. A
null value indicates that the elements' natural
ordering should be used.
ClassCastException
- if the array contains elements that are not
mutually comparable using the specified comparator,
or the search key in not mutually comparable with the
elements of the array using this comparator.Comparable
,
sort(Object[], Comparator)
public static boolean equals(long[] a, long[] a2)
a
- one array to be tested for equality.a2
- the other array to be tested for equality.
public static boolean equals(int[] a, int[] a2)
a
- one array to be tested for equality.a2
- the other array to be tested for equality.
public static boolean equals(short[] a, short[] a2)
a
- one array to be tested for equality.a2
- the other array to be tested for equality.
public static boolean equals(char[] a, char[] a2)
a
- one array to be tested for equality.a2
- the other array to be tested for equality.
public static boolean equals(byte[] a, byte[] a2)
a
- one array to be tested for equality.a2
- the other array to be tested for equality.
public static boolean equals(boolean[] a, boolean[] a2)
a
- one array to be tested for equality.a2
- the other array to be tested for equality.
public static boolean equals(double[] a, double[] a2)
Two doubles d1 and d2 are considered equal if:
new Double(d1).equals(new Double(d2))(Unlike the == operator, this method considers NaN equals to itself, and 0.0d unequal to -0.0d.)
a
- one array to be tested for equality.a2
- the other array to be tested for equality.
Double.equals(Object)
public static boolean equals(float[] a, float[] a2)
Two floats f1 and f2 are considered equal if:
new Float(f1).equals(new Float(f2))(Unlike the == operator, this method considers NaN equals to itself, and 0.0f unequal to -0.0f.)
a
- one array to be tested for equality.a2
- the other array to be tested for equality.
Float.equals(Object)
public static boolean equals(Object[] a, Object[] a2)
a
- one array to be tested for equality.a2
- the other array to be tested for equality.
public static void fill(long[] a, long val)
a
- the array to be filled.val
- the value to be stored in all elements of the array.public static void fill(long[] a, int fromIndex, int toIndex, long val)
a
- the array to be filled.fromIndex
- the index of the first element (inclusive) to be
filled with the specified value.toIndex
- the index of the last element (exclusive) to be
filled with the specified value.val
- the value to be stored in all elements of the array.
IllegalArgumentException
- if fromIndex > toIndex
ArrayIndexOutOfBoundsException
- if fromIndex < 0 or
toIndex > a.lengthpublic static void fill(int[] a, int val)
a
- the array to be filled.val
- the value to be stored in all elements of the array.public static void fill(int[] a, int fromIndex, int toIndex, int val)
a
- the array to be filled.fromIndex
- the index of the first element (inclusive) to be
filled with the specified value.toIndex
- the index of the last element (exclusive) to be
filled with the specified value.val
- the value to be stored in all elements of the array.
IllegalArgumentException
- if fromIndex > toIndex
ArrayIndexOutOfBoundsException
- if fromIndex < 0 or
toIndex > a.lengthpublic static void fill(short[] a, short val)
a
- the array to be filled.val
- the value to be stored in all elements of the array.public static void fill(short[] a, int fromIndex, int toIndex, short val)
a
- the array to be filled.fromIndex
- the index of the first element (inclusive) to be
filled with the specified value.toIndex
- the index of the last element (exclusive) to be
filled with the specified value.val
- the value to be stored in all elements of the array.
IllegalArgumentException
- if fromIndex > toIndex
ArrayIndexOutOfBoundsException
- if fromIndex < 0 or
toIndex > a.lengthpublic static void fill(char[] a, char val)
a
- the array to be filled.val
- the value to be stored in all elements of the array.public static void fill(char[] a, int fromIndex, int toIndex, char val)
a
- the array to be filled.fromIndex
- the index of the first element (inclusive) to be
filled with the specified value.toIndex
- the index of the last element (exclusive) to be
filled with the specified value.val
- the value to be stored in all elements of the array.
IllegalArgumentException
- if fromIndex > toIndex
ArrayIndexOutOfBoundsException
- if fromIndex < 0 or
toIndex > a.lengthpublic static void fill(byte[] a, byte val)
a
- the array to be filled.val
- the value to be stored in all elements of the array.public static void fill(byte[] a, int fromIndex, int toIndex, byte val)
a
- the array to be filled.fromIndex
- the index of the first element (inclusive) to be
filled with the specified value.toIndex
- the index of the last element (exclusive) to be
filled with the specified value.val
- the value to be stored in all elements of the array.
IllegalArgumentException
- if fromIndex > toIndex
ArrayIndexOutOfBoundsException
- if fromIndex < 0 or
toIndex > a.lengthpublic static void fill(boolean[] a, boolean val)
a
- the array to be filled.val
- the value to be stored in all elements of the array.public static void fill(boolean[] a, int fromIndex, int toIndex, boolean val)
a
- the array to be filled.fromIndex
- the index of the first element (inclusive) to be
filled with the specified value.toIndex
- the index of the last element (exclusive) to be
filled with the specified value.val
- the value to be stored in all elements of the array.
IllegalArgumentException
- if fromIndex > toIndex
ArrayIndexOutOfBoundsException
- if fromIndex < 0 or
toIndex > a.lengthpublic static void fill(double[] a, double val)
a
- the array to be filled.val
- the value to be stored in all elements of the array.public static void fill(double[] a, int fromIndex, int toIndex, double val)
a
- the array to be filled.fromIndex
- the index of the first element (inclusive) to be
filled with the specified value.toIndex
- the index of the last element (exclusive) to be
filled with the specified value.val
- the value to be stored in all elements of the array.
IllegalArgumentException
- if fromIndex > toIndex
ArrayIndexOutOfBoundsException
- if fromIndex < 0 or
toIndex > a.lengthpublic static void fill(float[] a, float val)
a
- the array to be filled.val
- the value to be stored in all elements of the array.public static void fill(float[] a, int fromIndex, int toIndex, float val)
a
- the array to be filled.fromIndex
- the index of the first element (inclusive) to be
filled with the specified value.toIndex
- the index of the last element (exclusive) to be
filled with the specified value.val
- the value to be stored in all elements of the array.
IllegalArgumentException
- if fromIndex > toIndex
ArrayIndexOutOfBoundsException
- if fromIndex < 0 or
toIndex > a.lengthpublic static void fill(Object[] a, Object val)
a
- the array to be filled.val
- the value to be stored in all elements of the array.public static void fill(Object[] a, int fromIndex, int toIndex, Object val)
a
- the array to be filled.fromIndex
- the index of the first element (inclusive) to be
filled with the specified value.toIndex
- the index of the last element (exclusive) to be
filled with the specified value.val
- the value to be stored in all elements of the array.
IllegalArgumentException
- if fromIndex > toIndex
ArrayIndexOutOfBoundsException
- if fromIndex < 0 or
toIndex > a.lengthpublic static List asList(Object[] a)
RandomAccess
.
a
- the array by which the list will be backed.
Collection.toArray()