Java数组排序降序？

有没有什么简便的方法可以按降序对数组进行排序，就像它们在Arrays类中如何按升序排序？

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

您可以使用它对各种对象进行排序

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

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

Arrays.sort()不能直接用于降序对原始数组进行排序。如果尝试Arrays.sort()通过传递由定义的反向Comparator 来调用该方法Collections.reverseOrder()，则会抛出错误

找不到适合sort（int []，comparator）的方法

可以与“对象数组”（例如Integer数组）一起使用，但不适用于基本数组（例如int数组）。

按降序对原始数组进行排序的唯一方法是，首先按升序对数组进行排序，然后将数组反转就位。对于二维基本数组也是如此。

清单

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

用于数组

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

您可以使用此：

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

Collections.reverseOrder()Comparator使用自然逆序返回。您可以使用来获得自己比较器的反向版本Collections.reverseOrder(myComparator)。

另一种可能是（用于数字！！！）

1. 将数组乘以-1
2. 分类
3. 再次乘以-1

从字面上讲：

array = -Arrays.sort(-array)

没有显式比较器：

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

使用显式比较器：

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

Java 8：

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

更新： reversed()反转指定的比较器。通常，比较器的顺序为升序，因此这会将顺序更改为降序。

对于包含基元元素的数组，如果org.apache.commons.lang(3)可以使用的话，可以使用简单的方法来反转数组（排序后）：

ArrayUtils.reverse(array);

首先，您需要使用以下方法对数组进行排序：

Collections.sort(Myarray);

然后，您需要使用以下命令将顺序从升序转换为降序：

Collections.reverse(Myarray);

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

int[] arr = {1, 2, 3};使用Arrays.sort()和不能直接对基元数组（即）进行反向排序，Collections.reverseOrder()因为这些方法需要引用类型（Integer）而不是基元类型（int）。

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

// an array of ints
int[] arr = {1, 2, 3, 4, 5, 6};

// an array of reverse sorted ints
int[] arrDesc = Arrays.stream(arr).boxed()
    .sorted(Collections.reverseOrder())
    .mapToInt(Integer::intValue)
    .toArray();

System.out.println(Arrays.toString(arrDesc)); // outputs [6, 5, 4, 3, 2, 1]

另一个解决方案是，如果您使用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;
}

其中，振幅是我程序中数据类型为double的属性。这是按照其大小按相反的顺序对我定义的类频率进行排序。因此，为了更正此问题，请切换由<和返回的值>。这给您以下内容：

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接口对您来说令人生畏，我鼓励您不要这样，实际上不是。这对如何实现可比的链接使事情对我来说要容易得多。希望人们可以使用此解决方案，并且您的喜悦甚至可以与我的喜悦相提并论。

array.sort(function(a, b) {return b - a;}); //descending 

要么

array.sort(function(a, b) {return a - b;}); //ascending

我知道这是一个很旧的线程，但是这里是Integers和Java 8的更新版本：

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

请注意，对于正常的升序（或Comparator.comparingInt（）），它是“ o1-o2”。

这也适用于任何其他种类的对象。说：

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

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条件中将“> =”更改为“ <=”以使顺序升序。

您可以将流操作（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));

或以降序（反向）打印它们，可以使用采用Comparator并颠倒顺序的已排序方法：

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

请注意，这要求集合已实现Comparable（Integer，String等）。

这里发生了很多混乱-人们建议非原始值的解决方案，尝试从地面实施一些排序算法，提供涉及其他库的解决方案，展示一些骇客的库等。原始问题的答案是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}现在。如果您的数组不是整数，则使用相应的对象代替Integer。

对于上面的讨论，这是一个简单的示例，以降序对基本数组进行排序。

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

简单的方法将一个int数组降序排序：

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

比较器的另一种方法

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