Java Array Absteigend sortieren?

Gibt es eine EINFACHE Möglichkeit, ein Array in absteigender Reihenfolge zu sortieren, so wie es in aufsteigender Reihenfolge sortiert ist? Arrays-Klasse ?

Oder muss ich aufhören faul zu sein und das selbst tun: [

Sie können dies verwenden, um alle Arten von Objekten zu sortieren

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

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

Arrays.sort()kann nicht direkt verwendet werden, um primitive Arrays in absteigender Reihenfolge zu sortieren. Wenn Sie versuchen, die Arrays.sort()Methode durch Übergeben des von definierten umgekehrten Komparators aufzurufen Collections.reverseOrder(), wird der Fehler ausgegeben

Keine geeignete Methode zum Sortieren gefunden (int [], Komparator)

Dies funktioniert gut mit 'Array of Objects' wie dem Integer-Array, aber nicht mit einem primitiven Array wie dem int-Array.

Die einzige Möglichkeit, ein primitives Array in absteigender Reihenfolge zu sortieren, besteht darin, das Array zuerst in aufsteigender Reihenfolge zu sortieren und dann das Array an Ort und Stelle umzukehren. Dies gilt auch für zweidimensionale primitive Arrays.

für eine Liste

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

für ein Array

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

Sie können dies verwenden:

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

Collections.reverseOrder()Gibt a Comparatormit der umgekehrten natürlichen Reihenfolge zurück. Sie können eine invertierte Version Ihres eigenen Komparators mit erhalten Collections.reverseOrder(myComparator).

eine Alternative könnte sein (für Zahlen !!!)

1. Multiplizieren Sie das Array mit -1
2. Sortieren
3. noch einmal mit -1 multiplizieren

Wörtlich gesprochen:

array = -Arrays.sort(-array)

ohne expliziten Komparator:

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

mit explizitem Komparator:

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

Java 8:

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

Update: reversed()Kehrt den angegebenen Komparator um. Normalerweise sortieren die Komparatoren in aufsteigender Reihenfolge, sodass die Reihenfolge in absteigender Reihenfolge geändert wird.

Für ein Array, das Elemente von Grundelementen enthält, wenn eine org.apache.commons.lang(3)einfache Möglichkeit zum Umkehren des Arrays (nach dem Sortieren) zur Verfügung steht, verwenden Sie:

ArrayUtils.reverse(array);

Zuerst müssen Sie Ihr Array sortieren mit:

Collections.sort(Myarray);

Dann müssen Sie die Reihenfolge von aufsteigend nach absteigend umkehren, indem Sie:

Collections.reverse(Myarray);

Ich weiß nicht, was Ihr Anwendungsfall war, aber zusätzlich zu anderen Antworten hier besteht eine andere (faule) Option darin, weiterhin in aufsteigender Reihenfolge zu sortieren, wie Sie angeben, und dann stattdessen in umgekehrter Reihenfolge zu iterieren .

Es ist nicht direkt möglich, ein Array von Grundelementen (dh int[] arr = {1, 2, 3};) mit Arrays.sort()und umzukehren, Collections.reverseOrder()da für diese Methoden Referenztypen ( Integer) anstelle von Grundelementtypen ( ) erforderlich sindint ) .

Wir können jedoch Java 8 Stream verwenden, um das Array zuerst in umgekehrter Reihenfolge zu sortieren:

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

Eine andere Lösung ist, wenn Sie das Vergleichbare verwenden Schnittstelle können Sie die Ausgangswerte umschalten , die Sie in Ihrem compareTo angegeben hatte (Object bCompared).

Zum Beispiel :

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

Wobei Größe ein Attribut mit dem Datentyp double in meinem Programm ist. Dies wurde meine definierte Klasse Sortierung Freq in umgekehrter Reihenfolge durch die Größe. Um dies zu korrigieren, wechseln Sie die vom <und zurückgegebenen Werte >. Dies gibt Ihnen Folgendes:

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

Um dieses compareTo zu nutzen, rufen wir einfach auf, Arrays.sort(mFreq)wodurch Sie das sortierte Array erhaltenfreq [] mFreq .

Das Schöne (meiner Meinung nach) an dieser Lösung ist, dass damit benutzerdefinierte Klassen sortiert werden können, und noch mehr, um sie nach einem bestimmten Attribut zu sortieren. Wenn die Implementierung einer vergleichbaren Schnittstelle für Sie entmutigend klingt, würde ich Sie ermutigen, nicht so zu denken, das ist es tatsächlich nicht. Dieser Link zur Implementierung vergleichbarer Dinge hat mir die Arbeit erheblich erleichtert. Hoffende Personen können von dieser Lösung Gebrauch machen, und Ihre Freude wird sogar mit meiner vergleichbar sein .

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

oder

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

Ich weiß, dass dies ein ziemlich alter Thread ist, aber hier ist eine aktualisierte Version für Integers und Java 8:

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

Beachten Sie, dass es "o1 - o2" für die normale aufsteigende Reihenfolge (oder Comparator.comparingInt ()) ist.

Dies funktioniert auch für alle anderen Arten von Objekten. Sagen:

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

Das hat bei mir funktioniert:

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

Ausgabe:

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

Verwenden Sie einfach diese Methode, um ein Array vom Typ double in absteigender Reihenfolge zu sortieren. Sie können damit Arrays anderer Typen (wie int, float usw.) sortieren, indem Sie einfach den "Rückgabetyp", den "Argumenttyp" und ändern die Variable "x" Typ auf den entsprechenden Typ. Sie können "> =" auch in der if-Bedingung in "<=" ändern, um die Reihenfolge aufsteigend zu gestalten.

Sie können Stream- Operationen ( Collections.stream () ) mit Comparator.reverseOrder () verwenden. .

Angenommen, Sie haben diese Sammlung:

List<String> items = new ArrayList<>();
items.add("item01");
items.add("item02");
items.add("item03");
items.add("item04");
items.add("item04");

Um die Elemente in ihrer "natürlichen" Reihenfolge zu drucken, können Sie die sorted () -Methode verwenden (oder sie weglassen und das gleiche Ergebnis erzielen):

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

Oder um sie in absteigender (umgekehrter) Reihenfolge zu drucken, können Sie die sortierte Methode verwenden, die einen Komparator verwendet, und die Reihenfolge umkehren:

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

Beachten Sie, dass für die Auflistung Comparable implementiert sein muss (wie Integer, String usw.).

Hier ist viel los - die Leute schlagen Lösungen für nicht-primitive Werte vor, versuchen, einige Sortieralgen vom Boden aus zu implementieren, geben Lösungen mit zusätzlichen Bibliotheken, zeigen einige hackige usw. Die Antwort auf die ursprüngliche Frage lautet 50 / 50. Für diejenigen, die nur kopieren / einfügen möchten:

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

arrOfObjectsist {6,5,4,3,2,1}jetzt. Wenn Sie ein Array mit etwas anderem als Ints haben, verwenden Sie stattdessen das entsprechende ObjektInteger .

Für die obigen Diskussionen ist hier ein einfaches Beispiel, um die primitiven Arrays in absteigender Reihenfolge zu sortieren.

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

Ausgabe:

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

Einfache Methode zum Sortieren eines absteigenden int-Arrays:

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

Ein anderer Weg mit 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()  );