对于按降序排序的2D数组，只需翻转参数的位置

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

当一个数组是Integer类的类型时，你可以使用下面的方法:

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

当一个数组是int类型的数据类型时，你可以使用下面的方法:

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

我不知道你的用例是什么，但是除了这里的其他答案之外，另一个(惰性)选项是仍然按照你指出的升序排序，但然后以反向顺序迭代。

这里有很多乱七八糟的东西——人们建议非原始值的解决方案，尝试从基础上实现一些排序算法，给出涉及额外库的解决方案，炫耀一些俗套的解决方案等等。最初问题的答案是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}。如果你有一个不是整数的数组——使用相应的对象而不是整数。

另一种使用Comparator的方法

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()  );

public double[] sortArrayAlgorithm(double[] array) { //sort in descending order
    for (int i = 0; i < array.length; i++) {
        for (int j = 0; j < array.length; j++) {
            if (array[i] >= array[j]) {
                double x = array[i];
                array[i] = array[j];
                array[j] = x;
            }
        }
    }
    return array;
}

只需使用此方法按降序对double类型的数组进行排序，您可以使用它对任何其他类型的数组(如int, float等)进行排序，只需将“返回类型”，“参数类型”和变量“x”类型更改为相应的类型。您还可以在if条件中将">="更改为"<="以使顺序上升。