Wie sortiere ich eine Liste/ArrayList?

Question

Ich habe eine Liste von doubles in Java und möchte das ArrayList in absteigender Reihenfolge sortieren.

Die Eingabe-ArrayList sieht wie folgt aus:

List testList = new ArrayList();

testList.add(0.5);
testList.add(0.2);
testList.add(0.9);
testList.add(0.1);
testList.add(0.1);
testList.add(0.1);
testList.add(0.54);
testList.add(0.71);
testList.add(0.71);
testList.add(0.71);
testList.add(0.92);
testList.add(0.12);
testList.add(0.65);
testList.add(0.34);
testList.add(0.62);

Das Ergebnis sollte so aussehen:

0.92
0.9
0.71
0.71
0.71
0.65
0.62
0.54
0.5
0.34
0.2
0.12
0.1
0.1
0.1

Answer 1

Mit Java8 gibt es eine Standard-Sortiermethode auf der List-Schnittstelle, mit der Sie die Sammlung sortieren können, wenn Sie einen Comparator bereitstellen. Sie können das Beispiel in der Frage wie folgt einfach sortieren:

testList.sort((a, b) -> Double.compare(b, a));

Hinweis: Die Argumente in der Lambda werden vertauscht, wenn sie an Double.compare übergeben werden, um sicherzustellen, dass die Sortierung absteigend ist.

Answer 2

Hier ist ein kurzes Merkblatt, das typische Fälle abdeckt:

import static java.util.Comparator.comparing;

// sort
list.sort(naturalOrder());

// sort (reversed)
list.sort(reverseOrder());

// sort by field
list.sort(comparing(Type::getField));

// sort by field (reversed)
list.sort(comparing(Type::getField).reversed());

// sort by int field
list.sort(comparingInt(Type::getIntField));

// sort by double field (reversed)
list.sort(comparingDouble(Type::getDoubleField).reversed());

// sort by nullable field (nulls last)
list.sort(comparing(Type::getNullableField, nullsLast(naturalOrder())));

// two-level sort
list.sort(comparing(Type::getField1).thenComparing(Type::getField2));

Answer 3

Sie können Collections.sort(list) verwenden, um list zu sortieren, wenn Ihre list Comparable-Elemente enthält. Andernfalls empfehle ich Ihnen, dieses Interface selbst zu implementieren, wie hier:

public class Circle implements Comparable {}

und natürlich Ihre eigene Realisierung der Methode compareTo bereitzustellen, wie hier:

@Override
    public int compareTo(Circle another) {
        if (this.getD()

``

Und dann können Sie Colection.sort(list) erneut verwenden, da die Liste jetzt Objekte vom Typ Comparable enthält und sortiert werden kann. Die Reihenfolge hängt von der Methode compareTo ab. Überprüfen Sie diese https://docs.oracle.com/javase/tutorial/collections/interfaces/order.html für weitere detaillierte Informationen.

``

Answer 4

Collections.sort ermöglicht es Ihnen, eine Instanz eines Comparator zu übergeben, der die Sortierlogik definiert. Anstatt die Liste in natürlicher Reihenfolge zu sortieren und dann umzukehren, kann man einfach Collections.reverseOrder() an sort übergeben, um die Liste in umgekehrter Reihenfolge zu sortieren:

// import java.util.Collections;
Collections.sort(testList, Collections.reverseOrder());

Wie von @Marco13 erwähnt, sorgt die Verwendung des Comparator für die umgekehrte Reihenfolge nicht nur für eine idiomatischere (und möglicherweise effizientere) Lösung, sondern stellt auch sicher, dass die Sortierung stabil ist (d. h. die Reihenfolge der Elemente wird nicht geändert, wenn sie gemäß des Comparators gleich sind, während die Umkehrung die Reihenfolge ändern würde)

Answer 5

//Hier ist die alphabetisch sortierte Liste mit Synchronisierung

Paket com.mnas.technology.automation.utility;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;

import org.apache.log4j.Logger;

/**
 * @author manoj.kumar
 */
public class SynchronizedArrayList {
    static Logger log = Logger.getLogger(SynchronizedArrayList.class.getName());

    @SuppressWarnings("unchecked")
    public static void main(String[] args) {

        List synchronizedList = Collections.synchronizedList(new ArrayList());
        synchronizedList.add(new Employee("Aditya"));
        synchronizedList.add(new Employee("Siddharth"));
        synchronizedList.add(new Employee("Manoj"));
        Collections.sort(synchronizedList, new Comparator() {
            public int compare(Object synchronizedListOne, Object synchronizedListTwo) {
                //use instanceof to verify the references are indeed of the type in question
                return ((Employee) synchronizedListOne).name
                        .compareTo(((Employee) synchronizedListTwo).name);
            }
        }); 
    /*for( Employee sd : synchronizedList) {
    log.info("Sortierte synchronisierte Array Liste..."+sd.name);
    }*/

        // Beim Iterieren über eine synchronisierte Liste müssen wir den Zugriff auf die synchronisierte Liste synchronisieren
        synchronized (synchronizedList) {
            Iterator iterator = synchronizedList.iterator();
            while (iterator.hasNext()) {
                log.info("Sortierte synchronisierte Array Listenpunkte: " + iterator.next().name);
            }
        }

    }
}

class Employee {
    String name;

    Employee(String name) {
        this.name = name;

    }
}