¿Cómo ordenar una ArrayList?

Tengo una Lista de dobles en Java y quiero ordenar ArrayList en orden descendente.

Input ArrayList es como a continuación:

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

El out put debería ser así

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

Eso hará lo que quieras. ¡Recuerde importar Collections aunque!

Aquí está la documentación para Collections .

Descendente:

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

Use el método util de la clase java.util.Collections , es decir,

 Collections.sort(list) 

De hecho, si desea ordenar un objeto personalizado, puede usar

 Collections.sort(List list, Comparator c) 

ver colecciones api

Para su ejemplo, esto hará la magia en Java 8

 testList.sort(); 

Pero si desea ordenar por algunos de los campos del objeto que está ordenando, puede hacerlo fácilmente de la siguiente manera:

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

o

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

o

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

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

Usando lambdas (Java8), y quitándolo de la syntax básica (la JVM inferirá mucho en este caso), obtienes:

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

Una versión más detallada:

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

El uso de un lambda es posible porque la interfaz del Comparador solo tiene un método único para implementar, por lo que la máquina virtual puede inferir qué método se está implementando. Como los tipos de los params se pueden inferir, no es necesario establecerlos (es decir, (a, b) lugar de (Double a, Double b) . Y dado que el cuerpo lambda tiene solo una línea, y el método es se espera que devuelva un valor, el return se deduce y las llaves no son necesarias.

Con Java8 hay un método de clasificación predeterminado en la interfaz de la Lista que le permitirá ordenar la colección si proporciona un Comparador. Puede ordenar fácilmente el ejemplo en la pregunta de la siguiente manera:

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

Nota: los argumentos en la lambda se intercambian cuando se pasan a Double.compare para garantizar que el orden sea descendente

Puede usar Collections.sort(list) para ordenar la list si su list contiene elementos Comparable . De lo contrario, te recomendaría implementar esa interfaz como aquí:

 public class Circle implements Comparable {} 

y por supuesto, proporcione su propia realización del método compareTo como aquí:

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

Y luego puede volver a utilizar Colection.sort(list) ya que ahora la lista contiene objetos del tipo Comparable y se puede ordenar. El orden depende del método compareTo . Consulte este https://docs.oracle.com/javase/tutorial/collections/interfaces/order.html para obtener información más detallada.

Collections.sort permite pasar una instancia de un Comparator que define la lógica de clasificación. Por lo tanto, en lugar de ordenar la lista en orden natural y luego invertirla, simplemente puede pasar Collections.reverseOrder() para sort y sort en orden inverso:

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

Como mencionó @ Marco13, además de ser más idiomático (y posiblemente más eficiente), el uso del comparador de orden inverso asegura que el orden sea estable (lo que significa que el orden de los elementos no cambiará cuando sean iguales según el comparador, mientras que invertir cambiará el orden)

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

si está utilizando Java SE 8, puede ser de ayuda.

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

puedes hacer esto:

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

Collection tiene un Comparador predeterminado que puede ayudarlo con eso.

Además, si desea utilizar algunas características nuevas de Java 8, puede hacer eso:

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

| * | Ordenar una lista:

 import java.util.Collections; 

| => Ordenar Asc Ordenar:

 Collections.sort(NamAryVar); 

| => Ordenar orden Dsc:

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

| * | Invierta el orden de la lista:

 Collections.reverse(NamAryVar); 

Puedes usar eso

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

Por ejemplo, tengo una clase Person: String name, int age ==> Constructor new Person (name, age)

 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 Eclipse Collections puede crear una lista doble primitiva, ordenarla y luego invertirla para ponerla en orden descendente. Este enfoque evitaría boxear los dobles.

 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 desea una List , entonces lo siguiente funcionaría.

 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 desea mantener el tipo como ArrayList , puede inicializar y ordenar la lista utilizando la clase de utilidad ArrayListIterate siguiente manera:

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

Nota: soy un committer para las colecciones de Eclipse .

En JAVA 8 es mucho más fácil ahora.

 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] 

– Para uso inverso, esto

.sorted (Comparator.reverseOrder ())

La siguiente línea debería hacer el grueso

 testList.sort(Collections.reverseOrder()); 

Simplemente use la función loop (bucle) o default sort ().

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