Java 数组。是否从较高的数字排序到较低的数字？

基本上，我想使用“arrays.sort”对数组进行排序，从较高的亨伯数到较低的数。遗憾的是，我不知道如何从高到低排序，因为“Arrays.sort”将这些数组从低到高排序

有什么建议吗

代码：

例如，输出如下：

[0.0,0.18018017709255219,0.36036035418510437,2.342342376708944,2.88288348034835,2.8828834808034835,4.504504683545,45.76576614379883]

正如Bhesh在下面指出的，您需要使用

Double[]

数组，而不是

Double[]

，因为这不适用于基本类型

直接应用于您的代码：

Double[] sortArrays = {
    (Double) probabilityOfFlush,
    (Double) probabilityOfFullHouse, 
    (Double) probabilityOfOnePair, 
    (Double) probabilityOfPoker, 
    (Double) probabilityOfRoad, 
    (Double) probabilityOfRoyalFlush, 
    (Double) probabilityOfTriple, 
    (Double) probabilityOfTwoPairs
};

Arrays.sort(sortArrays, Collections.reverseOrder());
System.out.println(Arrays.toString(sortArrays));

我将

double-sortarray[]

更改为

double-sortarray[/code>：


[]位置的改变没有什么区别，但这是编码风格/偏好的问题
但是，
Double
中的大写字母D不起作用。大写字母D使用
Double
对象类型，而不是
Double
原语类型

您还需要添加
import java.util.Collections到类文件的顶部。因为您提到您正在使用eclipse，所以可以按住ctrl+shift并按o键，通过导入未导入的类、删除未使用的导入以及按包组织导入来自动处理导入。
获取列表

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

对于数组

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

Collections.reverseOrder（）
使用比较器反转自然顺序

注意：它无法对基本体数组进行排序，因此需要将基本体转换为它们各自的对象。整数表示整数，双精度表示双精度，布尔值表示布尔值，等等

用法示例

Double sortArrays[] = new Double[]{1.0,2.0,3.0,5.0,6.0};
Arrays.sort(sortArrays, Collections.reverseOrder());
System.out.println(Arrays.toString(sortArrays));
//output [6.0, 5.0, 3.0, 2.0, 1.0]

我建议使用比较器

Arrays.sort(array, new Comparator<Double>()
{
    @Override
    public int compare(Double x, Double y)
    {
        return y - x;
    }
});

Arrays.sort（数组，新比较器（）
{
@凌驾
公共整数比较（双x，双y）
{
返回y-x；
}
});

使用带有y-x的比较器将从高到低排序，x-y将从低到高排序。
如果要保留原语，可以对数组进行排序，然后将其反转。请注意，您必须使用。这将在
O（nlogn）

如果不想使用外部库，可以使用以下代码：

public static void reverse(double[] array) {
            if (array == null) {
                return;
            }
            int i = 0;
            int j = array.length - 1;
            double tmp;
            while (j > i) {
                tmp = array[j];
                array[j] = array[i];
                array[i] = tmp;
                j--;
                i++;
            }
 }

检查重载的
sort
方法。你需要使用一个
Double
数组。你可以实现比较器，为什么要标记它？@Aroon我会使用我的and。你可以移动到
集合
并使用
Collections.reverse（）
+1，但你可以添加Sotirios在注释中指出的内容，因为OP有一个
Double[]
而不是
Double[]
@BheshGurung很好，没注意到。你能给我一个我在帖子中写的代码的例子吗？遗憾的是，这对我不起作用：S。无论如何，谢谢你@user3077388当然可以，给我几分钟。@user3077388没问题，很乐意帮忙！我本可以用这个，但是turbo seemd的代码更简单！不过还是要谢谢你@user3077388此解决方案需要两行代码：P，您正在处理primitive。您知道我的缺点，我应该采用此解决方案，因为它很简单，并且可以解释它本身。。。
Arrays.sort(array, new Comparator<Double>()
{
    @Override
    public int compare(Double x, Double y)
    {
        return y - x;
    }
});

Arrays.sort(array);
ArrayUtils.reverse(array);

public static void reverse(double[] array) {
            if (array == null) {
                return;
            }
            int i = 0;
            int j = array.length - 1;
            double tmp;
            while (j > i) {
                tmp = array[j];
                array[j] = array[i];
                array[i] = tmp;
                j--;
                i++;
            }
 }