Wie sortiere ich eine ArrayList?

Absteigend:

Collections.sort(mArrayList, new Comparator<CustomData>() {
    @Override
    public int compare(CustomData lhs, CustomData rhs) {
        // -1 - less than, 1 - greater than, 0 - equal, all inversed for descending
        return lhs.customInt > rhs.customInt ? -1 : (lhs.customInt < rhs.customInt) ? 1 : 0;
    }
});

Verwenden Sie die util-Methode von Java.util.Collections class, d

Collections.sort(list)

Wenn Sie benutzerdefinierte Objekte sortieren möchten, können Sie sie verwenden

Collections.sort(List<T> list, Comparator<? super T> c) 

siehe Sammlungen api

In Ihrem Beispiel wird dies die Magie in Java 8 bewirken

List<Double> testList = new ArrayList();
testList.sort(Comparator.naturalOrder());

Wenn Sie jedoch nach einigen Feldern des zu sortierenden Objekts sortieren möchten, können Sie dies ganz einfach tun:

testList.sort(Comparator.comparing(ClassName::getFieldName));

oder 

 testList.sort(Comparator.comparing(ClassName::getFieldName).reversed());

oder

 testList.stream().sorted(Comparator.comparing(ClassName::getFieldName).reversed()).collect(Collectors.toList());

Quellen: https://docs.Oracle.com/javase/8/docs/api/Java/util/Comparator.html

Wenn Sie Lambdas (Java8) verwenden und die Syntax auf ein Minimum beschränken (die JVM wird viel in diesem Fall ableiten), erhalten Sie:

Collections.sort(testList, (a, b) -> b.compareTo(a));

Eine ausführlichere Version:

// Implement a reverse-order Comparator by lambda function
Comparator<Double> comp = (Double a, Double b) -> {
    return b.compareTo(a);
};

Collections.sort(testList, comp);

Die Verwendung eines Lambda ist möglich, da die Comparator-Schnittstelle nur eine einzige zu implementierende Methode hat, so dass VM auf die implementierende Methode schließen kann. Da die Typen der Parameter abgeleitet werden können, müssen sie nicht angegeben werden (dh (a, b) anstelle von (Double a, Double b)). Da der Lambda-Body nur eine einzige Zeile hat und die Methode voraussichtlich einen Wert zurückgibt, wird die return abgeleitet und die Zahnspangen sind nicht notwendig.

In Java8 gibt es eine Standardsortiermethode für die Listenschnittstelle, mit der Sie die Sammlung sortieren können, wenn Sie einen Comparator bereitstellen. Sie können das Beispiel in der Frage einfach wie folgt sortieren:

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

Hinweis: Die Argumente im Lambda werden bei der Übergabe an Double.compare ausgetauscht, um sicherzustellen, dass die Sortierung absteigend ist

Sie können Collections.sort(list) verwenden, um list zu sortieren, wenn Ihre listComparable-Elemente enthält. Ansonsten würde ich Ihnen empfehlen, diese Schnittstelle wie hier zu implementieren:

public class Circle implements Comparable<Circle> {}

und stellen Sie natürlich Ihre eigene Umsetzung der compareTo-Methode wie hier dar:

@Override
    public int compareTo(Circle another) {
        if (this.getD()<another.getD()){
            return -1;
        }else{
            return 1;
        }
    }

Und dann können Sie wieder Colection.sort(list) verwenden, da jetzt die Liste Objekte vom Typ Comparable enthält und sortiert werden kann. Die Reihenfolge hängt von der compareTo-Methode ab. Weitere Informationen finden Sie unter https://docs.Oracle.com/javase/tutorial/collections/interfaces/order.html .

Mit Collections.sort können Sie eine Instanz einer Comparator übergeben, die die Sortierlogik definiert. Anstatt die Liste in natürlicher Reihenfolge zu sortieren und dann umzukehren, können Sie 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 der umgekehrte Sortiervergleich dafür, dass die Sortierung stabil ist (abgesehen davon, dass sie idiotischer (und möglicherweise effizienter ist)). Dies bedeutet, dass die Reihenfolge der Elemente nicht geändert wird, wenn sie gemäß dem Vergleicher gleich sind. während das Umkehren die Reihenfolge ändert)

//Here is sorted List alphabetically with syncronized

package 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<Employee> synchronizedList = Collections.synchronizedList(new ArrayList<Employee>());
        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("Sorted Synchronized Array List..."+sd.name);
    }*/

        // when iterating over a synchronized list, we need to synchronize access to the synchronized list
        synchronized (synchronizedList) {
            Iterator<Employee> iterator = synchronizedList.iterator();
            while (iterator.hasNext()) {
                log.info("Sorted Synchronized Array List Items: " + iterator.next().name);
            }
        }

    }
}

class Employee {
    String name;

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

    }
}

wenn Sie Java SE 8 verwenden, kann dies hilfreich sein.

//create a comparator object using a Lambda expression
Comparator<Double> compareDouble = (d1, d2) -> d1.compareTo(d2);

//Sort the Collection in this case 'testList' in reverse order
Collections.sort(testList, Collections.reverseOrder(compareDouble));

//print the sorted list using method reference only applicable in SE 8
testList.forEach(System.out::println);

| * | Sortieren einer Liste:

import Java.util.Collections;

| => Reihenfolge sortieren:

Collections.sort(NamAryVar);

| => Sortiere DSC-Reihenfolge:

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

| * | Die Reihenfolge der Liste umkehren:

Collections.reverse(NamAryVar);

das kannst du so machen:

    List<String> yourList = new ArrayList<String>();
    Collections.sort(yourList, Collections.reverseOrder());

Collection verfügt über einen Standardvergleicher, der Ihnen dabei helfen kann.

Wenn Sie einige neue Java 8-Funktionen verwenden möchten, können Sie Folgendes tun:

List<String> yourList = new ArrayList<String>();
yourList = yourList.stream().sorted(Collections.reverseOrder()).collect(Collectors.toList());

Sie können so verwenden 

              ArrayList<Group> groupList = new ArrayList<>();
              Collections.sort(groupList, Collections.reverseOrder());
              Collections.reverse(groupList);

Zum Beispiel habe ich eine Klasse Person: String name, int alter ==> Konstruktor neue Person (Name, Alter) 

import Java.util.Collections;
import Java.util.ArrayList;
import Java.util.Arrays;


public void main(String[] args){
    Person ibrahima=new Person("Timera",40);
    Person toto=new Person("Toto",35);
    Person alex=new Person("Alex",50);
    ArrayList<Person> myList=new ArrayList<Person>
    Collections.sort(myList, new Comparator<Person>() {
        @Override
        public int compare(Person p1, Person p2) {
            // return p1.age+"".compareTo(p2.age+""); //sort by age
            return p1.name.compareTo(p2.name); // if you want to short by name
        }
    });
    System.out.println(myList.toString());
    //[Person [name=Alex, age=50], Person [name=Timera, age=40], Person [name=Toto, age=35]]
    Collections.reverse(myList);
    System.out.println(myList.toString());
    //[Person [name=Toto, age=35], Person [name=Timera, age=40], Person [name=Alex, age=50]]

}

Die folgende Zeile sollte das dicke tun

testList.sort(Collections.reverseOrder());

In Java 8 ist es jetzt sehr einfach.

List<String> alphaNumbers = Arrays.asList("one", "two", "three", "four");
List<String> alphaNumbersUpperCase = alphaNumbers.stream()
    .map(String::toUpperCase)
    .sorted()
    .collect(Collectors.toList());
System.out.println(alphaNumbersUpperCase); // [FOUR, ONE, THREE, TWO]

- Für die umgekehrte Verwendung

.sorted(Comparator.reverseOrder())

Mit Eclipse Collections können Sie eine primitive Doppelliste erstellen, sortieren und dann in absteigender Reihenfolge umkehren. Dieser Ansatz würde das Boxen der Doppel vermeiden. 

MutableDoubleList doubleList =
    DoubleLists.mutable.with(
        0.5, 0.2, 0.9, 0.1, 0.1, 0.1, 0.54, 0.71,
        0.71, 0.71, 0.92, 0.12, 0.65, 0.34, 0.62)
        .sortThis().reverseThis();
doubleList.each(System.out::println);

Wenn Sie einen List<Double> wünschen, funktioniert Folgendes.

List<Double> objectList =
    Lists.mutable.with(
        0.5, 0.2, 0.9, 0.1, 0.1, 0.1, 0.54, 0.71,
        0.71, 0.71, 0.92, 0.12, 0.65, 0.34, 0.62)
        .sortThis(Collections.reverseOrder());
objectList.forEach(System.out::println);

Wenn Sie den Typ als ArrayList<Double> beibehalten möchten, können Sie die Liste mithilfe der Dienstklasse ArrayListIterate wie folgt initialisieren und sortieren:

ArrayList<Double> arrayList =
    ArrayListIterate.sortThis(
            new ArrayList<>(objectList), Collections.reverseOrder());
arrayList.forEach(System.out::println);

Hinweis: Ich bin Committer für Eclipse Collections .

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

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