método comparar con

Para organizar objetos del mismo tipo almacenados en una matriz o colección, los desarrolladores de Java crearon Comparable. Declara sólo un método compareTo:

public interface Comparable<T> {
    public int compareTo(T o);
}

Una interfaz Comparableestá parametrizada por el tipo de objeto que acepta como parámetro del método compareTo. En este caso, advertimos al compilador qué tipos de objetos vamos a comparar. Si no se cumple la condición de identidad del tipo, recibiremos un error ClassCastException. Un método compareToen Java compara el objeto que llama con el objeto pasado como parámetro y devuelve un número entero como resultado de la comparación:

• positivo si el objeto que llama es más grande que el objeto pasado como parámetro;
• negativo si el objeto que llama es más pequeño que el objeto pasado como parámetro;
• nulo si los objetos son iguales.

Escribir la lógica de comparación de objetos es responsabilidad exclusiva del desarrollador de la clase y está determinada por los resultados deseados del pedido.

¿Por qué se necesita el método compareTo en Java?

Un programador de Java muy a menudo tiene que lidiar con matrices y listas de objetos. Cuando se trabaja con grandes cantidades de datos, suele ser conveniente almacenarlos de forma organizada u ordenada. En primer lugar, acelera el trabajo con la colección a la hora de buscar la información necesaria y, en segundo lugar, los datos organizados se perciben visualmente mejor. Una de las formas más simples y efectivas de ordenar una matriz de objetos es el método sort()de clase Arrays, y una colección de objetos en forma de lista es un método de clase similar Collections. Para ordenar usando estos métodos, los desarrolladores de Java nos dieron la libertad de elegir cómo especificar los criterios de ordenación: implementando la interfaz Comparableen la clase de objetos que queremos ordenar, o usando el archivo Comparator. En el primer caso, los métodos de clasificación aceptan un conjunto de objetos en forma de matriz o lista:

sort(T[]array)//clasificación массива
sort(List<T> list)// clasificación списка

y en el segundo, más otra implementación de la interfaz Comparator:

sort(T[]array, Comparator <? super T> comparator)//clasificación массива
sort(List<T> list, Comparator <? super T> comparator)// clasificación списка

La interfaz Comparablese utiliza cuando queremos establecer un orden natural (el más lógico desde nuestro punto de vista) de los objetos al ordenar. También es una forma de "conectar" el algoritmo para comparar objetos de esta clase en la etapa de diseño. Por ejemplo, utilizando la implementación de esta interfaz, se definen los criterios para el ordenamiento natural en las clases contenedoras de los principales tipos primitivos: , , Byte, Character, Long, Integer, Short, Double, Float. Esto también significa que estas clases tienen un método implementado que podemos usar en el programa si es necesario. Veamos un ejemplo de comparación de cadenas para ver cómo se implementa este método en la clase . BooleanStringcompareToString

String str1="Аарон";
        String str2="АAPOH";
        String str3="аарон";
        String str4="ААрон";
        String str5="аАрон";
        String str6="Берта";
        String str7="берта";
String[] allStr=new String[]{str1,str2,str3,str4, str5,str6, str7};
        Arrays.sort(allStr);
        for (String s:allStr){
            System.out.println(s);
        }
    }

Si ejecutamos este código en el método main, obtendremos el siguiente resultado:

АAPOH
ААрон
Аарон
Берта
аАрон
аарон
берта

Como puede ver en el ejemplo de la clase String, el método compareToorganiza las cadenas alfabéticamente, lexicográficamente y distingue entre mayúsculas y minúsculas. Es este orden de comparación de cadenas el que los desarrolladores de la clase definen Stringcomo natural. Para comprender más fácilmente qué es el orden lexicográfico, basta recordar cómo se organizan las palabras en los diccionarios de idiomas. Al comparar números, los objetos se ordenan en orden ascendente. Esta lógica de comparación está integrada en las clases Byte, Character, Long, Integer, Shor, Double, Float.

Implementemos la comparación en nuestra clase.

Veamos un ejemplo de cómo puedes desarrollar la capacidad de comparar objetos en tu clase. Al implementar un comparetométodo Java, podemos especificar uno o más criterios para ordenar objetos y también usar métodos comparetode las clases Stringy Integer. Por ejemplo, para los objetos de clase Userconfiguramos la clasificación por nombre y, en caso de nombres iguales, por edad. Los objetos se ordenarán en su orden natural (a medida que aumenta el valor). Clase User:

public class User  implements Comparable <User>{//добавляем возможность сравнивать un objetoы User

    private String name;
    private Integer age;
    private String email;

    public User(String name, int age, String email) {
        this.name = name;
        this.age = age;
        this.email = email;
    }

    @Override
//реализуем метод compareTo интерфейса Comparable
    public int compareTo(User o) {

//используем метод compareTo из класса String для сравнения имен
        int result = this.name.compareTo(o.name);

//если имена одинаковые -  сравниваем возраст,
используя метод compareTo из класса Integer

        if (result == 0) {
            result = this.age.compareTo(o.age);
        }
        return result;
    }

    @Override
    public String toString() {
        return "{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", email='" + email + '\'' +
                '}';
    }

Probemos el funcionamiento del método compareToimplementado en la clase Userusando el método sortde clase Collections:

public static void main(String[] args) {
    User user = new User("andrey", 19, "andryha@mail.ru");
    User user2 = new User("Олег", 25, "oleg@mail.ru");
    User user3 = new User("andrey", 24,"opr@google.com");
    User user4 = new User("Ígor", 16, "igor@mail.ru");
    User user5 = new User("andrey", 44,"stary@google.com");
    List<User> list = new ArrayList<>();

    list.add(user);
    list.add(user2);
    list.add(user3);
    list.add(user4);
    list.add(user5);

    System.out.println("-------до сортировки--------");
    for (User u : list) {
        System.out.println(u);
    }
    System.out.println("-------после сортировки-----");
    Collections.sort(list);
    for (User u : list) {
        System.out.println(u);
    }
}
 }
}

Resultado del método main:

-------до сортировки--------
{name='Андрей',  age=19,  email='andryha@mail.ru'}
{name='Олег',    age=25,  email='oleg@mail.ru'}
{name='Андрей',  age=24,  email='opr@google.com'}
{name='Игорь',   age=16,  email='igor@mail.ru'}
{name='Андрей',  age=44,  email='stary@google.com'}
-------после сортировки-----
{name='Андрей',  age=19,  email='andryha@mail.ru'}
{name='Андрей',  age=24,  email='opr@google.com'}
{name='Андрей',  age=44,  email='stary@google.com'}
{name='Игорь',   age=16,  email='igor@mail.ru'}
{name='Олег',    age=25,  email='oleg@mail.ru'}

Entonces, resumamos. Si eres partidario del orden en todo y quieres organizar tus objetos en una matriz o lista sin código innecesario, utiliza la interfaz Comparable. La implementación de su método compareTo hace que sea bastante fácil crear un mecanismo para ordenar objetos de forma natural en su clase. Si tiene que trabajar con colecciones y matrices de objetos de clases estándar descritas en la biblioteca Java, utilice implementaciones listas para usar compareToen estas clases.