Come ordinare un ArrayList?

Ho una lista di doppi in java e voglio ordinare ArrayList in ordine decrescente.

Input ArrayList è il seguente:

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

L’out put dovrebbe essere così

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

Questo farà quello che vuoi. Ricordati di importare le Collections !

Ecco la documentazione per le Collections .

Discendente:

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

Utilizzare il metodo util della class java.util.Collections , ad es

 Collections.sort(list) 

In effetti, se vuoi ordinare un object personalizzato puoi usare

 Collections.sort(List list, Comparator c) 

vedi collezioni api

Per il tuo esempio, questo farà la magia in Java 8

 testList.sort(); 

Ma se vuoi ordinare da alcuni campi dell’object che stai ordinando, puoi farlo facilmente:

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

o

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

o

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

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

Usando lambdas (Java8) e riducendolo al minimo della syntax (la JVM dedurrà molto in questo caso), otterrai:

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

Una versione più dettagliata:

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

L’uso di una lambda è ansible perché l’interfaccia di Comparator ha solo un singolo metodo da implementare, quindi la VM può dedurre quale metodo sta implementando. Dato che i tipi di parametri possono essere dedotti, non è necessario che siano dichiarati (cioè (a, b) invece di (Double a, Double b) e poiché il corpo lambda ha solo una singola linea e il metodo è si prevede che restituisca un valore, il risultato viene inferito e le parentesi non sono necessarie.

Con Java8 è disponibile un metodo di ordinamento predefinito nell’interfaccia Elenco che consente di ordinare la raccolta se si fornisce un comparatore. Puoi facilmente ordinare l’esempio nella domanda come segue:

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

Nota: gli argomenti nel lambda vengono scambiati quando vengono passati a Double.compare per assicurare che l’ordinamento sia discendente

È ansible utilizzare Collections.sort(list) per ordinare l’ list se l’ list contiene elementi Comparable . Altrimenti ti consiglierei di implementare questa interfaccia come qui:

 public class Circle implements Comparable {} 

e ovviamente fornisci la tua realizzazione del metodo compareTo come qui:

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

E poi puoi usare nuovamente Colection.sort(list) come ora l'elenco contiene oggetti di tipo Comparable e può essere ordinato. L'ordine dipende dal metodo di confronto. Controlla questo https://docs.oracle.com/javase/tutorial/collections/interfaces/order.html per informazioni più dettagliate.

Collections.sort consente di passare un’istanza di un Comparator che definisce la logica di ordinamento. Quindi, invece di ordinare la lista in ordine naturale e poi invertirla, si può semplicemente passare a Collections.reverseOrder() per sort per ordinare la lista in ordine inverso:

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

Come menzionato da @ Marco13, oltre ad essere più idiomatico (e possibilmente più efficiente), l’uso del comparatore di ordine inverso fa sì che l’ordinamento sia stabile (nel senso che l’ordine degli elementi non verrà modificato quando sono uguali secondo il comparatore, considerando che l’inversione cambierà l’ordine)

 //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 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 { String name; Employee (String name) { this.name = name; } } 

se stai usando Java SE 8, questo potrebbe essere d’aiuto.

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

puoi fare così:

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

La raccolta ha un comparatore predefinito che può aiutarti in questo.

Inoltre, se vuoi utilizzare alcune nuove funzionalità di Java 8, puoi farlo in questo modo:

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

| * | Ordinamento di una lista:

 import java.util.Collections; 

| => Ordina Asc Ordine:

 Collections.sort(NamAryVar); 

| => Ordina ordine Dsc:

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

| * | Invertire l’ordine della lista:

 Collections.reverse(NamAryVar); 

Puoi usare così

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

Ad esempio, ho una class Persona: Nome stringa, età ==> Costruttore nuova persona (nome, età)

 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 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.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]] } 

Con le raccolte di Eclipse è ansible creare una doppia lista primitiva, ordinarla e quindi invertirla per metterla in ordine decrescente. Questo approccio eviterebbe di inscatolare il doppio.

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

Se vuoi una List , allora funzionerà il seguente.

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

Se si desidera mantenere il tipo come ArrayList , è ansible inizializzare e ordinare l’elenco utilizzando la class di utility ArrayListIterate come segue:

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

Nota: sono un committer per le raccolte di Eclipse .

In JAVA 8 è molto facile ora.

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

– Per l’uso inverso questo

.sorted (Comparator.reverseOrder ())

La seguente linea dovrebbe fare lo spessore

 testList.sort(Collections.reverseOrder()); 

Basta usare la funzione loop o default sort ().

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