|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object com.plumtree.openfoundation.util.XPArray
public class XPArray
This class contains various methods for manipulating arrays (such as sorting and searching). This class also contains a static factory that allows arrays to be viewed as lists.
The methods in this class all throw a NullPointerException if the specified array reference is null.
The documentation for the methods contained in this class includes briefs description of the implementations. Such descriptions should be regarded as implementation notes, rather than parts of the specification. Implementors should feel free to substitute other algorithms, so long as the specification itself is adhered to. (For example, the algorithm used by sort(Object[]) does not have to be a mergesort, but it does have to be stable.)
Constructor Summary | |
---|---|
XPArray()
|
Method Summary | |
---|---|
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(java.lang.Object[] a,
java.lang.Object key)
Searches the specified array for the specified object using the binary search algorithm. |
static int |
BinarySearch(java.lang.Object[] a,
java.lang.Object Key,
IXPComparer comparer)
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 int |
BinarySearch(java.lang.String[] a,
java.lang.String key)
Searches the specified array for the specified object using the binary search algorithm. |
static void |
Copy(java.lang.Object srcArray,
int srcIndex,
java.lang.Object destArray,
int destIndex,
int length)
Copies an array from the specified source array, beginning at the specified position, to the specified position of the destination array. |
static boolean |
Equals(boolean[] a,
boolean[] a2)
Returns true if the two specified arrays of equals 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(java.lang.Object[] a,
java.lang.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 |
Sort(byte[] a)
Sorts the specified array of bytes into ascending numerical order. |
static void |
Sort(byte[] a,
int fromIndex,
int length)
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 length)
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 length)
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 length)
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 length)
Sorts the specified range of the specified array of ints into ascending numerical order. |
static void |
Sort(java.lang.Object[] a)
Sorts the specified array of objects into ascending order, according to the natural ordering of its elements. |
static void |
Sort(java.lang.Object[] a,
int fromIndex,
int length)
Sorts the specified range of the specified array of objects into ascending order, according to the natural ordering of its elements. |
static void |
Sort(short[] a)
Sorts the specified array of shorts into ascending numerical order. |
static void |
Sort(short[] a,
int fromIndex,
int length)
Sorts the specified range of the specified array of shorts into ascending numerical order. |
static void |
Sort(java.lang.String[] a)
Sorts the specified array of objects into ascending order, according to the natural ordering of its elements. |
static void |
Sort(java.lang.String[] a,
int fromIndex,
int length)
Sorts the specified range of the specified array of objects into ascending order, according to the natural ordering of its elements. |
Methods inherited from class java.lang.Object |
---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
Constructor Detail |
---|
public XPArray()
Method Detail |
---|
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(char[] a, char key)
a
- the array to be searched.key
- the value to be searched for.
#sort(char[])
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(int[] a, int key)
a
- the array to be searched.key
- the value to be searched for.
#sort(int[])
public static int BinarySearch(java.lang.String[] a, java.lang.String key)
a
- the array to be searched.key
- the value to be searched for.
java.lang.ClassCastException
- if the search key in not comparable to the
elements of the array.Comparable
,
#sort(Object[])
public static int BinarySearch(java.lang.Object[] a, java.lang.Object key)
a
- the array to be searched.key
- the value to be searched for.
java.lang.ClassCastException
- if the search key in not comparable to the
elements of the array.Comparable
,
#sort(Object[])
public static int BinarySearch(java.lang.Object[] a, java.lang.Object Key, IXPComparer comparer)
a
- the array to be searched.Key
- the value to be searched for.comparer
- the comparator by which the array is ordered. A
null value indicates that the elements' natural
ordering should be used.
java.lang.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 int BinarySearch(short[] a, short key)
a
- the array to be searched.key
- the value to be searched for.
#sort(short[])
public static void Sort(byte[] a)
a
- the array to be sorted.public static void Sort(byte[] a, int fromIndex, int length)
The sorting algorithm is a tuned quicksort. 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.length
- Number of Elements to be sorted.
java.lang.IllegalArgumentException
- if fromIndex > toIndex
java.lang.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 length)
The sorting algorithm is a tuned quicksort. 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.length
- Number of Elements to be sorted.
java.lang.IllegalArgumentException
- if fromIndex > toIndex
java.lang.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. 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 length)
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. 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.length
- Number of Elements to be sorted.
java.lang.IllegalArgumentException
- if fromIndex > toIndex
java.lang.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. 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 length)
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. 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.length
- Number of Elements to be sorted.
java.lang.IllegalArgumentException
- if fromIndex > toIndex
java.lang.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 length)
The sorting algorithm is a tuned quicksort. 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.length
- Number of Elements to be sorted.
java.lang.IllegalArgumentException
- if fromIndex > toIndex
java.lang.ArrayIndexOutOfBoundsException
- if fromIndex < 0 or
toIndex > a.lengthpublic static void Sort(java.lang.String[] 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.
java.lang.ClassCastException
- if the array contains elements that are not
mutually comparable (for example, strings and integers).Comparable
public static void Sort(java.lang.String[] a, int fromIndex, int length)
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.length
- Number of Elements to be sorted.
java.lang.IllegalArgumentException
- if fromIndex > toIndex
java.lang.ArrayIndexOutOfBoundsException
- if fromIndex < 0 or
toIndex > a.length
java.lang.ClassCastException
- if the array contains elements that are
not mutually comparable (for example, strings and
integers).Comparable
public static void Sort(java.lang.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.
java.lang.ClassCastException
- if the array contains elements that are not
mutually comparable (for example, strings and integers).Comparable
public static void Sort(java.lang.Object[] a, int fromIndex, int length)
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.length
- Number of Elements to be sorted.
java.lang.IllegalArgumentException
- if fromIndex > toIndex
java.lang.ArrayIndexOutOfBoundsException
- if fromIndex < 0 or
toIndex > a.length
java.lang.ClassCastException
- if the array contains elements that are
not mutually comparable (for example, strings and
integers).Comparable
public static void Sort(short[] a)
a
- the array to be sorted.public static void Sort(short[] a, int fromIndex, int length)
The sorting algorithm is a tuned quicksort. 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.length
- Number of Elements to be sorted.
java.lang.IllegalArgumentException
- if fromIndex > toIndex
java.lang.ArrayIndexOutOfBoundsException
- if fromIndex < 0 or
toIndex > a.lengthpublic static void Copy(java.lang.Object srcArray, int srcIndex, java.lang.Object destArray, int destIndex, int length)
src
to the destination array
referenced by dest
. The number of components copied is
equal to the length
argument. The components at
positions srcPos
through
srcPos+length-1
in the source array are copied into
positions destPos
through
destPos+length-1
, respectively, of the destination
array.
If the src
and dest
arguments refer to the
same array object, then the copying is performed as if the
components at positions srcPos
through
srcPos+length-1
were first copied to a temporary
array with length
components and then the contents of
the temporary array were copied into positions
destPos
through destPos+length-1
of the
destination array.
If dest
is null
, then a
NullPointerException
is thrown.
If src
is null
, then a
NullPointerException
is thrown and the destination
array is not modified.
Otherwise, if any of the following is true, an
ArrayStoreException
is thrown and the destination is
not modified:
src
argument refers to an object that is not an
array.
dest
argument refers to an object that is not an
array.
src
argument and dest
argument refer
to arrays whose component types are different primitive types.
src
argument refers to an array with a primitive
component type and the dest
argument refers to an array
with a reference component type.
src
argument refers to an array with a reference
component type and the dest
argument refers to an array
with a primitive component type.
Otherwise, if any of the following is true, an
IndexOutOfBoundsException
is
thrown and the destination is not modified:
srcPos
argument is negative.
destPos
argument is negative.
length
argument is negative.
srcPos+length
is greater than
src.length
, the length of the source array.
destPos+length
is greater than
dest.length
, the length of the destination array.
Otherwise, if any actual component of the source array from
position srcPos
through
srcPos+length-1
cannot be converted to the component
type of the destination array by assignment conversion, an
ArrayStoreException
is thrown. In this case, let
k be the smallest nonnegative integer less than
length such that src[srcPos+
k]
cannot be converted to the component type of the destination
array; when the exception is thrown, source array components from
positions srcPos
through
srcPos+
k-1
will already have been copied to destination array positions
destPos
through
destPos+
k-1
and no other
positions of the destination array will have been modified.
(Because of the restrictions already itemized, this
paragraph effectively applies only to the situation where both
arrays have component types that are reference types.)
srcArray
- the source array.srcIndex
- starting position in the source array.destArray
- the destination array.destIndex
- starting position in the destination data.length
- the number of array elements to be copied.
java.lang.IndexOutOfBoundsException
- if copying would cause
access of data outside array bounds.
java.lang.ArrayStoreException
- if an element in the src
array could not be stored into the dest
array
because of a type mismatch.
java.lang.NullPointerException
- if either src
or
dest
is null
.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(java.lang.Object[] a, java.lang.Object[] a2)
a
- one array to be tested for equality.a2
- the other array to be tested for equality.
|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |