Comment sortinger un ArrayList?

J’ai une liste de doubles dans java et je veux sortinger ArrayList dans l’ordre décroissant.

Input ArrayList est comme ci-dessous:

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

La sortie devrait être comme ça

 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 

 Collections.sort(testList); Collections.reverse(testList); 

Cela fera ce que vous voulez. N’oubliez pas d’importer les Collections cependant!

Voici la documentation pour les Collections .

Descendant:

 Collections.sort(mArrayList, new Comparator() { @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; } }); 

Utiliser la méthode util de la classe java.util.Collections , c.-à-d.

 Collections.sort(list) 

En fait, si vous voulez sortinger un object personnalisé, vous pouvez utiliser

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

voir les collections api

Pour votre exemple, cela fera la magie dans Java 8

 testList.sort(); 

Mais si vous voulez sortinger certains des champs de l’object que vous sortingez, vous pouvez le faire facilement en:

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

ou

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

ou

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

Sources: https://docs.oracle.com/javase/8/docs/api/java/util/Comparator.html

En utilisant lambdas (Java8), et en le dépouillant de la syntaxe la plus simple (la JVM en déduira beaucoup dans ce cas), vous obtenez:

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

Une version plus verbeuse:

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

L’utilisation d’un lambda est possible car l’interface Comparator ne dispose que d’une seule méthode à implémenter. La machine virtuelle peut donc déduire quelle méthode est implémentée. Comme les types des parameters peuvent être déduits, il n’est pas nécessaire de les indiquer (c.-à-d. (a, b) au lieu de (Double a, Double b) . Et comme le corps lambda ne comporte qu’une seule ligne et que la méthode est attendu de renvoyer une valeur, le return est déduit et les accolades ne sont pas nécessaires.

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

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

Remarque: les arguments du lambda sont échangés lorsqu’ils sont transmis à Double.compare pour garantir que le sorting est décroissant

Vous pouvez utiliser Collections.sort(list) pour sortinger la list si votre list contient des éléments Comparable . Sinon, je vous recommande de mettre en œuvre cette interface comme ici:

 public class Circle implements Comparable {} 

et bien sûr de réaliser votre propre méthode compareTo comme ici:

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

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

Collections.sort vous permet de passer une instance d’un Comparator qui définit la logique de sorting. Ainsi, au lieu de sortinger la liste dans l’ordre naturel et de l’inverser, on peut simplement passer Collections.reverseOrder() pour sort afin de sortinger 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 garantit que le sorting est stable (ce qui signifie que l’ordre des éléments ne sera pas modifié lorsqu’ils sont égaux en fonction du comparateur). alors que l’inversion changera l’ordre)

 //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(Ssortingng[] 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("Sorted Synchronized Array List..."+sd.name); }*/ // when iterating over a synchronized list, we need to synchronize access to the synchronized list synchronized (synchronizedList) { Iterator iterator = synchronizedList.iterator(); while (iterator.hasNext()) { log.info("Sorted Synchronized Array List Items: " + iterator.next().name); } } } } class Employee { Ssortingng name; Employee (Ssortingng name) { this.name = name; } } 

Si vous utilisez Java SE 8, cela pourrait vous aider.

 //create a comparator object using a Lambda expression Comparator 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); 

vous pouvez faire comme ça:

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

Collection dispose d’un comparateur par défaut qui peut vous aider.

De plus, si vous souhaitez utiliser de nouvelles fonctionnalités Java 8, vous pouvez faire comme ça:

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

| * | Trier une liste:

 import java.util.Collections; 

| => Trier Ordre Asc:

 Collections.sort(NamAryVar); 

| => Trier la commande Dsc:

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

| * | Inverser l’ordre de la liste:

 Collections.reverse(NamAryVar); 

Vous pouvez utiliser comme ça

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

Par exemple, j’ai une classe Person: nom de la chaîne, int age ==> constructeur nouvelle personne (nom, âge)

 import java.util.Collections; import java.util.ArrayList; import java.util.Arrays; public void main(Ssortingng[] args){ Person ibrahima=new Person("Timera",40); Person toto=new Person("Toto",35); Person alex=new Person("Alex",50); ArrayList myList=new ArrayList Collections.sort(myList, new Comparator() { @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.toSsortingng()); //[Person [name=Alex, age=50], Person [name=Timera, age=40], Person [name=Toto, age=35]] Collections.reverse(myList); System.out.println(myList.toSsortingng()); //[Person [name=Toto, age=35], Person [name=Timera, age=40], Person [name=Alex, age=50]] } 

Avec les collections Eclipse, vous pouvez créer une liste double primitive, la sortinger puis l’inverser pour la placer dans l’ordre décroissant. Cette approche éviterait de boxer les doubles.

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

Si vous voulez une List , les éléments suivants fonctionneraient.

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

Si vous souhaitez conserver le type ArrayList , vous pouvez initialiser et sortinger la liste à l’aide de la classe d’utilitaires ArrayListIterate , comme suit:

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

Note: Je suis un committer pour les collections Eclipse .

En JAVA 8 c’est beaucoup plus facile maintenant.

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

– Pour une utilisation inverse

.sorted (Comparator.reverseOrder ())

La ligne suivante devrait faire l’épaisseur

 testList.sort(Collections.reverseOrder()); 

Utilisez simplement la fonction loop ou default sort ().

 for(int n = 0; n< = arrList[i]; n++){ i