Collections - Comparator - Comparable

En Java, existen varias clases y interfaces de utilidad que facilitan el trabajo con colecciones y arrays, proporcionando herramientas y funcionalidades adicionales para ordenar, buscar, comparar, y realizar otras operaciones comunes. A continuación, te explico cada una de las clases de utilidad más importantes: Collections,Comparator, y Comparable.

Clase/Interfaz	Propósito	Uso común
Collections	Métodos estáticos para operaciones sobre colecciones (ordenación, búsqueda, sincronización, etc.)	Ordenar, invertir, mezclar colecciones
Comparator	Permite ordenar objetos usando un criterio personalizado	Ordenar objetos con reglas específicas
Comparable	Permite ordenar objetos usando un criterio natural	Proporcionar un orden predeterminado para los objetos de una clase

---

1. Collections

La clase Collections es una clase utilitaria que contiene métodos estáticos para realizar operaciones sobre colecciones. Proporciona métodos para ordenar, buscar, y sincronizar colecciones, entre otros.

• sort(List<T> list):

  • Ordena los elementos de una lista en orden natural (según el orden de los elementos).

  • Ejemplo:

    List<Integer> list = Arrays.asList(3, 1, 4, 1, 5, 9);
    Collections.sort(list);
    System.out.println(list);  // [1, 1, 3, 4, 5, 9]

• reverse(List<T> list):

  • Invierte el orden de los elementos de la lista.

  • Ejemplo:

    List<String> list = Arrays.asList("Java", "Python", "C++");
    Collections.reverse(list);
    System.out.println(list);  // [C++, Python, Java]

• shuffle(List<T> list):

  • Mezcla aleatoriamente los elementos de una lista.

  • Ejemplo:

    List<String> list = Arrays.asList("a", "b", "c", "d");
    Collections.shuffle(list);
    System.out.println(list);  // [b, d, c, a] (el orden variará)

• binarySearch(List<T> list, T key):

  • Realiza una búsqueda binaria en una lista ordenada para encontrar un elemento.

  • Ejemplo:

    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
    int index = Collections.binarySearch(list, 3);
    System.out.println(index);  // 2

• max(Collection<? extends T> coll):

  • Devuelve el máximo elemento de la colección, según su orden natural.

  • Ejemplo:

    List<Integer> list = Arrays.asList(5, 2, 8, 1);
    Integer max = Collections.max(list);
    System.out.println(max);  // 8

• min(Collection<? extends T> coll):

  • Devuelve el mínimo elemento de la colección, según su orden natural.

  • Ejemplo:

    List<Integer> list = Arrays.asList(5, 2, 8, 1);
    Integer min = Collections.min(list);
    System.out.println(min);  // 1

• synchronizedList(List<T> list):

  • Devuelve una lista sincronizada (thread-safe) a partir de una lista dada.

  • Ejemplo:

    List<Integer> list = new ArrayList<>();
    List<Integer> syncList = Collections.synchronizedList(list);

---

---

2. Comparator

La interfaz Comparator permite definir un criterio personalizado para ordenar objetos de una colección. Si deseas ordenar objetos de una clase según un atributo específico o una condición personalizada, implementas esta interfaz.

Métodos clave de Comparator:

• compare(T o1, T o2):
  • Compara dos objetos y devuelve:
    • Un valor negativo si el primer objeto es menor que el segundo.
    • Cero si son iguales.
    • Un valor positivo si el primer objeto es mayor que el segundo.
• reversed():
  • Devuelve un comparador que invierte el orden del comparador original.

Ejemplo de uso de Comparator:

import java.util.*;

class Person {
    String name;
    int age;

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return name + " (" + age + ")";
    }
}

class AgeComparator implements Comparator<Person> {
    @Override
    public int compare(Person p1, Person p2) {
        return Integer.compare(p1.age, p2.age);  // Ordenar por edad
    }
}

public class ComparatorExample {
    public static void main(String[] args) {
        List<Person> people = Arrays.asList(
            new Person("Alice", 30),
            new Person("Bob", 25),
            new Person("Charlie", 35)
        );

        // Ordenar por edad usando un Comparator personalizado
        Collections.sort(people, new AgeComparator());
        System.out.println(people);  // [Bob (25), Alice (30), Charlie (35)]
    }
}

---

3. Comparable

La interfaz Comparable permite que los objetos de una clase se ordenen en función de un criterio natural. Es una forma de proporcionar un orden predeterminado para los objetos de una clase sin la necesidad de implementar un Comparator por separado.

Método clave de Comparable:

• compareTo(T o):
  • Compara el objeto actual con otro objeto del mismo tipo. Devuelve:
    • Un valor negativo si el objeto actual es menor.
    • Cero si son iguales.
    • Un valor positivo si el objeto actual es mayor.

Ejemplo de uso de Comparable:

import java.util.*;

class Person implements Comparable<Person> {
    String name;
    int age;

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public int compareTo(Person other) {
        return Integer.compare(this.age, other.age);  // Ordenar por edad
    }

    @Override
    public String toString() {
        return name + " (" + age + ")";
    }
}

public class ComparableExample {
    public static void main(String[] args) {
        List<Person> people = Arrays.asList(
            new Person("Alice", 30),
            new Person("Bob", 25),
            new Person("Charlie", 35)
        );

        // Ordenar por edad usando Comparable
        Collections.sort(people);
        System.out.println(people);  // [Bob (25), Alice (30), Charlie (35)]
    }
}

---