Diferencia entre comparable y comparador

en Java

Comparable y Comparator son las interfaces genéricas en Java que se utilizan para
comparar los elementos de datos de los objetos. La interfaz Comparable está
presente en el paquete java.lang y la interfaz Comparator está presente en el
paquete java.util.
La diferencia básica entre las interfaces Comparable y Comparator es que la interfaz
Comparable proporciona la única secuencia de clasificación, mientras que la interfaz
Comparator proporciona las múltiples secuencias de clasificación. Existen algunas
otras diferencias entre la interfaz Comparable y Comparator que estudiaremos en la
Tabla de comparación.

Bases Para la
Comparable Comparator
Comparación
Básico La interfaz comparable permite La interfaz del Comparator permite
solo una secuencia de clasificación. múltiples secuencias de
clasificación.
Paquetes La interfaz comparable está La interfaz del Comparator está
presente en el paquete java.lang. presente en el paquete java.util.
Métodos La interfaz Comparable contiene La interfaz del Comparator
solo un método contiene dos métodos.
public int compareTo (objeto obj); public int compare (Objeto obj1,
Objeto obj2)
boolean equals (Object obj)
Implementació La interfaz comparable es La interfaz del Comparator se
n implementada por la clase cuyos implementa mediante una clase
objetos se van a comparar. separada en lugar de la clase cuyos
objetos se van a comparar.
Comparación El método compareTo (Object obj) El método de compare (Objeto
compara el objeto que se utiliza obj1, Objeto obj2) compara los
para invocar el método con el objetos especificados que se pasan
objeto especificado que se pasa al al método.
método.
List/Array Cuando se debe comparar una lista Cuando se debe comparar una lista
de objetos de tipo Comparable, la de objetos del tipo Comparator, la
clase Collection proporciona un clase Collection proporciona un
método, por ejemplo, método, es decir,
Collections.sort (List lst). Collections.sort (List, Comparator).
Definición de Comparable
Comparable es una interfaz que está disponible en el paquete java.lang. La clase
implementa la interfaz del Comparable, para ordenar sus objetos en orden natural.
Los objetos se clasifican en orden natural significa que los objetos se comparan por
sus valores ASCII. Las clases que implementan la interfaz Comparable son las
clases Byte, Character, Double, Float, Long, Short, String y Integer. Incluso la clase
Date y Calendar también implementan la interfaz Comparable.
La interfaz Comparable contiene solo un método que es CompareTo (objeto obj).
Este método compara el objeto utilizado para invocar el método con el objeto
especificado en el parámetro. La sintaxis del método es la siguiente:

public int compareTo (objeto obj);

El método CompareTo (Objeto obj) devuelve 0, cuando el objeto comparado por el

método contiene el mismo valor, devuelve valor entero negativo si el objeto invocado
es más pequeño que el objeto especificado y devuelve valor entero positivo si el
objeto invocador tiene mayor valor en comparación con el objeto especificado. La
clase Collections proporciona un método de clasificación para ordenar los elementos
de la lista. Los elementos de lista (y matriz) del tipo Comparable pueden ordenarse
usando el método "Collections.sort (List lst)".

Definición de Comparator
Comparator es una interfaz que está disponible en el paquete java.util. La interfaz
Comparator no se implementa en la clase cuyos objetos se van a comparar, sino
que la clase separada implementa la interfaz Comparator para que la lógica de
clasificación se aplique a cada elemento de datos del objeto en una clase diferente.
Comparator contiene dos métodos de la siguiente manera:

public int compare (Object obj1, Object obj2) y boolean equals (Object obj)

El método compare() anterior compara el primer objeto obj1 con el segundo objeto
obj2. El método de compare( ) devuelve 0 cuando el objeto comparado por el
método contiene el mismo valor, devuelve el valor entero negativo si el objeto obj1
es más pequeño que el objeto obj2 y devuelve el valor entero positivo si el objeto
obj1 tiene un valor mayor en comparación al objeto obj2.
El método equals() comprueba si el objeto especificado es igual al objeto que invoca.
El método equals() devuelve verdadero si los dos objetos comparados son iguales;
de lo contrario, devuelve falso. La clase Collections proporciona el método para
ordenar los elementos de tipo List y Comparator. Los elementos de la lista de los
tipos Comparator se ordenan mediante el método Collections.sort(List, Comparator).
Diferencias clave entre comparable y Comparator
1. La interfaz comparable permite una secuencia de clasificación única, lo que significa
que puede comparar solo un elemento de datos único del objeto en el método
compareTo(). Por otro lado, la interfaz Comparator permite múltiples secuencias de
clasificación, lo que significa que puede comparar múltiples elementos de datos del
objeto.
2. La interfaz Comparable es implementada por la clase cuyos objetos se van a
comparar porque la lógica de clasificación se define dentro de la misma clase. Por
otro lado, la clase cuyos objetos se van a comparar no implementa la interfaz
Comparator porque la lógica de clasificación se define en clases separadas donde
cada clase define la clasificación en un solo elemento de datos del objeto y estas
clases de definición implementan la interfaz Comparator.
3. La interfaz Comparable se encuentra dentro del paquete java.lang, mientras que la
interfaz Comparator se encuentra dentro del paquete java.util.
4. La interfaz Comparable declara solo un método que es compareTo(Object obj)
mientras que la interfaz Comparator declara dos métodos que son, compare(Object
obj1, Object obj2) y equals(Object obj).
5. El método compareTo(Object obj) en Comparable compara el método que invoca el
objeto con el objeto especificado pasado al método, mientras que el método
compare(Object obj1, Object obj2) de Comparator compara los objetos obj1 con obj2
que se pasan al método.
6. La clase Collections proporciona un método de ordenación "Collections.sort(List lst)"
para ordenar los objetos del tipo Comparable. La clase Collections proporciona el
método de ordenación Collections.sort(List, Comparator) para ordenar los objetos de
tipo Comparator.

Conclusión:
Si desea ordenar los objetos en el orden natural, puede usar la interfaz Comparable
de lo contrario, si desea ordenar los objetos en función de cualquier atributo, se
utiliza la interfaz Comparator.

Fuente:
https://techdifferences.com/difference-between-comparable-and-comparator-in-java.html

Comparable vs Comparador en Java

Java proporciona dos interfaces para ordenar objetos usando miembros de datos
de la clase:

1. Comparable
2. comparador

Uso de interfaz Comparable

Un objeto comparable es capaz de compararse con otro objeto. La clase en sí
debe implementar la interfaz java.lang.Comparable para comparar sus
instancias.
Considere una clase de película que tiene miembros como, calificación, nombre,
año. Supongamos que deseamos ordenar una lista de películas según el año de
lanzamiento. Podemos implementar la interfaz Comparable con la clase Movie y
anulamos el método compareTo() de la interfaz Comparable.

// A Java program to demonstrate use of Comparable

import java.io.*;
import java.util.*;

// A class 'Movie' that implements Comparable

class Movie implements Comparable<Movie>
{
private double rating;
private String name;
private int year;

// Used to sort movies by year

public int compareTo(Movie m)
{
return this.year - m.year;
}

// Constructor
public Movie(String nm, double rt, int yr)
{
this.name = nm;
this.rating = rt;
this.year = yr;
}

// Getter methods for accessing private data

public double getRating() { return rating; }
public String getName() { return name; }
public int getYear() { return year; }
 }

// Driver class
class Main
{
public static void main(String[] args)
{
ArrayList<Movie> list = new ArrayList<Movie>();
list.add(new Movie("Force Awakens", 8.3, 2015));
list.add(new Movie("Star Wars", 8.7, 1977));
list.add(new Movie("Empire Strikes Back", 8.8, 1980));
list.add(new Movie("Return of the Jedi", 8.4, 1983));

Collections.sort(list);

System.out.println("Movies after sorting : ");

for (Movie movie: list)
{
System.out.println(movie.getName() + " " +
movie.getRating() + " " +
movie.getYear());
}
}
}

Output:
Movies after sorting:

Star Wars 8.7 1977

Empire Strikes Back 8.8 1980

Return of the Jedi 8.4 1983

Force Awakens 8.3 2015

Ahora, supongamos que también queremos ordenar las películas por su

calificación y nombres. Cuando hacemos que un elemento de colección sea
comparable (haciendo que implemente Comparable), solo tenemos una
oportunidad de implementar el método compareTo(). La solución es
usar Comparator.

Usando Comparator
A diferencia de Comparable, Comparator es externo al tipo de elemento que
estamos comparando. Es una clase separada. Creamos múltiples clases
separadas (que implementan Comparator) para comparar por diferentes miembros.
La clase Collections tiene un segundo método sort() y toma Comparator. El método
sort() invoca compare() para ordenar objetos.
Para comparar películas por calificación, debemos hacer 3 cosas:

1. Cree una clase que implemente Comparator (y, por lo tanto, el método
compare() que realiza el trabajo que anteriormente realizaba
compareTo()).
2. Cree una instancia de la clase Comparator.
3. Llame al método sort() sobrecargado, dándole tanto la lista como la
instancia de la clase que implementa Comparator.

//A Java program to demonstrate Comparator interface

import java.io.*;
import java.util.*;

// A class 'Movie' that implements Comparable

class Movie implements Comparable<Movie>
{
private double rating;
private String name;
private int year;

// Used to sort movies by year

public int compareTo(Movie m)
{
return this.year - m.year;
}

// Constructor
public Movie(String nm, double rt, int yr)
{
this.name = nm;
this.rating = rt;
this.year = yr;
}

// Getter methods for accessing private data

public double getRating() { return rating; }
public String getName() { return name; }
public int getYear() { return year; }
}
// Class to compare Movies by ratings
class RatingCompare implements Comparator<Movie>
{
public int compare(Movie m1, Movie m2)
{
if (m1.getRating() < m2.getRating()) return -1;
if (m1.getRating() > m2.getRating()) return 1;
else return 0;
}
}

// Class to compare Movies by name

class NameCompare implements Comparator<Movie>
{
public int compare(Movie m1, Movie m2)
{
return m1.getName().compareTo(m2.getName());
}
}

// Driver class
class Main
{
public static void main(String[] args)
{
ArrayList<Movie> list = new ArrayList<Movie>();
list.add(new Movie("Force Awakens", 8.3, 2015));
list.add(new Movie("Star Wars", 8.7, 1977));
list.add(new Movie("Empire Strikes Back", 8.8, 1980));
list.add(new Movie("Return of the Jedi", 8.4, 1983));

// Sort by rating : (1) Create an object of ratingCompare

// (2) Call Collections.sort
// (3) Print Sorted list
System.out.println("Sorted by rating");
RatingCompare ratingCompare = new RatingCompare();
Collections.sort(list, ratingCompare);
for (Movie movie: list)
System.out.println(movie.getRating() + " " +
movie.getName() + " " +
movie.getYear());

// Call overloaded sort method with RatingCompare

// (Same three steps as above)
System.out.println("\nSorted by name");
 NameCompare nameCompare = new NameCompare();
Collections.sort(list, nameCompare);
for (Movie movie: list)
System.out.println(movie.getName() + " " +
movie.getRating() + " " +
movie.getYear());

// Uses Comparable to sort by year

System.out.println("\nSorted by year");
Collections.sort(list);
for (Movie movie: list)
System.out.println(movie.getYear() + " " +
movie.getRating() + " " +
movie.getName()+" ");
}
}

Producción:
Ordenado por calificación
8.3 El despertar de la fuerza 2015
8.4 El retorno del Jedi 1983
8.7 Star Wars 1977
8.8 El imperio contraataca 1980

Ordenado por nombre

El imperio contraataca 8.8 1980 El despertar de la
fuerza 8.3 2015
El retorno del Jedi 8.4 1983
Star Wars 8.7 1977

Ordenado por año

1977 8.7 Estrella Guerras
1980 8.8 El imperio contraataca
1983 8.4 El retorno del Jedi
2015 8.3 El despertar de la fuerza

 Comparable está destinado a objetos con ordenamiento natural, lo que

significa que el objeto en sí debe saber cómo debe ordenarse. Por
ejemplo, Roll Numbers de estudiantes. Mientras que la clasificación de la
interfaz Comparator se realiza a través de una clase separada.
 Lógicamente, la interfaz Comparable compara "esta" referencia con el
objeto especificado y Comparator en Java compara dos objetos de clase
diferentes provistos.
 Si alguna clase implementa una interfaz Comparable en Java, la
colección de ese objeto, ya sea List o Array, se puede ordenar
automáticamente utilizando el método Collections.sort() o Arrays.sort() y
 los objetos se ordenarán según el orden natural definido por el método
CompareTo.
 Un rasgo diferenciador básico es que usando comparable podemos usar
solo una comparación. Mientras que podemos escribir más de un
comparador personalizado como desee para un tipo determinado, todos
usando diferentes interpretaciones de lo que significa la clasificación. Al
igual que en el ejemplo comparable, solo podíamos ordenar por un solo
atributo, es decir, año, pero en el comparator, también podíamos usar
diferentes atributos como calificación, nombre y año.

Para resumir, si la clasificación de objetos debe basarse en el orden natural, use

Comparable, mientras que, si la clasificación debe realizarse en atributos de diferentes
objetos, use Comparator en Java.

Fuente:
https://www.geeksforgeeks.org/comparable-vs-comparator-in-java/
Diferencia entre comparable y
comparador

En Java, puede escribir sus propios programas si desea ordenar una lista de
elementos. Es posible que tenga una clase de colección como ArrayList o
HashSet. En este caso, si desea ordenar los objetos almacenados en las clases,
podría ser difícil al escribir programas complejos.

Para ayudarlo a clasificar los elementos de una colección, Java proporciona dos
interfaces. Son Comparable y Comparator. La interfaz Comparable le proporcionará
una técnica única para ordenar los elementos. Por otro lado, la interfaz de
Comparator te ofrece diferentes formas de ordenar los elementos.

En este artículo, discutiremos las aplicaciones y las diferencias entre las dos
interfaces.

¿Qué es Comparable en Java?

Antes de clasificar algunos elementos, deben compararse individualmente. Por lo

tanto, para que una clase compare sus miembros de datos, debe implementar la
interfaz java.lang.Comparable. El objeto comparable es capaz de comparar otro
objeto consigo mismo.

La interfaz Comparable se usa comúnmente para clasificar el orden de los

elementos en las clases definidas por el usuario. Puede utilizar esta interfaz para
ordenar los siguientes objetos:

 Objetos de una clase Wrapper

 Objetos String
 Objetos de una clase definida por el usuario

De forma predeterminada, las clases String y Wrapper implementan la interfaz

Comparable. Por lo tanto, si almacena un objeto de clase String o Wrapper en un
conjunto, mapa o lista, serán comparables.
Por ejemplo, tenemos una clase que contiene información sobre libros. Los
miembros de datos son el nombre, el autor, el año de lanzamiento y la
calificación. Para esto, la interfaz Comparable tiene un método llamado
compareTo(T obj). Esto será utilizado por los métodos de clasificación para obtener
el resultado deseado.
En este caso, debe sobrescribir el método compareTo() de manera que
devuelva:

 Entero negativo si un objeto es menor que el otro

 Entero positivo si un objeto es mayor que el otro
 Cero si son iguales

Pero cuando hace que un elemento de una colección sea comparable, solo tendrá
una oportunidad para implementar el método compareTo(). Entonces, puede ordenar
los elementos por un solo criterio, como Autor del libro.
Ejemplo:
//Java Program Example for Comparable

import java.io.*;
import java.util.*;

class Customer implements Comparable<Customer>{

//Variable Declaration
private String name;
private int age;
private int bill;

//Function to compare values start

public int compareTo(Customer m){

return this.age - m.age;
}
//function ends

//Customer Constructor

public Customer (String nm, int ag, int bl)

{
this.name = nm;
this.age = ag;
this.bill = bl;
}

public String getName() { return name; } //Returns the name of customer

public int getAge() { return age; } //Returns the age of customer
public int getBill() {return bill; } //Returns the bill of customer

// Main / Driver Class of program

class Main
{
public static void main (String[] args) {
//object declaration for list
ArrayList<Customer> list = new ArrayList<Customer>();

//Adding Values to the list

list.add(new Customer("Customer 1",39, 49));
list.add(new Customer("Customer 2",14, 275));
 list.add(new Customer("Customer 3",75, 12));
list.add(new Customer("Customer 4",25, 99));
list.add(new Customer("Customer 5",23, 5));

//Here it will call the CompareTo function

Collections.sort(list);

System.out.println("Customers after sorting on Age : ");

for(Customer Customer: list)

{
System.out.println(Customer.getName() + " " +
Customer.getAge() + " " +
Customer.getBill());
}
}
}

PRODUCCIÓN:
Customers after sorting on Age:
Customer 2 14 275
Customer 5 23 5
Customer 4 25 99
Customer 1 39 49
Customer 3 75 12

¿Qué es el Comparator en Java?

Los objetos dentro de una clase definida por el usuario se pueden ordenar utilizando
la interfaz Comparator. Lo principal entre esta interfaz y Comparable es que
Comparator le brinda la funcionalidad de comparar múltiples miembros de datos.
El paquete java.util contiene la interfaz Comparator. El Comparador tiene dos
métodos:

 public int compare (Object obj1, Object obj2): compara el primer y el segundo
objeto que se le pasan.
 public boolean equals (elemento de objeto): este método compara el objeto
actual con el otro objeto que se especifica en el método.

Cuando utiliza el método compare, debe devolver lo siguiente:

 Obtendrá un entero negativo si el otro argumento es mayor que el

primer argumento
 Un entero positivo, si el primer argumento pasado es mayor que el
segundo argumento
 Si ambos argumentos son iguales, obtienes un cero
En el caso del método equals, comprueba si el objeto y el comparator que invoca
son iguales. Aquí, el argumento obj se usa para probar la igualdad. Si tanto el
argumento obj como los objetos que invocan son objetos Comparator, el método
devolverá verdadero. El orden de los objetos tiene que ser el mismo. O bien, el
método devolverá un valor falso.
Puede utilizar la interfaz Comparator en los siguientes casos:

 Para ordenar una lista de objetos o una matriz usando un orden

personalizado.
 Puede ordenar la misma lista de objetos o matriz en diferentes campos.
 Para ordenar una lista de objetos o una matriz cuyo código fuente no se
puede modificar para implementar la interfaz Comparable.
 La interfaz Comparator es útil al usar un grupo al ordenar una lista de objetos
o una matriz para diferentes campos.

La clase Collections tiene un método sort para organizar elementos de tipo

Comparator y una lista. Puede ordenar los elementos de la lista que tienen el tipo
Comparator por Collections.sort (Lista, Comparator).
Ejemplo:
//Java program for Comparator

import java.io.*;
import java.util.*;

// Class 'Customer' implements Comparable

class Customer implements Comparable<Customer>{

//Variable Declaration

private String name;

private int age;
private int bill;

//Function to compare values start

public int compareTo(Customer m){

return this.age - m.age;
}

//function ends

//Customer Constructor

public Customer (String nm, int ag, int bl)

{
this.name = nm;
this.age = ag;
 this.bill = bl;
}

public String getName() { return name; } //Returns the name

of customer
public int getAge() { return age; } //Returns the age of
customer
public int getBill() {return bill; } //Returns the bill of
customer

//This class used to get sorting on Name

class NameCompare implements Comparator<Customer>
{
public int compare(Customer c1, Customer c2)
{
return c1.getName().compareTo(c2.getName());
}
}

//Main / Driver Class of program

class Main
{
public static void main (String[] args) {

//object declaration for list

ArrayList<Customer> list = new ArrayList<Customer>();

//Adding Values to the list

list.add(new Customer("Customer 1",39, 49));

list.add(new Customer("Customer 2",14, 275));
list.add(new Customer("Customer 3",75, 12));
list.add(new Customer("Customer 4",25, 99));
list.add(new Customer("Customer 5",23, 5));

//Here it will call the CompareTo function

Collections.sort(list);

//Sorting on Age

System.out.println("Customers after sorting on Age : ");

for(Customer Customer: list)

{
System.out.println(Customer.getName() + " " +
Customer.getAge() + " " +
 Customer.getBill());
}

//Sorting on Name

System.out.println("\nCustomer Sorted by name : ");

NameCompare nameCompare = new NameCompare();
Collections.sort(list, nameCompare);
for (Customer Customer: list)
System.out.println(Customer.getName() + " " +
Customer.getAge() + " " +
Customer.getBill());
}
}

PRODUCCIÓN:

Customers after sorting on Age:

Customer 2 14 275
Customer 5 23 5
Customer 4 25 99
Customer 1 39 49
Customer 3 75 12

Customer Sorted by name:

Customer 1 39 49
Customer 2 14 275
Customer 3 75 12
Customer 4 25 99
Customer 5 23 5

Comparador vs Comparable

Base de
Comparable Comparator
Comparación
Número de Le ofrece con una sola técnica de Esta interfaz le brinda múltiples
técnicas de clasificación. Por ejemplo, puede técnicas para ordenar elementos.
clasificación ordenar los elementos en función
de una sola propiedad como ID o
nombre.
Ordenar Es útil para objetos que tienen un Es útil para objetos que pueden no
orden natural. Por ejemplo, tener un orden natural.
número de serie de los empleados.
Paquete La interfaz está presente en el Esto está presente en el paquete
paquete java.lang java.util
Métodos Esta interfaz tiene el int público Esta interfaz tiene el método public
 compareTo() para ordenar int compare() y boolean equals()
elementos
Procedimiento En compareTo(Object obj), el Aquí, en el método
de comparación objeto que invoca el método se compare(Object obj1, Object obj2),
compara con el objeto pasado en se comparan ambos objetos que se
el método pasan a este método
Efecto en la Aquí la clase original se ve afectada Esta interfaz no modifica la clase
clase original y se modifica. Esto se debe a que la original. Aquí, la interfaz es
clase implementa la interfaz cuyos implementada por una clase
objetos desea comparar. separada en lugar de la original.
Elementos de La clase Collection le proporciona La clase Collection le proporciona
las lista Collections.sort(List) para Collections.sort(List, Comparator)
comparar elementos de lista de para ordenar los elementos de la
tipo Comparable. lista que tienen el tipo Comparator

Conclusión

Las interfaces Comparable y Comparator tienen aplicaciones ligeramente

diferentes. Tienes que usarlos en función de tus necesidades. La interfaz
Comparable se usa cuando desea ordenar una colección de elementos en función
de un solo elemento. Por otro lado, puede utilizar la interfaz Comparator para
ordenar elementos en función de más de un criterio.

Para el método Comparable, Collection.sort() y Arrays.sort() usan el método

compareTo(). Pero en el caso de la interfaz Comparator, puede usar el método
compare() proporcionado por la clase Comparator.

Si desea ordenar los elementos en función de su orden de clasificación natural, debe

usar Comparable. Para clasificar elementos según un orden de clasificación
personalizado, utilice el Comparator.

Fuente:
https://www.stechies.com/difference-between-comparable-comparator/
Comparable y Comparator en Java

Visión general
Todos estamos familiarizados con la clasificación de datos de tipos de datos primitivos
como int, String, char, etc. Podemos pasar la matriz al método Arrays.sort() directamente,
y Java se encarga de clasificar esos valores porque Java sabe cómo ordenar números,
caracteres o cadenas. Pero, ¿qué pasa con los objetos personalizados que creamos
como Student, Employee, etc.? Java no sabe cómo ordenar estos objetos personalizados, y
necesitamos proporcionar la lógica para ordenar estos objetos personalizados
explícitamente.

Java proporciona dos interfaces, Comparable y Comparator, que se pueden usar para
ordenar objetos personalizados y objetos basados en varios miembros de datos.

Alcance
 En este artículo, comprenderemos las interfaces Comparable y Comparator y cómo
se utilizan para ordenar una colección de objetos en Java.
 Aprenderemos sobre las operaciones proporcionadas por las
interfaces Comparable y Comparator con ejemplos.

Introducción
Comparable y Comparator, está claro por el nombre que estos se usan para comparar
cosas. En Java, puede ser un valor o un objeto. Pero, ¿en qué se diferencian unos de
otros? Este artículo explicará el funcionamiento de Comparable y Comparator con un
ejemplo en tiempo real.

Considere crear una API REST (la API es responsable de la comunicación entre los sistemas
informáticos) que devuelva la lista de superhéroes del servidor. A continuación, se
muestran los casos de uso que necesitamos.

 GET /superheroes Devuelve todos los superhéroes ordenados por id en orden

ascendente.

 GET /superheroes?sort=name Devuelve todos los superhéroes ordenados

por nombre en orden ascendente.

 GET /superheroes?sort=age Devuelve todos los superhéroes ordenados

por edad en orden ascendente.
Antes de continuar, creemos la clase SuperHero con tres atributos id, name y age.
Usaremos esta clase en las partes posteriores de este artículo.

class SuperHero {
private final String id;
private final String name;
private final int age;

/* class constructor */
public SuperHero(String id, String name, int age) {
this.id = id;
this.name = name;
this.age = age;
}

public String getId() { return this.id; } // getId function

public String getName() { return this.name; } // getName

function

public int getAge() { return this.age; } // getAge function

@Override
public String toString() {
return String.format("ID: %s | name: %s | Age: %d", id,
name, age);
}
}

¿Qué es comparable en Java?

Comparable es una interfaz en Java que permite comparar un objeto con otros objetos
del mismo tipo. El paquete java.lang proporciona una interfaz comparable . Varias clases
integradas en Java como Integer, Double, String, etc., implementan la interfaz
Comparable.

Comparable se usa para ordenar objetos por orden natural o predeterminado, lo que
significa que el objeto mismo sabe cómo debe ordenarse. Ejemplo: Los
objetos SuperHero deben ordenarse por id.
Comparable proporciona una sola secuencia de clasificación. Significa que los objetos se
pueden ordenar en función de un solo miembro de datos. Ejemplo: el objeto SuperHero se
puede ordenar en función de un solo atributo como id, nombre o edad.

Sintaxis

class T implements Comparable<T> {

@Override
public int compareTo(T t) {
// comparasion logic
}
}

Una clase tiene que implementar la interfaz Comparable e implementar el método

compareTo() para poder compararla con otros objetos del mismo tipo.

Métodos utilizados en Comparable

compareTo()

La interfaz Comparable tiene exactamente un método compareTo() que acepta un solo

objeto como parámetro y devuelve un valor entero. Java determina el orden de
clasificación en función del valor entero devuelto por el método compareTo().

Sintaxis

int compareTo(T o1);

Considere que un objeto x se compara con y a través de la declaración x.compareTo(y),

entonces el valor devuelto por el método debe ser

 0, si los valores en x e y son iguales.

 Negativo, si el valor en x es menor que en y.
 Positivo, si el valor en x es mayor que en y.

Ejemplo de Comparable en Java

Tomaremos nuestro primer caso de uso, GET /superheroes. Este endpoint debería
devolver la lista de superhéroes ordenados por id en orden ascendente. Necesitamos
hacer que la clase SuperHero se ordene por id en orden ascendente. Esto se puede lograr
en dos pasos.

1. Haga que la clase SuperHero implemente la interfaz Comparable.

2. Sobrescriba el método compareTo() .

// 1. Implement Comparable interface

class SuperHero implements Comparable<SuperHero> {
private final String id;
private final String name;
private final int age;

public SuperHero(String id, String name, int age) {

this.id = id;
this.name = name;
this.age = age;
}

// 2. override compareTo method.

@Override
public int compareTo(final SuperHero superHero) {
return this.id.compareTo(superHero.id);
}

public String getId() { return this.id; }

public String getName() { return this.name; }

public int getAge() { return this.age; }

@Override
public String toString() {
return String.format("ID: %s | Name: %s | Age: %d", id,
name, age);
}
}

public class Main {

public static void main(String[] args) {
List<SuperHero> superHeroes = new ArrayList<>();

superHeroes.add(new SuperHero("2", "Iron Man", 35));

superHeroes.add(new SuperHero("1", "Captain America", 25));
superHeroes.add(new SuperHero("3", "Hulk", 20));

Collections.sort(superHeroes);
/* printing result */
superHeroes.forEach(superHero ->

System.out.println(superHero.toString()));
}
}

Salida

ID: 1 | Name: Captain America | Age: 25

ID: 2 | Name: Iron Man | Age: 35
ID: 3 | Name: Hulk | Age: 20

Explicación

Implementamos la interfaz Comparable y sobrescribimos el método compareTo() para

ordenar los objetos SuperHero por id . Collections.sort() llama internamente al método
compareTo() de los objetos SuperHero para ordenarlos por id.

¿Qué es Comparador en Java?

Comparator es una interfaz funcional en Java que se puede utilizar para clasificar objetos
y se proporciona en el paquete java.util .

Una interfaz funcional es una interfaz que contiene exactamente un método

abstracto. También se denomina interfaces de Método Abstracto Único (SAM) .

Pero espera, esto es lo que hace la interfaz Comparable. Entonces, ¿por qué necesitamos
la interfaz Comparator? Si una clase implementa la interfaz Comparable, entonces es
consciente de cómo ordenarse porque la propia clase ha implementado el método
compareTo() . Esto se denomina orden predeterminado. Comparador se usa
para pedidos personalizados donde la clase desconoce la lógica de pedido.

Comparator proporciona múltiples secuencias de clasificación (es decir) clasificación de

objetos en función de múltiples miembros de datos. Ejemplo: los objetos SuperHero se
pueden ordenar en función de múltiples atributos como id, nombre y edad.

Sintaxis

Comparator<T> comparator = (T t1, T t2) -> { //comparison logic }

Comparator se puede crear usando una lambda que acepta dos objetos del tipo dado y
debe devolver un valor entero.

Métodos utilizados en Comparator

compare()

El método compare() acepta dos objetos como parámetros de entrada y devuelve un valor
entero.

Sintaxis

int compare(T o1, T o2);

Comparator decide el orden de clasificación en función del valor entero devuelto por
el método compare() .

 0, si los valores en o1 y o2 son iguales.

 Negativo, si el valor en o1 es menor que en o2.
 Positivo, si el valor en o1 es mayor que en o2.

Ejemplo

En este ejemplo, sobrescribimos el método compare() a través de la expresión lambda.

Comparator<SuperHero> ageComparator =
(s1, s2) -> s1.getAge() - s2.getAge();

El código anterior es equivalente a

Comparator<SuperHero> ageComparator = new Comparator<SuperHero>() {

@Override
public int compare(final SuperHero s1, final SuperHero s2) {
return s1.getAge() - s2.getAge();
}
};
equals()

El método equals() se puede usar para verificar si un objeto y el comparator son iguales, es
decir; este método puede devolver verdadero solo si ambos objetos son comparators e
imponen el orden exacto. El método equals() acepta exactamente un objeto como entrada
y devuelve un valor booleano.

Sintaxis

comparator1.equals(comparator2);

El método equals() se puede invocar en cualquier instancia del comparator y acepta otra
instancia del comparator como entrada.

Ejemplo

En este ejemplo, creamos dos comparadores nameComparator y ageComparator y

verificamos su igualdad usando el método equals().

Comparator<SuperHero> comparator = new Comparator<SuperHero>() {

@Override
public boolean equals(final Object obj) {
if (!(obj instanceof Comparator)) return false;

SuperHero s1 = new SuperHero("1", "Tony", 24);

SuperHero s2 = new SuperHero("2", "Steve", 25);

// checking if both the comparator returns the same value.

return Integer.signum(this.compare(s1, s2))
== Integer.signum(((Comparator<SuperHero>)
obj).compare(s1, s2));
}

@Override
public int compare(final SuperHero s1, final SuperHero s2) {
return s1.getAge() - s2.getAge();
}
};

Comparator<SuperHero> ageComparator
 = (s1, s2) -> s1.getAge() - s2.getAge();

Comparator<SuperHero> nameComparator
= (s1, s2) -> s1.getName().compareTo(s2.getName());

System.out.println(comparator.equals(ageComparator));
System.out.println(comparator.equals(nameComparator));

Producción

true
false

Explicación

En este ejemplo, sobrescribimos el método equals() para comprobar si los comparators

son iguales comparando el valor de retorno de su método compare().

 comparator.equals(ageComparator) devuelve verdadero porque ambos clasifican

los objetos SuperHero por edad e imponen el mismo orden.
 comparator.equals(nameComparator) devuelve false porque comparator y nameC
omparator ordenan los objetos SuperHero por edad y nombre respectivamente y
no imponen el mismo orden.

Validar el ejemplo

comparing() and thenComparing()

Comparator proporciona los métodos comparing () y thenComparing () que se utilizan

para aplicar una serie de comparaciones a la colección. Se pueden encadenar múltiples
comparators para aplicar una serie de secuencias de ordenación a una colección de
objetos.

Sintaxis

comparing()

Comparator comparing(Function keyExtractor);

El método compare() acepta un Function como entrada y devuelve un Comparator .

 keyExtractor : la función utilizada para extraer la clave de ordenación Comparable.

thenComparing()

Comparator thenComparing(Function keyExtractor, Comparator

keyComparator);

El método thenComparing() acepta un Función y un Comparator como entradas y

devuelve un Comparator .

 keyExtractor : la función utilizada para extraer la clave de ordenación Comparable.

 keyComparator : el Comparator utilizado para comparar la clave de ordenación.

Example

public class Main {

public static void main(String[] args) {
List<SuperHero> superHeroes = new ArrayList<>();

superHeroes.add(new SuperHero("3", "Hulk", 20));

superHeroes.add(new SuperHero("4", "Captain America", 25));
superHeroes.add(new SuperHero("1", "Captain America", 28));

superHeroes.sort(
Comparator.comparing(SuperHero::getName)
.thenComparing(SuperHero::getAge,
Comparator.reverseOrder())
);

System.out.println("Ordered by Name asc and Age desc");

superHeroes.forEach(superHero ->

System.out.println(superHero.toString()));
}
}

Output

Ordered by Name asc and Age desc

ID: 4 | Name: Captain America | Age: 28
ID: 1 | Name: Captain America | Age: 25
ID: 3 | Name: Hulk | Age: 20
ID: 2 | Name: Iron Man | Age: 35
Explicación

 El comparator que creamos está encadenado con dos métodos, comparing() y

thenComparing() que ordena a los superhéroes por nombre ascendente y por edad
descendente, respectivamente. Comparator.reverseOrder() especifica que la lista
debe ordenarse en orden descendente.
 Después ordenando la lista a través de comparing(SuperHero::getName)

Ejemplo de Comparator en Java

Considere nuestro segundo y tercer caso de uso, GET /superheroes?sort=name y GET
/superheroes?sort=age que devuelve superhéroes ordenados por nombre y edad en
orden ascendente, respectivamente. Ya anulamos el método compareTo() para ordenar
los objetos SuperHero por id . Por lo tanto, no es posible usarlo para ordenar
por nombre o edad. Aquí llega el Comparator salvavidas que nos permite crear
comparadores personalizados. Ejemplo: nameComparator, ageComparator.

public class Main {

public static void sortByName(List<SuperHero> superHeroes) {
// Comparator to sort by name ascending
Comparator<SuperHero> nameComparator = (SuperHero s1,
SuperHero s2) ->
{
return s1.getName().compareTo(s2.getName());
};

superHeroes.sort(nameComparator);
}

public static void sortByAge(List<SuperHero> superHeroes) {

// Comparator to sort by age ascending
Comparator<SuperHero> ageComparator = (SuperHero s1,
SuperHero s2) ->
{
return s1.getAge() - s2.getAge();
};

superHeroes.sort(ageComparator);
}

public static void main(String[] args) {

List<SuperHero> superHeroes = new ArrayList<>();

superHeroes.add(new SuperHero("2", "Iron Man", 35));

superHeroes.add(new SuperHero("1", "Captain America", 25));
superHeroes.add(new SuperHero("3", "Hulk", 20));
 System.out.println("Sorting By Name Ascending...");
sortByName(superHeroes);
superHeroes.forEach(superHero ->

System.out.println(superHero.toString()));

System.out.println("");

System.out.println("Sorting By Age Ascending...");

sortByAge(superHeroes);
superHeroes.forEach(superHero ->

System.out.println(superHero.toString()));
}
}

Producción:

Sorting By Name Ascending...

ID: 1 | Name: Captain America | Age: 25
ID: 3 | Name: Hulk | Age: 20
ID: 2 | Name: Iron Man | Age: 35

Sorting By Age Ascending...

ID: 3 | Name: Hulk | Age: 20
ID: 1 | Name: Captain America | Age: 25
ID: 2 | Name: Iron Man | Age: 35

Explicación

Creamos nameComparator y comparator, que ordenan los objetos SuperHero por nombre
y edad, respectivamente. Los comparadores se crean usando expresiones lambda porque
Comparator es una interfaz funcional.

Una interfaz funcional es una interfaz que contiene exactamente un método abstracto.
También se denomina Interfaces de Método Abstracto Único (SAM). Puede tener
cualquier número de métodos predeterminados(default).

Difference Between Comparable and Comparator in Java

Comparable Comparator
Comparable es una interfaz en Java. Comparator es una interfaz funcional en
 Java.
Comparable proporciona el método Comparator proporciona el método
compareTo() para ordenar objetos. compare() para ordenar objetos.
Comparable es parte del paquete Java.lang. Comparator es parte del paquete java.util.
Comparable se puede utilizar para pedidos Comparator se puede utilizar para pedidos
naturales o predeterminados. personalizados.
Comparable proporciona una única secuencia Comparator proporciona múltiples
de clasificación. Ej: Ordenar por id o nombre secuencias de clasificación. Ej. Ordenar por id
y nombre.
Comparable modifica la clase que lo Comparator no modifica ninguna clase.
implementa.

Fuente:

https://www.scaler.com/topics/java/comparable-and-comparator-in-java/
 Comparable Vs Comparador En Java
Las interfaces Comparable y Comparator se utilizan para realizar
operaciones de clasificación en la colección de objetos. Java también
proporciona algunos métodos integrados para ordenar una matriz de tipos
primitivos o una matriz/lista de elementos de la clase Wrapper. Pero
cuando se trata de la clasificación de objetos de clase personalizados, se
utilizan las interfaces java.lang.Comparable y java.util.Comparator.

Ejemplo: ordenar matriz de tipos primitivos y lista de objetos

String

import java.util.*;
public class Main {

public static void main(String args[])

{
//Creating array of Primitive Type
int[] intArray = {15,93,10,50, 44};

//Print array elements

System.out.println("Int Array before sorting: "
+ Arrays.toString(intArray));

//Sorting array elements

Arrays.sort(intArray);

//Print array elements

System.out.println("Int Array after sorting: "
+ Arrays.toString(intArray));

//Creating String array

String[] strArray = {"java", "c", "php",
"oracle", "sql"};

//Print array elements

 System.out.println("String Array before
sorting: " + Arrays.toString(strArray));

//Sorting array elements

Arrays.sort(strArray);

//Print array elements

System.out.println("String Array after sorting:
" + Arrays.toString(strArray));

//Creating list of Wrapper class objects

List<String> strList = new ArrayList<>();

//Adding elements to list

strList.add("java");
strList.add("c");
strList.add("php");
strList.add("oracle");
strList.add("sql");

//Print array elements

System.out.println("String List before sorting:
" + strList);

//Sorting list elements

Collections.sort(strList);

//Print array elements

System.out.println("String List after sorting:
" + strList);
}
}

Producción

Int Array before sorting: [15, 93, 10, 50, 44]

Int Array after sorting: [10, 15, 44, 50, 93]
String Array before sorting: [java, c, php, oracle,
sql]
String Array after sorting: [c, java, oracle, php, sql]
String List before sorting: [java, c, php, oracle, sql]
String List after sorting: [c, java, oracle, php, sql]
Intentemos ordenar la lista de objetos personalizados.

import java.util.*;

class Student {
private int id;
private String name;
private int age;

public Student(int id, String name, int age) {

this.id = id;
this.name = name;
this.age = age;
}

public int getId() {

return id;
}

public String getName() {

return name;
}

public int getAge() {

return age;
}

@Override
//Override toString method to return Student
details
public String toString() {
return "[id=" + this.id + ", name=" + this.name
+ ", age=" + this.age +"]";
}

public class Main {

public static void main(String args[])

{
 //Creating Student list
ArrayList<Student> stuList = new
ArrayList<Student>();

//Adding Student elements

stuList.add(new Student(1, "Himanshi", 32));
stuList.add(new Student(4, "Amani", 33));
stuList.add(new Student(3, "Swati", 33));
stuList.add(new Student(2, "Prabhjot", 31));

//Print array elements

System.out.println("List before sorting: ");
for(Student student : stuList){
System.out.println(student);
}

//Sorting list elements

Collections.sort(stuList);

//Print array elements

System.out.println("List after sorting: ");
for(Student student : stuList){
System.out.println(student);
}
}
}

Producción

Main.java:54: error: no suitable method found for

sort(ArrayList)
Collections.sort(stuList);
^
method Collections.<T#1>sort(List<T#1>) is not
applicable
(inference variable T#1 has incompatible bounds
equality constraints: Student
upper bounds: Comparable<? super T#1>)
method Collections.<T#2>sort(List<T#2>,Comparator<?
super T#2>) is not applicable
(cannot infer type-variable(s) T#2
 (actual and formal argument lists differ in
length))
where T#1,T#2 are type-variables:
T#1 extends Comparable<? super T#1> declared in
method <T#1>sort(List<T#1>)
T#2 extends Object declared in method
<T#2>sort(List<T#2>,Comparator<? super T#2>)
1 error

Interfaz comparable

Se puede usar una interfaz comparable para la operación de clasificación

en la colección de objetos personalizados, que se define en el paquete
java.lang. Solo tiene un método que es compareTo(Object o). Devuelve
un valor int negativo, cero o un valor int positivo si "este", es decir, el
objeto actual es menor, igual o mayor que el objeto pasado como
parámetro/argumento.

Clases Wrapper y String implementa interfaz Comparable.

Nota:
Al implementar la interfaz Comparable, podemos tener una clasificación
predeterminada y no podemos cambiarla dinámicamente. Por ejemplo, en
el código a continuación, hemos realizado la clasificación según la
identificación del estudiante y si queremos ordenar los elementos según el
nombre del estudiante, no podemos hacerlo.

Ejemplo anterior con la implementación de Interface Comparable.

import java.util.*;

class Student implements Comparable<Student> {

private int id;
private String name;
private int age;

public Student(int id, String name, int age) {

this.id = id;
this.name = name;
this.age = age;
 }

public int getId() {

return id;
}

public String getName() {

return name;
}

public int getAge() {

return age;
}

@Override
//Override compareTo method to customizing sorting
algorithm
public int compareTo(Student stu) {
return (this.id - stu.id);
}

@Override
//Override toString method to return Student
details
public String toString() {
return "[id=" + this.id + ", name=" + this.name
+ ", age=" + this.age +"]";
}

public class Main {

public static void main(String args[])

{
//Creating Student list
ArrayList<Student> stuList = new
ArrayList<Student>();

//Adding Student elements

stuList.add(new Student(1, "Himanshi", 32));
stuList.add(new Student(4, "Amani", 33));
stuList.add(new Student(3, "Swati", 33));
stuList.add(new Student(2, "Prabhjot", 31));
 //Print array elements
System.out.println("List before sorting: ");
for(Student student : stuList){
System.out.println(student);
}

//Sorting list elements

Collections.sort(stuList);

//Print array elements

System.out.println("List after sorting: ");
for(Student student : stuList){
System.out.println(student);
}
}
}

Producción
List before sorting:
[id=4, name=Amani, age=33]
[id=3, name=Swati, age=33]
[id=2, name=Prabhjot, age=31]
List after sorting:
[id=1, name=Himanshi, age=32]
[id=2, name=Prabhjot, age=31]
[id=3, name=Swati, age=33]
[id=4, name=Amani, age=33]

Interfaz Comparator
Al igual que la interfaz Comparable, la interfaz Comparator también se usa
para ordenar una colección de objetos personalizados y se define en el
paquete java.util. Su método compare (Object obj1, Object obj2) debe
implementarse. El método compare(Object obj1,Object obj2) debe
implementarse de tal manera que devuelva un valor int negativo, cero o
un valor int positivo si el primer objeto/argumento es menor, igual o
mayor que el segundo. objeto/argumento.

Nota: Proporciona el mecanismo para cambiar dinámicamente el

mecanismo de clasificación predeterminado.
import java.util.*;
import java.io.*;

class Student {
private int id;
private String name;
private int age;

public Student(int id, String name, int age) {

this.id = id;
this.name = name;
this.age = age;
}

public int getId() {

return id;
}

public String getName() {

return name;
}

public int getAge() {

return age;
}

//Compare based on id
public static Comparator<Student> IdComparator =
new Comparator<Student>() {

@Override
public int compare(Student stu1, Student stu2)
{
return (int) (stu1.getId() - stu2.getId());
}
};

//Compare based on name

public static Comparator<Student> NameComparator =
new Comparator<Student>() {

@Override
public int compare(Student stu1, Student stu2)
{
 return
stu1.getName().compareTo(stu2.getName());
}
};

@Override
//Override toString method to return Student
details
public String toString() {
return "[id=" + this.id + ", name=" + this.name
+ ", age=" + this.age +"]";
}

public class Main {

public static void main(String args[])

{
//Creating Student list
ArrayList<Student> stuList = new
ArrayList<Student>();

//Adding Student elements

stuList.add(new Student(1, "Himanshi", 32));
stuList.add(new Student(4, "Amani", 33));
stuList.add(new Student(3, "Swati", 33));
stuList.add(new Student(2, "Prabhjot", 31));

//Print array elements

System.out.println("List before sorting: ");
for(Student student : stuList){
System.out.println(student);
}

//Sorting list elements by Student Id

Collections.sort(stuList,
Student.IdComparator);

//Print array elements

System.out.println("List after sorting by
Student Id: ");
for(Student student : stuList){
System.out.println(student);
}
 //Sorting list elements by Student Name
Collections.sort(stuList,
Student.NameComparator);

//Print array elements

System.out.println("List after sorting by
Student Name: ");
for(Student student : stuList){
System.out.println(student);
}
}
}

Producción
List before sorting:
[id=1, name=Himanshi, age=32]
[id=4, name=Amani, age=33]
[id=3, name=Swati, age=33]
[id=2, name=Prabhjot, age=31]
List after sorting by Student Id:
[id=1, name=Himanshi, age=32]
[id=2, name=Prabhjot, age=31]
[id=3, name=Swati, age=33]
[id=4, name=Amani, age=33]
List after sorting by Student Name:
[id=4, name=Amani, age=33]
[id=1, name=Himanshi, age=32]
[id=2, name=Prabhjot, age=31]
[id=3, name=Swati, age=33]

Diferencia entre comparable y comparador

en Java
Comparable Comparator
Solo proporciona una secuencia Proporciona múltiples tipos de secuencias y
predeterminada o de un tipo y no podemos podemos cambiar la secuencia de
cambiarla dinámicamente. clasificación dinámicamente.
Proporciona el método compareTo() que se Proporciona el método compare () que se
implementará para el mecanismo de implementará para el mecanismo de
clasificación. clasificación.
 Está en el paquete java.lang. Está en el paquete java.util.
Si implementamos la interfaz Comparable, la La clase real se puede modificar o
clase real se modifica. no. Depende de cómo hayamos
implementado la interfaz Comparator. En la
implementación anterior, tenemos que
modificar nuestra clase real, pero si
implementamos Comparator como un
comparador de clase separado, no habrá
ningún cambio en la clase real. Vea el
siguiente ejemplo como una referencia del
comparador de nombres de estudiantes
como una clase separada.

import java.util.*;
class NameComparator implements Comparator<Student>{
public int compare(Student stu1,Student stu2){
return stu1.name.compareTo(stu2.name);
}
}

Fuente:

https://www.w3schools.blog/comparable-comparator-java
Comparable y Comparador en Java:
diferencia entre ellos
Diferencia clave entre comparable y comparador en Java

 Comparable en Java es un objeto para compararse con otro objeto,

mientras que Comparator es un objeto para comparar diferentes objetos
de diferentes clases.
 Comparable proporciona el método compareTo() para ordenar elementos
en Java, mientras que Comparator proporciona el método compare()
para ordenar elementos en Java.
 Una interfaz Comparable está presente en el paquete java.lang, mientras
que la interfaz Comparator está presente en el paquete java.util.
 Comparable proporciona una sola secuencia de clasificación, mientras
que Comparator proporciona múltiples secuencias de clasificación.
 Comparable afecta a la clase original, mientras que Comparator no afecta
a la clase original.

¿Qué es comparable en Java?

Comparable en Java es un objeto para compararse con otro objeto. Ayuda a
ordenar la lista de objetos personalizados. Una clase debe implementar la
interfaz Comparable java.lang. para poder comparar sus instancias. La matriz de
objetos que implementan una interfaz comparable se ordena automáticamente
mediante los métodos Arrays.sort y Collections.sort.

¿Qué es el Comparator en Java?

Comparator en Java es un objeto para comparar diferentes objetos de
diferentes clases. La interfaz de Comparator en Java también se usa para
ordenar los objetos de las clases definidas por el usuario. Incluye dos
importantes métodos la interfaz de Comparator conocidos como compare
(Object obj1, Object obj2) y equals (Object element).
Diferencias entre Comparable y Comparator en Java
Aquí está la principal diferencia entre Java Comparable y Comparator:

Comparable Comparator
Comparable proporciona el método Comparator proporciona el método
compareTo() para ordenar elementos en compare() para ordenar elementos en Java.
Java.
La interfaz Comparable está presente en el La interfaz del Comparator está presente en
paquete java.lang. el paquete java.util.
La lógica de ordenación debe estar en la La lógica de ordenación debe estar en una
misma clase cuyo objeto va a ordenar. clase separada para escribir una ordenación
diferente basada en diferentes atributos de
objetos.
La clase cuyos objetos desea ordenar debe La clase, cuyos objetos desea ordenar, no
implementar una interfaz Comparable. necesita implementar la interfaz Comparator.
Proporciona secuencias de ordenación Proporciona múltiples secuencias de
individuales. ordenación.
Este método puede clasificar los datos según Este método ordena los datos según el orden
el orden de clasificación natural. de clasificación personalizado.
Afecta a la clase original. es decir, se altera la No afecta a la clase original, es decir, la clase
clase real. real no se altera.

Implementado con frecuencia en la API por: Se implementa para ordenar instancias de

Calendar, clases envoltorio, Date y clases de terceros.
String.
Todas las clases envoltorio y la clase String Las únicas clases implementadas de
implementan la interfaz Comparable. Comparator son Collator y RuleBasedColator.

Método utilizado en Comparable

El siguiente es un método importante utilizado en la interfaz Comparable:

CompareTo():
El método CompareTo() se utiliza para realizar una clasificación natural en
cadenas. El significado de clasificación natural es el orden de clasificación que
se aplica al objeto, por ejemplo, orden numérico para clasificar enteros, orden
alfabético para cadenas, etc.

La sintaxis del método CompareTo() es la siguiente:

int compareTo(T obj)

En la sintaxis anterior, T significa el tipo de objetos que va a comparar.

El método CompareTo() compara el objeto con T obj.

Producción:

 Devuelve 0 si los valores son iguales.

 En caso de que el objeto tenga un valor menor, este método devuelve un
valor negativo.
 Si el objeto tiene un valor más alto, devuelve un valor positivo.

Ejemplo del método CompareTo():

El siguiente programa de ejemplo comparable de Java muestra la comparación
de dos caracteres, "a" y "b". El carácter "a" viene antes de "b" alfabéticamente.

Por lo tanto, la salida es -1. El carácter "b" viene después de "a"

alfabéticamente. Por lo tanto, la salida es 1. Los caracteres "a" y "b" son
equivalentes. Por lo tanto, la salida es 0.

public class Sample_String {

public static void main(String[] args) {
String str_Sample = "a";
System.out.println("Compare To 'a' b is : " + str_Sample.compareTo("b"));
str_Sample = "b";
System.out.println("Compare To 'b' a is : " + str_Sample.compareTo("a"));
str_Sample = "b";
System.out.println("Compare To 'b' b is : " + str_Sample.compareTo("b"));
}
}

Producción

Comparar con 'a' b es: -1

Comparar con 'b' a es: 1
Comparar con 'b' b es: 0

Método utilizado en Comparator

Los siguientes son los métodos importantes utilizados en la interfaz del
Comparator:

Compare():
Compare() le permite ordenar objetos. Para hacer esto, debe crear una clase que
implemente la interfaz Comparator. Después de esto, debe sobrescribir el
método de compare.

La sintaxis del método compare() es la siguiente:

compare(Objeto obj1, Objeto obj2)

En la sintaxis anterior, obj1 y obj2 son dos objetos que debe comparar utilizando
el método compare().

Producción:

 Devuelve un entero negativo si el primer argumento es menor que el

segundo.
 Devuelve cero si el primer argumento y el segundo argumento son
iguales.
 Este método puede devolver un número entero positivo, en caso de que el
primer argumento sea mayor que el segundo.

Tienes que asegurarte de que la relación sea transitiva. Por ejemplo,

((compare(a, b)>0) && (compare(b, c)>0)) que implica compare(a, c)>0.

Ejemplo de método de compare:

En el siguiente programa ejemplo de Comparator de Java, hay 6 variables. “x”,
“y”, “p”, “q”, “r” y “s”. La salida es -1 ya que el valor de "x", 20 es menor que el
valor de "y", 30. La salida es 0 porque el valor de "p", 40 es igual al valor de "q",
40.

public class example {

public static void main(String args[])

{
int x = 20;
int y = 30;

// as 10 less than 20,

// Output will be a value less than zero
System.out.println(Integer.compare(x, y));
 int p = 40;
int q = 40;

// as 30 equals 30,
// Output will be zero
System.out.println(Integer.compare(p, q));

int r = 20;
int s = 7;

// as 15 is greater than 8,
// Output will be a value greater than zero
System.out.println(Integer.compare(r, s));
}
}

Producción:

-1
0
1

equals():
El método equals() verifica si el objeto numérico es igual al objeto que se pasa
como argumento o no.

La sintaxis del método equals() es la siguiente:

public boolean equals(Objeto o)

Este método toma dos parámetros 1) cualquier objeto 2) valor

devuelto. Devuelve verdadero si el argumento pasado no es nulo y es un objeto
del tipo similar que tiene el mismo valor numérico.

Ejemplo de método equals

En el siguiente ejemplo, estamos comparando las cuatro variables entre sí. Tres
variables son de tipo entero y una de tipo short. El primer resultado es falso ya
que el valor de p, que es 5, no es igual al valor de q, que es 20.

El segundo resultado es verdadero porque el valor de las variables p y r es el

mismo, que es 5. Por último, la salida es falsa, ya que las variables p y s tienen
valores asignados diferentes.
public class Test {

public static void main(String args[]) {

Integer p = 5;
Integer q = 20;
Integer r =5;
Short s = 5;

System.out.println(p.equals(q));
System.out.println(p.equals(r));
System.out.println(p.equals(s));
}
}

Producción

falso
verdadero
falso

Mejores prácticas al usar Comparator y Comparable

en Java
 Utilice una interfaz Comparable cuando la comparación sea estándar para
la clase específica.
 Puedes usar lambdas con un Comparador.
 Muchas clases principales disponibles en implementan la interfaz
Comparable.
 Es posible usar TreeSet y TreeMap o al ordenar Set o Map.
 El método compareTo() funciona tanto con el Comparator como con el
Comparable.
 Utilice la interfaz Comparator solo cuando necesite más flexibilidad.
 El método compareTo() devolverá un entero positivo si el primer objeto es
mayor que el otro, negativo si es menor y cero si ambos son iguales.

Fuente:

https://www.guru99.com/comparable-vs-comparator-java.html