LabEx
EntrarÚnete

Comparator y Comparable

JavaBeginner
Practicar Ahora

Introducción

En aplicaciones Java, a menudo necesitamos comparar y ordenar objetos. Para tipos de datos primitivos como enteros o cadenas, Java ya sabe cómo compararlos. Sin embargo, para objetos personalizados, necesitamos decirle a Java cómo deben compararse y ordenarse.

Java proporciona dos interfaces para ayudar con esto:

  • La interfaz Comparable permite que una clase defina su orden natural.
  • La interfaz Comparator proporciona lógica de comparación externa que se puede utilizar para diferentes criterios de ordenación.

En este laboratorio (LabEx), aprenderás cómo implementar ambas interfaces y utilizarlas para ordenar colecciones de objetos de varias maneras.

Comprendiendo la Interfaz Comparable

La interfaz Comparable se utiliza cuando una clase tiene un orden natural. Por ejemplo, las cadenas se ordenan naturalmente alfabéticamente y los enteros se ordenan naturalmente numéricamente.

Cuando una clase implementa la interfaz Comparable, debe definir un método compareTo() que especifique cómo deben ordenarse las instancias de la clase.

Creando una Clase Estudiante Básica

Vamos a crear una simple clase Student para demostrar cómo usar la interfaz Comparable. Definiremos un estudiante con un nombre, un promedio académico (GPA) y un número de registro.

  1. Abre el WebIDE y crea un nuevo archivo llamado Student.java en el directorio ~/project con el siguiente código:
public class Student implements Comparable<Student> {
    private String name;
    private double gpa;
    private int regNo;

    public Student(String name, double gpa, int regNo) {
        this.name = name;
        this.gpa = gpa;
        this.regNo = regNo;
    }

    // Implementing the compareTo method from Comparable interface
    @Override
    public int compareTo(Student other) {
        // Compare students based on GPA
        if (this.gpa < other.gpa) {
            return -1;
        } else if (this.gpa > other.gpa) {
            return 1;
        } else {
            return 0;
        }
    }

    // Getters
    public String getName() {
        return name;
    }

    public double getGpa() {
        return gpa;
    }

    public int getRegNo() {
        return regNo;
    }

    @Override
    public String toString() {
        return name + ", GPA: " + gpa + ", Reg No: " + regNo;
    }
}

Vamos a entender este código:

  • La clase Student implementa la interfaz Comparable<Student>
  • El método compareTo() compara a los estudiantes en función de su GPA
  • Si el GPA del estudiante actual es menor que el GPA del otro estudiante, devolvemos -1
  • Si el GPA del estudiante actual es mayor que el GPA del otro estudiante, devolvemos 1
  • Si los GPA son iguales, devolvemos 0

Ahora, vamos a crear un simple programa de prueba para ver cómo podemos usar la interfaz Comparable para ordenar a los estudiantes.

  1. Crea un nuevo archivo llamado ComparableDemo.java en el directorio ~/project con el siguiente código:
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class ComparableDemo {
    public static void main(String[] args) {
        // Create a list of students
        List<Student> students = new ArrayList<>();
        students.add(new Student("John", 3.5, 101));
        students.add(new Student("Mary", 3.8, 102));
        students.add(new Student("Alice", 3.2, 103));
        students.add(new Student("Bob", 3.9, 104));

        // Print the unsorted list
        System.out.println("Unsorted Student List:");
        for (Student student : students) {
            System.out.println(student);
        }

        // Sort the list using the natural ordering (defined by compareTo method)
        Collections.sort(students);

        // Print the sorted list
        System.out.println("\nStudents sorted by GPA (using Comparable):");
        for (Student student : students) {
            System.out.println(student);
        }
    }
}

Este programa:

  1. Crea una lista de objetos Student

  2. Imprime la lista sin ordenar

  3. Ordena la lista usando Collections.sort() que utiliza el orden natural definido por el método compareTo()

  4. Imprime la lista ordenada

  5. Ahora, vamos a compilar y ejecutar nuestro código para ver la salida:

cd ~/project
javac Student.java ComparableDemo.java
java ComparableDemo

Deberías ver una salida similar a:

Unsorted Student List:
John, GPA: 3.5, Reg No: 101
Mary, GPA: 3.8, Reg No: 102
Alice, GPA: 3.2, Reg No: 103
Bob, GPA: 3.9, Reg No: 104

Students sorted by GPA (using Comparable):
Alice, GPA: 3.2, Reg No: 103
John, GPA: 3.5, Reg No: 101
Mary, GPA: 3.8, Reg No: 102
Bob, GPA: 3.9, Reg No: 104

Como puedes ver, los estudiantes ahora están ordenados por su GPA en orden ascendente. Este es el orden natural que definimos en el método compareTo().

Creando y Usando Comparators

Si bien la interfaz Comparable define un orden natural para una clase, a veces necesitamos ordenar objetos en función de diferentes criterios. Aquí es donde entra en juego la interfaz Comparator.

La interfaz Comparator nos permite definir una lógica de ordenación personalizada que es independiente de la clase que se está comparando. Esto significa que podemos tener múltiples formas de ordenar la misma clase de objetos.

Creación de un Comparador para Ordenar por Nombre

Vamos a crear un Comparator que ordene a los estudiantes por sus nombres alfabéticamente:

  1. Crea un nuevo archivo llamado StudentNameComparator.java en el directorio ~/project con el siguiente código:
import java.util.Comparator;

public class StudentNameComparator implements Comparator<Student> {
    @Override
    public int compare(Student s1, Student s2) {
        // Compare students based on their names
        return s1.getName().compareTo(s2.getName());
    }
}

Este Comparator:

  • Implementa la interfaz Comparator<Student>
  • Define un método compare() que toma dos objetos Student
  • Compara a los estudiantes en función de sus nombres utilizando el método compareTo() de la clase String
  1. Ahora, vamos a crear un programa para demostrar cómo usar este Comparator. Crea un archivo llamado ComparatorDemo.java en el directorio ~/project:
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class ComparatorDemo {
    public static void main(String[] args) {
        // Create a list of students
        List<Student> students = new ArrayList<>();
        students.add(new Student("John", 3.5, 101));
        students.add(new Student("Mary", 3.8, 102));
        students.add(new Student("Alice", 3.2, 103));
        students.add(new Student("Bob", 3.9, 104));

        // Print the unsorted list
        System.out.println("Unsorted Student List:");
        for (Student student : students) {
            System.out.println(student);
        }

        // Sort by name using the StudentNameComparator
        Collections.sort(students, new StudentNameComparator());

        // Print the list sorted by name
        System.out.println("\nStudents sorted by name (using Comparator):");
        for (Student student : students) {
            System.out.println(student);
        }
    }
}

Este programa:

  1. Crea una lista de objetos Student

  2. Imprime la lista sin ordenar

  3. Ordena la lista utilizando Collections.sort() con nuestro StudentNameComparator personalizado

  4. Imprime la lista ordenada

  5. Vamos a compilar y ejecutar nuestro código:

cd ~/project
javac Student.java StudentNameComparator.java ComparatorDemo.java
java ComparatorDemo

Deberías ver una salida similar a:

Unsorted Student List:
John, GPA: 3.5, Reg No: 101
Mary, GPA: 3.8, Reg No: 102
Alice, GPA: 3.2, Reg No: 103
Bob, GPA: 3.9, Reg No: 104

Students sorted by name (using Comparator):
Alice, GPA: 3.2, Reg No: 103
Bob, GPA: 3.9, Reg No: 104
John, GPA: 3.5, Reg No: 101
Mary, GPA: 3.8, Reg No: 102

Como puedes ver, los estudiantes ahora se ordenan alfabéticamente por nombre, en lugar de por GPA.

Uso de Expresiones Lambda para Comparadores

Java 8 introdujo las expresiones lambda, que pueden simplificar la creación de comparadores. En lugar de crear una clase separada, podemos definir la lógica de comparación en línea.

  1. Crea un nuevo archivo llamado LambdaComparatorDemo.java en el directorio ~/project:
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class LambdaComparatorDemo {
    public static void main(String[] args) {
        // Create a list of students
        List<Student> students = new ArrayList<>();
        students.add(new Student("John", 3.5, 101));
        students.add(new Student("Mary", 3.8, 102));
        students.add(new Student("Alice", 3.2, 103));
        students.add(new Student("Bob", 3.9, 104));

        // Sort by registration number using lambda expression
        Collections.sort(students, (s1, s2) -> s1.getRegNo() - s2.getRegNo());

        // Print the list sorted by registration number
        System.out.println("Students sorted by registration number (using lambda):");
        for (Student student : students) {
            System.out.println(student);
        }

        // Sort by name using method reference
        Collections.sort(students, Comparator.comparing(Student::getName));

        // Print the list sorted by name
        System.out.println("\nStudents sorted by name (using method reference):");
        for (Student student : students) {
            System.out.println(student);
        }
    }
}

Este programa demuestra:

  1. El uso de una expresión lambda para crear un comparador que ordene a los estudiantes por número de registro

  2. El uso del método Comparator.comparing() con una referencia a método para crear un comparador que ordene a los estudiantes por nombre

  3. Compila y ejecuta este código:

cd ~/project
javac Student.java LambdaComparatorDemo.java
java LambdaComparatorDemo

Deberías ver una salida similar a:

Students sorted by registration number (using lambda):
John, GPA: 3.5, Reg No: 101
Mary, GPA: 3.8, Reg No: 102
Alice, GPA: 3.2, Reg No: 103
Bob, GPA: 3.9, Reg No: 104

Students sorted by name (using method reference):
Alice, GPA: 3.2, Reg No: 103
Bob, GPA: 3.9, Reg No: 104
John, GPA: 3.5, Reg No: 101
Mary, GPA: 3.8, Reg No: 102

Los estudiantes se ordenan primero por número de registro y luego por nombre.

Técnicas Avanzadas de Ordenamiento

En aplicaciones del mundo real, a menudo necesitamos una lógica de ordenación más compleja, como:

  • Ordenar por múltiples criterios (por ejemplo, ordenar por GPA y, si los GPA son iguales, ordenar por nombre)
  • Ordenar en orden inverso
  • Crear cadenas de comparadores personalizados

Exploremos estas técnicas avanzadas.

Ordenación por Múltiples Criterios

  1. Crea un nuevo archivo llamado MultiCriteriaDemo.java en el directorio ~/project:
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class MultiCriteriaDemo {
    public static void main(String[] args) {
        // Create a list of students with some having the same GPA
        List<Student> students = new ArrayList<>();
        students.add(new Student("John", 3.5, 101));
        students.add(new Student("Mary", 3.8, 102));
        students.add(new Student("Alice", 3.5, 103)); // Same GPA as John
        students.add(new Student("Bob", 3.8, 104));   // Same GPA as Mary
        students.add(new Student("Charlie", 3.2, 105));

        // Print the unsorted list
        System.out.println("Unsorted Student List:");
        for (Student student : students) {
            System.out.println(student);
        }

        // Sort first by GPA, then by name
        Comparator<Student> byGpa = Comparator.comparing(Student::getGpa);
        Comparator<Student> byName = Comparator.comparing(Student::getName);

        // Combine the comparators using thenComparing
        Comparator<Student> byGpaThenName = byGpa.thenComparing(byName);

        // Sort the list
        Collections.sort(students, byGpaThenName);

        // Print the sorted list
        System.out.println("\nStudents sorted by GPA, then by name:");
        for (Student student : students) {
            System.out.println(student);
        }
    }
}

Este programa:

  1. Crea una lista de estudiantes, algunos con el mismo GPA

  2. Crea un comparador para el GPA y un comparador para el nombre

  3. Combina estos comparadores utilizando el método thenComparing()

  4. Ordena a los estudiantes primero por GPA y luego por nombre si los GPA son iguales

  5. Compila y ejecuta el código:

cd ~/project
javac Student.java MultiCriteriaDemo.java
java MultiCriteriaDemo

Deberías ver una salida similar a:

Unsorted Student List:
John, GPA: 3.5, Reg No: 101
Mary, GPA: 3.8, Reg No: 102
Alice, GPA: 3.5, Reg No: 103
Bob, GPA: 3.8, Reg No: 104
Charlie, GPA: 3.2, Reg No: 105

Students sorted by GPA, then by name:
Charlie, GPA: 3.2, Reg No: 105
Alice, GPA: 3.5, Reg No: 103
John, GPA: 3.5, Reg No: 101
Bob, GPA: 3.8, Reg No: 104
Mary, GPA: 3.8, Reg No: 102

Observa que los estudiantes con el mismo GPA (Alice y John con 3.5, Bob y Mary con 3.8) se ordenan alfabéticamente.

Ordenación en Orden Inverso

  1. Crea un nuevo archivo llamado ReverseOrderDemo.java en el directorio ~/project:
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class ReverseOrderDemo {
    public static void main(String[] args) {
        // Create a list of students
        List<Student> students = new ArrayList<>();
        students.add(new Student("John", 3.5, 101));
        students.add(new Student("Mary", 3.8, 102));
        students.add(new Student("Alice", 3.2, 103));
        students.add(new Student("Bob", 3.9, 104));
        students.add(new Student("Charlie", 3.0, 105));

        // Print the unsorted list
        System.out.println("Unsorted Student List:");
        for (Student student : students) {
            System.out.println(student);
        }

        // Method 1: Using Collections.reverseOrder() with a comparator
        Comparator<Student> byGpa = Comparator.comparing(Student::getGpa);
        Comparator<Student> byGpaReversed = Collections.reverseOrder(byGpa);

        Collections.sort(students, byGpaReversed);

        System.out.println("\nStudents sorted by GPA in descending order (Method 1):");
        for (Student student : students) {
            System.out.println(student);
        }

        // Method 2: Using the reversed() method of Comparator
        Collections.sort(students, Comparator.comparing(Student::getName).reversed());

        System.out.println("\nStudents sorted by name in reverse alphabetical order (Method 2):");
        for (Student student : students) {
            System.out.println(student);
        }
    }
}

Este programa demuestra dos formas de ordenar en orden inverso:

  1. Utilizando Collections.reverseOrder() para invertir un comparador

  2. Utilizando el método reversed() de un comparador

  3. Compila y ejecuta el código:

cd ~/project
javac Student.java ReverseOrderDemo.java
java ReverseOrderDemo

Deberías ver una salida similar a:

Unsorted Student List:
John, GPA: 3.5, Reg No: 101
Mary, GPA: 3.8, Reg No: 102
Alice, GPA: 3.2, Reg No: 103
Bob, GPA: 3.9, Reg No: 104
Charlie, GPA: 3.0, Reg No: 105

Students sorted by GPA in descending order (Method 1):
Bob, GPA: 3.9, Reg No: 104
Mary, GPA: 3.8, Reg No: 102
John, GPA: 3.5, Reg No: 101
Alice, GPA: 3.2, Reg No: 103
Charlie, GPA: 3.0, Reg No: 105

Students sorted by name in reverse alphabetical order (Method 2):
Mary, GPA: 3.8, Reg No: 102
John, GPA: 3.5, Reg No: 101
Charlie, GPA: 3.0, Reg No: 105
Bob, GPA: 3.9, Reg No: 104
Alice, GPA: 3.2, Reg No: 103

La primera ordenación muestra a los estudiantes en orden descendente por GPA, y la segunda ordenación muestra a los estudiantes en orden alfabético inverso por nombre.

Cadena de Ordenación Compleja

  1. Vamos a crear un ejemplo más que combine múltiples criterios y ordenación inversa. Crea un archivo llamado ComplexSortingDemo.java en el directorio ~/project:
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class ComplexSortingDemo {
    public static void main(String[] args) {
        // Create a list of students with varied data
        List<Student> students = new ArrayList<>();
        students.add(new Student("John", 3.5, 101));
        students.add(new Student("Mary", 3.8, 102));
        students.add(new Student("Alice", 3.5, 103)); // Same GPA as John
        students.add(new Student("Bob", 3.8, 104));   // Same GPA as Mary
        students.add(new Student("Charlie", 3.2, 105));
        students.add(new Student("David", 3.2, 106)); // Same GPA as Charlie

        // Print the unsorted list
        System.out.println("Unsorted Student List:");
        for (Student student : students) {
            System.out.println(student);
        }

        // Create a complex sorting chain:
        // 1. Sort by GPA in descending order
        // 2. If GPAs are equal, sort by name in ascending order
        // 3. If names are also equal, sort by registration number in descending order
        Comparator<Student> complexComparator = Comparator
            .comparing(Student::getGpa, Comparator.reverseOrder())
            .thenComparing(Student::getName)
            .thenComparing(Student::getRegNo, Comparator.reverseOrder());

        Collections.sort(students, complexComparator);

        System.out.println("\nStudents sorted by complex criteria:");
        System.out.println("(GPA descending, then name ascending, then reg. number descending)");
        for (Student student : students) {
            System.out.println(student);
        }
    }
}

Este programa crea una cadena de ordenación compleja que:

  1. Ordena primero a los estudiantes por GPA en orden descendente

  2. Si los GPA son iguales, ordena por nombre en orden ascendente

  3. Si tanto el GPA como el nombre son iguales, ordena por número de registro en orden descendente

  4. Compila y ejecuta el código:

cd ~/project
javac Student.java ComplexSortingDemo.java
java ComplexSortingDemo

Deberías ver una salida similar a:

Unsorted Student List:
John, GPA: 3.5, Reg No: 101
Mary, GPA: 3.8, Reg No: 102
Alice, GPA: 3.5, Reg No: 103
Bob, GPA: 3.8, Reg No: 104
Charlie, GPA: 3.2, Reg No: 105
David, GPA: 3.2, Reg No: 106

Students sorted by complex criteria:
(GPA descending, then name ascending, then reg. number descending)
Bob, GPA: 3.8, Reg No: 104
Mary, GPA: 3.8, Reg No: 102
Alice, GPA: 3.5, Reg No: 103
John, GPA: 3.5, Reg No: 101
Charlie, GPA: 3.2, Reg No: 105
David, GPA: 3.2, Reg No: 106

En esta salida:

  • Bob y Mary tienen un GPA de 3.8, pero Bob aparece primero alfabéticamente
  • Alice y John tienen un GPA de 3.5, pero Alice aparece primero alfabéticamente
  • Charlie y David tienen un GPA de 3.2, y Charlie aparece primero alfabéticamente

Esto demuestra cómo se puede crear una lógica de ordenación compleja y de múltiples niveles encadenando comparadores.

Construyendo una Aplicación Completa de Ordenamiento

Ahora que hemos aprendido sobre la interfaz Comparable, la interfaz Comparator y diversas técnicas de ordenación, vamos a unir todo en una aplicación completa.

Vamos a crear un sistema de gestión de estudiantes que permita ordenar a los estudiantes de diferentes maneras.

  1. Primero, vamos a crear una versión actualizada de nuestra clase Student. Esta versión implementará Comparable e incluirá un método toString() mejorado para una mejor visualización. Crea un archivo llamado StudentManager.java en el directorio ~/project:
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Scanner;

class Student implements Comparable<Student> {
    private String name;
    private double gpa;
    private int regNo;
    private String major;

    public Student(String name, double gpa, int regNo, String major) {
        this.name = name;
        this.gpa = gpa;
        this.regNo = regNo;
        this.major = major;
    }

    @Override
    public int compareTo(Student other) {
        // Default natural ordering by registration number
        return this.regNo - other.regNo;
    }

    // Getters
    public String getName() {
        return name;
    }

    public double getGpa() {
        return gpa;
    }

    public int getRegNo() {
        return regNo;
    }

    public String getMajor() {
        return major;
    }

    @Override
    public String toString() {
        return String.format("%-10s | GPA: %.1f | Reg No: %-5d | Major: %-10s",
                            name, gpa, regNo, major);
    }
}

public class StudentManager {
    private List<Student> students;

    public StudentManager() {
        students = new ArrayList<>();
        // Add some sample students
        students.add(new Student("John", 3.5, 101, "Computer Science"));
        students.add(new Student("Mary", 3.8, 102, "Physics"));
        students.add(new Student("Alice", 3.5, 103, "Mathematics"));
        students.add(new Student("Bob", 3.9, 104, "Computer Science"));
        students.add(new Student("Charlie", 3.2, 105, "Physics"));
        students.add(new Student("David", 3.6, 106, "Mathematics"));
        students.add(new Student("Eve", 3.8, 107, "Biology"));
    }

    public void displayStudents() {
        System.out.println("----------------------------------------------------------");
        System.out.println("Name       | GPA   | Reg No | Major      ");
        System.out.println("----------------------------------------------------------");
        for (Student student : students) {
            System.out.println(student);
        }
        System.out.println("----------------------------------------------------------");
    }

    public void sortByNaturalOrder() {
        Collections.sort(students);
        System.out.println("\nStudents sorted by registration number (natural order):");
        displayStudents();
    }

    public void sortByName() {
        Collections.sort(students, Comparator.comparing(Student::getName));
        System.out.println("\nStudents sorted by name:");
        displayStudents();
    }

    public void sortByGpaDescending() {
        Collections.sort(students, Comparator.comparing(Student::getGpa).reversed());
        System.out.println("\nStudents sorted by GPA (descending):");
        displayStudents();
    }

    public void sortByMajorThenGpa() {
        Collections.sort(students,
            Comparator.comparing(Student::getMajor)
                     .thenComparing(Student::getGpa, Comparator.reverseOrder()));
        System.out.println("\nStudents sorted by major, then by GPA (descending):");
        displayStudents();
    }

    public static void main(String[] args) {
        StudentManager manager = new StudentManager();
        Scanner scanner = new Scanner(System.in);

        while (true) {
            System.out.println("\nStudent Manager");
            System.out.println("1. Display students (unsorted)");
            System.out.println("2. Sort by registration number");
            System.out.println("3. Sort by name");
            System.out.println("4. Sort by GPA (highest first)");
            System.out.println("5. Sort by major, then by GPA (highest first)");
            System.out.println("6. Exit");
            System.out.print("Enter your choice: ");

            int choice = scanner.nextInt();

            switch (choice) {
                case 1:
                    System.out.println("\nUnsorted student list:");
                    manager.displayStudents();
                    break;
                case 2:
                    manager.sortByNaturalOrder();
                    break;
                case 3:
                    manager.sortByName();
                    break;
                case 4:
                    manager.sortByGpaDescending();
                    break;
                case 5:
                    manager.sortByMajorThenGpa();
                    break;
                case 6:
                    System.out.println("Exiting program. Goodbye!");
                    scanner.close();
                    return;
                default:
                    System.out.println("Invalid choice. Please try again.");
            }
        }
    }
}

Esta aplicación:

  1. Define una clase Student con nombre, GPA, número de registro y especialización (major)

  2. Implementa Comparable para definir el orden natural por número de registro

  3. Crea una clase StudentManager que mantiene una lista de estudiantes

  4. Proporciona métodos para ordenar a los estudiantes de diferentes maneras

  5. Incluye una interfaz sencilla basada en menú para que el usuario elija diferentes opciones de ordenación

  6. Compila y ejecuta la aplicación:

cd ~/project
javac StudentManager.java
java StudentManager
  1. Prueba la aplicación probando diferentes opciones de ordenación. Aquí tienes una interacción de ejemplo:
Student Manager
1. Display students (unsorted)
2. Sort by registration number
3. Sort by name
4. Sort by GPA (highest first)
5. Sort by major, then by GPA (highest first)
6. Exit
Enter your choice: 1

Unsorted student list:
----------------------------------------------------------
Name       | GPA   | Reg No | Major
----------------------------------------------------------
John       | GPA: 3.5 | Reg No: 101   | Major: Computer Science
Mary       | GPA: 3.8 | Reg No: 102   | Major: Physics
Alice      | GPA: 3.5 | Reg No: 103   | Major: Mathematics
Bob        | GPA: 3.9 | Reg No: 104   | Major: Computer Science
Charlie    | GPA: 3.2 | Reg No: 105   | Major: Physics
David      | GPA: 3.6 | Reg No: 106   | Major: Mathematics
Eve        | GPA: 3.8 | Reg No: 107   | Major: Biology
----------------------------------------------------------

Student Manager
1. Display students (unsorted)
2. Sort by registration number
3. Sort by name
4. Sort by GPA (highest first)
5. Sort by major, then by GPA (highest first)
6. Exit
Enter your choice: 3

Students sorted by name:
----------------------------------------------------------
Name       | GPA   | Reg No | Major
----------------------------------------------------------
Alice      | GPA: 3.5 | Reg No: 103   | Major: Mathematics
Bob        | GPA: 3.9 | Reg No: 104   | Major: Computer Science
Charlie    | GPA: 3.2 | Reg No: 105   | Major: Physics
David      | GPA: 3.6 | Reg No: 106   | Major: Mathematics
Eve        | GPA: 3.8 | Reg No: 107   | Major: Biology
John       | GPA: 3.5 | Reg No: 101   | Major: Computer Science
Mary       | GPA: 3.8 | Reg No: 102   | Major: Physics
----------------------------------------------------------

Student Manager
1. Display students (unsorted)
2. Sort by registration number
3. Sort by name
4. Sort by GPA (highest first)
5. Sort by major, then by GPA (highest first)
6. Exit
Enter your choice: 5

Students sorted by major, then by GPA (descending):
----------------------------------------------------------
Name       | GPA   | Reg No | Major
----------------------------------------------------------
Eve        | GPA: 3.8 | Reg No: 107   | Major: Biology
Bob        | GPA: 3.9 | Reg No: 104   | Major: Computer Science
John       | GPA: 3.5 | Reg No: 101   | Major: Computer Science
David      | GPA: 3.6 | Reg No: 106   | Major: Mathematics
Alice      | GPA: 3.5 | Reg No: 103   | Major: Mathematics
Mary       | GPA: 3.8 | Reg No: 102   | Major: Physics
Charlie    | GPA: 3.2 | Reg No: 105   | Major: Physics
----------------------------------------------------------

Student Manager
1. Display students (unsorted)
2. Sort by registration number
3. Sort by name
4. Sort by GPA (highest first)
5. Sort by major, then by GPA (highest first)
6. Exit
Enter your choice: 6
Exiting program. Goodbye!

Puedes experimentar con diferentes opciones de ordenación para ver cómo la lista de estudiantes se muestra de manera diferente cada vez.

Esta aplicación completa demuestra el poder y la flexibilidad de las interfaces Comparable y Comparator en Java. Te permite ordenar objetos de diversas maneras para satisfacer diferentes requisitos de tu aplicación.

Resumen

En este laboratorio, aprendiste cómo comparar y ordenar objetos en Java utilizando las interfaces Comparable y Comparator.

Conceptos clave cubiertos:

  1. Interfaz Comparable

    • Implementar el método compareTo() para definir el orden natural de una clase
    • Utilizar Collections.sort() con objetos ordenados naturalmente

  2. Interfaz Comparator

    • Crear comparadores personalizados para diferentes criterios de ordenación
    • Utilizar Collections.sort() con un comparador personalizado
    • Utilizar expresiones lambda y referencias a métodos para crear comparadores de manera concisa

  3. Técnicas Avanzadas de Ordenación

    • Ordenar por múltiples criterios utilizando thenComparing()
    • Ordenar en orden inverso utilizando Collections.reverseOrder() o reversed()
    • Crear cadenas de ordenación complejas

  4. Aplicación Práctica

    • Construir un sistema completo de gestión de estudiantes con diversas opciones de ordenación
    • Implementar una interfaz de usuario para demostrar diferentes capacidades de ordenación

Estas capacidades de ordenación son fundamentales para muchas aplicaciones Java, especialmente aquellas que manejan colecciones de datos. Ya sea que estés ordenando estudiantes en un sistema de gestión de estudiantes, pedidos en una aplicación de comercio electrónico o cualquier otro tipo de datos, las técnicas que aprendiste en este laboratorio te ayudarán a implementar una lógica de ordenación eficiente y flexible.

Relacionado Java Cursos
Java para Principiantes

Java para Principiantes

java
Ejercicios de programación en Java

Ejercicios de programación en Java

java
Inserción masiva de datos en el horario de cursos

Inserción masiva de datos en el horario de cursos

java