método compareTo

Para organizar objetos do mesmo tipo armazenados em um array ou coleção, os desenvolvedores Java criaram o Comparable. Ele declara apenas um método compareTo:

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

Uma interface Comparableé parametrizada pelo tipo de objeto que ela aceita como parâmetro para o método compareTo. Nesse caso, avisamos ao compilador quais tipos de objetos iremos comparar. Se a condição de identidade do tipo não for atendida, receberemos um erro ClassCastException. Um método compareToem Java compara o objeto chamador com o objeto passado como parâmetro e retorna um número inteiro como resultado da comparação:

• positivo se o objeto chamador for maior que o objeto passado como parâmetro;
• negativo se o objeto chamador for menor que o objeto passado como parâmetro;
• null se os objetos forem iguais.

Escrever a lógica de comparação de objetos é preocupação exclusiva do desenvolvedor da classe e é determinada pelos resultados desejados da ordenação.

Por que o método compareTo é necessário em Java?

Um programador Java muitas vezes precisa lidar com arrays e listas de objetos. Ao trabalhar com grandes quantidades de dados, muitas vezes é conveniente armazená-los de forma organizada ou ordenada. Em primeiro lugar, agiliza o trabalho com a coleta na busca das informações necessárias e, em segundo lugar, os dados organizados são melhor percebidos visualmente. Uma das maneiras mais simples e eficazes de classificar uma matriz de objetos é o método sort()de classe Arrays, e uma coleção de objetos na forma de uma lista é um método de classe semelhante Collections. Para classificar usando esses métodos, os desenvolvedores Java nos deram a liberdade de escolher como especificar os critérios de classificação: implementando a interface Comparablena classe de objetos que queremos classificar ou usando o método Comparator. No primeiro caso, os métodos de classificação aceitam um conjunto de objetos na forma de um array ou lista:

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

e no segundo - mais outra implementação da interface Comparator:

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

A interface Comparableé usada quando queremos definir uma ordem natural (a mais lógica do nosso ponto de vista) dos objetos durante a classificação. É também uma forma de “conectar” o algoritmo para comparar objetos desta classe na fase de projeto. Por exemplo, usando a implementação desta interface, são definidos os critérios de ordenação natural nas classes wrapper dos principais tipos primitivos: , Byte, Character, , Long, Integer, Short, Double, Float, Boolean. StringIsso também significa que essas classes possuem um método implementado compareToque podemos usar no programa se necessário. Vejamos um exemplo de comparação de strings para ver como esse método é implementado na classe String.

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);
        }
    }

Se executarmos este código no método main, obteremos o seguinte resultado:

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

Como você pode ver no exemplo da classe String, o método compareToorganiza as strings em ordem alfabética, lexicográfica e diferenciando maiúsculas de minúsculas. É essa ordem de comparação de strings que é definida pelos desenvolvedores da classe Stringcomo natural. Para uma compreensão mais simples do que é ordem lexicográfica, basta lembrar como as palavras são organizadas nos dicionários de línguas. Ao comparar números, os objetos são ordenados em ordem crescente. Essa lógica de comparação está embutida nas classes Byte, Character, Long, Integer, Shor, Double, Float.

Vamos implementar a comparação em nossa classe

Vejamos um exemplo de como você pode desenvolver a capacidade de comparar objetos em sua classe. Ao implementar um comparetométodo Java, podemos especificar um ou mais critérios para ordenar objetos e também usar métodos comparetodas classes Stringe Integer. Por exemplo, para objetos de classe Userdefinimos a classificação por nome e, no caso de nomes iguais, por idade. Os objetos serão organizados em sua ordem natural (conforme o valor aumenta). Aula User:

public class User  implements Comparable <User>{//добавляем возможность сравнивать an objectы 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 + '\'' +
                '}';
    }

Vamos testar o funcionamento do método compareToimplementado na classe Userusando o método sortde classe 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("Igor", 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 do 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'}

Então, vamos resumir. Se você é um defensor da ordem em tudo e deseja organizar seus objetos em um array ou lista sem código desnecessário, use a interface Comparable. A implementação de seu método compareTo facilita bastante a construção de um mecanismo para ordenar naturalmente objetos em sua classe. Se você precisar trabalhar com coleções e matrizes de objetos de classes padrão descritas na biblioteca Java, use implementações prontas compareTonessas classes.