Java数组排序降序？

是否有任何简单的方法可以按降序对数组进行排序，就像在数组中按升序排序一样

---

还是我必须停止懒惰，自己动手：[

你可以用它来对所有类型的对象进行排序

sort(T[] a, Comparator<? super T> c) 

Arrays.sort(a, Collections.reverseOrder());

sort（T[]a，Comparator您可以使用：

    Arrays.sort(data, Collections.reverseOrder());

Collections.reverseOrder（）
使用逆自然顺序返回一个
Comparator
。您可以使用
Collections.reverseOrder（myComparator）
获取自己的比较器的反转版本，以获取列表

Collections.sort(list, Collections.reverseOrder());

对于数组

Arrays.sort(array, Collections.reverseOrder());

对于包含原语元素的数组，如果有
org.apache.commons.lang（3）
可供使用，则反转数组（排序后）的简单方法是使用：

ArrayUtils.reverse(array);

我不知道您的用例是什么，但是除了这里的其他答案之外，另一个（惰性）选项仍然是按照您指示的升序排序，然后以相反的顺序进行迭代。
另一种选择可能是（对于数字！！！）

将数组乘以-1
分类
再乘以-1
字面上说：

array = -Arrays.sort(-array)

没有明确的比较器：

Collections.sort（list，Collections.reverseOrder（））；

使用显式比较器：

Collections.sort（list，Collections.reverseOrder（newcomparator（））；
Java 8:

Arrays.sort(list, comparator.reversed());

更新：
reversed（）
反转指定的比较器。通常，比较器的顺序为升序，因此这会将顺序更改为降序。
首先，您需要使用以下命令对数组进行排序：

Collections.sort(myArray);

然后，您需要使用以下命令反转从升序到降序的顺序：

Collections.reverse(myArray);

另一个解决方案是，如果使用可比较接口，可以将在compareTo中指定的输出值切换为（对象b比较）

例如：

public int compareTo(freq arg0) 
{
    int ret=0;
    if(this.magnitude>arg0.magnitude)
        ret= 1;
    else if (this.magnitude==arg0.magnitude)
        ret= 0;
    else if (this.magnitude<arg0.magnitude)
        ret= -1;
    return ret;
}

为了利用这个比较，我们只需调用
Arrays.sort（mFreq）
，它将为您提供排序后的数组
freq[]mFreq

美（在我看来）这个解决方案的一个特点是，它可以用来对用户定义的类进行排序，甚至比按特定属性对它们进行排序更重要。如果一个可比较的接口的实现对您来说听起来让人望而生畏，我鼓励您不要这样想，它实际上不是。这让事情对我来说容易多了。希望人们能够利用这个解决方案，并且t你的快乐甚至可以与我的相比。
我知道这是一个非常古老的线程，但这里有一个整数和Java 8的更新版本：

Arrays.sort(array, (o1, o2) -> o2 - o1);

请注意，它是“o1-o2”，表示正常的升序（或Comparator.comparingit（））

这也适用于任何其他类型的对象。例如：

Arrays.sort(array, (o1, o2) -> o2.getValue() - o1.getValue());

这对我很有用：

package doublearraysort;

import java.util.Arrays;
import java.util.Collections;

public class Gpa {


    public static void main(String[] args) {
        // initializing unsorted double array
        Double[] dArr = new Double[] {                 
            new Double(3.2),
            new Double(1.2),
            new Double(4.7),
            new Double(3.3),
            new Double(4.6),
           };
        // print all the elements available in list
        for (double number : dArr) {
            System.out.println("GPA = " + number);
        }

        // sorting the array
        Arrays.sort(dArr, Collections.reverseOrder());

        // print all the elements available in list again
        System.out.println("The sorted GPA Scores are:");
        for (double number : dArr) {
            System.out.println("GPA = " + number);
        }
    }
}

输出：

GPA = 3.2
GPA = 1.2
GPA = 4.7
GPA = 3.3
GPA = 4.6
The sorted GPA Scores are:
GPA = 4.7
GPA = 4.6
GPA = 3.3
GPA = 3.2
GPA = 1.2

nums[0] = 9
nums[1] = 8
nums[2] = 7
nums[3] = 6
nums[4] = 5
nums[5] = 4
nums[6] = 3
nums[7] = 2
nums[8] = 1
nums[9] = 0

public double[]排序算法（double[]数组）{//按降序排序
for（int i=0；i=数组[j]）{
双x=数组[i]；
数组[i]=数组[j]；
数组[j]=x；
}
}
}
返回数组；
}

只需使用此方法按降序对double类型的数组进行排序，您就可以使用它对任何其他类型的数组（如int、float等）进行排序，只需将“返回类型”、“参数类型”和变量“x”类型更改为相应的类型。您还可以将“>=”更改为“，您可以将操作（）与一起使用

例如，假设您拥有此集合：

List<String> items = new ArrayList<>();
items.add("item01");
items.add("item02");
items.add("item03");
items.add("item04");
items.add("item04");

或者，要按降序（反转）打印，可以使用比较器并反转顺序的方法：

items.stream()
     .sorted(Comparator.reverseOrder())
     .forEach(item -> System.out.println(item));

注意，这要求集合实现了Comparable（整数、字符串等）。
不能直接使用
Arrays.sort（）
和
Collections.reverseOrder（）
对原语数组（即
int[]arr={1,2,3}；
）进行反向排序，因为这些方法需要引用类型（
Integer
）而不是基元类型（
int
）

但是，我们可以使用Java 8 Stream首先对数组进行装箱，以便按相反顺序进行排序：

//整数数组
int[]arr={1,2,3,4,5,6}；
//反向排序整数的数组
int[]arrDesc=Arrays.stream（arr）.boxed（）
.sorted（Collections.reverseOrder（））
.mapToInt（整数：：intValue）
.toArray（）；
System.out.println（Arrays.toString（arrDesc））；//输出[6,5,4,3,2,1]
这里有很多乱七八糟的事情发生-人们建议非原始值的解决方案，尝试从底层实现一些排序算法，给出涉及附加库的解决方案，展示一些黑客库等。原始问题的答案是50/50。对于那些只想复制/粘贴的人：

// our initial int[] array containing primitives
int[] arrOfPrimitives = new int[]{1,2,3,4,5,6};

// we have to convert it into array of Objects, using java's boxing
Integer[] arrOfObjects = new Integer[arrOfPrimitives.length];
for (int i = 0; i < arrOfPrimitives.length; i++) 
    arrOfObjects[i] = new Integer(arrOfPrimitives[i]);

// now when we have an array of Objects we can use that nice built-in method
Arrays.sort(arrOfObjects, Collections.reverseOrder());

//我们的初始int[]数组包含原语
int[]arrOfPrimitives=新的int[]{1,2,3,4,5,6}；
//我们必须使用java的装箱将其转换为对象数组
整数[]arrOfObjects=新整数[arrOfPrimitives.length]；
for（int i=0；i

arrOfObjects
现在是
{6,5,4,3,2,1}
。如果您有一个非整数的数组，请使用相应的而不是
整数来进行上述讨论，下面是一个简单的示例，可以按降序对基本数组进行排序

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] nums = { 5, 4, 1, 2, 9, 7, 3, 8, 6, 0 };
        Arrays.sort(nums);

        // reverse the array, just like dumping the array!
        // swap(1st, 1st-last) <= 1st: 0, 1st-last: nums.length - 1
        // swap(2nd, 2nd-last) <= 2nd: i++,  2nd-last: j--
        // swap(3rd, 3rd-last) <= 3rd: i++,  3rd-last: j--
        //
        for (int i = 0, j = nums.length - 1, tmp; i < j; i++, j--) {
            tmp = nums[i];
            nums[i] = nums[j];
            nums[j] = tmp;
        }

        // dump the array (for Java 4/5/6/7/8/9)
        for (int i = 0; i < nums.length; i++) {
            System.out.println("nums[" + i + "] = " + nums[i]);
        }
    }
}

对整型数组进行降序排序的简单方法：

private static int[] descendingArray(int[] array) {
    Arrays.sort(array);
    int[] descArray = new int[array.length];
    for(int i=0; i<array.length; i++) {
        descArray[i] = array[(array.length-1)-i];
    }
    return descArray;
}

私有静态int[]下降数组（int[]数组）{
数组。排序（数组）；
int[]descArray=新的int[array.length]；
对于（int i=0；i另一种使用比较器的方法

import java.util.Arrays;
import java.util.Comparator;
...

Integer[] aInt = {6,2,3,4,1,5,7,8,9,10};
Arrays.sort(aInt, Comparator.reverseOrder()  );

有时候我们通过一个例子来练习是很好的，下面是一个完整的例子：

sortdesc.java

import java.util.Arrays;
import java.util.Collections;
class sortdesc{
public static void main(String[] args){
       // int Array
       Integer[] intArray=new Integer[]{
                 new Integer(15),
                 new Integer(9),
                 new Integer(16),
                 new Integer(2),
                 new Integer(30)};

       // Sorting int Array in descending order
       Arrays.sort(intArray,Collections.reverseOrder());

       // Displaying elements of int Array
       System.out.println("Int Array Elements in reverse order:");
       for(int i=0;i<intArray.length;i++)
          System.out.println(intArray[i]);

       // String Array
       String[] stringArray=new String[]{"FF","PP","AA","OO","DD"};

       // Sorting String Array in descending order
       Arrays.sort(stringArray,Collections.reverseOrder());

       // Displaying elements of String Array
       System.out.println("String Array Elements in reverse order:");
       for(int i=0;i<stringArray.length;i++)
          System.out.println(stringArray[i]);}}

叫它

输出

Int Array Elements in reverse order:
30
16
15
9
2
String Array Elements in reverse order:
PP
OO
FF
DD
AA

如果您想尝试字母数字数组

//replace this line:
String[] stringArray=new String[]{"FF","PP","AA","OO","DD"};

//with this:
String[] stringArray=new String[]{"10FF","20AA","50AA"};

您将得到如下输出：

50AA
20AA
10FF

javac sortdec.java

java sortdesc

Int Array Elements in reverse order:
30
16
15
9
2
String Array Elements in reverse order:
PP
OO
FF
DD
AA

//replace this line:
String[] stringArray=new String[]{"FF","PP","AA","OO","DD"};

//with this:
String[] stringArray=new String[]{"10FF","20AA","50AA"};

50AA
20AA
10FF

public static int[] sortArray (int[] array) {
    int [] sortedArray = new int[array.length];
    for (int i = 0; i < sortedArray.length; i++) {
        sortedArray[i] = array[i];
    }
    
    boolean flag = true;
    int temp;
    while (flag) {
        flag = false;
        for (int i = 0; i < sortedArray.length - 1; i++) {
            if(sortedArray[i] < sortedArray[i+1]) {
                temp = sortedArray[i];
                sortedArray[i] = sortedArray[i+1];
                sortedArray[i+1] = temp;
                flag = true;
            }
        }
    }
    
    return sortedArray;
    
}

    public static int[] sortArrayDesc(int[] intArray){
    Arrays.sort(intArray);                      //sort intArray in Asc order
    int[] sortedArray = new int[intArray.length];   //this array will hold the sorted values

    int indexSortedArray = 0;
    for(int i=intArray.length-1 ; i >= 0 ; i--){    //insert to sortedArray in reverse order
        sortedArray[indexSortedArray ++] = intArray [i];
    }
    return sortedArray;
}

Integer[] arr = {7, 10, 4, 3, 20, 15};
Arrays.sort(arr, Collections.reverseOrder());

int[] arr = {7, 10, 4, 3, 20, 15};
int[] reverseArr = IntStream.rangeClosed(1, arr.length).map(i -> arr[arr.length-i]).toArray();

int[][] array= {
    {1, 5},
    {13, 1},
    {12, 100},
    {12, 85} 
};
Arrays.sort(array, (a, b) -> Integer.compare(a[1], b[1])); // for ascending order
Arrays.sort(array, (b, a) -> Integer.compare(a[1], b[1])); // for descending order

12, 100
12, 85
1, 5
13, 1