Arrays.sort如何实现降序排序

import java.util.*;   public class Main {     public static void main(String[] args) { //        注意这里是Integer，不是int         Integer[] arr={9,8,7,6,5,4,3,2,1};         Arrays.sort(arr,Collections.reverseOrder());         for(int i:arr){             System.out.println(i);         }     } }

import java.util.*;   public class Main {     public static void main(String[] args) {         Integer[] arr={9,8,7,6,5,4,3,2,1};         Comparator cmp=new CMP();         Arrays.sort(arr,cmp);         for(int i:arr){             System.out.println(i);         }     } } class CMP implements Comparator{     @Override //可以去掉。作用是检查下面的方法名是不是父类中所有的     public int compare(Integer a,Integer b){ //        两种都可以，升序排序的话反过来就行 //        return a-b<0?1:-1;         return b-a;     } }

	public static void main(String[] args) { int[] nums = new int[]{6,5,4,3,2,1}; List list = Arrays.asList(6, 5, 4, 3, 2, 1); Arrays.sort(nums); Collections.sort(list); System.out.println(Arrays.toString(nums)); System.out.println(list); }

/** * Sorts the specified array into ascending numerical order. * * 
Implementation note: The sorting algorithm is a Dual-Pivot Quicksort * by Vladimir Yaroslavskiy, Jon Bentley, and Joshua Bloch. This algorithm * offers O(n log(n)) performance on many data sets that cause other * quicksorts to degrade to quadratic performance, and is typically * faster than traditional (one-pivot) Quicksort implementations. * * @param a the array to be sorted */ public static void sort(int[] a) { DualPivotQuicksort.sort(a, 0, a.length - 1, null, 0, 0); }

 	// Use Quicksort on small arrays if (right - left 

	 // Use insertion sort on tiny arrays if (length 

// Inexpensive approximation of length / 7 int seventh = (length >> 3) + (length >> 6) + 1;

		/* * Sort five evenly spaced elements around (and including) the * center element in the range. These elements will be used for * pivot selection as described below. The choice for spacing * these elements was empirically determined to work well on * a wide variety of inputs. */ int e3 = (left + right) >>> 1; // The midpoint int e2 = e3 - seventh; int e1 = e2 - seventh; int e4 = e3 + seventh; int e5 = e4 + seventh;

		// Sort these elements using insertion sort if (a[e2] 

		 /* * Use the second and fourth of the five sorted elements as pivots. * These values are inexpensive approximations of the first and * second terciles of the array. Note that pivot1 <= pivot2. */ int pivot1 = a[e2]; int pivot2 = a[e4]; /* * The first and the last elements to be sorted are moved to the * locations formerly occupied by the pivots. When partitioning * is complete, the pivots are swapped back into their final * positions, and excluded from subsequent sorting. */ a[e2] = a[left]; a[e4] = a[right]; /* * Skip elements, which are less or greater than pivot values. */ while (a[++less]  pivot2);

			/* * Partitioning: * *   left part           center part                   right part * +--------------------------------------------------------------+ * |   pivot2  | * +--------------------------------------------------------------+ *               ^                          ^       ^ *               |                          |       | *              less                        k     great * * Invariants: * *              all in (left, less)    pivot2 * * Pointer k is the first index of ?-part. */ outer: for (int k = less - 1; ++k <= great; ) { short ak = a[k]; if (ak  pivot2) { // Move a[k] to right part while (a[great] > pivot2) { if (great-- == k) { break outer; } } if (a[great] 

	// Swap pivots into their final positions a[left]  = a[less  - 1]; a[less  - 1] = pivot1; a[right] = a[great + 1]; a[great + 1] = pivot2;

		// Sort left and right parts recursively, excluding known pivots sort(a, left, less - 2, leftmost); sort(a, great + 2, right, false);

			/* * If center part is too large (comprises > 4/7 of the array), * swap internal pivot values to ends. */ if (less