metodo compareTo

Per organizzare oggetti dello stesso tipo memorizzati in un array o in una raccolta, gli sviluppatori Java hanno inventato il file Comparable. Dichiara un solo metodo compareTo:

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

Un'interfaccia Comparableè parametrizzata in base al tipo di oggetto che accetta come parametro nel metodo compareTo. In questo caso, avvisiamo il compilatore quali tipi di oggetti confronteremo. Se la condizione di identità del tipo non è soddisfatta, riceveremo un errore ClassCastException. Un metodo compareToin Java confronta l'oggetto chiamante con l'oggetto passato come parametro e restituisce un numero intero come risultato del confronto:

• positivo se l'oggetto chiamante è più grande dell'oggetto passato come parametro;
• negativo se l'oggetto chiamante è più piccolo dell'oggetto passato come parametro;
• null se gli oggetti sono uguali.

La scrittura della logica di confronto degli oggetti è l'unica preoccupazione dello sviluppatore della classe ed è determinata dai risultati desiderati dell'ordinamento.

Perché il metodo compareTo è necessario in Java?

Un programmatore Java molto spesso ha a che fare con array ed elenchi di oggetti. Quando si lavora con grandi quantità di dati, spesso è conveniente archiviarli in forma organizzata o ordinata. In primo luogo, accelera il lavoro con la raccolta durante la ricerca delle informazioni necessarie e, in secondo luogo, i dati organizzati vengono percepiti visivamente meglio. Uno dei modi più semplici ed efficaci per ordinare un array di oggetti è il metodo della sort()classe Arrays, e una raccolta di oggetti sotto forma di elenco è un metodo di classe simile Collections. Per ordinare utilizzando questi metodi, gli sviluppatori Java ci hanno dato la libertà di scegliere come specificare i criteri di ordinamento: implementando l'interfaccia Comparablenella classe di oggetti che vogliamo ordinare, oppure utilizzando l'estensione Comparator. Nel primo caso, i metodi di ordinamento accettano un insieme di oggetti sotto forma di array o elenco:

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

e nel secondo - più un'altra implementazione dell'interfaccia Comparator:

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

L'interfaccia Comparableviene utilizzata quando vogliamo impostare un ordine naturale (il più logico dal nostro punto di vista) degli oggetti durante l'ordinamento. È anche un modo per “cablare” l'algoritmo per confrontare oggetti di questa classe in fase di progettazione. Ad esempio, utilizzando l'implementazione di questa interfaccia, vengono definiti i criteri per l'ordinamento naturale nelle classi wrapper dei principali tipi primitivi: , Byte, Character, Long, , Integer, Short, Double, Float. Ciò significa anche che queste classi hanno un metodo implementato che possiamo utilizzare nel programma se necessario. Diamo un'occhiata ad un esempio di confronto tra stringhe per vedere come questo metodo è implementato nella classe . 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);
        }
    }

Se eseguiamo questo codice nel metodo main, otterremo il seguente risultato:

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

Come puoi vedere nell'esempio della classe String, il metodo compareTodispone le stringhe in ordine alfabetico, lessicografico e con distinzione tra maiuscole e minuscole. StringÈ questo ordine di confronto delle stringhe che viene definito naturale dagli sviluppatori della classe . Per una comprensione più semplice di cos'è l'ordine lessicografico, è sufficiente ricordare come sono disposte le parole nei dizionari di lingua. Quando si confrontano i numeri, gli oggetti vengono ordinati in ordine crescente. Questa logica di confronto è incorporata nelle classi Byte, Character, Long, Integer, Shor, Double, Float.

Implementiamo il confronto nella nostra classe

Diamo un'occhiata a un esempio di come puoi sviluppare la capacità di confrontare oggetti nella tua classe. Quando implementiamo un comparetometodo Java, possiamo specificare uno o più criteri per ordinare gli oggetti e utilizzare anche i metodi comparetodelle classi Stringe Integer. Ad esempio, per gli oggetti classe Userimpostiamo l'ordinamento per nome e, in caso di nomi uguali, per età. Gli oggetti verranno disposti nel loro ordine naturale (all'aumentare del valore). Classe 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 + '\'' +
                '}';
    }

Testiamo il funzionamento del metodo compareToimplementato nella classe Userutilizzando il metodo sortclass 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);
    }
}
 }
}

Risultato del metodo 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'}

Quindi, riassumiamo. Se sei un sostenitore dell'ordine in ogni cosa e desideri disporre i tuoi oggetti in un array o in un elenco senza codice non necessario, utilizza l'interfaccia Comparable. L'implementazione del suo metodo compareTo rende abbastanza semplice la creazione di un meccanismo per ordinare in modo naturale gli oggetti nella tua classe. Se devi lavorare con raccolte e array di oggetti di classi standard descritte nella libreria Java, utilizza implementazioni già pronte compareToin queste classi.