Java Academy · Lección

Ordenación de arrays y colecciones en la práctica

Aplique la ordenación a listas de productos, clasificaciones y calendarios de eventos mediante ejemplos reales.

Ordenación de arrays y colecciones en la práctica es una lección gratuita de Java Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Java Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Java Academy incluye 4 lecciones en total.

Ordenación en la práctica

En esta lección se aplican técnicas de ordenación a situaciones realistas: catálogos de productos, tablas de clasificación, programación de eventos y clasificación de resultados de búsqueda.

Arrays.sort para arrays de tipos primitivos

Arrays.sort() para arrays de tipos primitivos utiliza quicksort de doble pivote, extremadamente rápido, con un coste medio de O(n log n).

int[] scores = {45, 90, 78, 62, 88, 33};
Arrays.sort(scores);
System.out.println(Arrays.toString(scores)); // [33, 45, 62, 78, 88, 90]

// Sort a range only
int[] data = {9, 3, 7, 1, 5};
Arrays.sort(data, 1, 4); // sort indices 1-3 only
System.out.println(Arrays.toString(data)); // [9, 1, 3, 7, 5]

Arrays.sort para arrays de objetos

Para arrays de objetos, Arrays.sort() utiliza TimSort (estable). Puede proporcionar un Comparator para definir un orden personalizado.

String[] names = {"Charlie", "Alice", "Bob", "Diana"};
Arrays.sort(names);
System.out.println(Arrays.toString(names)); // [Alice, Bob, Charlie, Diana]

// Custom order: by length, then alphabetically
Arrays.sort(names, Comparator.comparingInt(String::length).thenComparing(Comparator.naturalOrder()));
System.out.println(Arrays.toString(names)); // [Bob, Alice, Diana, Charlie]

Collections.sort y List.sort

Ambos ordenan List in situ. List.sort() es la forma moderna y preferida.

List<Integer> nums = new ArrayList<>(List.of(5, 2, 8, 1, 9, 3));

// Old way
Collections.sort(nums);
System.out.println(nums); // [1, 2, 3, 5, 8, 9]

// Modern way (same result)
nums.sort(Comparator.naturalOrder());
nums.sort(null); // null means natural order

// Descending
nums.sort(Comparator.reverseOrder());
System.out.println(nums); // [9, 8, 5, 3, 2, 1]

Stream.sorted() para un estilo funcional

Utilice stream().sorted() al construir una canalización: genera un nuevo stream ordenado sin modificar el origen.

List<String> cities = List.of("Tokyo", "London", "New York", "Paris", "Sydney");

// Sorted stream — source list unchanged
List<String> sorted = cities.stream()
    .sorted(Comparator.comparingInt(String::length).thenComparing(Comparator.naturalOrder()))
    .collect(Collectors.toList());

System.out.println(sorted);
// [Paris, Tokyo, London, Sydney, New York]

Ordenar un Map por valor

Una pregunta clásica de entrevistas: ordenar un Map por sus valores mediante stream y Comparator.

import java.util.*;
import java.util.stream.*;

Map<String, Integer> scores = Map.of(
    "Alice", 95, "Bob", 87, "Charlie", 92, "Diana", 87
);

Map<String, Integer> sorted = scores.entrySet().stream()
    .sorted(Map.Entry.<String, Integer>comparingByValue(Comparator.reverseOrder())
        .thenComparing(Map.Entry.comparingByKey()))
    .collect(Collectors.toLinkedHashMap(
        Map.Entry::getKey, Map.Entry::getValue,
        (v1, v2) -> v1, LinkedHashMap::new));

sorted.forEach((k, v) -> System.out.println(k + ": " + v));
// Alice: 95 / Charlie: 92 / Bob: 87 / Diana: 87

Ordenación con Collator según la configuración regional

Para ordenar cadenas teniendo en cuenta el idioma, utilice java.text.Collator en lugar de String.compareTo: gestiona los acentos, las mayúsculas y minúsculas y el orden específico de la configuración regional.

import java.text.*;
import java.util.*;

List<String> names = new ArrayList<>(List.of("éclair", "apple", "Über", "banana"));

Collator collator = Collator.getInstance(Locale.GERMAN);
names.sort(collator);
System.out.println(names); // locale-aware sort

Ordenar objetos con varios criterios

Ordenación de productos de comercio electrónico: productos en stock primero, después por precio de oferta, luego por valoración y, por último, por nombre.

record Product(String name, double price, double salePrice, double rating, boolean inStock) {}

Comparator<Product> bestFirst = Comparator
    .comparing(Product::inStock).reversed()           // in-stock first
    .thenComparingDouble(Product::salePrice)          // cheapest sale price
    .thenComparingDouble(Product::rating).reversed()  // highest rated
    .thenComparing(Product::name);                    // alphabetical tiebreak

Ordenar eventos por fecha y hora

Ordenar cronológicamente un calendario de eventos mediante tipos de java.time que implementan Comparable.

import java.time.*;
import java.util.*;

record Event(String title, LocalDate date, LocalTime time) {}

List<Event> schedule = new ArrayList<>(List.of(
    new Event("Workshop",  LocalDate.of(2024,7,15), LocalTime.of(9, 0)),
    new Event("Keynote",   LocalDate.of(2024,7,14), LocalTime.of(10, 30)),
    new Event("Lunch Talk",LocalDate.of(2024,7,15), LocalTime.of(12, 0)),
    new Event("Hackathon", LocalDate.of(2024,7,14), LocalTime.of(9, 0))
));

schedule.sort(Comparator.comparing(Event::date).thenComparing(Event::time));
schedule.forEach(e -> System.out.println(e.date() + " " + e.time() + " " + e.title()));

Elementos Top-N mediante ordenación

Cómo encontrar los N elementos principales de forma eficiente: ordene en orden descendente y tome los primeros N, o utilice una PriorityQueue para conjuntos de datos grandes.

List<Integer> values = List.of(42, 17, 88, 5, 73, 56, 91, 33);

// Simple approach: sort descending, take first 3
List<Integer> top3 = values.stream()
    .sorted(Comparator.reverseOrder())
    .limit(3)
    .collect(Collectors.toList());
System.out.println(top3); // [91, 88, 73]

// For very large datasets: PriorityQueue min-heap approach is O(n log k)
import java.util.PriorityQueue;
PriorityQueue<Integer> heap = new PriorityQueue<>(3);
for (int v : values) {
    heap.offer(v);
    if (heap.size() > 3) heap.poll();
}
System.out.println(new TreeSet<>(heap).descendingSet()); // [73, 88, 91]

Eliminación de duplicados mediante ordenación

Después de ordenar, los duplicados quedan adyacentes, por lo que es posible detectarlos en O(n).

int[] arr = {3, 1, 4, 1, 5, 9, 2, 6, 5};
Arrays.sort(arr); // sort first

// Remove duplicates in O(n) after sorting
int[] unique = Arrays.stream(arr).distinct().toArray();
System.out.println(Arrays.toString(unique)); // [1, 2, 3, 4, 5, 6, 9]

Rendimiento: elegir el método de ordenación

Cómo elegir el método de ordenación adecuado:

Arrays de tipos primitivos: Arrays.sort(): el más rápido, quicksort in situ
Arrays/listas de objetos con Comparable: Collections.sort() o List.sort(null)
Varios órdenes: cadenas de Comparator con thenComparing
Top-N de un stream grande: PriorityQueue o Stream.sorted().limit(N)

Comprobación rápida

¿Qué algoritmo de ordenación utiliza Java para los arrays de objetos en Arrays.sort()?

Recapitulación: ordenar arrays y colecciones en la práctica

Aspectos clave:

Arrays.sort() utiliza quicksort de doble pivote para tipos primitivos y TimSort (estable) para objetos
List.sort(comparator) y Collections.sort() utilizan TimSort estable
stream().sorted() genera un nuevo stream ordenado sin modificar el origen
Ordenar un Map por valor: entrySet().stream().sorted(Map.Entry.comparingByValue())
Utilice Collator para ordenar cadenas según la configuración regional
Para obtener los elementos Top-N de grandes volúmenes de datos, PriorityQueue con capacidad k es más eficiente que una ordenación completa

Preguntas frecuentes

¿La lección «Ordenación de arrays y colecciones en la práctica» es gratis?

Sí — el texto completo de «Ordenación de arrays y colecciones en la práctica» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Java Academy, actualiza a CoddyKit PRO. El curso de Java Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Ordenación de arrays y colecciones en la práctica»?

Aplique la ordenación a listas de productos, clasificaciones y calendarios de eventos mediante ejemplos reales. Practicas Java Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Java Academy?

No se requiere experiencia previa. Java Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Ordenación de arrays y colecciones en la práctica»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Java Academy?

Sí. Cada lección de Java Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

La interfaz Comparable
Comparator y ordenación con lambdas
Ordenación por varias claves con thenComparing
Ordenación de arrays y colecciones en la práctica

← Volver a Java Academy