1. Información general
En este tutorial, discutiremos métodos comunes para ordenar matrices en orden ascendente y descendente.
Veremos el uso del método de clasificación de clases de matrices de Java, así como la implementación de nuestro propio Comparador para ordenar los valores de nuestras matrices.
2. Definiciones de objetos
Antes de comenzar, definamos rápidamente algunas matrices que ordenaremos a lo largo de este tutorial. Primero, crearemos una matriz de entradas y una matriz de cadenas:
int[] numbers = new int[] { -8, 7, 5, 9, 10, -2, 3 }; String[] strings = new String[] { "learning", "java", "with", "baeldung" };Y también creemos una matriz de objetos Empleado donde cada empleado tiene una identificación y un atributo de nombre :
Employee john = new Employee(6, "John"); Employee mary = new Employee(3, "Mary"); Employee david = new Employee(4, "David"); Employee[] employees = new Employee[] { john, mary, david };3. Clasificación en orden ascendente
El método util.Arrays.sort de Java nos proporciona una forma rápida y sencilla de ordenar una serie de primitivas u objetos que implementan la interfaz Comparable en orden ascendente.
Al ordenar primitivas, el método Arrays.sort usa una implementación Dual-Pivot de Quicksort. Sin embargo, al ordenar objetos se usa una implementación iterativa de MergeSort.
3.1. Primitivos
Para ordenar una matriz primitiva en orden ascendente, pasamos nuestra matriz al método sort :
Arrays.sort(numbers); assertArrayEquals(new int[] { -8, -2, 3, 5, 7, 9, 10 }, numbers); 3.2. Objetos que implementan comparables
Para los objetos que implementan la interfaz Comparable , como con nuestra matriz primitiva, también podemos simplemente pasar nuestra matriz al método de clasificación :
Arrays.sort(strings); assertArrayEquals(new String[] { "baeldung", "java", "learning", "with" }, strings);3.3. Objetos que no se implementan comparables
Ordenar objetos que no implementan la Interfaz Comparable , como nuestra matriz de Empleados , requiere que especifiquemos nuestro propio comparador.
Podemos hacer esto muy fácilmente en Java 8 especificando la propiedad con la que nos gustaría comparar nuestros objetos Empleados dentro de nuestro Comparador:
Arrays.sort(employees, Comparator.comparing(Employee::getName)); assertArrayEquals(new Employee[] { david, john, mary }, employees);En este caso, hemos especificado que nos gustaría ordenar a nuestros empleados por sus atributos de nombre .
También podemos ordenar nuestros objetos en más de un atributo encadenando nuestras comparaciones usando el método de comparación de Comparator :
Arrays.sort(employees, Comparator.comparing(Employee::getName).thenComparing(Employee::getId));4. Clasificación en orden descendente
4.1. Primitivos
Ordenar una matriz primitiva en orden descendente no es tan simple como ordenarla en orden ascendente porque Java no admite el uso de Comparadores en tipos primitivos. Para superar este déficit tenemos algunas opciones.
Primero, podríamos ordenar nuestra matriz en orden ascendente y luego hacer una inversión in situ de la matriz.
En segundo lugar, podría convertir nuestra matriz en una lista, usar el método Lists.reverse () de Guava y luego convertir nuestra lista nuevamente en una matriz.
Finalmente, podríamos transformar nuestra matriz en Stream y luego mapearla de nuevo a una matriz int . Tiene una buena ventaja de ser una sola línea y solo usar el núcleo de Java:
numbers = IntStream.of(numbers).boxed().sorted(Comparator.reverseOrder()).mapToInt(i -> i).toArray(); assertArrayEquals(new int[] { 10, 9, 7, 5, 3, -2, -8 }, numbers);La razón por la que esto funciona es que en caja vueltas cada int en un número entero , que no implementar comparador.
4.2. Objetos que implementan comparables
Clasificar una matriz de objetos que implementa la interfaz Comparable en orden descendente es bastante simple. Todo lo que tenemos que hacer es pasar un Comparador como segundo parámetro de nuestro método de clasificación .
En Java 8 podemos usar Comparator.reverseOrder () para indicar que nos gustaría que nuestra matriz se clasificara en orden descendente:
Arrays.sort(strings, Comparator.reverseOrder()); assertArrayEquals(new String[] { "with", "learning", "java", "baeldung" }, strings);4.3. Objetos que no se implementan comparables
De manera similar a la clasificación de objetos que implementan comparables, podemos invertir el orden de nuestro Comparador personalizado agregando inverted () al final de nuestra definición de comparación:
Arrays.sort(employees, Comparator.comparing(Employee::getName).reversed()); assertArrayEquals(new Employee[] { mary, john, david }, employees);5. Conclusión
En este artículo, discutimos cómo ordenar matrices de primitivas y objetos en orden ascendente y descendente usando el método Arrays.sort .
Como de costumbre, el código fuente de este artículo se puede encontrar en Github.