La interfaz Comparator en Java te permite ordenar colecciones de objetos fácilmente. En programación es muy común requerir ordenar listas de elementos, de ahí que hablar del comparator en Java sea prioridad. Por eso, en este artículo queremos explicarte qué es el comparator en Java y cómo fue que Java 8 introdujo lambdas para simplificar este proceso.

¿Qué encontrarás en este post?

¿Qué es el Comparator en Java?

El comparator en Java es una interfaz que nos permite hace la comparación entre dos objetos y definir el orden entre estos. A diferencia de la interfaz Comparable, la cual se implementa de manera directa en la clase del objeto que se desea comparar, el Comparator en Java nos permite crear diferentes criterios de comparación, todo sin modificar el código original de la clase.

Por ejemplo, verás que es muy común el caso en donde tienes una lista de objetos que no tienen un orden establecido, o cuando se requiere ordenar una lista de diferentes modos, con base en las distintas propiedades del objeto. Ahí es donde entra en juego el Comparator en Java.

Comparator: ejemplo de su uso

De cara a entender mejor el Comparator en Java, veamos uno de los ejemplos clásicos. Tenemos una lista de objetos de tipo Persona, esta clase tiene atributos como nombre, apellido1 y apellido 2. Digamos que queremos ordenar la lista por nombre, lo haríamos del siguiente modo:

public class Persona {
    private String nombre;
    private String apellido1;
    private String apellido2;

    public Persona(String nombre, String apellido1, String apellido2) {
        this.nombre = nombre;
        this.apellido1 = apellido1;
        this.apellido2 = apellido2;
    }

    public String getNombre() { return nombre; }
    public String getApellido1() { return apellido1; }
    public String getApellido2() { return apellido2; }

    @Override
    public String toString() {
        return nombre + " " + apellido1 + " " + apellido2;
    }
}

Ahora creamos un Comparator para ordenar por el nombre:

import java.util.Comparator;

public class ComparadorNombre implements Comparator<Persona> {
    @Override
    public int compare(Persona p1, Persona p2) {
        return p1.getNombre().compareTo(p2.getNombre());
    }
}

Para ordenar la lista usamos el método sort de List:

lista.sort(new ComparadorNombre());
lista.forEach(System.out::println);

En este caso hemos ordenado un atributo con el comparator en Java, pero, ¿qué pasa si queremos ordenar por más de un atributo? ¡Es posible!

Ordenaciones múltiples con Comparator en Java

Ahora supongamos que quieres ordenar primero por apellido1 y, en caso de empate, por apellido2. Aquí es donde entran las mejoras de Java 8 con lambdas y el método theComparing, que nos facilitan enormemente el trabajo:

Comparator<Persona> comparadorApellido = Comparator.comparing(Persona::getApellido1)
    .thenComparing(Persona::getApellido2);

Con solo unas pocas líneas puedes encadenar comparadores para crear ordenaciones más complejas:

lista.sort(comparadorApellido);
lista.forEach(System.out::println);

De esta manera el código nos permite que primero se ordene por el apellido 1 y, en caso de que dos personas tengan el mismo primer apellido, entonces que se ordene por el apellido 2.

Las lambdas en Java 8: un plus para el Comparator

Previo a la llegada de Java 8, era necesario crear clases adicionales para cada tipo de ordenación que se quisiera aplicar, esto convertía el código en algo poco manejable y muy extenso. Con la llegada de las expresiones lambda a Java 8 podemos definir el Comparator de manera directa y simple. Veamos el mismo ejemplo del anterior, pero usando lambdas:

lista.sort((p1, p2) -> p1.getNombre().compareTo(p2.getNombre()));

Este enfoque elimina la necesidad de clases adicionales, reduce el código y mejora la legibilidad.

Otros métodos para usar el Comparator en Java

El comparator en Java no se limita a las comparaciones simples y básicas. Esta interfaz nos ofrece diversos métodos que nos permiten ajustar el comportamiento de los comparadores. Veamos:

reversed(): Si necesitas invertir el orden, puedes hacerlo fácilmente utilizando este método:

  Comparator<Persona> comparadorInverso = Comparator.comparing(Persona::getNombre).reversed();

nullsFirst() y nullsLast(): Estos métodos son útiles cuando necesitas manejar valores null en tus listas:

  Comparator<Persona> comparadorNombres = Comparator.nullsFirst(Comparator.comparing(Persona::getNombre));

Java tiene herramientas muy útiles y extensas, por eso si quieres seguir aprendiendo, te invitamos a unirte al bootcamp de java que tenemos en Keepcoding, con el cual aprenderás a diseñar apps java en diferentes plataformas y muchas otras cosas. ¡Únete ahora para seguir cumpliendo tus sueños! ¡te esperamos!