Find Usages Diff Raw Download HTML Widget Stack Overflow Q&A
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
1. Examples of GoF Design Patterns
I am learning GoF Java Design Patterns and I want to see some real life examples of them. Can you guys point to some good usage of these Design Patterns.(preferably in Java's core libraries). Thank you
2. Accurracy of technical arguments in JWZ's ten-year-old "java sucks" article with today's Java?
I'm currently using Java in a larger project and was curious which of the technical arguments in JWZ's famous "java sucks" article were still valid ten years later. The article starts like this: I think Java is the best language going today, which is to say, it's the marginally acceptable one among the set of complete bagbiting loser languages that we have to work with out here in the real ...
3. How to concatenate two arrays in Java?
I need to concatenate two String arrays in Java. void f(String[] first, String[] second) { String[] both = ??? } What is the easiest way to do this?
4. In Java, how can I test if an Array contains a certain value?
I have a String[] with values like so: public static final String[] VALUES = new String[] {"AB","BC","CD","AE"}; Given String s, is there a good way of testing whether VALUES contains s?
5. How to convert List to int[] in Java?
This is similar to this question: http://stackoverflow.com/questions/880581/java-convert-int-to-integer I'm new to Java. How can i convert a List to int[] in Java? I'm confused because List.toArray() actually returns an Object[], which can be cast to nether Integer[] or int[]. Right now I'm using a loop to do so: int[] toIntArray(List<Integer> list){ int[] ret = new int[list.size()];...
6. Java: what is this: [Ljava.lang.Object;?
I get this when I call toString on an object I received from a function call. I know the type of the object is encoded in this string, but I don't know how to read it. What is this type of encoding called?
7. Best way to list files in Java, sorted by Date Modified?
I want to get a list of files in a directory, but I want to sort it such that the oldest files are first. My solution was to call File.listFiles and just resort the list based on File.lastModified, but I was wondering if there was a better way. Edit: My current solution, as suggested, is to use an anonymous Comparator: File[] files = directory.listFiles(); Arrays.sort(files, new Comparator&...
8. Why does java.util.Arrays.sort(Object[]) use 2 kinds of sorting algorithms?
I found that java.util.Arrays.sort(Object[]) use 2 kinds of sorting algorithms(in JDK 1.6). pseudocode: if(array.length<7) insertionSort(array); else mergeSort(array); Why does it need 2 kinds of sorting here? for efficiency?
9. How do I sort an array in Scala?
I can see there's a Sorting object with a quickSort method on it. Can someone provide a code example of using it, sorting an array of object of arbitrary type? It looks like I need to pass in an impl of the Orderable trait, but I am unsure of the syntax. Also, I would prefer answers doing this the 'scala way'. I know I can just use a Java library.
10. How to convert an int[] array to a List?
I expected this code to display true: int[] array = {1, 2}; System.out.println(Arrays.asList(array).contains(1));
11. Sort String "13,5,8,4,2,1,9" in ascending order 1,2,4,5,8,9,13 in Java
How can I sort a string "13,5,8,4,2,1,9" in ascending order, to get 1,2,4,5,8,9,13?
12. Grokking Timsort
There's a (relatively) new sort on the block called Timsort. It's been used as Python's list.sort, and is now going to be the new Array.sort in Java 7). There's some documentation and a tiny Wikipedia article describing the high-level properties of the sort and some low-level performance evaluations, but I was curious if anybody can provide some pseudocode to illustrate what Timsort is doing, ...
13. Most memory efficient way to grow an array in Java?
I'm not too concerned about time efficiency (the operation will be rare), but rather about memory efficiency: Can I grow the array without temporarily having all the values twice? Is there a more efficient way to grow a large array than creating a new one and copying over all the values? Like, concatenating it with a new one? What about having fixed-size arrays stored in another array and rea...
14. Is it bad form to have a a MiscUtilities class?
Our company keeps a MiscUtilities class that consists solely of public static methods that do often unrelated tasks like converting dates from String to Calendar and writing ArrayLists to files. We refer to it in other classes and find it pretty convenient. However, I've seen that sort of Utilities class derided on TheDailyWTF. I'm just wondering if there's any actual downside to this sort of c...
15. Is this an immutable class?
I have no idea what immutable class should look like but am pretty sure this one is. Am I right? If I'm not please specify what should be added/removed. import java.io.Serializable; public class Triangle implements IShape, Serializable { private static final long serialVersionUID = 0x100; private Point[] points; public Triangle(Point a, Point b, Point c) { this.points = ...
16. How to avoid repetition when working with primitive types?
I have the need to perform algorithms on various primitive types; the algorithm is essentially the same with the exception of which type the variables are. So for instance, /** * Determine if <code>value</code> is the bitwise OR of elements of <code>validValues</code> array. * For instance, our valid choices are 0001, 0010, and 1000. * We are given a value of 1001. T...
17. Java ArrayList initialization
I am aware that you can initialize an array during instantiation as follows: String[] names = new String[] {"Ryan", "Julie", "Bob"}; Is there a way to do the same thing with an ArrayList? Or must I add the contents individually with array.add()? Thanks, Jonathan
18. How to write a basic swap function in Java
I am new to java. How to write the java equivalent of the following C code. public void Swap(int &p, int &q) { int temp; temp = *p; *p = *q; *q = temp; }
19. How to sort an array of ints using a custom comparator?
I need to sort an array of ints using a custom comparator, but Java's library doesn't provide a sort function for ints with comparators (comparators can be used only with objects). Is there any easy way to do this?
20. Initializing an array in Java using the 'advanced' for each loop
Is it possible to initialise an array in Java using the 'advanced' for loop? e.g. Integer[ ] numbers = new Integer[20]; int counter = 0; for ( Integer i : numbers ) { i = counter++; } for ( Integer i : numbers ) { System.out.println(i); } This prints all nulls, why is that?
21. What is the fast way of getting an index of an element in an array?
I was asked this question in an interview. Although the interview was for dot net position, he asked me this question in context to java, because I had mentioned java also in my resume. How to find the index of an element having value X in an array ? I said iterating from the first element till last and checking whether the value is X would give the result. He asked about a method involving ... 
1
   /*
2
    * Copyright 1997-2007 Sun Microsystems, Inc.  All Rights Reserved.
3
    * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4
    *
5
    * This code is free software; you can redistribute it and/or modify it
6
    * under the terms of the GNU General Public License version 2 only, as
7
    * published by the Free Software Foundation.  Sun designates this
8
    * particular file as subject to the "Classpath" exception as provided
9
    * by Sun in the LICENSE file that accompanied this code.
10
   *
11
   * This code is distributed in the hope that it will be useful, but WITHOUT
12
   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13
   * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14
   * version 2 for more details (a copy is included in the LICENSE file that
15
   * accompanied this code).
16
   *
17
   * You should have received a copy of the GNU General Public License version
18
   * 2 along with this work; if not, write to the Free Software Foundation,
19
   * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20
   *
21
   * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
22
   * CA 95054 USA or visit www.sun.com if you need additional information or
23
   * have any questions.
24
   */
25
  
26
  package java.util;
27
  
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, except where noted.

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.)

This class is a member of the Java Collections Framework.

Author(s):
Josh Bloch
Neal Gafter
John Rose
Since:
1.2
54
  
55
  
56
  public class Arrays {
57
      // Suppresses default constructor, ensuring non-instantiability.
58
      private Arrays() {
59
      }
60
  
61
      // Sorting
62
  
    
Sorts the specified array of longs into ascending numerical order. 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.

Parameters:
a the array to be sorted
72
  
73
      public static void sort(long[] a) {
74
          sort1(a, 0, a.length);
75
      }

    
Sorts the specified range of the specified array of longs into ascending numerical order. The range to be sorted extends from index fromIndex, inclusive, to index toIndex, exclusive. (If fromIndex==toIndex, the range to be sorted is empty.)

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.

Parameters:
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
Throws:
java.lang.IllegalArgumentException if fromIndex > toIndex
java.lang.ArrayIndexOutOfBoundsException if fromIndex < 0 or toIndex > a.length
96
  
97
      public static void sort(long[] a, int fromIndex, int toIndex) {
98
          rangeCheck(a.length, fromIndex, toIndex);
99
          sort1(a, fromIndex, toIndex-fromIndex);
100
     }

    
Sorts the specified array of ints into ascending numerical order. 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.

Parameters:
a the array to be sorted
111
 
112
     public static void sort(int[] a) {
113
         sort1(a, 0, a.length);
114
     }

    
Sorts the specified range of the specified array of ints into ascending numerical order. The range to be sorted extends from index fromIndex, inclusive, to index toIndex, exclusive. (If fromIndex==toIndex, the range to be sorted is empty.)

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.

Parameters:
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
Throws:
java.lang.IllegalArgumentException if fromIndex > toIndex
java.lang.ArrayIndexOutOfBoundsException if fromIndex < 0 or toIndex > a.length
135
 
136
     public static void sort(int[] a, int fromIndex, int toIndex) {
137
         rangeCheck(a.length, fromIndex, toIndex);
138
         sort1(a, fromIndex, toIndex-fromIndex);
139
     }

    
Sorts the specified array of shorts into ascending numerical order. 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.

Parameters:
a the array to be sorted
150
 
151
     public static void sort(short[] a) {
152
         sort1(a, 0, a.length);
153
     }

    
Sorts the specified range of the specified array of shorts into ascending numerical order. The range to be sorted extends from index fromIndex, inclusive, to index toIndex, exclusive. (If fromIndex==toIndex, the range to be sorted is empty.)

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.

Parameters:
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
Throws:
java.lang.IllegalArgumentException if fromIndex > toIndex
java.lang.ArrayIndexOutOfBoundsException if fromIndex < 0 or toIndex > a.length
174
 
175
     public static void sort(short[] a, int fromIndex, int toIndex) {
176
         rangeCheck(a.length, fromIndex, toIndex);
177
         sort1(a, fromIndex, toIndex-fromIndex);
178
     }

    
Sorts the specified array of chars into ascending numerical order. 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.

Parameters:
a the array to be sorted
189
 
190
     public static void sort(char[] a) {
191
         sort1(a, 0, a.length);
192
     }

    
Sorts the specified range of the specified array of chars into ascending numerical order. The range to be sorted extends from index fromIndex, inclusive, to index toIndex, exclusive. (If fromIndex==toIndex, the range to be sorted is empty.)

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.

Parameters:
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
Throws:
java.lang.IllegalArgumentException if fromIndex > toIndex
java.lang.ArrayIndexOutOfBoundsException if fromIndex < 0 or toIndex > a.length
213
 
214
     public static void sort(char[] a, int fromIndex, int toIndex) {
215
         rangeCheck(a.length, fromIndex, toIndex);
216
         sort1(a, fromIndex, toIndex-fromIndex);
217
     }

    
Sorts the specified array of bytes into ascending numerical order. 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.

Parameters:
a the array to be sorted
228
 
229
     public static void sort(byte[] a) {
230
         sort1(a, 0, a.length);
231
     }

    
Sorts the specified range of the specified array of bytes into ascending numerical order. The range to be sorted extends from index fromIndex, inclusive, to index toIndex, exclusive. (If fromIndex==toIndex, the range to be sorted is empty.)

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.

Parameters:
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
Throws:
java.lang.IllegalArgumentException if fromIndex > toIndex
java.lang.ArrayIndexOutOfBoundsException if fromIndex < 0 or toIndex > a.length
252
 
253
     public static void sort(byte[] a, int fromIndex, int toIndex) {
254
         rangeCheck(a.length, fromIndex, toIndex);
255
         sort1(a, fromIndex, toIndex-fromIndex);
256
     }

    
Sorts the specified array of doubles into ascending numerical order.

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 java.lang.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.

Parameters:
a the array to be sorted
282
 
283
     public static void sort(double[] a) {
284
         sort2(a, 0, a.length);
285
     }

    
Sorts the specified range of the specified array of doubles into ascending numerical order. The range to be sorted extends from index fromIndex, inclusive, to index toIndex, exclusive. (If fromIndex==toIndex, the range to be sorted is empty.)

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 java.lang.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.

Parameters:
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
Throws:
java.lang.IllegalArgumentException if fromIndex > toIndex
java.lang.ArrayIndexOutOfBoundsException if fromIndex < 0 or toIndex > a.length
320
 
321
     public static void sort(double[] a, int fromIndex, int toIndex) {
322
         rangeCheck(a.length, fromIndex, toIndex);
323
         sort2(a, fromIndex, toIndex);
324
     }

    
Sorts the specified array of floats into ascending numerical order.

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 java.lang.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.

Parameters:
a the array to be sorted
350
 
351
     public static void sort(float[] a) {
352
         sort2(a, 0, a.length);
353
     }

    
Sorts the specified range of the specified array of floats into ascending numerical order. The range to be sorted extends from index fromIndex, inclusive, to index toIndex, exclusive. (If fromIndex==toIndex, the range to be sorted is empty.)

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 java.lang.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.

Parameters:
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
Throws:
java.lang.IllegalArgumentException if fromIndex > toIndex
java.lang.ArrayIndexOutOfBoundsException if fromIndex < 0 or toIndex > a.length
388
 
389
     public static void sort(float[] a, int fromIndex, int toIndex) {
390
         rangeCheck(a.length, fromIndex, toIndex);
391
         sort2(a, fromIndex, toIndex);
392
     }
393
 
394
     private static void sort2(double a[], int fromIndex, int toIndex) {
395
         final long NEG_ZERO_BITS = Double.doubleToLongBits(-0.0d);
396
         /*
397
          * The sort is done in three phases to avoid the expense of using
398
          * NaN and -0.0 aware comparisons during the main sort.
399
          */
400
 
401
         /*
402
          * Preprocessing phase:  Move any NaN's to end of array, count the
403
          * number of -0.0's, and turn them into 0.0's.
404
          */
405
         int numNegZeros = 0;
406
         int i = fromIndex, n = toIndex;
407
         while(i < n) {
408
             if (a[i] != a[i]) {
409
                 swap(a, i, --n);
410
             } else {
411
                 if (a[i]==0 && Double.doubleToLongBits(a[i])==NEG_ZERO_BITS) {
412
                     a[i] = 0.0d;
413
                     numNegZeros++;
414
                 }
415
                 i++;
416
             }
417
         }
418
 
419
         // Main sort phase: quicksort everything but the NaN's
420
         sort1(a, fromIndex, n-fromIndex);
421
 
422
         // Postprocessing phase: change 0.0's to -0.0's as required
423
         if (numNegZeros != 0) {
424
             int j = binarySearch0(a, fromIndex, n, 0.0d); // posn of ANY zero
425
             do {
426
                 j--;
427
             } while (j>=fromIndex && a[j]==0.0d);
428
 
429
             // j is now one less than the index of the FIRST zero
430
             for (int k=0; k<numNegZeros; k++)
431
                 a[++j] = -0.0d;
432
         }
433
     }
434
 
435
 
436
     private static void sort2(float a[], int fromIndex, int toIndex) {
437
         final int NEG_ZERO_BITS = Float.floatToIntBits(-0.0f);
438
         /*
439
          * The sort is done in three phases to avoid the expense of using
440
          * NaN and -0.0 aware comparisons during the main sort.
441
          */
442
 
443
         /*
444
          * Preprocessing phase:  Move any NaN's to end of array, count the
445
          * number of -0.0's, and turn them into 0.0's.
446
          */
447
         int numNegZeros = 0;
448
         int i = fromIndex, n = toIndex;
449
         while(i < n) {
450
             if (a[i] != a[i]) {
451
                 swap(a, i, --n);
452
             } else {
453
                 if (a[i]==0 && Float.floatToIntBits(a[i])==NEG_ZERO_BITS) {
454
                     a[i] = 0.0f;
455
                     numNegZeros++;
456
                 }
457
                 i++;
458
             }
459
         }
460
 
461
         // Main sort phase: quicksort everything but the NaN's
462
         sort1(a, fromIndex, n-fromIndex);
463
 
464
         // Postprocessing phase: change 0.0's to -0.0's as required
465
         if (numNegZeros != 0) {
466
             int j = binarySearch0(a, fromIndex, n, 0.0f); // posn of ANY zero
467
             do {
468
                 j--;
469
             } while (j>=fromIndex && a[j]==0.0f);
470
 
471
             // j is now one less than the index of the FIRST zero
472
             for (int k=0; k<numNegZeros; k++)
473
                 a[++j] = -0.0f;
474
         }
475
     }
476
 
477
 
478
     /*
479
      * The code for each of the seven primitive types is largely identical.
480
      * C'est la vie.
481
      */

    
Sorts the specified sub-array of longs into ascending order. 
485
 
486
     private static void sort1(long x[], int off, int len) {
487
         // Insertion sort on smallest arrays
488
         if (len < 7) {
489
             for (int i=off; i<len+off; i++)
490
                 for (int j=i; j>off && x[j-1]>x[j]; j--)
491
                     swap(x, j, j-1);
492
             return;
493
         }
494
 
495
         // Choose a partition element, v
496
         int m = off + (len >> 1);       // Small arrays, middle element
497
         if (len > 7) {
498
             int l = off;
499
             int n = off + len - 1;
500
             if (len > 40) {        // Big arrays, pseudomedian of 9
501
                 int s = len/8;
502
                 l = med3(x, l,     l+s, l+2*s);
503
                 m = med3(x, m-s,   m,   m+s);
504
                 n = med3(x, n-2*s, n-s, n);
505
             }
506
             m = med3(x, l, m, n); // Mid-size, med of 3
507
         }
508
         long v = x[m];
509
 
510
         // Establish Invariant: v* (<v)* (>v)* v*
511
         int a = off, b = a, c = off + len - 1, d = c;
512
         while(true) {
513
             while (b <= c && x[b] <= v) {
514
                 if (x[b] == v)
515
                     swap(x, a++, b);
516
                 b++;
517
             }
518
             while (c >= b && x[c] >= v) {
519
                 if (x[c] == v)
520
                     swap(x, c, d--);
521
                 c--;
522
             }
523
             if (b > c)
524
                 break;
525
             swap(x, b++, c--);
526
         }
527
 
528
         // Swap partition elements back to middle
529
         int s, n = off + len;
530
         s = Math.min(a-off, b-a  );  vecswap(x, off, b-s, s);
531
         s = Math.min(d-c,   n-d-1);  vecswap(x, b,   n-s, s);
532
 
533
         // Recursively sort non-partition-elements
534
         if ((s = b-a) > 1)
535
             sort1(x, off, s);
536
         if ((s = d-c) > 1)
537
             sort1(x, n-s, s);
538
     }

    
Swaps x[a] with x[b]. 
542
 
543
     private static void swap(long x[], int a, int b) {
544
         long t = x[a];
545
         x[a] = x[b];
546
         x[b] = t;
547
     }

    
Swaps x[a .. (a+n-1)] with x[b .. (b+n-1)]. 
551
 
552
     private static void vecswap(long x[], int a, int b, int n) {
553
         for (int i=0; i<n; i++, a++, b++)
554
             swap(x, a, b);
555
     }

    
Returns the index of the median of the three indexed longs. 
559
 
560
     private static int med3(long x[], int a, int b, int c) {
561
         return (x[a] < x[b] ?
562
                 (x[b] < x[c] ? b : x[a] < x[c] ? c : a) :
563
                 (x[b] > x[c] ? b : x[a] > x[c] ? c : a));
564
     }

    
Sorts the specified sub-array of integers into ascending order. 
568
 
569
     private static void sort1(int x[], int off, int len) {
570
         // Insertion sort on smallest arrays
571
         if (len < 7) {
572
             for (int i=off; i<len+off; i++)
573
                 for (int j=i; j>off && x[j-1]>x[j]; j--)
574
                     swap(x, j, j-1);
575
             return;
576
         }
577
 
578
         // Choose a partition element, v
579
         int m = off + (len >> 1);       // Small arrays, middle element
580
         if (len > 7) {
581
             int l = off;
582
             int n = off + len - 1;
583
             if (len > 40) {        // Big arrays, pseudomedian of 9
584
                 int s = len/8;
585
                 l = med3(x, l,     l+s, l+2*s);
586
                 m = med3(x, m-s,   m,   m+s);
587
                 n = med3(x, n-2*s, n-s, n);
588
             }
589
             m = med3(x, l, m, n); // Mid-size, med of 3
590
         }
591
         int v = x[m];
592
 
593
         // Establish Invariant: v* (<v)* (>v)* v*
594
         int a = off, b = a, c = off + len - 1, d = c;
595
         while(true) {
596
             while (b <= c && x[b] <= v) {
597
                 if (x[b] == v)
598
                     swap(x, a++, b);
599
                 b++;
600
             }
601
             while (c >= b && x[c] >= v) {
602
                 if (x[c] == v)
603
                     swap(x, c, d--);
604
                 c--;
605
             }
606
             if (b > c)
607
                 break;
608
             swap(x, b++, c--);
609
         }
610
 
611
         // Swap partition elements back to middle
612
         int s, n = off + len;
613
         s = Math.min(a-off, b-a  );  vecswap(x, off, b-s, s);
614
         s = Math.min(d-c,   n-d-1);  vecswap(x, b,   n-s, s);
615
 
616
         // Recursively sort non-partition-elements
617
         if ((s = b-a) > 1)
618
             sort1(x, off, s);
619
         if ((s = d-c) > 1)
620
             sort1(x, n-s, s);
621
     }

    
Swaps x[a] with x[b]. 
625
 
626
     private static void swap(int x[], int a, int b) {
627
         int t = x[a];
628
         x[a] = x[b];
629
         x[b] = t;
630
     }

    
Swaps x[a .. (a+n-1)] with x[b .. (b+n-1)]. 
634
 
635
     private static void vecswap(int x[], int a, int b, int n) {
636
         for (int i=0; i<n; i++, a++, b++)
637
             swap(x, a, b);
638
     }

    
Returns the index of the median of the three indexed integers. 
642
 
643
     private static int med3(int x[], int a, int b, int c) {
644
         return (x[a] < x[b] ?
645
                 (x[b] < x[c] ? b : x[a] < x[c] ? c : a) :
646
                 (x[b] > x[c] ? b : x[a] > x[c] ? c : a));
647
     }

    
Sorts the specified sub-array of shorts into ascending order. 
651
 
652
     private static void sort1(short x[], int off, int len) {
653
         // Insertion sort on smallest arrays
654
         if (len < 7) {
655
             for (int i=off; i<len+off; i++)
656
                 for (int j=i; j>off && x[j-1]>x[j]; j--)
657
                     swap(x, j, j-1);
658
             return;
659
         }
660
 
661
         // Choose a partition element, v
662
         int m = off + (len >> 1);       // Small arrays, middle element
663
         if (len > 7) {
664
             int l = off;
665
             int n = off + len - 1;
666
             if (len > 40) {        // Big arrays, pseudomedian of 9
667
                 int s = len/8;
668
                 l = med3(x, l,     l+s, l+2*s);
669
                 m = med3(x, m-s,   m,   m+s);
670
                 n = med3(x, n-2*s, n-s, n);
671
             }
672
             m = med3(x, l, m, n); // Mid-size, med of 3
673
         }
674
         short v = x[m];
675
 
676
         // Establish Invariant: v* (<v)* (>v)* v*
677
         int a = off, b = a, c = off + len - 1, d = c;
678
         while(true) {
679
             while (b <= c && x[b] <= v) {
680
                 if (x[b] == v)
681
                     swap(x, a++, b);
682
                 b++;
683
             }
684
             while (c >= b && x[c] >= v) {
685
                 if (x[c] == v)
686
                     swap(x, c, d--);
687
                 c--;
688
             }
689
             if (b > c)
690
                 break;
691
             swap(x, b++, c--);
692
         }
693
 
694
         // Swap partition elements back to middle
695
         int s, n = off + len;
696
         s = Math.min(a-off, b-a  );  vecswap(x, off, b-s, s);
697
         s = Math.min(d-c,   n-d-1);  vecswap(x, b,   n-s, s);
698
 
699
         // Recursively sort non-partition-elements
700
         if ((s = b-a) > 1)
701
             sort1(x, off, s);
702
         if ((s = d-c) > 1)
703
             sort1(x, n-s, s);
704
     }

    
Swaps x[a] with x[b]. 
708
 
709
     private static void swap(short x[], int a, int b) {
710
         short t = x[a];
711
         x[a] = x[b];
712
         x[b] = t;
713
     }

    
Swaps x[a .. (a+n-1)] with x[b .. (b+n-1)]. 
717
 
718
     private static void vecswap(short x[], int a, int b, int n) {
719
         for (int i=0; i<n; i++, a++, b++)
720
             swap(x, a, b);
721
     }

    
Returns the index of the median of the three indexed shorts. 
725
 
726
     private static int med3(short x[], int a, int b, int c) {
727
         return (x[a] < x[b] ?
728
                 (x[b] < x[c] ? b : x[a] < x[c] ? c : a) :
729
                 (x[b] > x[c] ? b : x[a] > x[c] ? c : a));
730
     }


    
Sorts the specified sub-array of chars into ascending order. 
735
 
736
     private static void sort1(char x[], int off, int len) {
737
         // Insertion sort on smallest arrays
738
         if (len < 7) {
739
             for (int i=off; i<len+off; i++)
740
                 for (int j=i; j>off && x[j-1]>x[j]; j--)
741
                     swap(x, j, j-1);
742
             return;
743
         }
744
 
745
         // Choose a partition element, v
746
         int m = off + (len >> 1);       // Small arrays, middle element
747
         if (len > 7) {
748
             int l = off;
749
             int n = off + len - 1;
750
             if (len > 40) {        // Big arrays, pseudomedian of 9
751
                 int s = len/8;
752
                 l = med3(x, l,     l+s, l+2*s);
753
                 m = med3(x, m-s,   m,   m+s);
754
                 n = med3(x, n-2*s, n-s, n);
755
             }
756
             m = med3(x, l, m, n); // Mid-size, med of 3
757
         }
758
         char v = x[m];
759
 
760
         // Establish Invariant: v* (<v)* (>v)* v*
761
         int a = off, b = a, c = off + len - 1, d = c;
762
         while(true) {
763
             while (b <= c && x[b] <= v) {
764
                 if (x[b] == v)
765
                     swap(x, a++, b);
766
                 b++;
767
             }
768
             while (c >= b && x[c] >= v) {
769
                 if (x[c] == v)
770
                     swap(x, c, d--);
771
                 c--;
772
             }
773
             if (b > c)
774
                 break;
775
             swap(x, b++, c--);
776
         }
777
 
778
         // Swap partition elements back to middle
779
         int s, n = off + len;
780
         s = Math.min(a-off, b-a  );  vecswap(x, off, b-s, s);
781
         s = Math.min(d-c,   n-d-1);  vecswap(x, b,   n-s, s);
782
 
783
         // Recursively sort non-partition-elements
784
         if ((s = b-a) > 1)
785
             sort1(x, off, s);
786
         if ((s = d-c) > 1)
787
             sort1(x, n-s, s);
788
     }

    
Swaps x[a] with x[b]. 
792
 
793
     private static void swap(char x[], int a, int b) {
794
         char t = x[a];
795
         x[a] = x[b];
796
         x[b] = t;
797
     }

    
Swaps x[a .. (a+n-1)] with x[b .. (b+n-1)]. 
801
 
802
     private static void vecswap(char x[], int a, int b, int n) {
803
         for (int i=0; i<n; i++, a++, b++)
804
             swap(x, a, b);
805
     }

    
Returns the index of the median of the three indexed chars. 
809
 
810
     private static int med3(char x[], int a, int b, int c) {
811
         return (x[a] < x[b] ?
812
                 (x[b] < x[c] ? b : x[a] < x[c] ? c : a) :
813
                 (x[b] > x[c] ? b : x[a] > x[c] ? c : a));
814
     }


    
Sorts the specified sub-array of bytes into ascending order. 
819
 
820
     private static void sort1(byte x[], int off, int len) {
821
         // Insertion sort on smallest arrays
822
         if (len < 7) {
823
             for (int i=off; i<len+off; i++)
824
                 for (int j=i; j>off && x[j-1]>x[j]; j--)
825
                     swap(x, j, j-1);
826
             return;
827
         }
828
 
829
         // Choose a partition element, v
830
         int m = off + (len >> 1);       // Small arrays, middle element
831
         if (len > 7) {
832
             int l = off;
833
             int n = off + len - 1;
834
             if (len > 40) {        // Big arrays, pseudomedian of 9
835
                 int s = len/8;
836
                 l = med3(x, l,     l+s, l+2*s);
837
                 m = med3(x, m-s,   m,   m+s);
838
                 n = med3(x, n-2*s, n-s, n);
839
             }
840
             m = med3(x, l, m, n); // Mid-size, med of 3
841
         }
842
         byte v = x[m];
843
 
844
         // Establish Invariant: v* (<v)* (>v)* v*
845
         int a = off, b = a, c = off + len - 1, d = c;
846
         while(true) {
847
             while (b <= c && x[b] <= v) {
848
                 if (x[b] == v)
849
                     swap(x, a++, b);
850
                 b++;
851
             }
852
             while (c >= b && x[c] >= v) {
853
                 if (x[c] == v)
854
                     swap(x, c, d--);
855
                 c--;
856
             }
857
             if (b > c)
858
                 break;
859
             swap(x, b++, c--);
860
         }
861
 
862
         // Swap partition elements back to middle
863
         int s, n = off + len;
864
         s = Math.min(a-off, b-a  );  vecswap(x, off, b-s, s);
865
         s = Math.min(d-c,   n-d-1);  vecswap(x, b,   n-s, s);
866
 
867
         // Recursively sort non-partition-elements
868
         if ((s = b-a) > 1)
869
             sort1(x, off, s);
870
         if ((s = d-c) > 1)
871
             sort1(x, n-s, s);
872
     }

    
Swaps x[a] with x[b]. 
876
 
877
     private static void swap(byte x[], int a, int b) {
878
         byte t = x[a];
879
         x[a] = x[b];
880
         x[b] = t;
881
     }

    
Swaps x[a .. (a+n-1)] with x[b .. (b+n-1)]. 
885
 
886
     private static void vecswap(byte x[], int a, int b, int n) {
887
         for (int i=0; i<n; i++, a++, b++)
888
             swap(x, a, b);
889
     }

    
Returns the index of the median of the three indexed bytes. 
893
 
894
     private static int med3(byte x[], int a, int b, int c) {
895
         return (x[a] < x[b] ?
896
                 (x[b] < x[c] ? b : x[a] < x[c] ? c : a) :
897
                 (x[b] > x[c] ? b : x[a] > x[c] ? c : a));
898
     }


    
Sorts the specified sub-array of doubles into ascending order. 
903
 
904
     private static void sort1(double x[], int off, int len) {
905
         // Insertion sort on smallest arrays
906
         if (len < 7) {
907
             for (int i=off; i<len+off; i++)
908
                 for (int j=i; j>off && x[j-1]>x[j]; j--)
909
                     swap(x, j, j-1);
910
             return;
911
         }
912
 
913
         // Choose a partition element, v
914
         int m = off + (len >> 1);       // Small arrays, middle element
915
         if (len > 7) {
916
             int l = off;
917
             int n = off + len - 1;
918
             if (len > 40) {        // Big arrays, pseudomedian of 9
919
                 int s = len/8;
920
                 l = med3(x, l,     l+s, l+2*s);
921
                 m = med3(x, m-s,   m,   m+s);
922
                 n = med3(x, n-2*s, n-s, n);
923
             }
924
             m = med3(x, l, m, n); // Mid-size, med of 3
925
         }
926
         double v = x[m];
927
 
928
         // Establish Invariant: v* (<v)* (>v)* v*
929
         int a = off, b = a, c = off + len - 1, d = c;
930
         while(true) {
931
             while (b <= c && x[b] <= v) {
932
                 if (x[b] == v)
933
                     swap(x, a++, b);
934
                 b++;
935
             }
936
             while (c >= b && x[c] >= v) {
937
                 if (x[c] == v)
938
                     swap(x, c, d--);
939
                 c--;
940
             }
941
             if (b > c)
942
                 break;
943
             swap(x, b++, c--);
944
         }
945
 
946
         // Swap partition elements back to middle
947
         int s, n = off + len;
948
         s = Math.min(a-off, b-a  );  vecswap(x, off, b-s, s);
949
         s = Math.min(d-c,   n-d-1);  vecswap(x, b,   n-s, s);
950
 
951
         // Recursively sort non-partition-elements
952
         if ((s = b-a) > 1)
953
             sort1(x, off, s);
954
         if ((s = d-c) > 1)
955
             sort1(x, n-s, s);
956
     }

    
Swaps x[a] with x[b]. 
960
 
961
     private static void swap(double x[], int a, int b) {
962
         double t = x[a];
963
         x[a] = x[b];
964
         x[b] = t;
965
     }

    
Swaps x[a .. (a+n-1)] with x[b .. (b+n-1)]. 
969
 
970
     private static void vecswap(double x[], int a, int b, int n) {
971
         for (int i=0; i<n; i++, a++, b++)
972
             swap(x, a, b);
973
     }

    
Returns the index of the median of the three indexed doubles. 
977
 
978
     private static int med3(double x[], int a, int b, int c) {
979
         return (x[a] < x[b] ?
980
                 (x[b] < x[c] ? b : x[a] < x[c] ? c : a) :
981
                 (x[b] > x[c] ? b : x[a] > x[c] ? c : a));
982
     }


    
Sorts the specified sub-array of floats into ascending order. 
987
 
988
     private static void sort1(float x[], int off, int len) {
989
         // Insertion sort on smallest arrays
990
         if (len < 7) {
991
             for (int i=off; i<len+off; i++)
992
                 for (int j=i; j>off && x[j-1]>x[j]; j--)
993
                     swap(x, j, j-1);
994
             return;
995
         }
996
 
997
         // Choose a partition element, v
998
         int m = off + (len >> 1);       // Small arrays, middle element
999
         if (len > 7) {
1000
            int l = off;
1001
            int n = off + len - 1;
1002
            if (len > 40) {        // Big arrays, pseudomedian of 9
1003
                int s = len/8;
1004
                l = med3(x, l,     l+s, l+2*s);
1005
                m = med3(x, m-s,   m,   m+s);
1006
                n = med3(x, n-2*s, n-s, n);
1007
            }
1008
            m = med3(x, l, m, n); // Mid-size, med of 3
1009
        }
1010
        float v = x[m];
1012
        // Establish Invariant: v* (<v)* (>v)* v*
1013
        int a = off, b = a, c = off + len - 1, d = c;
1014
        while(true) {
1015
            while (b <= c && x[b] <= v) {
1016
                if (x[b] == v)
1017
                    swap(x, a++, b);
1018
                b++;
1019
            }
1020
            while (c >= b && x[c] >= v) {
1021
                if (x[c] == v)
1022
                    swap(x, c, d--);
1023
                c--;
1024
            }
1025
            if (b > c)
1026
                break;
1027
            swap(x, b++, c--);
1028
        }
1030
        // Swap partition elements back to middle
1031
        int s, n = off + len;
1032
        s = Math.min(a-off, b-a  );  vecswap(x, off, b-s, s);
1033
        s = Math.min(d-c,   n-d-1);  vecswap(x, b,   n-s, s);
1035
        // Recursively sort non-partition-elements
1036
        if ((s = b-a) > 1)
1037
            sort1(x, off, s);
1038
        if ((s = d-c) > 1)
1039
            sort1(x, n-s, s);
1040
    }

    
Swaps x[a] with x[b]. 
1045
    private static void swap(float x[], int a, int b) {
1046
        float t = x[a];
1047
        x[a] = x[b];
1048
        x[b] = t;
1049
    }

    
Swaps x[a .. (a+n-1)] with x[b .. (b+n-1)]. 
1054
    private static void vecswap(float x[], int a, int b, int n) {
1055
        for (int i=0; i<n; i++, a++, b++)
1056
            swap(x, a, b);
1057
    }

    
Returns the index of the median of the three indexed floats. 
1062
    private static int med3(float x[], int a, int b, int c) {
1063
        return (x[a] < x[b] ?
1064
                (x[b] < x[c] ? b : x[a] < x[c] ? c : a) :
1065
                (x[b] > x[c] ? b : x[a] > x[c] ? c : a));
1066
    }


    
Sorts the specified array of objects into ascending order, according to the natural ordering of its elements. All elements in the array must implement the java.lang.Comparable interface. Furthermore, all elements in the array must be mutually comparable (that is, e1.compareTo(e2) must not throw a ClassCastException for any elements e1 and e2 in the array).

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.

Parameters:
a the array to be sorted
Throws:
java.lang.ClassCastException if the array contains elements that are not mutually comparable (for example, strings and integers).
1090
    public static void sort(Object[] a) {
1091
        Object[] aux = (Object[])a.clone();
1092
        mergeSort(aux, a, 0, a.length, 0);
1093
    }

    
Sorts the specified range of the specified array of objects into ascending order, according to the natural ordering of its elements. The range to be sorted extends from index fromIndex, inclusive, to index toIndex, exclusive. (If fromIndex==toIndex, the range to be sorted is empty.) All elements in this range must implement the java.lang.Comparable interface. Furthermore, all elements in this range must be mutually comparable (that is, e1.compareTo(e2) must not throw a ClassCastException for any elements e1 and e2 in the array).

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.

Parameters:
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
Throws:
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).
1127
    public static void sort(Object[] a, int fromIndex, int toIndex) {
1128
        rangeCheck(a.length, fromIndex, toIndex);
1129
        Object[] aux = copyOfRange(a, fromIndex, toIndex);
1130
        mergeSort(aux, a, fromIndex, toIndex, -fromIndex);
1131
    }

    
Tuning parameter: list size at or below which insertion sort will be used in preference to mergesort or quicksort. 
1137
    private static final int INSERTIONSORT_THRESHOLD = 7;

    
Src is the source array that starts at index 0 Dest is the (possibly larger) array destination with a possible offset low is the index in dest to start sorting high is the end index in dest to end sorting off is the offset to generate corresponding low, high in src 
1146
    private static void mergeSort(Object[] src,
1147
                                  Object[] dest,
1148
                                  int low,
1149
                                  int high,
1150
                                  int off) {
1151
        int length = high - low;
1153
        // Insertion sort on smallest arrays
1154
        if (length < ) {
1155
            for (int i=low; i<high; i++)
1156
                for (int j=i; j>low &&
1157
                         ((Comparable) dest[j-1]).compareTo(dest[j])>0; j--)
1158
                    swap(dest, j, j-1);
1159
            return;
1160
        }
1162
        // Recursively sort halves of dest into src
1163
        int destLow  = low;
1164
        int destHigh = high;
1165
        low  += off;
1166
        high += off;
1167
        int mid = (low + high) >>> 1;
1168
        mergeSort(dest, src, low, mid, -off);
1169
        mergeSort(dest, src, mid, high, -off);
1171
        // If list is already sorted, just copy from src to dest.  This is an
1172
        // optimization that results in faster sorts for nearly ordered lists.
1173
        if (((Comparable)src[mid-1]).compareTo(src[mid]) <= 0) {
1174
            System.arraycopy(src, low, dest, destLow, length);
1175
            return;
1176
        }
1178
        // Merge sorted halves (now in src) into dest
1179
        for(int i = destLow, p = low, q = mid; i < destHigh; i++) {
1180
            if (q >= high || p < mid && ((Comparable)src[p]).compareTo(src[q])<=0)
1181
                dest[i] = src[p++];
1182
            else
1183
                dest[i] = src[q++];
1184
        }
1185
    }

    
Swaps x[a] with x[b]. 
1190
    private static void swap(Object[] x, int a, int b) {
1191
        Object t = x[a];
1192
        x[a] = x[b];
1193
        x[b] = t;
1194
    }

    
Sorts the specified array of objects according to the order induced by the specified comparator. All elements in the array must be mutually comparable by the specified comparator (that is, c.compare(e1, e2) must not throw a ClassCastException for any elements e1 and e2 in the array).

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.

Parameters:
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.
Throws:
java.lang.ClassCastException if the array contains elements that are not mutually comparable using the specified comparator.
1218
    public static <T> void sort(T[] a, Comparator<? super T> c) {
1219
        T[] aux = (T[])a.clone();
1220
        if (c==null)
1221
            mergeSort(aux, a, 0, a.length, 0);
1222
        else
1223
            mergeSort(aux, a, 0, a.length, 0, c);
1224
    }

    
Sorts the specified range of the specified array of objects according to the order induced by the specified comparator. The range to be sorted extends from index fromIndex, inclusive, to index toIndex, exclusive. (If fromIndex==toIndex, the range to be sorted is empty.) All elements in the range must be mutually comparable by the specified comparator (that is, c.compare(e1, e2) must not throw a ClassCastException for any elements e1 and e2 in the range).

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.

Parameters:
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.
Throws:
java.lang.ClassCastException if the array contains elements that are not mutually comparable using the specified comparator.
java.lang.IllegalArgumentException if fromIndex > toIndex
java.lang.ArrayIndexOutOfBoundsException if fromIndex < 0 or toIndex > a.length
1257
    public static <T> void sort(T[] a, int fromIndex, int toIndex,
1258
                                Comparator<? super T> c) {
1259
        rangeCheck(a.length, fromIndex, toIndex);
1260
        T[] aux = (T[])copyOfRange(a, fromIndex, toIndex);
1261
        if (c==null)
1262
            mergeSort(aux, a, fromIndex, toIndex, -fromIndex);
1263
        else
1264
            mergeSort(aux, a, fromIndex, toIndex, -fromIndex, c);
1265
    }

    
Src is the source array that starts at index 0 Dest is the (possibly larger) array destination with a possible offset low is the index in dest to start sorting high is the end index in dest to end sorting off is the offset into src corresponding to low in dest 
1274
    private static void mergeSort(Object[] src,
1275
                                  Object[] dest,
1276
                                  int low, int high, int off,
1277
                                  Comparator c) {
1278
        int length = high - low;
1280
        // Insertion sort on smallest arrays
1281
        if (length < ) {
1282
            for (int i=low; i<high; i++)
1283
                for (int j=i; j>low && c.compare(dest[j-1], dest[j])>0; j--)
1284
                    swap(dest, j, j-1);
1285
            return;
1286
        }
1288
        // Recursively sort halves of dest into src
1289
        int destLow  = low;
1290
        int destHigh = high;
1291
        low  += off;
1292
        high += off;
1293
        int mid = (low + high) >>> 1;
1294
        mergeSort(dest, src, low, mid, -off, c);
1295
        mergeSort(dest, src, mid, high, -off, c);
1297
        // If list is already sorted, just copy from src to dest.  This is an
1298
        // optimization that results in faster sorts for nearly ordered lists.
1299
        if (c.compare(src[mid-1], src[mid]) <= 0) {
1300
           System.arraycopy(src, low, dest, destLow, length);
1301
           return;
1302
        }
1304
        // Merge sorted halves (now in src) into dest
1305
        for(int i = destLow, p = low, q = mid; i < destHigh; i++) {
1306
            if (q >= high || p < mid && c.compare(src[p], src[q]) <= 0)
1307
                dest[i] = src[p++];
1308
            else
1309
                dest[i] = src[q++];
1310
        }
1311
    }

    
Check that fromIndex and toIndex are in range, and throw an appropriate exception if they aren't. 
1317
    private static void rangeCheck(int arrayLen, int fromIndex, int toIndex) {
1318
        if (fromIndex > toIndex)
1319
            throw new IllegalArgumentException("fromIndex(" + fromIndex +
1320
                       ") > toIndex(" + toIndex+")");
1321
        if (fromIndex < 0)
1322
            throw new ArrayIndexOutOfBoundsException(fromIndex);
1323
        if (toIndex > arrayLen)
1324
            throw new ArrayIndexOutOfBoundsException(toIndex);
1325
    }
1327
    // Searching
1328

    
Searches the specified array of longs for the specified value using the binary search algorithm. The array must be sorted (as by the sort(long[]) method) prior to making this call. If it is not sorted, the results are undefined. If the array contains multiple elements with the specified value, there is no guarantee which one will be found.

Parameters:
a the array to be searched
key the value to be searched for
Returns:
index of the search key, if it is contained in the array; otherwise, (-(insertion point) - 1). The insertion point is defined as the point at which the key would be inserted into the array: the index of the first element greater than the key, or a.length if all elements in the array are less than the specified key. Note that this guarantees that the return value will be >= 0 if and only if the key is found.
1348
    public static int binarySearch(long[] a, long key) {
1349
        return binarySearch0(a, 0, a.length, key);
1350
    }

    
Searches a range of the specified array of longs for the specified value using the binary search algorithm. The range must be sorted (as by the sort(long[],int,int) method) prior to making this call. If it is not sorted, the results are undefined. If the range contains multiple elements with the specified value, there is no guarantee which one will be found.

Parameters:
a the array to be searched
fromIndex the index of the first element (inclusive) to be searched
toIndex the index of the last element (exclusive) to be searched
key the value to be searched for
Returns:
index of the search key, if it is contained in the array within the specified range; otherwise, (-(insertion point) - 1). The insertion point is defined as the point at which the key would be inserted into the array: the index of the first element in the range greater than the key, or toIndex if all elements in the range are less than the specified key. Note that this guarantees that the return value will be >= 0 if and only if the key is found.
Throws:
java.lang.IllegalArgumentException if fromIndex > toIndex
java.lang.ArrayIndexOutOfBoundsException if fromIndex < 0 or toIndex > a.length
Since:
1.6
1384
    public static int binarySearch(long[] a, int fromIndex, int toIndex,
1385
                                   long key) {
1386
        rangeCheck(a.length, fromIndex, toIndex);
1387
        return binarySearch0(a, fromIndex, toIndex, key);
1388
    }
1390
    // Like public version, but without range checks.
1391
    private static int binarySearch0(long[] a, int fromIndex, int toIndex,
1392
                                     long key) {
1393
        int low = fromIndex;
1394
        int high = toIndex - 1;
1396
        while (low <= high) {
1397
            int mid = (low + high) >>> 1;
1398
            long midVal = a[mid];
1400
            if (midVal < key)
1401
                low = mid + 1;
1402
            else if (midVal > key)
1403
                high = mid - 1;
1404
            else
1405
                return mid; // key found
1406
        }
1407
        return -(low + 1);  // key not found.
1408
    }

    
Searches the specified array of ints for the specified value using the binary search algorithm. The array must be sorted (as by the sort(int[]) method) prior to making this call. If it is not sorted, the results are undefined. If the array contains multiple elements with the specified value, there is no guarantee which one will be found.

Parameters:
a the array to be searched
key the value to be searched for
Returns:
index of the search key, if it is contained in the array; otherwise, (-(insertion point) - 1). The insertion point is defined as the point at which the key would be inserted into the array: the index of the first element greater than the key, or a.length if all elements in the array are less than the specified key. Note that this guarantees that the return value will be >= 0 if and only if the key is found.
1429
    public static int binarySearch(int[] a, int key) {
1430
        return binarySearch0(a, 0, a.length, key);
1431
    }

    
Searches a range of the specified array of ints for the specified value using the binary search algorithm. The range must be sorted (as by the sort(int[],int,int) method) prior to making this call. If it is not sorted, the results are undefined. If the range contains multiple elements with the specified value, there is no guarantee which one will be found.

Parameters:
a the array to be searched
fromIndex the index of the first element (inclusive) to be searched
toIndex the index of the last element (exclusive) to be searched
key the value to be searched for
Returns:
index of the search key, if it is contained in the array within the specified range; otherwise, (-(insertion point) - 1). The insertion point is defined as the point at which the key would be inserted into the array: the index of the first element in the range greater than the key, or toIndex if all elements in the range are less than the specified key. Note that this guarantees that the return value will be >= 0 if and only if the key is found.
Throws:
java.lang.IllegalArgumentException if fromIndex > toIndex
java.lang.ArrayIndexOutOfBoundsException if fromIndex < 0 or toIndex > a.length
Since:
1.6
1465
    public static int binarySearch(int[] a, int fromIndex, int toIndex,
1466
                                   int key) {
1467
        rangeCheck(a.length, fromIndex, toIndex);
1468
        return binarySearch0(a, fromIndex, toIndex, key);
1469
    }
1471
    // Like public version, but without range checks.
1472
    private static int binarySearch0(int[] a, int fromIndex, int toIndex,
1473
                                     int key) {
1474
        int low = fromIndex;
1475
        int high = toIndex - 1;
1477
        while (low <= high) {
1478
            int mid = (low + high) >>> 1;
1479
            int midVal = a[mid];
1481
            if (midVal < key)
1482
                low = mid + 1;
1483
            else if (midVal > key)
1484
                high = mid - 1;
1485
            else
1486
                return mid; // key found
1487
        }
1488
        return -(low + 1);  // key not found.
1489
    }

    
Searches the specified array of shorts for the specified value using the binary search algorithm. The array must be sorted (as by the sort(short[]) method) prior to making this call. If it is not sorted, the results are undefined. If the array contains multiple elements with the specified value, there is no guarantee which one will be found.

Parameters:
a the array to be searched
key the value to be searched for
Returns:
index of the search key, if it is contained in the array; otherwise, (-(insertion point) - 1). The insertion point is defined as the point at which the key would be inserted into the array: the index of the first element greater than the key, or a.length if all elements in the array are less than the specified key. Note that this guarantees that the return value will be >= 0 if and only if the key is found.
1510
    public static int binarySearch(short[] a, short key) {
1511
        return binarySearch0(a, 0, a.length, key);
1512
    }

    
Searches a range of the specified array of shorts for the specified value using the binary search algorithm. The range must be sorted (as by the sort(short[],int,int) method) prior to making this call. If it is not sorted, the results are undefined. If the range contains multiple elements with the specified value, there is no guarantee which one will be found.

Parameters:
a the array to be searched
fromIndex the index of the first element (inclusive) to be searched
toIndex the index of the last element (exclusive) to be searched
key the value to be searched for
Returns:
index of the search key, if it is contained in the array within the specified range; otherwise, (-(insertion point) - 1). The insertion point is defined as the point at which the key would be inserted into the array: the index of the first element in the range greater than the key, or toIndex if all elements in the range are less than the specified key. Note that this guarantees that the return value will be >= 0 if and only if the key is found.
Throws:
java.lang.IllegalArgumentException if fromIndex > toIndex
java.lang.ArrayIndexOutOfBoundsException if fromIndex < 0 or toIndex > a.length
Since:
1.6
1546
    public static int binarySearch(short[] a, int fromIndex, int toIndex,
1547
                                   short key) {
1548
        rangeCheck(a.length, fromIndex, toIndex);
1549
        return binarySearch0(a, fromIndex, toIndex, key);
1550
    }
1552
    // Like public version, but without range checks.
1553
    private static int binarySearch0(short[] a, int fromIndex, int toIndex,
1554
                                     short key) {
1555
        int low = fromIndex;
1556
        int high = toIndex - 1;
1558
        while (low <= high) {
1559
            int mid = (low + high) >>> 1;
1560
            short midVal = a[mid];
1562
            if (midVal < key)
1563
                low = mid + 1;
1564
            else if (midVal > key)
1565
                high = mid - 1;
1566
            else
1567
                return mid; // key found
1568
        }
1569
        return -(low + 1);  // key not found.
1570
    }

    
Searches the specified array of chars for the specified value using the binary search algorithm. The array must be sorted (as by the sort(char[]) method) prior to making this call. If it is not sorted, the results are undefined. If the array contains multiple elements with the specified value, there is no guarantee which one will be found.

Parameters:
a the array to be searched
key the value to be searched for
Returns:
index of the search key, if it is contained in the array; otherwise, (-(insertion point) - 1). The insertion point is defined as the point at which the key would be inserted into the array: the index of the first element greater than the key, or a.length if all elements in the array are less than the specified key. Note that this guarantees that the return value will be >= 0 if and only if the key is found.
1591
    public static int binarySearch(char[] a, char key) {
1592
        return binarySearch0(a, 0, a.length, key);
1593
    }

    
Searches a range of the specified array of chars for the specified value using the binary search algorithm. The range must be sorted (as by the sort(char[],int,int) method) prior to making this call. If it is not sorted, the results are undefined. If the range contains multiple elements with the specified value, there is no guarantee which one will be found.

Parameters:
a the array to be searched
fromIndex the index of the first element (inclusive) to be searched
toIndex the index of the last element (exclusive) to be searched
key the value to be searched for
Returns:
index of the search key, if it is contained in the array within the specified range; otherwise, (-(insertion point) - 1). The insertion point is defined as the point at which the key would be inserted into the array: the index of the first element in the range greater than the key, or toIndex if all elements in the range are less than the specified key. Note that this guarantees that the return value will be >= 0 if and only if the key is found.
Throws:
java.lang.IllegalArgumentException if fromIndex > toIndex
java.lang.ArrayIndexOutOfBoundsException if fromIndex < 0 or toIndex > a.length
Since:
1.6
1627
    public static int binarySearch(char[] a, int fromIndex, int toIndex,
1628
                                   char key) {
1629
        rangeCheck(a.length, fromIndex, toIndex);
1630
        return binarySearch0(a, fromIndex, toIndex, key);
1631
    }
1633
    // Like public version, but without range checks.
1634
    private static int binarySearch0(char[] a, int fromIndex, int toIndex,
1635
                                     char key) {
1636
        int low = fromIndex;
1637
        int high = toIndex - 1;
1639
        while (low <= high) {
1640
            int mid = (low + high) >>> 1;
1641
            char midVal = a[mid];
1643
            if (midVal < key)
1644
                low = mid + 1;
1645
            else if (midVal > key)
1646
                high = mid - 1;
1647
            else
1648
                return mid; // key found
1649
        }
1650
        return -(low + 1);  // key not found.
1651
    }

    
Searches the specified array of bytes for the specified value using the binary search algorithm. The array must be sorted (as by the sort(byte[]) method) prior to making this call. If it is not sorted, the results are undefined. If the array contains multiple elements with the specified value, there is no guarantee which one will be found.

Parameters:
a the array to be searched
key the value to be searched for
Returns:
index of the search key, if it is contained in the array; otherwise, (-(insertion point) - 1). The insertion point is defined as the point at which the key would be inserted into the array: the index of the first element greater than the key, or a.length if all elements in the array are less than the specified key. Note that this guarantees that the return value will be >= 0 if and only if the key is found.
1672
    public static int binarySearch(byte[] a, byte key) {
1673
        return binarySearch0(a, 0, a.length, key);
1674
    }

    
Searches a range of the specified array of bytes for the specified value using the binary search algorithm. The range must be sorted (as by the sort(byte[],int,int) method) prior to making this call. If it is not sorted, the results are undefined. If the range contains multiple elements with the specified value, there is no guarantee which one will be found.

Parameters:
a the array to be searched
fromIndex the index of the first element (inclusive) to be searched
toIndex the index of the last element (exclusive) to be searched
key the value to be searched for
Returns:
index of the search key, if it is contained in the array within the specified range; otherwise, (-(insertion point) - 1). The insertion point is defined as the point at which the key would be inserted into the array: the index of the first element in the range greater than the key, or toIndex if all elements in the range are less than the specified key. Note that this guarantees that the return value will be >= 0 if and only if the key is found.
Throws:
java.lang.IllegalArgumentException if fromIndex > toIndex
java.lang.ArrayIndexOutOfBoundsException if fromIndex < 0 or toIndex > a.length
Since:
1.6
1708
    public static int binarySearch(byte[] a, int fromIndex, int toIndex,
1709
                                   byte key) {
1710
        rangeCheck(a.length, fromIndex, toIndex);
1711
        return binarySearch0(a, fromIndex, toIndex, key);
1712
    }
1714
    // Like public version, but without range checks.
1715
    private static int binarySearch0(byte[] a, int fromIndex, int toIndex,
1716
                                     byte key) {
1717
        int low = fromIndex;
1718
        int high = toIndex - 1;
1720
        while (low <= high) {
1721
            int mid = (low + high) >>> 1;
1722
            byte midVal = a[mid];
1724
            if (midVal < key)
1725
                low = mid + 1;
1726
            else if (midVal > key)
1727
                high = mid - 1;
1728
            else
1729
                return mid; // key found
1730
        }
1731
        return -(low + 1);  // key not found.
1732
    }

    
Searches the specified array of doubles for the specified value using the binary search algorithm. The array must be sorted (as by the sort(double[]) method) prior to making this call. If it is not sorted, the results are undefined. If the array contains multiple elements with the specified value, there is no guarantee which one will be found. This method considers all NaN values to be equivalent and equal.

Parameters:
a the array to be searched
key the value to be searched for
Returns:
index of the search key, if it is contained in the array; otherwise, (-(insertion point) - 1). The insertion point is defined as the point at which the key would be inserted into the array: the index of the first element greater than the key, or a.length if all elements in the array are less than the specified key. Note that this guarantees that the return value will be >= 0 if and only if the key is found.
1754
    public static int binarySearch(double[] a, double key) {
1755
        return binarySearch0(a, 0, a.length, key);
1756
    }

    
Searches a range of the specified array of doubles for the specified value using the binary search algorithm. The range must be sorted (as by the sort(double[],int,int) method) prior to making this call. If it is not sorted, the results are undefined. If the range contains multiple elements with the specified value, there is no guarantee which one will be found. This method considers all NaN values to be equivalent and equal.

Parameters:
a the array to be searched
fromIndex the index of the first element (inclusive) to be searched
toIndex the index of the last element (exclusive) to be searched
key the value to be searched for
Returns:
index of the search key, if it is contained in the array within the specified range; otherwise, (-(insertion point) - 1). The insertion point is defined as the point at which the key would be inserted into the array: the index of the first element in the range greater than the key, or toIndex if all elements in the range are less than the specified key. Note that this guarantees that the return value will be >= 0 if and only if the key is found.
Throws:
java.lang.IllegalArgumentException if fromIndex > toIndex
java.lang.ArrayIndexOutOfBoundsException if fromIndex < 0 or toIndex > a.length
Since:
1.6
1791
    public static int binarySearch(double[] a, int fromIndex, int toIndex,
1792
                                   double key) {
1793
        rangeCheck(a.length, fromIndex, toIndex);
1794
        return binarySearch0(a, fromIndex, toIndex, key);
1795
    }
1797
    // Like public version, but without range checks.
1798
    private static int binarySearch0(double[] a, int fromIndex, int toIndex,
1799
                                     double key) {
1800
        int low = fromIndex;
1801
        int high = toIndex - 1;
1803
        while (low <= high) {
1804
            int mid = (low + high) >>> 1;
1805
            double midVal = a[mid];
1807
            if (midVal < key)
1808
                low = mid + 1;  // Neither val is NaN, thisVal is smaller
1809
            else if (midVal > key)
1810
                high = mid - 1; // Neither val is NaN, thisVal is larger
1811
            else {
1812
                long midBits = Double.doubleToLongBits(midVal);
1813
                long keyBits = Double.doubleToLongBits(key);
1814
                if (midBits == keyBits)     // Values are equal
1815
                    return mid;             // Key found
1816
                else if (midBits < keyBits) // (-0.0, 0.0) or (!NaN, NaN)
1817
                    low = mid + 1;
1818
                else                        // (0.0, -0.0) or (NaN, !NaN)
1819
                    high = mid - 1;
1820
            }
1821
        }
1822
        return -(low + 1);  // key not found.
1823
    }

    
Searches the specified array of floats for the specified value using the binary search algorithm. The array must be sorted (as by the sort(float[]) method) prior to making this call. If it is not sorted, the results are undefined. If the array contains multiple elements with the specified value, there is no guarantee which one will be found. This method considers all NaN values to be equivalent and equal.

Parameters:
a the array to be searched
key the value to be searched for
Returns:
index of the search key, if it is contained in the array; otherwise, (-(insertion point) - 1). The insertion point is defined as the point at which the key would be inserted into the array: the index of the first element greater than the key, or a.length if all elements in the array are less than the specified key. Note that this guarantees that the return value will be >= 0 if and only if the key is found.
1845
    public static int binarySearch(float[] a, float key) {
1846
        return binarySearch0(a, 0, a.length, key);
1847
    }

    
Searches a range of the specified array of floats for the specified value using the binary search algorithm. The range must be sorted (as by the sort(float[],int,int) method) prior to making this call. If it is not sorted, the results are undefined. If the range contains multiple elements with the specified value, there is no guarantee which one will be found. This method considers all NaN values to be equivalent and equal.

Parameters:
a the array to be searched
fromIndex the index of the first element (inclusive) to be searched
toIndex the index of the last element (exclusive) to be searched
key the value to be searched for
Returns:
index of the search key, if it is contained in the array within the specified range; otherwise, (-(insertion point) - 1). The insertion point is defined as the point at which the key would be inserted into the array: the index of the first element in the range greater than the key, or toIndex if all elements in the range are less than the specified key. Note that this guarantees that the return value will be >= 0 if and only if the key is found.
Throws:
java.lang.IllegalArgumentException if fromIndex > toIndex
java.lang.ArrayIndexOutOfBoundsException if fromIndex < 0 or toIndex > a.length
Since:
1.6
1882
    public static int binarySearch(float[] a, int fromIndex, int toIndex,
1883
                                   float key) {
1884
        rangeCheck(a.length, fromIndex, toIndex);
1885
        return binarySearch0(a, fromIndex, toIndex, key);
1886
    }
1888
    // Like public version, but without range checks.
1889
    private static int binarySearch0(float[] a, int fromIndex, int toIndex,
1890
                                     float key) {
1891
        int low = fromIndex;
1892
        int high = toIndex - 1;
1894
        while (low <= high) {
1895
            int mid = (low + high) >>> 1;
1896
            float midVal = a[mid];
1898
            if (midVal < key)
1899
                low = mid + 1;  // Neither val is NaN, thisVal is smaller
1900
            else if (midVal > key)
1901
                high = mid - 1; // Neither val is NaN, thisVal is larger
1902
            else {
1903
                int midBits = Float.floatToIntBits(midVal);
1904
                int keyBits = Float.floatToIntBits(key);
1905
                if (midBits == keyBits)     // Values are equal
1906
                    return mid;             // Key found
1907
                else if (midBits < keyBits) // (-0.0, 0.0) or (!NaN, NaN)
1908
                    low = mid + 1;
1909
                else                        // (0.0, -0.0) or (NaN, !NaN)
1910
                    high = mid - 1;
1911
            }
1912
        }
1913
        return -(low + 1);  // key not found.
1914
    }


    
Searches the specified array for the specified object using the binary search algorithm. The array must be sorted into ascending order according to the natural ordering of its elements (as by the sort(java.lang.Object[]) method) prior to making this call. If it is not sorted, the results are undefined. (If the array contains elements that are not mutually comparable (for example, strings and integers), it cannot be sorted according to the natural ordering of its elements, hence results are undefined.) If the array contains multiple elements equal to the specified object, there is no guarantee which one will be found.

Parameters:
a the array to be searched
key the value to be searched for
Returns:
index of the search key, if it is contained in the array; otherwise, (-(insertion point) - 1). The insertion point is defined as the point at which the key would be inserted into the array: the index of the first element greater than the key, or a.length if all elements in the array are less than the specified key. Note that this guarantees that the return value will be >= 0 if and only if the key is found.
Throws:
java.lang.ClassCastException if the search key is not comparable to the elements of the array.
1945
    public static int binarySearch(Object[] a, Object key) {
1946
        return binarySearch0(a, 0, a.length, key);
1947
    }

    
Searches a range of the specified array for the specified object using the binary search algorithm. The range must be sorted into ascending order according to the natural ordering of its elements (as by the sort(java.lang.Object[],int,int) method) prior to making this call. If it is not sorted, the results are undefined. (If the range contains elements that are not mutually comparable (for example, strings and integers), it cannot be sorted according to the natural ordering of its elements, hence results are undefined.) If the range contains multiple elements equal to the specified object, there is no guarantee which one will be found.

Parameters:
a the array to be searched
fromIndex the index of the first element (inclusive) to be searched
toIndex the index of the last element (exclusive) to be searched
key the value to be searched for
Returns:
index of the search key, if it is contained in the array within the specified range; otherwise, (-(insertion point) - 1). The insertion point is defined as the point at which the key would be inserted into the array: the index of the first element in the range greater than the key, or toIndex if all elements in the range are less than the specified key. Note that this guarantees that the return value will be >= 0 if and only if the key is found.
Throws:
java.lang.ClassCastException if the search key is not comparable to the elements of the array within the specified range.
java.lang.IllegalArgumentException if fromIndex > toIndex
java.lang.ArrayIndexOutOfBoundsException if fromIndex < 0 or toIndex > a.length
Since:
1.6
1989
    public static int binarySearch(Object[] a, int fromIndex, int toIndex,
1990
                                   Object key) {
1991
        rangeCheck(a.length, fromIndex, toIndex);
1992
        return binarySearch0(a, fromIndex, toIndex, key);
1993
    }
1995
    // Like public version, but without range checks.
1996
    private static int binarySearch0(Object[] a, int fromIndex, int toIndex,
1997
                                     Object key) {
1998
        int low = fromIndex;
1999
        int high = toIndex - 1;
2001
        while (low <= high) {
2002
            int mid = (low + high) >>> 1;
2003
            Comparable midVal = (Comparable)a[mid];
2004
            int cmp = midVal.compareTo(key);
2006
            if (cmp < 0)
2007
                low = mid + 1;
2008
            else if (cmp > 0)
2009
                high = mid - 1;
2010
            else
2011
                return mid; // key found
2012
        }
2013
        return -(low + 1);  // key not found.
2014
    }

    
Searches the specified array for the specified object using the binary search algorithm. The array must be sorted into ascending order according to the specified comparator (as by the sort(T[], Comparator) method) prior to making this call. If it is not sorted, the results are undefined. If the array contains multiple elements equal to the specified object, there is no guarantee which one will be found.

Parameters:
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.
Returns:
index of the search key, if it is contained in the array; otherwise, (-(insertion point) - 1). The insertion point is defined as the point at which the key would be inserted into the array: the index of the first element greater than the key, or a.length if all elements in the array are less than the specified key. Note that this guarantees that the return value will be >= 0 if and only if the key is found.
Throws:
java.lang.ClassCastException if the array contains elements that are not mutually comparable using the specified comparator, or the search key is not comparable to the elements of the array using this comparator.
2045
    public static <T> int binarySearch(T[] a, T key, Comparator<? super T> c) {
2046
        return binarySearch0(a, 0, a.length, key, c);
2047
    }

    
Searches a range of the specified array for the specified object using the binary search algorithm. The range must be sorted into ascending order according to the specified comparator (as by the sort(T[], int, int, Comparator) method) prior to making this call. If it is not sorted, the results are undefined. If the range contains multiple elements equal to the specified object, there is no guarantee which one will be found.

Parameters:
a the array to be searched
fromIndex the index of the first element (inclusive) to be searched
toIndex the index of the last element (exclusive) 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.
Returns:
index of the search key, if it is contained in the array within the specified range; otherwise, (-(insertion point) - 1). The insertion point is defined as the point at which the key would be inserted into the array: the index of the first element in the range greater than the key, or toIndex if all elements in the range are less than the specified key. Note that this guarantees that the return value will be >= 0 if and only if the key is found.
Throws:
java.lang.ClassCastException if the range contains elements that are not mutually comparable using the specified comparator, or the search key is not comparable to the elements in the range using this comparator.
java.lang.IllegalArgumentException if fromIndex > toIndex
java.lang.ArrayIndexOutOfBoundsException if fromIndex < 0 or toIndex > a.length
Since:
1.6
2090
    public static <T> int binarySearch(T[] a, int fromIndex, int toIndex,
2091
                                       T key, Comparator<? super T> c) {
2092
        rangeCheck(a.length, fromIndex, toIndex);
2093
        return binarySearch0(a, fromIndex, toIndex, key, c);
2094
    }
2096
    // Like public version, but without range checks.
2097
    private static <T> int binarySearch0(T[] a, int fromIndex, int toIndex,
2098
                                         T key, Comparator<? super T> c) {
2099
        if (c == null) {
2100
            return binarySearch0(a, fromIndex, toIndex, key);
2101
        }
2102
        int low = fromIndex;
2103
        int high = toIndex - 1;
2105
        while (low <= high) {
2106
            int mid = (low + high) >>> 1;
2107
            T midVal = a[mid];
2108
            int cmp = c.compare(midVal, key);
2110
            if (cmp < 0)
2111
                low = mid + 1;
2112
            else if (cmp > 0)
2113
                high = mid - 1;
2114
            else
2115
                return mid; // key found
2116
        }
2117
        return -(low + 1);  // key not found.
2118
    }
2121
    // Equality Testing
2122

    
Returns true if the two specified arrays of longs are equal to one another. Two arrays are considered equal if both arrays contain the same number of elements, and all corresponding pairs of elements in the two arrays are equal. In other words, two arrays are equal if they contain the same elements in the same order. Also, two array references are considered equal if both are null.

Parameters:
a one array to be tested for equality
a2 the other array to be tested for equality
Returns:
true if the two arrays are equal
2135
    public static boolean equals(long[] a, long[] a2) {
2136
        if (a==a2)
2137
            return true;
2138
        if (a==null || a2==null)
2139
            return false;
2141
        int length = a.length;
2142
        if (a2.length != length)
2143
            return false;
2145
        for (int i=0; i<length; i++)
2146
            if (a[i] != a2[i])
2147
                return false;
2149
        return true;
2150
    }

    
Returns true if the two specified arrays of ints are equal to one another. Two arrays are considered equal if both arrays contain the same number of elements, and all corresponding pairs of elements in the two arrays are equal. In other words, two arrays are equal if they contain the same elements in the same order. Also, two array references are considered equal if both are null.

Parameters:
a one array to be tested for equality
a2 the other array to be tested for equality
Returns:
true if the two arrays are equal
2164
    public static boolean equals(int[] a, int[] a2) {
2165
        if (a==a2)
2166
            return true;
2167
        if (a==null || a2==null)
2168
            return false;
2170
        int length = a.length;
2171
        if (a2.length != length)
2172
            return false;
2174
        for (int i=0; i<length; i++)
2175
            if (a[i] != a2[i])
2176
                return false;
2178
        return true;
2179
    }

    
Returns true if the two specified arrays of shorts are equal to one another. Two arrays are considered equal if both arrays contain the same number of elements, and all corresponding pairs of elements in the two arrays are equal. In other words, two arrays are equal if they contain the same elements in the same order. Also, two array references are considered equal if both are null.

Parameters:
a one array to be tested for equality
a2 the other array to be tested for equality
Returns:
true if the two arrays are equal
2193
    public static boolean equals(short[] a, short a2[]) {
2194
        if (a==a2)
2195
            return true;
2196
        if (a==null || a2==null)
2197
            return false;
2199
        int length = a.length;
2200
        if (a2.length != length)
2201
            return false;
2203
        for (int i=0; i<length; i++)
2204
            if (a[i] != a2[i])
2205
                return false;
2207
        return true;
2208
    }

    
Returns true if the two specified arrays of chars are equal to one another. Two arrays are considered equal if both arrays contain the same number of elements, and all corresponding pairs of elements in the two arrays are equal. In other words, two arrays are equal if they contain the same elements in the same order. Also, two array references are considered equal if both are null.

Parameters:
a one array to be tested for equality
a2 the other array to be tested for equality
Returns:
true if the two arrays are equal
2222
    public static boolean equals(char[] a, char[] a2) {
2223
        if (a==a2)
2224
            return true;
2225
        if (a==null || a2==null)
2226
            return false;
2228
        int length = a.length;
2229
        if (a2.length != length)
2230
            return false;
2232
        for (int i=0; i<length; i++)
2233
            if (a[i] != a2[i])
2234
                return false;
2236
        return true;
2237
    }

    
Returns true if the two specified arrays of bytes are equal to one another. Two arrays are considered equal if both arrays contain the same number of elements, and all corresponding pairs of elements in the two arrays are equal. In other words, two arrays are equal if they contain the same elements in the same order. Also, two array references are considered equal if both are null.

Parameters:
a one array to be tested for equality
a2 the other array to be tested for equality
Returns:
true if the two arrays are equal
2251
    public static boolean equals(byte[] a, byte[] a2) {
2252
        if (a==a2)
2253
            return true;
2254
        if (a==null || a2==null)
2255
            return false;
2257
        int length = a.length;
2258
        if (a2.length != length)
2259
            return false;
2261
        for (int i=0; i<length; i++)
2262
            if (a[i] != a2[i])
2263
                return false;
2265
        return true;
2266
    }

    
Returns true if the two specified arrays of booleans are equal to one another. Two arrays are considered equal if both arrays contain the same number of elements, and all corresponding pairs of elements in the two arrays are equal. In other words, two arrays are equal if they contain the same elements in the same order. Also, two array references are considered equal if both are null.

Parameters:
a one array to be tested for equality
a2 the other array to be tested for equality
Returns:
true if the two arrays are equal
2280
    public static boolean equals(boolean[] a, boolean[] a2) {
2281
        if (a==a2)
2282
            return true;
2283
        if (a==null || a2==null)
2284
            return false;
2286
        int length = a.length;
2287
        if (a2.length != length)
2288
            return false;
2290
        for (int i=0; i<length; i++)
2291
            if (a[i] != a2[i])
2292
                return false;
2294
        return true;
2295
    }

    
Returns true if the two specified arrays of doubles are equal to one another. Two arrays are considered equal if both arrays contain the same number of elements, and all corresponding pairs of elements in the two arrays are equal. In other words, two arrays are equal if they contain the same elements in the same order. Also, two array references are considered equal if both are null.

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.)

Parameters:
a one array to be tested for equality
a2 the other array to be tested for equality
Returns:
true if the two arrays are equal
See also:
java.lang.Double.equals(java.lang.Object)
2315
    public static boolean equals(double[] a, double[] a2) {
2316
        if (a==a2)
2317
            return true;
2318
        if (a==null || a2==null)
2319
            return false;
2321
        int length = a.length;
2322
        if (a2.length != length)
2323
            return false;
2325
        for (int i=0; i<length; i++)
2326
            if (Double.doubleToLongBits(a[i])!=Double.doubleToLongBits(a2[i]))
2327
                return false;
2329
        return true;
2330
    }

    
Returns true if the two specified arrays of floats are equal to one another. Two arrays are considered equal if both arrays contain the same number of elements, and all corresponding pairs of elements in the two arrays are equal. In other words, two arrays are equal if they contain the same elements in the same order. Also, two array references are considered equal if both are null.

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.)

Parameters:
a one array to be tested for equality
a2 the other array to be tested for equality
Returns:
true if the two arrays are equal
See also:
java.lang.Float.equals(java.lang.Object)
2350
    public static boolean equals(float[] a, float[] a2) {
2351
        if (a==a2)
2352
            return true;
2353
        if (a==null || a2==null)
2354
            return false;
2356
        int length = a.length;
2357
        if (a2.length != length)
2358
            return false;
2360
        for (int i=0; i<length; i++)
2361
            if (Float.floatToIntBits(a[i])!=Float.floatToIntBits(a2[i]))
2362
                return false;
2364
        return true;
2365
    }


    
Returns true if the two specified arrays of Objects are equal to one another. The two arrays are considered equal if both arrays contain the same number of elements, and all corresponding pairs of elements in the two arrays are equal. Two objects e1 and e2 are considered equal if (e1==null ? e2==null : e1.equals(e2)). In other words, the two arrays are equal if they contain the same elements in the same order. Also, two array references are considered equal if both are null.

Parameters:
a one array to be tested for equality
a2 the other array to be tested for equality
Returns:
true if the two arrays are equal
2382
    public static boolean equals(Object[] a, Object[] a2) {
2383
        if (a==a2)
2384
            return true;
2385
        if (a==null || a2==null)
2386
            return false;
2388
        int length = a.length;
2389
        if (a2.length != length)
2390
            return false;
2392
        for (int i=0; i<length; i++) {
2393
            Object o1 = a[i];
2394
            Object o2 = a2[i];
2395
            if (!(o1==null ? o2==null : o1.equals(o2)))
2396
                return false;
2397
        }
2399
        return true;
2400
    }
2403
    // Filling
2404

    
Assigns the specified long value to each element of the specified array of longs.

Parameters:
a the array to be filled
val the value to be stored in all elements of the array
2412
    public static void fill(long[] a, long val) {
2413
        for (int i = 0, len = a.length; i < len; i++)
2414
            a[i] = val;
2415
    }

    
Assigns the specified long value to each element of the specified range of the specified array of longs. The range to be filled extends from index fromIndex, inclusive, to index toIndex, exclusive. (If fromIndex==toIndex, the range to be filled is empty.)

Parameters:
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
Throws:
java.lang.IllegalArgumentException if fromIndex > toIndex
java.lang.ArrayIndexOutOfBoundsException if fromIndex < 0 or toIndex > a.length
2434
    public static void fill(long[] a, int fromIndex, int toIndex, long val) {
2435
        rangeCheck(a.length, fromIndex, toIndex);
2436
        for (int i = fromIndex; i < toIndex; i++)
2437
            a[i] = val;
2438
    }

    
Assigns the specified int value to each element of the specified array of ints.

Parameters:
a the array to be filled
val the value to be stored in all elements of the array
2447
    public static void fill(int[] a, int val) {
2448
        for (int i = 0, len = a.length; i < len; i++)
2449
            a[i] = val;
2450
    }

    
Assigns the specified int value to each element of the specified range of the specified array of ints. The range to be filled extends from index fromIndex, inclusive, to index toIndex, exclusive. (If fromIndex==toIndex, the range to be filled is empty.)

Parameters:
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
Throws:
java.lang.IllegalArgumentException if fromIndex > toIndex
java.lang.ArrayIndexOutOfBoundsException if fromIndex < 0 or toIndex > a.length
2469
    public static void fill(int[] a, int fromIndex, int toIndex, int val) {
2470
        rangeCheck(a.length, fromIndex, toIndex);
2471
        for (int i = fromIndex; i < toIndex; i++)
2472
            a[i] = val;
2473
    }

    
Assigns the specified short value to each element of the specified array of shorts.

Parameters:
a the array to be filled
val the value to be stored in all elements of the array
2482
    public static void fill(short[] a, short val) {
2483
        for (int i = 0, len = a.length; i < len; i++)
2484
            a[i] = val;
2485
    }

    
Assigns the specified short value to each element of the specified range of the specified array of shorts. The range to be filled extends from index fromIndex, inclusive, to index toIndex, exclusive. (If fromIndex==toIndex, the range to be filled is empty.)

Parameters:
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
Throws:
java.lang.IllegalArgumentException if fromIndex > toIndex
java.lang.ArrayIndexOutOfBoundsException if fromIndex < 0 or toIndex > a.length
2504
    public static void fill(short[] a, int fromIndex, int toIndex, short val) {
2505
        rangeCheck(a.length, fromIndex, toIndex);
2506
        for (int i = fromIndex; i < toIndex; i++)
2507
            a[i] = val;
2508
    }

    
Assigns the specified char value to each element of the specified array of chars.

Parameters:
a the array to be filled
val the value to be stored in all elements of the array
2517
    public static void fill(char[] a, char val) {
2518
        for (int i = 0, len = a.length; i < len; i++)
2519
            a[i] = val;
2520
    }

    
Assigns the specified char value to each element of the specified range of the specified array of chars. The range to be filled extends from index fromIndex, inclusive, to index toIndex, exclusive. (If fromIndex==toIndex, the range to be filled is empty.)

Parameters:
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
Throws:
java.lang.IllegalArgumentException if fromIndex > toIndex
java.lang.ArrayIndexOutOfBoundsException if fromIndex < 0 or toIndex > a.length
2539
    public static void fill(char[] a, int fromIndex, int toIndex, char val) {
2540
        rangeCheck(a.length, fromIndex, toIndex);
2541
        for (int i = fromIndex; i < toIndex; i++)
2542
            a[i] = val;
2543
    }

    
Assigns the specified byte value to each element of the specified array of bytes.

Parameters:
a the array to be filled
val the value to be stored in all elements of the array
2552
    public static void fill(byte[] a, byte val) {
2553
        for (int i = 0, len = a.length; i < len; i++)
2554
            a[i] = val;
2555
    }

    
Assigns the specified byte value to each element of the specified range of the specified array of bytes. The range to be filled extends from index fromIndex, inclusive, to index toIndex, exclusive. (If fromIndex==toIndex, the range to be filled is empty.)

Parameters:
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
Throws:
java.lang.IllegalArgumentException if fromIndex > toIndex
java.lang.ArrayIndexOutOfBoundsException if fromIndex < 0 or toIndex > a.length
2574
    public static void fill(byte[] a, int fromIndex, int toIndex, byte val) {
2575
        rangeCheck(a.length, fromIndex, toIndex);
2576
        for (int i = fromIndex; i < toIndex; i++)
2577
            a[i] = val;
2578
    }

    
Assigns the specified boolean value to each element of the specified array of booleans.

Parameters:
a the array to be filled
val the value to be stored in all elements of the array
2587
    public static void fill(boolean[] a, boolean val) {
2588
        for (int i = 0, len = a.length; i < len; i++)
2589
            a[i] = val;
2590
    }

    
Assigns the specified boolean value to each element of the specified range of the specified array of booleans. The range to be filled extends from index fromIndex, inclusive, to index toIndex, exclusive. (If fromIndex==toIndex, the range to be filled is empty.)

Parameters:
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
Throws:
java.lang.IllegalArgumentException if fromIndex > toIndex
java.lang.ArrayIndexOutOfBoundsException if fromIndex < 0 or toIndex > a.length
2609
    public static void fill(boolean[] a, int fromIndex, int toIndex,
2610
                            boolean val) {
2611
        rangeCheck(a.length, fromIndex, toIndex);
2612
        for (int i = fromIndex; i < toIndex; i++)
2613
            a[i] = val;
2614
    }

    
Assigns the specified double value to each element of the specified array of doubles.

Parameters:
a the array to be filled
val the value to be stored in all elements of the array
2623
    public static void fill(double[] a, double val) {
2624
        for (int i = 0, len = a.length; i < len; i++)
2625
            a[i] = val;
2626
    }

    
Assigns the specified double value to each element of the specified range of the specified array of doubles. The range to be filled extends from index fromIndex, inclusive, to index toIndex, exclusive. (If fromIndex==toIndex, the range to be filled is empty.)

Parameters:
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
Throws:
java.lang.IllegalArgumentException if fromIndex > toIndex
java.lang.ArrayIndexOutOfBoundsException if fromIndex < 0 or toIndex > a.length
2645
    public static void fill(double[] a, int fromIndex, int toIndex,double val){
2646
        rangeCheck(a.length, fromIndex, toIndex);
2647
        for (int i = fromIndex; i < toIndex; i++)
2648
            a[i] = val;
2649
    }

    
Assigns the specified float value to each element of the specified array of floats.

Parameters:
a the array to be filled
val the value to be stored in all elements of the array
2658
    public static void fill(float[] a, float val) {
2659
        for (int i = 0, len = a.length; i < len; i++)
2660
            a[i] = val;
2661
    }

    
Assigns the specified float value to each element of the specified range of the specified array of floats. The range to be filled extends from index fromIndex, inclusive, to index toIndex, exclusive. (If fromIndex==toIndex, the range to be filled is empty.)

Parameters:
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
Throws:
java.lang.IllegalArgumentException if fromIndex > toIndex
java.lang.ArrayIndexOutOfBoundsException if fromIndex < 0 or toIndex > a.length
2680
    public static void fill(float[] a, int fromIndex, int toIndex, float val) {
2681
        rangeCheck(a.length, fromIndex, toIndex);
2682
        for (int i = fromIndex; i < toIndex; i++)
2683
            a[i] = val;
2684
    }

    
Assigns the specified Object reference to each element of the specified array of Objects.

Parameters:
a the array to be filled
val the value to be stored in all elements of the array
Throws:
java.lang.ArrayStoreException if the specified value is not of a runtime type that can be stored in the specified array
2695
    public static void fill(Object[] a, Object val) {
2696
        for (int i = 0, len = a.length; i < len; i++)
2697
            a[i] = val;
2698
    }

    
Assigns the specified Object reference to each element of the specified range of the specified array of Objects. The range to be filled extends from index fromIndex, inclusive, to index toIndex, exclusive. (If fromIndex==toIndex, the range to be filled is empty.)

Parameters:
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
Throws:
java.lang.IllegalArgumentException if fromIndex > toIndex
java.lang.ArrayIndexOutOfBoundsException if fromIndex < 0 or toIndex > a.length
java.lang.ArrayStoreException if the specified value is not of a runtime type that can be stored in the specified array
2719
    public static void fill(Object[] a, int fromIndex, int toIndex, Object val) {
2720
        rangeCheck(a.length, fromIndex, toIndex);
2721
        for (int i = fromIndex; i < toIndex; i++)
2722
            a[i] = val;
2723
    }
2726
    // Cloning
2727
    
Copies the specified array, truncating or padding with nulls (if necessary) so the copy has the specified length. For all indices that are valid in both the original array and the copy, the two arrays will contain identical values. For any indices that are valid in the copy but not the original, the copy will contain null. Such indices will exist if and only if the specified length is greater than that of the original array. The resulting array is of exactly the same class as the original array.

Parameters:
original the array to be copied
newLength the length of the copy to be returned
Returns:
a copy of the original array, truncated or padded with nulls to obtain the specified length
Throws:
java.lang.NegativeArraySizeException if newLength is negative
java.lang.NullPointerException if original is null
Since:
1.6
2745
    public static <T> T[] copyOf(T[] original, int newLength) {
2746
        return (T[]) copyOf(original, newLength, original.getClass());
2747
    }

    
Copies the specified array, truncating or padding with nulls (if necessary) so the copy has the specified length. For all indices that are valid in both the original array and the copy, the two arrays will contain identical values. For any indices that are valid in the copy but not the original, the copy will contain null. Such indices will exist if and only if the specified length is greater than that of the original array. The resulting array is of the class newType.

Parameters:
original the array to be copied
newLength the length of the copy to be returned
newType the class of the copy to be returned
Returns:
a copy of the original array, truncated or padded with nulls to obtain the specified length
Throws:
java.lang.NegativeArraySizeException if newLength is negative
java.lang.NullPointerException if original is null
java.lang.ArrayStoreException if an element copied from original is not of a runtime type that can be stored in an array of class newType
Since:
1.6
2771
    public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
2772
        T[] copy = ((Object)newType == (Object)Object[].class)
2773
            ? (T[]) new Object[newLength]
2774
            : (T[]) Array.newInstance(newType.getComponentType(), newLength);
2775
        System.arraycopy(original, 0, copy, 0,
2776
                         Math.min(original.length, newLength));
2777
        return copy;
2778
    }

    
Copies the specified array, truncating or padding with zeros (if necessary) so the copy has the specified length. For all indices that are valid in both the original array and the copy, the two arrays will contain identical values. For any indices that are valid in the copy but not the original, the copy will contain (byte)0. Such indices will exist if and only if the specified length is greater than that of the original array.

Parameters:
original the array to be copied
newLength the length of the copy to be returned
Returns:
a copy of the original array, truncated or padded with zeros to obtain the specified length
Throws:
java.lang.NegativeArraySizeException if newLength is negative
java.lang.NullPointerException if original is null
Since:
1.6
2797
    public static byte[] copyOf(byte[] original, int newLength) {
2798
        byte[] copy = new byte[newLength];
2799
        System.arraycopy(original, 0, copy, 0,
2800
                         Math.min(original.length, newLength));
2801
        return copy;
2802
    }

    
Copies the specified array, truncating or padding with zeros (if necessary) so the copy has the specified length. For all indices that are valid in both the original array and the copy, the two arrays will contain identical values. For any indices that are valid in the copy but not the original, the copy will contain (short)0. Such indices will exist if and only if the specified length is greater than that of the original array.

Parameters:
original the array to be copied
newLength the length of the copy to be returned
Returns:
a copy of the original array, truncated or padded with zeros to obtain the specified length
Throws:
java.lang.NegativeArraySizeException if newLength is negative
java.lang.NullPointerException if original is null
Since:
1.6
2821
    public static short[] copyOf(short[] original, int newLength) {
2822
        short[] copy = new short[newLength];
2823
        System.arraycopy(original, 0, copy, 0,
2824
                         Math.min(original.length, newLength));
2825
        return copy;
2826
    }

    
Copies the specified array, truncating or padding with zeros (if necessary) so the copy has the specified length. For all indices that are valid in both the original array and the copy, the two arrays will contain identical values. For any indices that are valid in the copy but not the original, the copy will contain 0. Such indices will exist if and only if the specified length is greater than that of the original array.

Parameters:
original the array to be copied
newLength the length of the copy to be returned
Returns:
a copy of the original array, truncated or padded with zeros to obtain the specified length
Throws:
java.lang.NegativeArraySizeException if newLength is negative
java.lang.NullPointerException if original is null
Since:
1.6
2845
    public static int[] copyOf(int[] original, int newLength) {
2846
        int[] copy = new int[newLength];
2847
        System.arraycopy(original, 0, copy, 0,
2848
                         Math.min(original.length, newLength));
2849
        return copy;
2850
    }

    
Copies the specified array, truncating or padding with zeros (if necessary) so the copy has the specified length. For all indices that are valid in both the original array and the copy, the two arrays will contain identical values. For any indices that are valid in the copy but not the original, the copy will contain 0L. Such indices will exist if and only if the specified length is greater than that of the original array.

Parameters:
original the array to be copied
newLength the length of the copy to be returned
Returns:
a copy of the original array, truncated or padded with zeros to obtain the specified length
Throws:
java.lang.NegativeArraySizeException if newLength is negative
java.lang.NullPointerException if original is null
Since:
1.6
2869
    public static long[] copyOf(long[] original, int newLength) {
2870
        long[] copy = new long[newLength];
2871
        System.arraycopy(original, 0, copy, 0,
2872
                         Math.min(original.length, newLength));
2873
        return copy;
2874
    }

    
Copies the specified array, truncating or padding with null characters (if necessary) so the copy has the specified length. For all indices that are valid in both the original array and the copy, the two arrays will contain identical values. For any indices that are valid in the copy but not the original, the copy will contain '\\u000'. Such indices will exist if and only if the specified length is greater than that of the original array.

Parameters:
original the array to be copied
newLength the length of the copy to be returned
Returns:
a copy of the original array, truncated or padded with null characters to obtain the specified length
Throws:
java.lang.NegativeArraySizeException if newLength is negative
java.lang.NullPointerException if original is null
Since:
1.6
2893
    public static char[] copyOf(char[] original, int newLength) {
2894
        char[] copy = new char[newLength];
2895
        System.arraycopy(original, 0, copy, 0,
2896
                         Math.min(original.length, newLength));
2897
        return copy;
2898
    }

    
Copies the specified array, truncating or padding with zeros (if necessary) so the copy has the specified length. For all indices that are valid in both the original array and the copy, the two arrays will contain identical values. For any indices that are valid in the copy but not the original, the copy will contain 0f. Such indices will exist if and only if the specified length is greater than that of the original array.

Parameters:
original the array to be copied
newLength the length of the copy to be returned
Returns:
a copy of the original array, truncated or padded with zeros to obtain the specified length
Throws:
java.lang.NegativeArraySizeException if newLength is negative
java.lang.NullPointerException if original is null
Since:
1.6
2917
    public static float[] copyOf(float[] original, int newLength) {
2918
        float[] copy = new float[newLength];
2919
        System.arraycopy(original, 0, copy, 0,
2920
                         Math.min(original.length, newLength));
2921
        return copy;
2922
    }

    
Copies the specified array, truncating or padding with zeros (if necessary) so the copy has the specified length. For all indices that are valid in both the original array and the copy, the two arrays will contain identical values. For any indices that are valid in the copy but not the original, the copy will contain 0d. Such indices will exist if and only if the specified length is greater than that of the original array.

Parameters:
original the array to be copied
newLength the length of the copy to be returned
Returns:
a copy of the original array, truncated or padded with zeros to obtain the specified length
Throws:
java.lang.NegativeArraySizeException if newLength is negative
java.lang.NullPointerException if original is null
Since:
1.6
2941
    public static double[] copyOf(double[] original, int newLength) {
2942
        double[] copy = new double[newLength];
2943
        System.arraycopy(original, 0, copy, 0,
2944
                         Math.min(original.length, newLength));
2945
        return copy;
2946
    }

    
Copies the specified array, truncating or padding with false (if necessary) so the copy has the specified length. For all indices that are valid in both the original array and the copy, the two arrays will contain identical values. For any indices that are valid in the copy but not the original, the copy will contain false. Such indices will exist if and only if the specified length is greater than that of the original array.

Parameters:
original the array to be copied
newLength the length of the copy to be returned
Returns:
a copy of the original array, truncated or padded with false elements to obtain the specified length
Throws:
java.lang.NegativeArraySizeException if newLength is negative
java.lang.NullPointerException if original is null
Since:
1.6
2965
    public static boolean[] copyOf(boolean[] original, int newLength) {
2966
        boolean[] copy = new boolean[newLength];
2967
        System.arraycopy(original, 0, copy, 0,
2968
                         Math.min(original.length, newLength));
2969
        return copy;
2970
    }

    
Copies the specified range of the specified array into a new array. The initial index of the range (from) must lie between zero and original.length, inclusive. The value at original[from] is placed into the initial element of the copy (unless from == original.length or from == to). Values from subsequent elements in the original array are placed into subsequent elements in the copy. The final index of the range (to), which must be greater than or equal to from, may be greater than original.length, in which case null is placed in all elements of the copy whose index is greater than or equal to original.length - from. The length of the returned array will be to - from.

The resulting array is of exactly the same class as the original array.

Parameters:
original the array from which a range is to be copied
from the initial index of the range to be copied, inclusive
to the final index of the range to be copied, exclusive. (This index may lie outside the array.)
Returns:
a new array containing the specified range from the original array, truncated or padded with nulls to obtain the required length
Throws:
java.lang.ArrayIndexOutOfBoundsException if from < 0 or from > original.length
java.lang.IllegalArgumentException if from > to
java.lang.NullPointerException if original is null
Since:
1.6
3000
    public static <T> T[] copyOfRange(T[] original, int from, int to) {
3001
        return copyOfRange(original, from, to, (Class<T[]>) original.getClass());
3002
    }

    
Copies the specified range of the specified array into a new array. The initial index of the range (from) must lie between zero and original.length, inclusive. The value at original[from] is placed into the initial element of the copy (unless from == original.length or from == to). Values from subsequent elements in the original array are placed into subsequent elements in the copy. The final index of the range (to), which must be greater than or equal to from, may be greater than original.length, in which case null is placed in all elements of the copy whose index is greater than or equal to original.length - from. The length of the returned array will be to - from. The resulting array is of the class newType.

Parameters:
original the array from which a range is to be copied
from the initial index of the range to be copied, inclusive
to the final index of the range to be copied, exclusive. (This index may lie outside the array.)
newType the class of the copy to be returned
Returns:
a new array containing the specified range from the original array, truncated or padded with nulls to obtain the required length
Throws:
java.lang.ArrayIndexOutOfBoundsException if from < 0 or from > original.length
java.lang.IllegalArgumentException if from > to
java.lang.NullPointerException if original is null
java.lang.ArrayStoreException if an element copied from original is not of a runtime type that can be stored in an array of class newType.
Since:
1.6
3035
    public static <T,U> T[] copyOfRange(U[] original, int from, int to, Class<? extends T[]> newType) {
3036
        int newLength = to - from;
3037
        if (newLength < 0)
3038
            throw new IllegalArgumentException(from + " > " + to);
3039
        T[] copy = ((Object)newType == (Object)Object[].class)
3040
            ? (T[]) new Object[newLength]
3041
            : (T[]) Array.newInstance(newType.getComponentType(), newLength);
3042
        System.arraycopy(original, from, copy, 0,
3043
                         Math.min(original.length - from, newLength));
3044
        return copy;
3045
    }

    
Copies the specified range of the specified array into a new array. The initial index of the range (from) must lie between zero and original.length, inclusive. The value at original[from] is placed into the initial element of the copy (unless from == original.length or from == to). Values from subsequent elements in the original array are placed into subsequent elements in the copy. The final index of the range (to), which must be greater than or equal to from, may be greater than original.length, in which case (byte)0 is placed in all elements of the copy whose index is greater than or equal to original.length - from. The length of the returned array will be to - from.

Parameters:
original the array from which a range is to be copied
from the initial index of the range to be copied, inclusive
to the final index of the range to be copied, exclusive. (This index may lie outside the array.)
Returns:
a new array containing the specified range from the original array, truncated or padded with zeros to obtain the required length
Throws:
java.lang.ArrayIndexOutOfBoundsException if from < 0 or from > original.length
java.lang.IllegalArgumentException if from > to
java.lang.NullPointerException if original is null
Since:
1.6
3073
    public static byte[] copyOfRange(byte[] original, int from, int to) {
3074
        int newLength = to - from;
3075
        if (newLength < 0)
3076
            throw new IllegalArgumentException(from + " > " + to);
3077
        byte[] copy = new byte[newLength];
3078
        System.arraycopy(original, from, copy, 0,
3079
                         Math.min(original.length - from, newLength));
3080
        return copy;
3081
    }

    
Copies the specified range of the specified array into a new array. The initial index of the range (from) must lie between zero and original.length, inclusive. The value at original[from] is placed into the initial element of the copy (unless from == original.length or from == to). Values from subsequent elements in the original array are placed into subsequent elements in the copy. The final index of the range (to), which must be greater than or equal to from, may be greater than original.length, in which case (short)0 is placed in all elements of the copy whose index is greater than or equal to original.length - from. The length of the returned array will be to - from.

Parameters:
original the array from which a range is to be copied
from the initial index of the range to be copied, inclusive
to the final index of the range to be copied, exclusive. (This index may lie outside the array.)
Returns:
a new array containing the specified range from the original array, truncated or padded with zeros to obtain the required length
Throws:
java.lang.ArrayIndexOutOfBoundsException if from < 0 or from > original.length
java.lang.IllegalArgumentException if from > to
java.lang.NullPointerException if original is null
Since:
1.6
3109
    public static short[] copyOfRange(short[] original, int from, int to) {
3110
        int newLength = to - from;
3111
        if (newLength < 0)
3112
            throw new IllegalArgumentException(from + " > " + to);
3113
        short[] copy = new short[newLength];
3114
        System.arraycopy(original, from, copy, 0,
3115
                         Math.min(original.length - from, newLength));
3116
        return copy;
3117
    }

    
Copies the specified range of the specified array into a new array. The initial index of the range (from) must lie between zero and original.length, inclusive. The value at original[from] is placed into the initial element of the copy (unless from == original.length or from == to). Values from subsequent elements in the original array are placed into subsequent elements in the copy. The final index of the range (to), which must be greater than or equal to from, may be greater than original.length, in which case 0 is placed in all elements of the copy whose index is greater than or equal to original.length - from. The length of the returned array will be to - from.

Parameters:
original the array from which a range is to be copied
from the initial index of the range to be copied, inclusive
to the final index of the range to be copied, exclusive. (This index may lie outside the array.)
Returns:
a new array containing the specified range from the original array, truncated or padded with zeros to obtain the required length
Throws:
java.lang.ArrayIndexOutOfBoundsException if from < 0 or from > original.length
java.lang.IllegalArgumentException if from > to
java.lang.NullPointerException if original is null
Since:
1.6
3145
    public static int[] copyOfRange(int[] original, int from, int to) {
3146
        int newLength = to - from;
3147
        if (newLength < 0)
3148
            throw new IllegalArgumentException(from + " > " + to);
3149
        int[] copy = new int[newLength];
3150
        System.arraycopy(original, from, copy, 0,
3151
                         Math.min(original.length - from, newLength));
3152
        return copy;
3153
    }

    
Copies the specified range of the specified array into a new array. The initial index of the range (from) must lie between zero and original.length, inclusive. The value at original[from] is placed into the initial element of the copy (unless from == original.length or from == to). Values from subsequent elements in the original array are placed into subsequent elements in the copy. The final index of the range (to), which must be greater than or equal to from, may be greater than original.length, in which case 0L is placed in all elements of the copy whose index is greater than or equal to original.length - from. The length of the returned array will be to - from.

Parameters:
original the array from which a range is to be copied
from the initial index of the range to be copied, inclusive
to the final index of the range to be copied, exclusive. (This index may lie outside the array.)
Returns:
a new array containing the specified range from the original array, truncated or padded with zeros to obtain the required length
Throws:
java.lang.ArrayIndexOutOfBoundsException if from < 0 or from > original.length
java.lang.IllegalArgumentException if from > to
java.lang.NullPointerException if original is null
Since:
1.6
3181
    public static long[] copyOfRange(long[] original, int from, int to) {
3182
        int newLength = to - from;
3183
        if (newLength < 0)
3184
            throw new IllegalArgumentException(from + " > " + to);
3185
        long[] copy = new long[newLength];
3186
        System.arraycopy(original, from, copy, 0,
3187
                         Math.min(original.length - from, newLength));
3188
        return copy;
3189
    }

    
Copies the specified range of the specified array into a new array. The initial index of the range (from) must lie between zero and original.length, inclusive. The value at original[from] is placed into the initial element of the copy (unless from == original.length or from == to). Values from subsequent elements in the original array are placed into subsequent elements in the copy. The final index of the range (to), which must be greater than or equal to from, may be greater than original.length, in which case '\\u000' is placed in all elements of the copy whose index is greater than or equal to original.length - from. The length of the returned array will be to - from.

Parameters:
original the array from which a range is to be copied
from the initial index of the range to be copied, inclusive
to the final index of the range to be copied, exclusive. (This index may lie outside the array.)
Returns:
a new array containing the specified range from the original array, truncated or padded with null characters to obtain the required length
Throws:
java.lang.ArrayIndexOutOfBoundsException if from < 0 or from > original.length
java.lang.IllegalArgumentException if from > to
java.lang.NullPointerException if original is null
Since:
1.6
3217
    public static char[] copyOfRange(char[] original, int from, int to) {
3218
        int newLength = to - from;
3219
        if (newLength < 0)
3220
            throw new IllegalArgumentException(from + " > " + to);
3221
        char[] copy = new char[newLength];
3222
        System.arraycopy(original, from, copy, 0,
3223
                         Math.min(original.length - from, newLength));
3224
        return copy;
3225
    }

    
Copies the specified range of the specified array into a new array. The initial index of the range (from) must lie between zero and original.length, inclusive. The value at original[from] is placed into the initial element of the copy (unless from == original.length or from == to). Values from subsequent elements in the original array are placed into subsequent elements in the copy. The final index of the range (to), which must be greater than or equal to from, may be greater than original.length, in which case 0f is placed in all elements of the copy whose index is greater than or equal to original.length - from. The length of the returned array will be to - from.

Parameters:
original the array from which a range is to be copied
from the initial index of the range to be copied, inclusive
to the final index of the range to be copied, exclusive. (This index may lie outside the array.)
Returns:
a new array containing the specified range from the original array, truncated or padded with zeros to obtain the required length
Throws:
java.lang.ArrayIndexOutOfBoundsException if from < 0 or from > original.length
java.lang.IllegalArgumentException if from > to
java.lang.NullPointerException if original is null
Since:
1.6
3253
    public static float[] copyOfRange(float[] original, int from, int to) {
3254
        int newLength = to - from;
3255
        if (newLength < 0)
3256
            throw new IllegalArgumentException(from + " > " + to);
3257
        float[] copy = new float[newLength];
3258
        System.arraycopy(original, from, copy, 0,
3259
                         Math.min(original.length - from, newLength));
3260
        return copy;
3261
    }

    
Copies the specified range of the specified array into a new array. The initial index of the range (from) must lie between zero and original.length, inclusive. The value at original[from] is placed into the initial element of the copy (unless from == original.length or from == to). Values from subsequent elements in the original array are placed into subsequent elements in the copy. The final index of the range (to), which must be greater than or equal to from, may be greater than original.length, in which case 0d is placed in all elements of the copy whose index is greater than or equal to original.length - from. The length of the returned array will be to - from.

Parameters:
original the array from which a range is to be copied
from the initial index of the range to be copied, inclusive
to the final index of the range to be copied, exclusive. (This index may lie outside the array.)
Returns:
a new array containing the specified range from the original array, truncated or padded with zeros to obtain the required length
Throws:
java.lang.ArrayIndexOutOfBoundsException if from < 0 or from > original.length
java.lang.IllegalArgumentException if from > to
java.lang.NullPointerException if original is null
Since:
1.6
3289
    public static double[] copyOfRange(double[] original, int from, int to) {
3290
        int newLength = to - from;
3291
        if (newLength < 0)
3292
            throw new IllegalArgumentException(from + " > " + to);
3293
        double[] copy = new double[newLength];
3294
        System.arraycopy(original, from, copy, 0,
3295
                         Math.min(original.length - from, newLength));
3296
        return copy;
3297
    }

    
Copies the specified range of the specified array into a new array. The initial index of the range (from) must lie between zero and original.length, inclusive. The value at original[from] is placed into the initial element of the copy (unless from == original.length or from == to). Values from subsequent elements in the original array are placed into subsequent elements in the copy. The final index of the range (to), which must be greater than or equal to from, may be greater than original.length, in which case false is placed in all elements of the copy whose index is greater than or equal to original.length - from. The length of the returned array will be to - from.

Parameters:
original the array from which a range is to be copied
from the initial index of the range to be copied, inclusive
to the final index of the range to be copied, exclusive. (This index may lie outside the array.)
Returns:
a new array containing the specified range from the original array, truncated or padded with false elements to obtain the required length
Throws:
java.lang.ArrayIndexOutOfBoundsException if from < 0 or from > original.length
java.lang.IllegalArgumentException if from > to
java.lang.NullPointerException if original is null
Since:
1.6
3325
    public static boolean[] copyOfRange(boolean[] original, int from, int to) {
3326
        int newLength = to - from;
3327
        if (newLength < 0)
3328
            throw new IllegalArgumentException(from + " > " + to);
3329
        boolean[] copy = new boolean[newLength];
3330
        System.arraycopy(original, from, copy, 0,
3331
                         Math.min(original.length - from, newLength));
3332
        return copy;
3333
    }
3336
    // Misc
3337

    
Returns a fixed-size list backed by the specified array. (Changes to the returned list "write through" to the array.) This method acts as bridge between array-based and collection-based APIs, in combination with Collection.toArray(). The returned list is serializable and implements RandomAccess.

This method also provides a convenient way to create a fixed-size list initialized to contain several elements: 

     List<String> stooges = Arrays.asList("Larry", "Moe", "Curly");

Parameters:
a the array by which the list will be backed
Returns:
a list view of the specified array
3354
    public static <T> List<T> asList(T... a) {
3355
        return new ArrayList<T>(a);
3356
    }

    

Serial:
include
3361
    private static class ArrayList<E> extends AbstractList<E>
3362
        implements RandomAccess, java.io.Serializable
3363
    {
3364
        private static final long serialVersionUID = -2764017481108945198L;
3365
        private final E[] a;
3367
        ArrayList(E[] array) {
3368
            if (array==null)
3369
                throw new NullPointerException();
3370
             = array;
3371
        }
3373
        public int size() {
3374
            return .;
3375
        }
3377
        public Object[] toArray() {
3378
            return .clone();
3379
        }
3381
        public <T> T[] toArray(T[] a) {
3382
            int size = size();
3383
            if (a.length < size)
3384
                return Arrays.copyOf(this., size,
3385
                                     (Class<? extends T[]>) a.getClass());
3386
            System.arraycopy(this., 0, a, 0, size);
3387
            if (a.length > size)
3388
                a[size] = null;
3389
            return a;
3390
        }
3392
        public E get(int index) {
3393
            return [index];
3394
        }
3396
        public E set(int index, E element) {
3397
            E oldValue = [index];
3398
            [index] = element;
3399
            return oldValue;
3400
        }
3402
        public int indexOf(Object o) {
3403
            if (o==null) {
3404
                for (int i=0; i<.; i++)
3405
                    if ([i]==null)
3406
                        return i;
3407
            } else {
3408
                for (int i=0; i<.; i++)
3409
                    if (o.equals([i]))
3410
                        return i;
3411
            }
3412
            return -1;
3413
        }
3415
        public boolean contains(Object o) {
3416
            return indexOf(o) != -1;
3417
        }
3418
    }

    
Returns a hash code based on the contents of the specified array. For any two long arrays a and b such that Arrays.equals(a, b), it is also the case that Arrays.hashCode(a) == Arrays.hashCode(b).

The value returned by this method is the same value that would be obtained by invoking the hashCode method on a List containing a sequence of java.lang.Long instances representing the elements of a in the same order. If a is null, this method returns 0.

Parameters:
a the array whose hash value to compute
Returns:
a content-based hash code for a
Since:
1.5
3436
    public static int hashCode(long a[]) {
3437
        if (a == null)
3438
            return 0;
3440
        int result = 1;
3441
        for (long element : a) {
3442
            int elementHash = (int)(element ^ (element >>> 32));
3443
            result = 31 * result + elementHash;
3444
        }
3446
        return result;
3447
    }

    
Returns a hash code based on the contents of the specified array. For any two non-null int arrays a and b such that Arrays.equals(a, b), it is also the case that Arrays.hashCode(a) == Arrays.hashCode(b).

The value returned by this method is the same value that would be obtained by invoking the hashCode method on a List containing a sequence of java.lang.Integer instances representing the elements of a in the same order. If a is null, this method returns 0.

Parameters:
a the array whose hash value to compute
Returns:
a content-based hash code for a
Since:
1.5
3465
    public static int hashCode(int a[]) {
3466
        if (a == null)
3467
            return 0;
3469
        int result = 1;
3470
        for (int element : a)
3471
            result = 31 * result + element;
3473
        return result;
3474
    }

    
Returns a hash code based on the contents of the specified array. For any two short arrays a and b such that Arrays.equals(a, b), it is also the case that Arrays.hashCode(a) == Arrays.hashCode(b).

The value returned by this method is the same value that would be obtained by invoking the hashCode method on a List containing a sequence of java.lang.Short instances representing the elements of a in the same order. If a is null, this method returns 0.

Parameters:
a the array whose hash value to compute
Returns:
a content-based hash code for a
Since:
1.5
3492
    public static int hashCode(short a[]) {
3493
        if (a == null)
3494
            return 0;
3496
        int result = 1;
3497
        for (short element : a)
3498
            result = 31 * result + element;
3500
        return result;
3501
    }

    
Returns a hash code based on the contents of the specified array. For any two char arrays a and b such that Arrays.equals(a, b), it is also the case that Arrays.hashCode(a) == Arrays.hashCode(b).

The value returned by this method is the same value that would be obtained by invoking the hashCode method on a List containing a sequence of java.lang.Character instances representing the elements of a in the same order. If a is null, this method returns 0.

Parameters:
a the array whose hash value to compute
Returns:
a content-based hash code for a
Since:
1.5
3519
    public static int hashCode(char a[]) {
3520
        if (a == null)
3521
            return 0;
3523
        int result = 1;
3524
        for (char element : a)
3525
            result = 31 * result + element;
3527
        return result;
3528
    }

    
Returns a hash code based on the contents of the specified array. For any two byte arrays a and b such that Arrays.equals(a, b), it is also the case that Arrays.hashCode(a) == Arrays.hashCode(b).

The value returned by this method is the same value that would be obtained by invoking the hashCode method on a List containing a sequence of java.lang.Byte instances representing the elements of a in the same order. If a is null, this method returns 0.

Parameters:
a the array whose hash value to compute
Returns:
a content-based hash code for a
Since:
1.5
3546
    public static int hashCode(byte a[]) {
3547
        if (a == null)
3548
            return 0;
3550
        int result = 1;
3551
        for (byte element : a)
3552
            result = 31 * result + element;
3554
        return result;
3555
    }

    
Returns a hash code based on the contents of the specified array. For any two boolean arrays a and b such that Arrays.equals(a, b), it is also the case that Arrays.hashCode(a) == Arrays.hashCode(b).

The value returned by this method is the same value that would be obtained by invoking the hashCode method on a List containing a sequence of java.lang.Boolean instances representing the elements of a in the same order. If a is null, this method returns 0.

Parameters:
a the array whose hash value to compute
Returns:
a content-based hash code for a
Since:
1.5
3573
    public static int hashCode(boolean a[]) {
3574
        if (a == null)
3575
            return 0;
3577
        int result = 1;
3578
        for (boolean element : a)
3579
            result = 31 * result + (element ? 1231 : 1237);
3581
        return result;
3582
    }

    
Returns a hash code based on the contents of the specified array. For any two float arrays a and b such that Arrays.equals(a, b), it is also the case that Arrays.hashCode(a) == Arrays.hashCode(b).

The value returned by this method is the same value that would be obtained by invoking the hashCode method on a List containing a sequence of java.lang.Float instances representing the elements of a in the same order. If a is null, this method returns 0.

Parameters:
a the array whose hash value to compute
Returns:
a content-based hash code for a
Since:
1.5
3600
    public static int hashCode(float a[]) {
3601
        if (a == null)
3602
            return 0;
3604
        int result = 1;
3605
        for (float element : a)
3606
            result = 31 * result + Float.floatToIntBits(element);
3608
        return result;
3609
    }

    
Returns a hash code based on the contents of the specified array. For any two double arrays a and b such that Arrays.equals(a, b), it is also the case that Arrays.hashCode(a) == Arrays.hashCode(b).

The value returned by this method is the same value that would be obtained by invoking the hashCode method on a List containing a sequence of java.lang.Double instances representing the elements of a in the same order. If a is null, this method returns 0.

Parameters:
a the array whose hash value to compute
Returns:
a content-based hash code for a
Since:
1.5
3627
    public static int hashCode(double a[]) {
3628
        if (a == null)
3629
            return 0;
3631
        int result = 1;
3632
        for (double element : a) {
3633
            long bits = Double.doubleToLongBits(element);
3634
            result = 31 * result + (int)(bits ^ (bits >>> 32));
3635
        }
3636
        return result;
3637
    }

    
Returns a hash code based on the contents of the specified array. If the array contains other arrays as elements, the hash code is based on their identities rather than their contents. It is therefore acceptable to invoke this method on an array that contains itself as an element, either directly or indirectly through one or more levels of arrays.

For any two arrays a and b such that Arrays.equals(a, b), it is also the case that Arrays.hashCode(a) == Arrays.hashCode(b).

The value returned by this method is equal to the value that would be returned by Arrays.asList(a).hashCode(), unless a is null, in which case 0 is returned.

Parameters:
a the array whose content-based hash code to compute
Returns:
a content-based hash code for a
Since:
1.5
See also:
deepHashCode(java.lang.Object[])
3660
    public static int hashCode(Object a[]) {
3661
        if (a == null)
3662
            return 0;
3664
        int result = 1;
3666
        for (Object element : a)
3667
            result = 31 * result + (element == null ? 0 : element.hashCode());
3669
        return result;
3670
    }

    
Returns a hash code based on the "deep contents" of the specified array. If the array contains other arrays as elements, the hash code is based on their contents and so on, ad infinitum. It is therefore unacceptable to invoke this method on an array that contains itself as an element, either directly or indirectly through one or more levels of arrays. The behavior of such an invocation is undefined.

For any two arrays a and b such that Arrays.deepEquals(a, b), it is also the case that Arrays.deepHashCode(a) == Arrays.deepHashCode(b).

The computation of the value returned by this method is similar to that of the value returned by List.hashCode() on a list containing the same elements as a in the same order, with one difference: If an element e of a is itself an array, its hash code is computed not by calling e.hashCode(), but as by calling the appropriate overloading of Arrays.hashCode(e) if e is an array of a primitive type, or as by calling Arrays.deepHashCode(e) recursively if e is an array of a reference type. If a is null, this method returns 0.

Parameters:
a the array whose deep-content-based hash code to compute
Returns:
a deep-content-based hash code for a
Since:
1.5
See also:
hashCode(java.lang.Object[])
3701
    public static int deepHashCode(Object a[]) {
3702
        if (a == null)
3703
            return 0;
3705
        int result = 1;
3707
        for (Object element : a) {
3708
            int elementHash = 0;
3709
            if (element instanceof Object[])
3710
                elementHash = deepHashCode((Object[]) element);
3711
            else if (element instanceof byte[])
3712
                elementHash = hashCode((byte[]) element);
3713
            else if (element instanceof short[])
3714
                elementHash = hashCode((short[]) element);
3715
            else if (element instanceof int[])
3716
                elementHash = hashCode((int[]) element);
3717
            else if (element instanceof long[])
3718
                elementHash = hashCode((long[]) element);
3719
            else if (element instanceof char[])
3720
                elementHash = hashCode((char[]) element);
3721
            else if (element instanceof float[])
3722
                elementHash = hashCode((float[]) element);
3723
            else if (element instanceof double[])
3724
                elementHash = hashCode((double[]) element);
3725
            else if (element instanceof boolean[])
3726
                elementHash = hashCode((boolean[]) element);
3727
            else if (element != null)
3728
                elementHash = element.hashCode();
3730
            result = 31 * result + elementHash;
3731
        }
3733
        return result;
3734
    }

    
Returns true if the two specified arrays are deeply equal to one another. Unlike the equals(java.lang.Object[],java.lang.Object[]) method, this method is appropriate for use with nested arrays of arbitrary depth.

Two array references are considered deeply equal if both are null, or if they refer to arrays that contain the same number of elements and all corresponding pairs of elements in the two arrays are deeply equal.

Two possibly null elements e1 and e2 are deeply equal if any of the following conditions hold:

  • e1 and e2 are both arrays of object reference types, and Arrays.deepEquals(e1, e2) would return true
  • e1 and e2 are arrays of the same primitive type, and the appropriate overloading of Arrays.equals(e1, e2) would return true.
  • e1 == e2
  • e1.equals(e2) would return true.
Note that this definition permits null elements at any depth.

If either of the specified arrays contain themselves as elements either directly or indirectly through one or more levels of arrays, the behavior of this method is undefined.

Parameters:
a1 one array to be tested for equality
a2 the other array to be tested for equality
Returns:
true if the two arrays are equal
Since:
1.5
See also:
equals(java.lang.Object[],java.lang.Object[])
3770
    public static boolean deepEquals(Object[] a1, Object[] a2) {
3771
        if (a1 == a2)
3772
            return true;
3773
        if (a1 == null || a2==null)
3774
            return false;
3775
        int length = a1.length;
3776
        if (a2.length != length)
3777
            return false;
3779
        for (int i = 0; i < length; i++) {
3780
            Object e1 = a1[i];
3781
            Object e2 = a2[i];
3783
            if (e1 == e2)
3784
                continue;
3785
            if (e1 == null)
3786
                return false;
3788
            // Figure out whether the two elements are equal
3789
            boolean eq;
3790
            if (e1 instanceof Object[] && e2 instanceof Object[])
3791
                eq = deepEquals ((Object[]) e1, (Object[]) e2);
3792
            else if (e1 instanceof byte[] && e2 instanceof byte[])
3793
                eq = equals((byte[]) e1, (byte[]) e2);
3794
            else if (e1 instanceof short[] && e2 instanceof short[])
3795
                eq = equals((short[]) e1, (short[]) e2);
3796
            else if (e1 instanceof int[] && e2 instanceof int[])
3797
                eq = equals((int[]) e1, (int[]) e2);
3798
            else if (e1 instanceof long[] && e2 instanceof long[])
3799
                eq = equals((long[]) e1, (long[]) e2);
3800
            else if (e1 instanceof char[] && e2 instanceof char[])
3801
                eq = equals((char[]) e1, (char[]) e2);
3802
            else if (e1 instanceof float[] && e2 instanceof float[])
3803
                eq = equals((float[]) e1, (float[]) e2);
3804
            else if (e1 instanceof double[] && e2 instanceof double[])
3805
                eq = equals((double[]) e1, (double[]) e2);
3806
            else if (e1 instanceof boolean[] && e2 instanceof boolean[])
3807
                eq = equals((boolean[]) e1, (boolean[]) e2);
3808
            else
3809
                eq = e1.equals(e2);
3811
            if (!eq)
3812
                return false;
3813
        }
3814
        return true;
3815
    }

    
Returns a string representation of the contents of the specified array. The string representation consists of a list of the array's elements, enclosed in square brackets ("[]"). Adjacent elements are separated by the characters ", " (a comma followed by a space). Elements are converted to strings as by String.valueOf(long). Returns "null" if a is null.

Parameters:
a the array whose string representation to return
Returns:
a string representation of a
Since:
1.5
3830
    public static String toString(long[] a) {
3831
        if (a == null)
3832
            return "null";
3833
        int iMax = a.length - 1;
3834
        if (iMax == -1)
3835
            return "[]";
3837
        StringBuilder b = new StringBuilder();
3838
        b.append('[');
3839
        for (int i = 0; ; i++) {
3840
            b.append(a[i]);
3841
            if (i == iMax)
3842
                return b.append(']').toString();
3843
            b.append(", ");
3844
        }
3845
    }

    
Returns a string representation of the contents of the specified array. The string representation consists of a list of the array's elements, enclosed in square brackets ("[]"). Adjacent elements are separated by the characters ", " (a comma followed by a space). Elements are converted to strings as by String.valueOf(int). Returns "null" if a is null.

Parameters:
a the array whose string representation to return
Returns:
a string representation of a
Since:
1.5
3860
    public static String toString(int[] a) {
3861
        if (a == null)
3862
            return "null";
3863
        int iMax = a.length - 1;
3864
        if (iMax == -1)
3865
            return "[]";
3867
        StringBuilder b = new StringBuilder();
3868
        b.append('[');
3869
        for (int i = 0; ; i++) {
3870
            b.append(a[i]);
3871
            if (i == iMax)
3872
                return b.append(']').toString();
3873
            b.append(", ");
3874
        }
3875
    }

    
Returns a string representation of the contents of the specified array. The string representation consists of a list of the array's elements, enclosed in square brackets ("[]"). Adjacent elements are separated by the characters ", " (a comma followed by a space). Elements are converted to strings as by String.valueOf(short). Returns "null" if a is null.

Parameters:
a the array whose string representation to return
Returns:
a string representation of a
Since:
1.5
3890
    public static String toString(short[] a) {
3891
        if (a == null)
3892
            return "null";
3893
        int iMax = a.length - 1;
3894
        if (iMax == -1)
3895
            return "[]";
3897
        StringBuilder b = new StringBuilder();
3898
        b.append('[');
3899
        for (int i = 0; ; i++) {
3900
            b.append(a[i]);
3901
            if (i == iMax)
3902
                return b.append(']').toString();
3903
            b.append(", ");
3904
        }
3905
    }

    
Returns a string representation of the contents of the specified array. The string representation consists of a list of the array's elements, enclosed in square brackets ("[]"). Adjacent elements are separated by the characters ", " (a comma followed by a space). Elements are converted to strings as by String.valueOf(char). Returns "null" if a is null.

Parameters:
a the array whose string representation to return
Returns:
a string representation of a
Since:
1.5
3920
    public static String toString(char[] a) {
3921
        if (a == null)
3922
            return "null";
3923
        int iMax = a.length - 1;
3924
        if (iMax == -1)
3925
            return "[]";
3927
        StringBuilder b = new StringBuilder();
3928
        b.append('[');
3929
        for (int i = 0; ; i++) {
3930
            b.append(a[i]);
3931
            if (i == iMax)
3932
                return b.append(']').toString();
3933
            b.append(", ");
3934
        }
3935
    }

    
Returns a string representation of the contents of the specified array. The string representation consists of a list of the array's elements, enclosed in square brackets ("[]"). Adjacent elements are separated by the characters ", " (a comma followed by a space). Elements are converted to strings as by String.valueOf(byte). Returns "null" if a is null.

Parameters:
a the array whose string representation to return
Returns:
a string representation of a
Since:
1.5
3950
    public static String toString(byte[] a) {
3951
        if (a == null)
3952
            return "null";
3953
        int iMax = a.length - 1;
3954
        if (iMax == -1)
3955
            return "[]";
3957
        StringBuilder b = new StringBuilder();
3958
        b.append('[');
3959
        for (int i = 0; ; i++) {
3960
            b.append(a[i]);
3961
            if (i == iMax)
3962
                return b.append(']').toString();
3963
            b.append(", ");
3964
        }
3965
    }

    
Returns a string representation of the contents of the specified array. The string representation consists of a list of the array's elements, enclosed in square brackets ("[]"). Adjacent elements are separated by the characters ", " (a comma followed by a space). Elements are converted to strings as by String.valueOf(boolean). Returns "null" if a is null.

Parameters:
a the array whose string representation to return
Returns:
a string representation of a
Since:
1.5
3980
    public static String toString(boolean[] a) {
3981
        if (a == null)
3982
            return "null";
3983
        int iMax = a.length - 1;
3984
        if (iMax == -1)
3985
            return "[]";
3987
        StringBuilder b = new StringBuilder();
3988
        b.append('[');
3989
        for (int i = 0; ; i++) {
3990
            b.append(a[i]);
3991
            if (i == iMax)
3992
                return b.append(']').toString();
3993
            b.append(", ");
3994
        }
3995
    }

    
Returns a string representation of the contents of the specified array. The string representation consists of a list of the array's elements, enclosed in square brackets ("[]"). Adjacent elements are separated by the characters ", " (a comma followed by a space). Elements are converted to strings as by String.valueOf(float). Returns "null" if a is null.

Parameters:
a the array whose string representation to return
Returns:
a string representation of a
Since:
1.5
4010
    public static String toString(float[] a) {
4011
        if (a == null)
4012
            return "null";
4013
        int iMax = a.length - 1;
4014
        if (iMax == -1)
4015
            return "[]";
4017
        StringBuilder b = new StringBuilder();
4018
        b.append('[');
4019
        for (int i = 0; ; i++) {
4020
            b.append(a[i]);
4021
            if (i == iMax)
4022
                return b.append(']').toString();
4023
            b.append(", ");
4024
        }
4025
    }

    
Returns a string representation of the contents of the specified array. The string representation consists of a list of the array's elements, enclosed in square brackets ("[]"). Adjacent elements are separated by the characters ", " (a comma followed by a space). Elements are converted to strings as by String.valueOf(double). Returns "null" if a is null.

Parameters:
a the array whose string representation to return
Returns:
a string representation of a
Since:
1.5
4040
    public static String toString(double[] a) {
4041
        if (a == null)
4042
            return "null";
4043
        int iMax = a.length - 1;
4044
        if (iMax == -1)
4045
            return "[]";
4047
        StringBuilder b = new StringBuilder();
4048
        b.append('[');
4049
        for (int i = 0; ; i++) {
4050
            b.append(a[i]);
4051
            if (i == iMax)
4052
                return b.append(']').toString();
4053
            b.append(", ");
4054
        }
4055
    }

    
Returns a string representation of the contents of the specified array. If the array contains other arrays as elements, they are converted to strings by the java.lang.Object.toString() method inherited from Object, which describes their identities rather than their contents.

The value returned by this method is equal to the value that would be returned by Arrays.asList(a).toString(), unless a is null, in which case "null" is returned.

Parameters:
a the array whose string representation to return
Returns:
a string representation of a
Since:
1.5
See also:
deepToString(java.lang.Object[])
4073
    public static String toString(Object[] a) {
4074
        if (a == null)
4075
            return "null";
4076
        int iMax = a.length - 1;
4077
        if (iMax == -1)
4078
            return "[]";
4080
        StringBuilder b = new StringBuilder();
4081
        b.append('[');
4082
        for (int i = 0; ; i++) {
4083
            b.append(String.valueOf(a[i]));
4084
            if (i == iMax)
4085
                return b.append(']').toString();
4086
            b.append(", ");
4087
        }
4088
    }

    
Returns a string representation of the "deep contents" of the specified array. If the array contains other arrays as elements, the string representation contains their contents and so on. This method is designed for converting multidimensional arrays to strings.

The string representation consists of a list of the array's elements, enclosed in square brackets ("[]"). Adjacent elements are separated by the characters ", " (a comma followed by a space). Elements are converted to strings as by String.valueOf(Object), unless they are themselves arrays.

If an element e is an array of a primitive type, it is converted to a string as by invoking the appropriate overloading of Arrays.toString(e). If an element e is an array of a reference type, it is converted to a string as by invoking this method recursively.

To avoid infinite recursion, if the specified array contains itself as an element, or contains an indirect reference to itself through one or more levels of arrays, the self-reference is converted to the string "[...]". For example, an array containing only a reference to itself would be rendered as "[[...]]".

This method returns "null" if the specified array is null.

Parameters:
a the array whose string representation to return
Returns:
a string representation of a
Since:
1.5
See also:
toString(java.lang.Object[])
4123
    public static String deepToString(Object[] a) {
4124
        if (a == null)
4125
            return "null";
4127
        int bufLen = 20 * a.length;
4128
        if (a.length != 0 && bufLen <= 0)
4129
            bufLen = .;
4130
        StringBuilder buf = new StringBuilder(bufLen);
4131
        deepToString(a, buf, new HashSet());
4132
        return buf.toString();
4133
    }
4135
    private static void deepToString(Object[] a, StringBuilder buf,
4136
                                     Set<Object[]> dejaVu) {
4137
        if (a == null) {
4138
            buf.append("null");
4139
            return;
4140
        }
4141
        int iMax = a.length - 1;
4142
        if (iMax == -1) {
4143
            buf.append("[]");
4144
            return;
4145
        }
4147
        dejaVu.add(a);
4148
        buf.append('[');
4149
        for (int i = 0; ; i++) {
4151
            Object element = a[i];
4152
            if (element == null) {
4153
                buf.append("null");
4154
            } else {
4155
                Class eClass = element.getClass();
4157
                if (eClass.isArray()) {
4158
                    if (eClass == byte[].class)
4159
                        buf.append(toString((byte[]) element));
4160
                    else if (eClass == short[].class)
4161
                        buf.append(toString((short[]) element));
4162
                    else if (eClass == int[].class)
4163
                        buf.append(toString((int[]) element));
4164
                    else if (eClass == long[].class)
4165
                        buf.append(toString((long[]) element));
4166
                    else if (eClass == char[].class)
4167
                        buf.append(toString((char[]) element));
4168
                    else if (eClass == float[].class)
4169
                        buf.append(toString((float[]) element));
4170
                    else if (eClass == double[].class)
4171
                        buf.append(toString((double[]) element));
4172
                    else if (eClass == boolean[].class)
4173
                        buf.append(toString((boolean[]) element));
4174
                    else { // element is an array of object references
4175
                        if (dejaVu.contains(element))
4176
                            buf.append("[...]");
4177
                        else
4178
                            deepToString((Object[])element, buf, dejaVu);
4179
                    }
4180
                } else {  // element is non-null and not an array
4181
                    buf.append(element.toString());
4182
                }
4183
            }
4184
            if (i == iMax)
4185
                break;
4186
            buf.append(", ");
4187
        }
4188
        buf.append(']');
4189
        dejaVu.remove(a);
4190
    }
New to GrepCode? Check out our FAQ X