Comment trier une liste/un tableau ?

Question

J'ai une liste de doubles en java et je veux trier ArrayList en ordre décroissant.

L'entrée ArrayList est comme ci-dessous :

List<Double> 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);

Le résultat devrait être le suivant

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

Avec Java8, il existe une méthode de tri par défaut sur l'interface List qui vous permettra de trier la collection si vous fournissez un comparateur. Vous pouvez facilement trier l'exemple de la question comme suit :

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

Note : les arguments dans le lambda sont échangés lorsqu'ils sont passés à Double.compare pour s'assurer que le tri est descendant.

Answer 2

Voici une courte fiche technique qui couvre les cas typiques :

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

Vous pouvez utiliser Collections.sort(list) de trier list si votre list contient Comparable éléments. Sinon, je vous recommande d'implémenter cette interface comme ici :

public class Circle implements Comparable<Circle> {}

et bien sûr, fournissez votre propre réalisation de compareTo méthode comme ici :

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

Et puis vous pouvez à nouveau utiliser Colection.sort(list) car maintenant la liste contient des objets de type Comparable et peut être triée. L'ordre dépend de compareTo méthode. Vérifiez ceci https://docs.oracle.com/javase/tutorial/collections/interfaces/order.html pour des informations plus détaillées.

Answer 4

Collections.sort vous permet de passer une instance d'un Comparator qui définit la logique de tri. Ainsi, au lieu de trier la liste dans l'ordre naturel et de l'inverser ensuite, on peut simplement faire passer Collections.reverseOrder() a sort afin de trier la liste dans l'ordre inverse :

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

Comme mentionné par @Marco13, en plus d'être plus idiomatique (et peut-être plus efficace), l'utilisation du comparateur d'ordre inverse permet de s'assurer que le tri est stable (c'est-à-dire que l'ordre des éléments ne sera pas modifié lorsqu'ils sont égaux selon le comparateur, alors que l'inversion modifiera l'ordre).

Answer 5

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

    }
}