java - sort - ¿Cómo ordenar un ArrayList?

ordenar un array java

Question

Tengo una lista de dobles en java y quiero ordenar ArrayList en orden descendente.

La entrada ArrayList es la siguiente:

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

La salida debe 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

Answer 1

Con Eclipse Collections puede crear una doble lista 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<Double> , lo siguiente funcionaría.

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

Si desea mantener el tipo como ArrayList<Double> , puede inicializar y ordenar la lista utilizando la clase de utilidad ArrayListIterate siguiente manera:

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

Nota: Soy un comendador de Eclipse Collections .

Answer 2

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 la clasificación sea descendente

Answer 3

Descendente

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

Answer 4

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

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]

- Para uso inverso este.

.sorted (Comparator.reverseOrder ())

Answer 5

La siguiente línea debe hacer el grueso

testList.sort(Collections.reverseOrder());

Answer 6

Para tu ejemplo, esto hará la magia en Java 8.

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

Pero si desea ordenar algunos de los campos del objeto que está clasificando, puede hacerlo fácilmente:

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

o

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

o

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

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

Answer 7

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

Answer 8

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<Circle> {}

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

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

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

Answer 9

Puedes usar asi

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

Answer 10

Si está utilizando Java SE 8, esto podría ser de ayuda.

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

Answer 11

Simplemente use la función de bucle o orden por defecto ().

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

Answer 12

Usando lambdas (Java8), y eliminando la sintaxis (la JVM infiere bastante 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<Double> 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 tiene un solo método para implementar, por lo que la VM puede inferir qué método está implementando. Dado que los tipos de parámetros se pueden inferir, no es necesario indicarlos (es decir, (a, b) lugar de (Double a, Double b) . Y dado que el cuerpo lambda tiene una sola línea, el método es Se espera que devuelva un valor, el return se infiere y las llaves no son necesarias.

Answer 13

Utilice 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<T> list, Comparator<? super T> c)

ver colecciones api

Answer 14

puedes hacer así:

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

La colección tiene un comparador predeterminado que puede ayudarte con eso.

Además, si desea utilizar algunas características nuevas de Java 8, puede hacerlo de la siguiente manera:

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

Answer 15

| * | Ordenar una lista:

import java.util.Collections;

| => Ordenar Asc Orden:

Collections.sort(NamAryVar);

| => Ordenar Dsc Orden:

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

| * | Invertir el orden de la lista:

Collections.reverse(NamAryVar);

Answer 16

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

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

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

Answer 17

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

Answer 18

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

Eso hará lo que quieras. Recuerda importar Collections aunque!

Aquí está la documentación para las Collections .