Java数组降序排序？

Posted 2023-02-25

【中文标题】Java数组降序排序？

【英文标题】：Java Array Sort descending?

【发布时间】：2010-12-14 06:20:38

【问题描述】：

是否有任何简单的方法可以按降序对数组进行排序，例如在Arrays class 中按升序排序？

或者我必须停止懒惰并自己做这个：[

【问题讨论】：

看看usages of Collections.reverseOrder

以下很多解决方案都适用于 Integer 而不是 int 类型（确保您使用的是适当的）

【参考方案1】：

您可以使用它对所有类型的对象进行排序

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

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

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

没有找到适合 sort(int[],comarator) 的方法

这适用于“对象数组”，例如整数数组，但不适用于原始数组，例如 int 数组。

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

【讨论】：

它不能对基元数组进行排序

将您的图元转换为它们各自的对象。 Integer for int，Double for double，Boolean for boolean 等

如果您仍想使用自定义comparator：Collections.reverseOrder(this)

Collections.reverseOrder() 不接受任何参数（除非我遗漏了什么？），而是我使用了 myComparator.reversed()。

我使用这个（示例）： Comparator notificationDataComparator = Collections.reverseOrder(GenericComparator .createComparator(AdMessage.CREATED_AT_COMPARATOR)); Collections.sort(allMessageList, notificationDataComparator);

【参考方案2】：

列表

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

对于一个数组

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

【讨论】：

int []array = 2,4,3,6,8,7; Arrays.sort(array, Collections.reverseOrder());给我一个错误！错误是：“数组类型中的方法 sort(int[]) 不适用于参数 (int[], Comparator

int 不是对象。尝试使用 Integer[] 代替。

int 是主要类型，而 Integer 不是。这就是为什么 Integer 有 parse、toString 等方法的原因。

【参考方案3】：

你可以用这个：

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

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

【讨论】：

OP 想要对数组进行排序。 Collections.sort() 将 List 作为输入参数，而不是数组。

【参考方案4】：

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

将数组乘以 -1 排序 再次乘以 -1

字面意思：

array = -Arrays.sort(-array)

【讨论】：

如果我们对数字进行排序，这个方法实际上是有创意的，即使它不是通用的并且可能导致溢出问题......

这对于原始类型来说是一个很好的答案。你是天才。

除非它对于Integer.MIN_VALUE（或使用的任何原语）会失败。最好是sort()，然后是reverse()，但你必须自己做反转，因为他们没有添加Arrays.reverse() 实现。

@Halil İbrahim Oymacı：-array 语法对我不起作用：“一元运算符'-'的错误操作数类型 int[]”

@line 您必须使用多个 -1 来排列。上面的代码是伪代码。您可以在 for 循环中将多个 -1 排列成数组，然后调用 Array.sort() 方法，最后再将多个 -1 排列成数组。

【参考方案5】：

没有明确的比较器：

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

带有显式比较器：

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

【参考方案6】：

不能直接使用Arrays.sort() 和Collections.reverseOrder() 对原始数组（即int[] arr = 1, 2, 3;）进行反向排序，因为这些方法需要引用类型（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]

【参考方案7】：

Java 8：

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

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

【讨论】：

它适用于对象但不适用于基元。对于排序原语 int，您应该按 ASC 顺序排序，然后反转答案。

【参考方案8】：

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

Collections.sort(myArray);

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

Collections.reverse(myArray);

【参考方案9】：

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

ArrayUtils.reverse(array);

【讨论】：

为什么要先升序排序，然后再使用外部库恢复这个顺序，什么时候可以一步完成？

那一步是什么？

是的，但是（如这些答案的 cmets 所述）不适用于我的答案所针对的原语。当然，我的答案肯定不是最佳答案，但我发现它符合原作者强调的“简单”标准——即。 Arrays.sort(primitives); ArrayUtils.reverse(primitives);

【参考方案10】：

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

【参考方案11】：

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

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

【参考方案12】：

当数组是 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();

【参考方案13】：

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

其中 ma​​gnitude 是我的程序中数据类型为 double 的属性。这是我定义的类 freq 按其大小倒序排序。因此，为了纠正这个问题，您切换< 和> 返回的值。这为您提供以下内容：

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 接口的实现听起来让您望而生畏，我鼓励您不要那样想，实际上并非如此。这个link on how to implement comparable 让我的事情变得容易多了。希望人们可以使用此解决方案，并且您的快乐甚至会与我的可比。

【参考方案14】：

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

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

【参考方案15】：

我知道这是一个相当老的线程，但这里是整数和 Java 8 的更新版本：

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

注意正常升序是“o1 - o2”（或 Comparator.comparingInt()）。

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

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

【讨论】：

这仅适用于引用类型数组，不适用于原始类型数组。

【参考方案16】：

这里发生了很多混乱 - 人们建议非原始值的解决方案，尝试从地面实现一些排序算法，提供涉及额外库的解决方案，展示一些 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。如果您有一个非整数数组 - 使用相应的 object 而不是 Integer。

【讨论】：

我认为这是对原始数组进行逆序排序的最简单方法。

【参考方案17】：

这对我有用：

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

【参考方案18】：

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 等）的数组进行排序，只需更改“返回类型”、“参数” type”和变量“x”类型为对应的类型。也可以在 if 条件中将 ">=" 改为 "

【参考方案19】：

您可以将 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));

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

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

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

【参考方案20】：

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

【参考方案21】：

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

【参考方案22】：

有时我们练习一个例子很好，这是一个完整的例子：

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

正在编译...

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

source

【参考方案23】：

有一种方法可能会稍长一些，但效果很好。这是一种对 int 数组进行降序排序的方法。

希望有一天这会对某人有所帮助：

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;
    

【参考方案24】：

我有以下工作解决方案

    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;

【参考方案25】：

我知道这里有很多答案，但仍然认为，没有一个人尝试过使用核心 java。 而使用collection api，你最终会浪费很多内存和reeduals。

这是一个纯核心概念的尝试，是的，如果您更关心内存占用，这可能是更好的方法。

    int[] elements = new int [] 10,999,999,-58,548,145,255,889,1,1,4,5555,0,-1,-52;
    //int[] elements = null;
    
    if(elements != null && elements.length >1)
    
        int max = 0, index = 0;
        for(int i =0;i<elements.length;i++)//find out what is Max
        
            if(elements[i] > max)
                
                    max = elements[i];
                    index = i;
                
        
        elements[index] = elements[0];//Swap the places
        elements[0] = max;
        for(int i =0;i < elements.length;i++)//loop over element
        
            for(int j = i+1;j < elements.length;j++)//loop to compare the elements
            
                if(elements[j] > elements[i])
                
                    max = elements[j];
                    elements[j] = elements[i];
                    elements[i] = max;
                
            
        
        
    //i ended up using three loops and 2 extra variables
    System.out.println(Arrays.toString(elements));//if null it will print null
    // still love to learn more, please advise if we can do it better.

也喜欢向你学习！