Cómo ordenar una lista en Java: list.sort, Comparator, múltiples condiciones y manejo de nulos

1. Qué aprenderás en este artículo (La forma más corta de ordenar una lista de Java)

Al trabajar con Java, es extremadamente común encontrarse con situaciones en las que necesitas ordenar una List.
Al mismo tiempo, muchos desarrolladores —especialmente los principiantes— se confunden con preguntas como:

• ¿Qué método debo usar para ordenar una List?
• ¿Cuál es la diferencia entre list.sort() y Collections.sort()?
• ¿Cómo ordeno una List de objetos en lugar de valores simples?

Este artículo está diseñado para responder esas preguntas de forma clara y práctica, comenzando con la conclusión y luego explicando gradualmente los detalles y casos de uso reales.

1.1 La conclusión: este es el único patrón que necesitas recordar

Si solo quieres la forma más corta y estándar de ordenar una List en Java, es esta:

list.sort(Comparator.naturalOrder());

Esto ordena la List en orden ascendente (de menor a mayor, de A a Z, de más antiguo a más reciente).

Si deseas orden descendente, usa esto en su lugar:

list.sort(Comparator.reverseOrder());

Con solo estas dos líneas, ya puedes ordenar Lists de:

• Integer
• String
• LocalDate
• y la mayoría de los tipos comunes

Para muchos casos cotidianos, esto es todo lo que necesitas.

1.2 Ordenar una List de objetos: especificar la clave de ordenación

En aplicaciones reales, las Lists suelen contener objetos, no valores simples.

Por ejemplo:

class Person {
    private String name;
    private int age;

    // getters omitted
}

Para ordenar una List<Person> por edad, escribe:

list.sort(Comparator.comparing(Person::getAge));

Esta única línea significa:

• Extraer age de cada Person
• Comparar esos valores
• Ordenar la List en orden ascendente

No necesitas implementar manualmente la lógica de comparación.
Solo recuerda este patrón:

Comparator.comparing(whatToCompare)

1.3 Qué cubre este artículo

Este artículo explica la ordenación de Lists en Java desde lo básico hasta el uso práctico, incluyendo:

• La diferencia entre list.sort() y Collections.sort()
• Cómo funciona Comparator en términos simples
• Ordenar con múltiples condiciones (por ejemplo: edad → nombre)
• Mezclar orden ascendente y descendente
• Cómo manejar de forma segura valores null
• Cuándo usar stream().sorted() en lugar de list.sort()

El objetivo no es memorizar, sino entender por qué existe cada enfoque.

1.4 A quién va dirigido este artículo

Este artículo está escrito para desarrolladores que:

• Entienden la sintaxis básica de Java (clases, métodos, Lists)
• Han usado ArrayList o List antes
• Aún tienen que buscar el código de ordenación cada vez que lo necesitan

No está destinado a principiantes absolutos que nunca han escrito código Java,
pero sí es amigable para principiantes que están aprendiendo programación práctica en Java.

2. Tres formas comunes de ordenar una List en Java (¿Cuál deberías usar?)

En Java, no hay solo una manera de ordenar una List.
En la práctica, los desarrolladores usan principalmente tres enfoques diferentes, cada uno con un comportamiento e intención ligeramente distintos.

Antes de profundizar en Comparator, es importante entender cuándo y por qué existe cada opción.

2.1 list.sort(Comparator) — El enfoque moderno y recomendado

Desde Java 8, esta es la forma estándar y más recomendada de ordenar una List.

list.sort(Comparator.naturalOrder());

Características clave

• Definido directamente en la interfaz List
• Claro y legible
• Ordena la List original in situ (destructivo)

Ordenar objetos funciona de la misma manera:

list.sort(Comparator.comparing(Person::getAge));

Cuándo usarlo

• Cuando te vale modificar la List original
• Cuando buscas la solución más clara y sencilla

👉 Si no estás seguro, list.sort() suele ser la elección correcta.

2.2 Collections.sort(list) — Estilo antiguo que aún debes reconocer

Puedes ver código como este en tutoriales más viejos o proyectos heredados:

Collections.sort(list);

O con un Comparator:

Collections.sort(list, Comparator.reverseOrder());

Características clave

• Existe desde Java 1.2
• Internamente se comporta casi igual que list.sort
• También modifica la Lista original

Por qué es menos frecuente hoy

• Java 8 introdujo list.sort, lo que resulta más natural
• Ordenar una Lista mediante Collections es menos intuitivo

Para código nuevo, list.sort es la opción preferida.
Sin embargo, comprender Collections.sort sigue siendo importante al leer bases de código más antiguas.

2.3 stream().sorted() — Ordenamiento no destructivo

La tercera opción utiliza la API Stream.

List<Integer> sorted =
    list.stream()
        .sorted()
        .toList();

Con un Comparator:

List<Person> sorted =
    list.stream()
        .sorted(Comparator.comparing(Person::getAge))
        .toList();

Características clave

• No modifica la Lista original
• Devuelve una nueva Lista ordenada
• Fácil de combinar con filter, map y otras operaciones de stream

Cuándo usarlo

• Cuando debes mantener la Lista original sin cambios
• Cuando el ordenamiento forma parte de una canalización de procesamiento de datos

Para un ordenamiento simple, sin embargo, list.sort suele ser más claro y eficiente.

2.4 Cómo elegir (Guía rápida de decisión)

En este punto, recuerda solo una regla:

Usa list.sort() a menos que tengas una razón clara para no hacerlo.

3. Ordenamiento básico: orden ascendente y descendente

Ahora que sabes qué método de ordenamiento usar, centrémonos en el requisito más común: ordenar en forma ascendente o descendente.

Esta sección cubre Listas de tipos básicos como números, cadenas y fechas, la base de todo lo que sigue.

3.1 Ordenamiento en orden ascendente (orden natural)

Muchos tipos de Java tienen un orden natural, como:

• Números → de menor a mayor
• Cadenas → orden alfabético (A a Z)
• Fechas → de más antiguas a más recientes

Para ordenar una Lista en orden ascendente, usa:

list.sort(Comparator.naturalOrder());

Ejemplo: Ordenando números

List<Integer> numbers = Arrays.asList(5, 1, 3, 2);
numbers.sort(Comparator.naturalOrder());

Resultado:

[1, 2, 3, 5]

Ejemplo: Ordenando cadenas

List<String> names = Arrays.asList("Tom", "Alice", "Bob");
names.sort(Comparator.naturalOrder());

Resultado:

[Alice, Bob, Tom]

👉 Si solo deseas orden ascendente, este es el enfoque más simple y seguro.

3.2 Ordenamiento en orden descendente

Para invertir el orden natural, usa Comparator.reverseOrder().

list.sort(Comparator.reverseOrder());

Ejemplo: Números en orden descendente

List<Integer> numbers = Arrays.asList(5, 1, 3, 2);
numbers.sort(Comparator.reverseOrder());

Resultado:

[5, 3, 2, 1]

Ejemplo: Cadenas en orden descendente

List<String> names = Arrays.asList("Tom", "Alice", "Bob");
names.sort(Comparator.reverseOrder());

Resultado:

[Tom, Bob, Alice]

3.3 Cuando se puede omitir el Comparator

En algunos casos, puedes ver código de ordenamiento escrito sin un Comparator explícito.

Collections.sort(list);

O incluso:

list.sort(null);

Esto funciona solo si:

• Los elementos implementan Comparable
• Deseas el orden natural (ascendente)

Aunque válidos, estos estilos son menos explícitos.
En bases de código reales, esta versión suele preferirse por claridad:

list.sort(Comparator.naturalOrder());

3.4 Un malentendido común: ¿Quién decide el orden?

Una fuente frecuente de confusión para principiantes es pensar que:

sort() decide el orden ascendente o descendente

En realidad:

• sort() realiza el ordenamiento
• Comparator define cómo se comparan los elementos

Una vez que comprendes esta separación de responsabilidades, todo lo demás —ordenamiento de objetos, múltiples condiciones y manejo de null— se vuelve mucho más fácil.

4. Ordenar una Lista de objetos: comprendiendo Comparator

En aplicaciones Java del mundo real, rara vez ordenas valores simples como Integer o String. La mayor parte del tiempo, estarás ordenando listas de objetos personalizados.

Es aquí donde Comparator se convierte en el concepto central.

4.1 ¿Qué es un Comparator?

Un Comparator define cómo deben compararse dos elementos.

Conceptualmente, responde a esta pregunta:

“Dado dos objetos, ¿cuál debería aparecer primero?”

Internamente, un Comparator devuelve:

• Un número negativo → el primer elemento va primero
• Cero → el orden no importa
• Un número positivo → el segundo elemento va primero

Afortunadamente, en Java moderno casi nunca necesitas implementar esta lógica manualmente.

4.2 Ordenar por un campo con Comparator.comparing

Considera la siguiente clase:

class Person {
    private String name;
    private int age;

    // getters omitted
}

Para ordenar una List<Person> por edad, usa:

list.sort(Comparator.comparing(Person::getAge));

Esto se lee de forma natural:

• Tomar cada Person
• Extraer la age
• Comparar esos valores
• Ordenar la lista en orden ascendente

Esta única línea reemplaza muchas líneas de código de comparación anterior.

4.3 Ordenar por cadenas, fechas y otros tipos

El mismo patrón funciona para casi cualquier tipo de campo.

Ordenar por nombre

list.sort(Comparator.comparing(Person::getName));

Ordenar por fecha

list.sort(Comparator.comparing(Person::getBirthDate));

Mientras el valor extraído tenga un orden natural, Comparator.comparing funcionará sin configuración adicional.

4.4 Uso de comparadores específicos para tipos primitivos

Para campos numéricos, Java ofrece métodos optimizados:

• comparingInt
• comparingLong
• comparingDouble

Ejemplo:

list.sort(Comparator.comparingInt(Person::getAge));

Estos métodos:

• Evitan el empaquetado innecesario de objetos
• Hacen tu intención más clara
• Son ligeramente más eficientes para listas grandes

Aunque la diferencia es pequeña, se consideran la mejor práctica para campos numéricos.

4.5 Por qué es importante

Una vez que entiendes Comparator.comparing, desbloqueas:

• Ordenamiento con múltiples condiciones
• Orden mixto ascendente y descendente
• Manejo seguro de valores null

En otras palabras, esto es la base del ordenamiento práctico de listas en Java.

5. Ordenar con múltiples condiciones (el patrón más común en el mundo real)

En aplicaciones reales, ordenar por un solo campo a menudo no es suficiente. Normalmente necesitas condiciones secundarias y terciarias para crear un orden estable y significativo.

Los ejemplos incluyen:

• Ordenar por edad, luego por nombre
• Ordenar por prioridad, luego por marca de tiempo
• Ordenar por puntuación (descendente), luego por ID (ascendente)

La API Comparator de Java está diseñada específicamente para esto.

5.1 Lo básico de thenComparing

El ordenamiento con múltiples condiciones sigue una regla simple:

Si dos elementos son iguales según la primera condición, usa la siguiente condición.

Este es el patrón básico:

list.sort(
    Comparator.comparingInt(Person::getAge)
              .thenComparing(Person::getName)
);

Esto significa:

1. Ordenar por age (ascendente)
2. Si las edades son iguales, ordenar por name (ascendente)

Esto produce un orden consistente y predecible.

5.2 Mezclar orden ascendente y descendente

Muy a menudo, deseas un campo en orden descendente y otro en orden ascendente.

Ejemplo: Puntuación (descendente), Nombre (ascendente)

list.sort(
    Comparator.comparingInt(Person::getScore).reversed()
              .thenComparing(Person::getName)
);

Detalle importante:

• reversed() solo se aplica al Comparator inmediatamente anterior a él

Esto hace seguro combinar diferentes direcciones de ordenamiento.

5.3 Pasar un Comparator a thenComparing

Para una mejor legibilidad, puedes definir explícitamente la dirección de ordenamiento dentro de thenComparing.

Ejemplo: Edad (ascendente), Fecha de registro (descendente)

list.sort(
    Comparator.comparingInt(Person::getAge)
              .thenComparing(
                  Comparator.comparing(Person::getRegisterDate).reversed()
              )
);

Este estilo deja muy claro qué campos son ascendente o descendente, lo cual es útil para revisiones de código y el mantenimiento a largo plazo.

5.4 Un ejemplo empresarial realista

list.sort(
    Comparator.comparingInt(Order::getPriority)
              .thenComparing(Order::getDeadline)
              .thenComparing(Order::getOrderId)
);

Lógica de ordenación:

1. Mayor prioridad primero
2. Fecha límite más próxima primero
3. ID de orden más bajo primero

Esto garantiza un orden estable y orientado al negocio.

5.5 Mantener legible la ordenación con múltiples condiciones

A medida que la lógica de ordenación crece, la legibilidad se vuelve más importante que la brevedad.

Mejores prácticas:

• Separar líneas para cada condición
• Evitar lambdas anidadas profundamente
• Agregar comentarios si las reglas de negocio no son obvias

Una lógica de ordenación clara ahorra tiempo a todos los que leen el código más tarde.

6. Manejo seguro de valores null (Una fuente muy común de errores)

Al ordenar datos del mundo real, los valores null son casi inevitables. Los campos pueden ser opcionales, los datos heredados pueden estar incompletos o los valores simplemente pueden faltar.

Si no manejas null explícitamente, la ordenación puede fallar fácilmente en tiempo de ejecución.

6.1 Por qué null causa problemas al ordenar

Considera este código:

list.sort(Comparator.comparing(Person::getName));

Si getName() devuelve null para cualquier elemento, Java lanzará una NullPointerException durante la comparación.

Esto ocurre porque:

• Un Comparator asume que los valores pueden compararse
• null no tiene un orden natural a menos que lo definas

Por lo tanto, el manejo de null debe ser explícito.

6.2 Uso de nullsFirst y nullsLast

Java proporciona métodos auxiliares para definir cómo deben ordenarse los valores null.

Colocar valores null primero

list.sort(
    Comparator.comparing(
        Person::getName,
        Comparator.nullsFirst(Comparator.naturalOrder())
    )
);

Colocar valores null al final

list.sort(
    Comparator.comparing(
        Person::getName,
        Comparator.nullsLast(Comparator.naturalOrder())
    )
);

Estos enfoques:

• Previenen NullPointerException
• Hacen que la regla de ordenación sea explícita y legible

6.3 Cuando la propia lista contiene elementos null

A veces, los elementos de la Lista pueden ser null.

List<Person> list = Arrays.asList(
    new Person("Alice", 20),
    null,
    new Person("Bob", 25)
);

Para manejar esto de forma segura:

list.sort(
    Comparator.nullsLast(
        Comparator.comparing(Person::getName)
    )
);

Esto asegura:

• Los elementos null se mueven al final
• Los elementos no nulos se ordenan normalmente

6.4 Ten cuidado con comparingInt y null

Los comparadores específicos de primitivos como comparingInt no pueden manejar null.

Comparator.comparingInt(Person::getAge); // age must be int

Si el campo es un Integer que puede ser null, usa:

Comparator.comparing(
    Person::getAge,
    Comparator.nullsLast(Integer::compare)
);

Esto evita errores inesperados en tiempo de ejecución.

6.5 Tratar el manejo de null como parte de la especificación

Decidir si los valores null deben aparecer:

• Al principio
• Al final
• O ser filtrados completamente

es una decisión de negocio, no solo una técnica.

Al usar nullsFirst o nullsLast, documentas esa decisión directamente en el código, haciendo que tu lógica de ordenación sea más segura y fácil de entender.

7. Errores y trampas comunes (Cómo evitar bugs sutiles)

Ordenar una List en Java parece simple, pero existen varias trampas fáciles de pasar por alto que pueden provocar errores, comportamientos inesperados o problemas de rendimiento.

Entenderlas de antemano te ahorrará tiempo durante la depuración y las revisiones de código.

7.1 Olvidar que la ordenación es destructiva

Tanto list.sort() como Collections.sort() modifican la Lista original.

List<Integer> original = new ArrayList<>(List.of(3, 1, 2));
List<Integer> alias = original;

original.sort(Comparator.naturalOrder());

En este caso:

• original está ordenado
• alias también está ordenado (porque hacen referencia a la misma Lista)

Cómo evitar esto

Si necesitas preservar el orden original:

List<Integer> sorted = new ArrayList<>(original);
sorted.sort(Comparator.naturalOrder());

O usa streams:

List<Integer> sorted =
    original.stream()
            .sorted()
            .toList();

Siempre pregúntate:
“¿Está bien modificar la Lista original?”

7.2 Consistencia del Comparator y Ordenamiento Estable

Un Comparator debe producir resultados consistentes y predecibles.

Ejemplo:

Comparator.comparing(Person::getAge);

Si varias personas tienen la misma edad, su orden relativo es indefinido.

Esto puede ser aceptable, pero a menudo no lo es.

Mejores prácticas

Añade una condición secundaria para estabilizar el orden:

Comparator.comparingInt(Person::getAge)
          .thenComparing(Person::getId);

Esto garantiza que el resultado del ordenamiento sea determinista.

7.3 Sensibilidad a Mayúsculas y Minúsculas en el Ordenamiento de Cadenas

El orden natural de String es sensible a mayúsculas y minúsculas.

List<String> list = List.of("apple", "Banana", "orange");
list.sort(Comparator.naturalOrder());

Esto puede producir resultados que resultan poco intuitivos.

Ordenamiento sin sensibilidad a mayúsculas

list.sort(String.CASE_INSENSITIVE_ORDER);

Antes de elegir, considera:

• ¿Es esto para visualización?
• ¿O para lógica interna?

La respuesta determina el enfoque correcto.

7.4 Realizar Trabajo Pesado Dentro de un Comparator

Un Comparator puede ser llamado muchas veces durante el ordenamiento.

Evita:

• Acceso a bases de datos
• Llamadas a la red
• Cálculos costosos

  // Bad idea (conceptual example)
  Comparator.comparing(p -> expensiveOperation(p));
  

Enfoque mejor

• Precalcula valores
• Almacénalos en campos
• Compara valores simples y baratos

Los comparators eficientes hacen una gran diferencia con Listas grandes.

7.5 Prioriza la Legibilidad Sobre la Astucia

La lógica de ordenamiento se lee a menudo más veces de las que se escribe.

En lugar de:

• Una expresión larga encadenada
• Lambdas profundamente anidadas

Prefiere:

• Saltos de línea
• Estructura clara
• Comentarios opcionales para reglas de negocio

El código de ordenamiento legible reduce errores y facilita el mantenimiento.

8. Consideraciones de Rendimiento y Elección del Enfoque Correcto

A estas alturas, sabes cómo ordenar Listas en Java.
Esta sección se centra en qué enfoque elegir desde una perspectiva de rendimiento y diseño.

En la mayoría de las aplicaciones, el ordenamiento no es un cuello de botella, pero las malas decisiones pueden generar sobrecarga innecesaria.

8.1 list.sort() vs stream().sorted()

Este es el punto de decisión más común.

list.sort()

list.sort(Comparator.comparingInt(Person::getAge));

Ventajas

• Sin asignación de Lista extra
• Intención clara: “ordenar esta Lista”
• Ligeramente más eficiente

Desventajas

• Modifica la Lista original

stream().sorted()

List<Person> sorted =
    list.stream()
        .sorted(Comparator.comparingInt(Person::getAge))
        .toList();

Ventajas

• La Lista original permanece sin cambios
• Se integra de forma natural en pipelines de streams

Desventajas

• Asigna una nueva Lista
• Ligeramente más sobrecarga

Regla práctica

• Ordenamiento simple → list.sort()
• Pipelines de transformación o inmutabilidad → stream().sorted()

8.2 Ordenar Listas Grandes de Forma Eficiente

Los algoritmos de ordenamiento llaman al Comparator muchas veces. En Listas grandes, esto importa.

Directrices clave

• Mantén los comparators ligeros
• Evita cadenas de métodos que realicen trabajo pesado
• Prefiere comparators primitivos ( comparingInt, etc.)

Ejemplo: Precalcular claves costosas

En lugar de:

Comparator.comparing(p -> calculateScore(p));

Haz:

// Precompute once
p.setScore(calculateScore(p));

Luego ordene por el campo:

Comparator.comparingInt(Person::getScore);

Esto reduce drásticamente el trabajo repetido durante la ordenación.

8.3 ¿Es Collections.sort() alguna vez la elección correcta?

Para código nuevo, casi nunca.

Sin embargo, todavía aparece en:

• Proyectos heredados
• Tutoriales antiguos
• Bases de código de Java 7 y anteriores

No necesita usarlo, pero debería reconocerlo.

8.4 Lista de verificación de decisiones recomendada

Antes de ordenar, pregunte:

1. ¿Puedo modificar la lista original?
2. ¿Necesito múltiples condiciones de ordenación?
3. ¿Algún campo puede ser null ?
4. ¿Es importante el rendimiento a gran escala?

Responder a estas preguntas lleva naturalmente a la solución correcta.

9. Resumen: Hoja de trucos para ordenar listas en Java

Recapitulemos todo en una guía de referencia rápida en la que puede confiar.

9.1 Patrones rápidos que usará con más frecuencia

Orden ascendente

list.sort(Comparator.naturalOrder());

Orden descendente

list.sort(Comparator.reverseOrder());

9.2 Ordenar objetos por un campo

list.sort(Comparator.comparing(Person::getName));

Para números:

list.sort(Comparator.comparingInt(Person::getAge));

9.3 Múltiples condiciones

list.sort(
    Comparator.comparingInt(Person::getAge)
              .thenComparing(Person::getName)
);

Orden mixto:

list.sort(
    Comparator.comparingInt(Person::getScore).reversed()
              .thenComparing(Person::getName)
);

9.4 Manejo seguro de null

list.sort(
    Comparator.comparing(
        Person::getName,
        Comparator.nullsLast(Comparator.naturalOrder())
    )
);

La lista puede contener elementos null:

list.sort(
    Comparator.nullsLast(
        Comparator.comparing(Person::getName)
    )
);

9.5 Ordenación no destructiva

List<Person> sorted =
    list.stream()
        .sorted(Comparator.comparingInt(Person::getAge))
        .toList();

9.6 Conclusión final

Ordenar listas en Java se vuelve simple una vez que recuerde:

• Comparator define el orden
• sort() realiza la operación
• La claridad supera la astucia
• El manejo explícito de null previene errores

Si interioriza estos principios, nunca volverá a necesitar “reaprender” la ordenación de listas en Java.