Interfaz Comparator

Parte de la sección Programación Orientada a Objetos del Journey de Java de Coddy — lección 45 de 87.

Mientras que Comparable define el orden natural de una clase, a veces es necesario ordenar objetos de diferentes maneras. La interfaz Comparator le permite crear una lógica de comparación independiente sin modificar la clase original.

Un Comparator es un objeto externo que compara dos objetos del mismo tipo. Esto es útil cuando deseas múltiples opciones de ordenación o cuando no puedes modificar la clase en sí misma:

import java.util.Comparator;

class NameComparator implements Comparator<Person> {
    @Override
    public int compare(Person p1, Person p2) {
        return p1.getName().compareTo(p2.getName());
    }
}

class AgeComparator implements Comparator<Person> {
    @Override
    public int compare(Person p1, Person p2) {
        return p1.getAge() - p2.getAge();
    }
}

Luego puedes pasar el comparador a los métodos de ordenación:

List<Person> people = new ArrayList<>();
people.add(new Person("Charlie", 30));
people.add(new Person("Alice", 25));

Collections.sort(people, new NameComparator());  // Ordenado por nombre
Collections.sort(people, new AgeComparator());   // Ordenado por edad

Para escribir código conciso, puedes usar expresiones lambda ya que Comparator es una interfaz funcional:

Collections.sort(people, (p1, p2) -> p1.getName().compareTo(p2.getName()));

La diferencia clave: Comparable es implementada por la clase que se está comparando y define un orden natural, mientras que Comparator es una clase separada que puede definir ordenamientos personalizados ilimitados.

Desafío

Fácil

Vamos a construir un sistema de ordenación de empleados que demuestre el poder de la interfaz Comparator. Crearás múltiples comparadores para ordenar empleados de diferentes maneras—por salario y por nombre—sin modificar la clase Employee en sí misma.

Organizarás tu código en cuatro archivos:

Employee.java: Crea una clase que represente a un empleado con tres campos privados: name (String), department (String) y salary (double). Incluye un constructor para inicializar todos los campos y métodos getter para cada uno. Sobrescribe toString() para que devuelva: [name] ([department]) - $[salary]
SalaryComparator.java: Crea un comparador que ordene a los empleados por salario en orden descendente (el mejor pagado primero). Implementa la interfaz Comparator<Employee> y su método compare(). Usa Double.compare() para una comparación segura de los valores de salario.
NameComparator.java: Crea otro comparador que ordene a los empleados alfabéticamente por nombre en orden ascendente (de la A a la Z). Implementa Comparator<Employee> y usa el método compareTo() de String para la comparación.
Main.java: Une todo creando una lista de empleados y ordenándolos usando tus comparadores. Recibirás la entrada de tres empleados, cada uno en una línea separada con el formato: name,department,salary
Crea un ArrayList de empleados, luego demuestra ambos enfoques de ordenación:
1. Primero, ordena por salario usando tu SalaryComparator e imprime cada empleado
2. Imprime una línea vacía
3. Luego ordena por nombre usando tu NameComparator e imprime cada empleado

Recibirás tres líneas de entrada, cada una con los datos del empleado en el formato: name,department,salary

Por ejemplo, una línea de entrada podría verse así: Alice,Engineering,75000.0

Recuerda importar java.util.Comparator en tus archivos de comparadores, y java.util.ArrayList, java.util.Collections y java.util.Scanner en tu archivo Main. ¡Observa cómo los comparadores te permiten definir múltiples estrategias de ordenación externamente—la clase Employee no necesita saber nada sobre cómo podría ser ordenada!

Hoja de referencia

La interfaz Comparator le permite crear una lógica de comparación externa para ordenar objetos sin modificar la clase original. Esto es útil cuando necesita múltiples opciones de ordenación.

Un Comparator compara dos objetos del mismo tipo implementando el método compare():

import java.util.Comparator;

class NameComparator implements Comparator<Person> {
    @Override
    public int compare(Person p1, Person p2) {
        return p1.getName().compareTo(p2.getName());
    }
}

Pase el comparador a los métodos de ordenación:

Collections.sort(people, new NameComparator());

Puede utilizar expresiones lambda para obtener un código conciso, ya que Comparator es una interfaz funcional:

Collections.sort(people, (p1, p2) -> p1.getName().compareTo(p2.getName()));

Para comparar valores numéricos, utilice métodos de clases envolventes como Double.compare() para una comparación segura:

class AgeComparator implements Comparator<Person> {
    @Override
    public int compare(Person p1, Person p2) {
        return p1.getAge() - p2.getAge();
    }
}

Diferencia clave: Comparable define un orden natural dentro de la propia clase, mientras que Comparator es una clase separada que puede definir ordenaciones personalizadas ilimitadas de forma externa.

Pruébalo tú mismo

import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // Leer tres empleados de la entrada
        // Formato de cada línea: name,department,salary
        String line1 = scanner.nextLine();
        String line2 = scanner.nextLine();
        String line3 = scanner.nextLine();
        
        // TODO: Analizar cada línea y crear objetos Employee
        // Hint: Usar split(",") para separar los valores
        
        // TODO: Crear un ArrayList de empleados y añadir los tres
        
        // TODO: Ordenar por salary usando SalaryComparator e imprimir cada empleado
        // Hint: Usar Collections.sort(list, comparator)
        
        // TODO: Imprimir una línea vacía
        
        // TODO: Ordenar por name usando NameComparator e imprimir cada empleado
    }
}