Java数组按降序排序？

对于二维数组按降序排序，您只需要翻转参数的位置即可。

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

我不知道你的使用场景是什么，但除了其他答案之外，还有另一种（懒惰的）选择，就是按照你指示的升序排序，然后以相反的顺序迭代。

针对以上讨论，这里有一个简单的例子来将原始数组按降序排序。

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]);
        }
    }
}

输出：

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

另一种解决方案是，如果您正在使用“Comparable”接口，则可以切换在compareTo(Object bCompared)中指定的输出值。
例如：

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;
}

在我的程序中，magnitude是一个带有double数据类型的属性。这导致我的定义类freq按照它们的magnitude值以相反的顺序进行排序。为了纠正这个问题，您需要交换<和>返回的值。这将给您以下结果:

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;
}

为了使用这个compareTo，我们只需要调用Arrays.sort(mFreq)，它将为您提供排序后的数组freq[] mFreq。
这种解决方案的美妙之处（在我看来）在于它可以用于对用户定义的类进行排序，甚至可以按特定属性对它们进行排序。如果实现Comparable接口听起来让你感到困惑，我鼓励你不要那样想，它实际上并不难。这个如何实现comparable的链接让事情变得更容易了。希望人们能够利用这个解决方案，并且你的喜悦会与我相当。

以下是几种不同情况下的答案：

针对数组：

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

FWIW Lists

Lists.reverse(a);

所有集合

Collections.reverse(a);

这是我如何对一个原始类型 int 数组进行排序的方法。

int[] intArr = new int[] {9,4,1,7};
Arrays.sort(nums);
Collections.reverse(Arrays.asList(nums));

结果：

[1, 4, 7, 9]

你可以使用stream操作(Collections.stream())和Comparator.reverseOrder()。例如，假设你有这个集合：

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

要按照它们的“自然”顺序打印项目，您可以使用sorted()方法（或省略它并获得相同的结果）：

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

或者，要以降序（反向）打印它们，您可以使用sorted方法，该方法采用比较器并反转顺序：

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

请注意，这要求集合已经实现了Comparable接口（例如Integer、String等）。

Arrays.sort(nums, Collections.reverseOrder())；
但是，Arrays.sort() 无法与像 int[] 这样的原始对象一起使用。 它会抛出以下错误：
error: no suitable method found for sort(int[],Comparator)
Arrays.sort() 只能按递增顺序处理原始对象。
最好将其转换为集合，然后进行排序
Collections.sort(Arrays.asList(nums), Collections.reverseOrder())

这里很混乱 - 人们提出了针对非原始值的解决方案，尝试从头实现一些排序算法，给出涉及额外库的解决方案，展示一些hacky的方法等等。对于原始问题的答案是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());

arrOfObjects现在是{6,5,4,3,2,1}。如果您有一个除了int以外的其他东西的数组 - 请使用相应的对象代替Integer。

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

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;
}