Java 數組降序？

Question

有沒有什么簡單的方法可以像Arrays class中的升序一樣對數組進行降序排序？

還是我必須停止懶惰並自己做：[

Answer 1

您可以使用它對所有類型的對象進行排序

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

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

Arrays.sort()不能直接用於按降序對原始數組進行排序。 如果您嘗試通過傳遞Collections.reverseOrder()定義的反向 Comparator 來調用Arrays.sort()方法，則會拋出錯誤

找不到適合 sort(int[],comparator) 的方法

這將適用於“對象數組”，例如整數數組，但不適用於原始數組，例如 int 數組。

按降序對原始數組進行排序的唯一方法是，首先按升序對數組進行排序，然后將數組原地反轉。 對於二維原始數組也是如此。

Answer 2

一份清單

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

對於數組

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

Answer 3

你可以使用這個：

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

Collections.reverseOrder()使用逆自然順序返回一個Comparator 。 您可以使用Collections.reverseOrder(myComparator)獲得您自己的比較器的反轉版本。

Answer 4

另一種可能是（對於數字！！！）

1. 將數組乘以 -1
2. 種類
3. 再次乘以-1

字面意思：

array = -Arrays.sort(-array)

Answer 5

沒有顯式比較器：

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

使用顯式比較器：

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

Answer 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]

Answer 7

爪哇 8：

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

更新： reversed()反轉指定的比較器。 通常，比較器按升序排列，因此這會將順序更改為降序。

Answer 8

首先，您需要使用以下方法對數組進行排序：

Collections.sort(myArray);

然后，您需要使用以下方法將順序從升序反轉為降序：

Collections.reverse(myArray);

Answer 9

對於包含基元元素的數組，如果有org.apache.commons.lang(3)可以使用，那么反轉數組（排序后org.apache.commons.lang(3)的簡單方法是使用：

ArrayUtils.reverse(array);

Answer 10

我不知道您的用例是什么，但是除了這里的其他答案之外，另一個（懶惰的）選項仍然是按照您的指示按升序排序，然后以相反的順序迭代。

Answer 11

另一個解決方案是，如果您使用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 接口的實現對您來說聽起來令人生畏，我鼓勵您不要那樣想，實際上並非如此。 這個關於如何實現可比性的鏈接讓我更容易。 希望大家能用上這個方案，希望你們的快樂能和我的一樣。

Answer 12

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

要么

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

Answer 13

對於上面的討論，這里有一個簡單的例子來按降序對原始數組進行排序。

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

Answer 14

我知道這是一個很舊的線程，但這里是整數和 Java 8 的更新版本：

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

請注意，對於正常的升序（或 Comparator.comparingInt()），它是“o1 - o2”。

這也適用於任何其他類型的對象。 說：

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

Answer 15

這里有很多混亂 - 人們建議非原始值的解決方案，嘗試從地面實施一些排序算法，提供涉及額外庫的解決方案，炫耀一些黑客等。原始問題的答案是 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 。

Answer 16

當數組是 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();

Answer 17

對於按降序排序的二維數組，您只需翻轉參數的位置

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

Answer 18

這對我有用：

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

Answer 19

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 條件中將 ">=" 更改為 "<=" 以使順序升序。

Answer 20

您可以將流操作（ 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 等）。

Answer 21

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

Answer 22

比較器的另一種方式

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

Answer 23

有時我們練習一個例子很好，這是一個完整的例子：

排序描述文件

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

來源

Answer 24

有一種方法可能會更長一點，但效果很好。 這是一種對 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;
    
}

Answer 25

我有以下工作解決方案

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

Answer 26

我知道這里有很多答案，但仍然認為，他們都沒有嘗試使用核心 java。 並且使用 collection api ，你最終會浪費這么多內存和剩余資源。

這是純核心概念的嘗試，是的，如果您更關心內存占用，這可能是更好的方法。

    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.

也喜歡向你學習！

Answer 27

這是我對原始類型 int 數組進行排序的方式。

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

結果：

[1, 4, 7, 9]

Answer 28

在這里為幾個不同的場景添加我的答案對於一個數組

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

FWIW 列表

Lists.reverse(a);

任何和所有 Collections

Collections.reverse(a);