Ordenar lista en orden ascendente en Java
Esta publicación discutirá varias formas de ordenar la lista en orden ascendente en Java. Suponga que la lista especificada es modificable pero no necesariamente redimensionable.
1. Usando Collections.sort() método
Collections la clase de utilidad proporciona una estática sort() método para clasificar la lista especificada en orden ascendente, según el orden natural de sus elementos.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
import java.util.Arrays; import java.util.Collections; import java.util.List; // Ordenar la lista en orden ascendente en Java class Main { public static void main(String[] args) { List<Integer> list = Arrays.asList(10, 4, 2, 6, 5, 8); Collections.sort(list); System.out.println(list); } } |
Resultado:
[2, 4, 5, 6, 8, 10]
Este método producirá una ordenación estable. Esto funcionará solo si todos los elementos de la lista implementan el Comparable interfaz y son mutuamente comparables, es decir, para cualquier par de elementos (a, b) en la lista, a.compareTo(b) no tira un ClassCastException.
2. Usando List.sort() método
Cada List implementación proporciona una estática sort() método que ordena la lista de acuerdo con el orden inducido por el especificado Comparator. Para que este método funcione, todos los elementos de la lista deben ser comparables entre sí mediante el comparador especificado.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
import java.util.Arrays; import java.util.Comparator; import java.util.List; // Ordenar la lista en orden ascendente en Java class Main { public static void main(String[] args) { List<Integer> list = Arrays.asList(10, 4, 2, 6, 5, 8); list.sort(Comparator.naturalOrder()); System.out.println(list); } } |
Resultado:
[2, 4, 5, 6, 8, 10]
Si el comparador especificado es nulo, todos los elementos de esta lista deben implementar el Comparable interfaz, y se utilizará el orden natural del elemento.
|
1 2 3 |
List<Integer> list = Arrays.asList(10, 4, 2, 6, 5, 8); list.sort(null); System.out.println(list); // [2, 4, 5, 6, 8, 10] |
3. Usando Java 8
ordenar un List se hizo aún más fácil con la introducción de Stream en Java 8 y superior. La idea es obtener un flujo que consiste en los elementos de la lista, ordenarlos en orden natural usando el Stream.sorted() método y finalmente recopilar todos los elementos ordenados en una lista usando Stream.collect() con Collectors.toList(). Para que la ordenación funcione, todos los elementos de la lista deben ser comparables entre sí.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; // Ordenar la lista en orden ascendente en Java class Main { public static void main(String[] args) { List<Integer> list = Arrays.asList(10, 4, 2, 6, 5, 8); list = list.stream() .sorted() .collect(Collectors.toList()); System.out.println(list); } } |
Resultado:
[2, 4, 5, 6, 8, 10]
4. Ordenar la lista de objetos
Collections.sort(list) y list.sort(null) El método funcionará solo si todos los elementos de la lista implementan el Comparable interfaz.
Por ejemplo, el siguiente código crea una lista de User y desde User la clase no implementa Comparable, el programa arrojará un error de compilación al llamar Collections.sort() y un ClassCastException en List.sort(null).
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
import java.util.Arrays; import java.util.Collections; import java.util.List; class User { private String name; public User(String name) { this.name = name; } @Override public String toString() { return name; } } class Main { public static void main(String[] args) { List<User> users = Arrays.asList(new User("John"), new User("Smith"), new User("Andrew")); Collections.sort(users); // Error de compilación System.out.println(users); } } |
Hay varias formas de ordenar una lista de Objetos:
1. Hacer que el Objeto implemente el Comparable interfaz y anular la compareTo() método.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 |
import java.util.Arrays; import java.util.Collections; import java.util.Comparator; import java.util.List; class Company implements Comparable<Company> { private String company; private int rank; public Company(String company, int rank) { this.company = company; this.rank = rank; } @Override public int compareTo(Company o) { return company.compareTo(o.company); } @Override public String toString() { return "{" + company + ", " + rank + "}"; } } // Ordenar la lista en orden ascendente en Java class Main { public static void main(String[] args) { List<Company> list = Arrays.asList(new Company("Google", 1), new Company("Apple", 3), new Company("Microsoft", 2)); // ordenar la lista según el orden natural del objeto Collections.sort(list); System.out.println(list); } } |
Resultado:
[{Apple, 3}, {Google, 1}, {Microsoft, 2}]
2. Pasa un Comparator hacia Collections.sort() método, que define cómo se ordenarán los objetos en la lista.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 |
import java.util.Arrays; import java.util.Collections; import java.util.Comparator; import java.util.List; class Company { private String company; private int rank; public Company(String company, int rank) { this.company = company; this.rank = rank; } @Override public String toString() { return "{" + company + ", " + rank + "}"; } public int getPrice() { return rank; } } // Ordenar la lista en orden ascendente en Java class Main { public static void main(String[] args) { List<Company> list = Arrays.asList(new Company("Google", 1), new Company("Apple", 3), new Company("Microsoft", 2)); // ordenar la lista según el orden personalizado definido por Comparator Collections.sort(list, new Comparator<Company>() { @Override public int compare(Company o1, Company o2) { return o1.getPrice() - o2.getPrice(); } }); System.out.println(list); } } |
Resultado:
[{Google, 1}, {Microsoft, 2}, {Apple, 3}]
3. Pase la expresión lambda a Collections.sort() método que define el orden de ordenación de la lista. Esto funcionará solo en Java 8 y superior.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
import java.util.Arrays; import java.util.Collections; import java.util.List; class Company { private String company; private int rank; public Company(String company, int rank) { this.company = company; this.rank = rank; } @Override public String toString() { return "{" + company + ", " + rank + "}"; } public int getPrice() { return rank; } } // Ordenar la lista en orden ascendente en Java 8 y superior class Main { public static void main(String[] args) { List<Company> list = Arrays.asList(new Company("Google", 1), new Company("Apple", 3), new Company("Microsoft", 2) ); // define el orden personalizado para ordenar una lista usando la expresión lambda Collections.sort(list, (o1, o2) -> o1.getPrice() - o2.getPrice()); System.out.println(list); } } |
Resultado:
[{Google, 1}, {Microsoft, 2}, {Apple, 3}]
Se trata de ordenar una lista en orden ascendente en Java.