méthode compareTo

Pour organiser des objets du même type stockés dans un tableau ou une collection, les développeurs Java ont proposé le Comparable. Il déclare une seule méthode compareTo:

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

Une interface Comparableest paramétrée par le type de l'objet qu'elle accepte comme paramètre de la méthode compareTo. Dans ce cas, nous avertissons le compilateur des types d’objets que nous allons comparer. Si la condition d'identité de type n'est pas remplie, nous recevrons une erreur ClassCastException. Une méthode compareToen Java compare l'objet appelant avec l'objet passé en paramètre et renvoie un entier à la suite de la comparaison :

• positif si l'objet appelant est plus grand que l'objet passé en paramètre ;
• négatif si l'objet appelant est plus petit que l'objet passé en paramètre ;
• null si les objets sont égaux.

L'écriture de la logique de comparaison d'objets est la seule préoccupation du développeur de classe et est déterminée par les résultats souhaités du classement.

Pourquoi la méthode compareTo est-elle nécessaire en Java ?

Un programmeur Java doit très souvent gérer des tableaux et des listes d'objets. Lorsque vous travaillez avec de grandes quantités de données, il est souvent pratique de les stocker sous une forme organisée ou triée. Premièrement, cela accélère le travail avec la collection lors de la recherche des informations nécessaires, et deuxièmement, les données organisées sont visuellement mieux perçues. L'un des moyens les plus simples et les plus efficaces de trier un tableau d'objets est la méthode sort()de classe Arrays, et une collection d'objets sous forme de liste est une méthode de classe similaire Collections. Pour trier à l'aide de ces méthodes, les développeurs Java nous ont donné la liberté de choisir comment spécifier les critères de tri : en implémentant l'interface Comparabledans la classe d'objets que l'on souhaite trier, ou en utilisant le Comparator. Dans le premier cas, les méthodes de tri acceptent un ensemble d'objets sous la forme d'un tableau ou d'une liste :

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

et dans le second - plus une autre implémentation de l'interface Comparator:

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

L'interface Comparableest utilisée lorsque nous souhaitons définir un ordre naturel (le plus logique de notre point de vue) des objets lors du tri. C’est aussi un moyen de « câbler » l’algorithme de comparaison des objets de cette classe dès la phase de conception. Par exemple, en utilisant l'implémentation de cette interface, les critères d'ordre naturel dans les classes wrapper des principaux types primitifs sont définis : , Byte, Character, , Long, Integer, Short, Double, Float. Cela signifie également que ces classes ont une méthode implémentée que nous pouvons utiliser dans le programme si nécessaire. Regardons un exemple de comparaison de chaînes pour voir comment cette méthode est implémentée dans la 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);
        }
    }

Si nous exécutons ce code dans la méthode main, nous obtiendrons le résultat suivant :

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

Comme vous pouvez le voir dans l'exemple de la classe String, la méthode compareToorganise les chaînes par ordre alphabétique, lexicographique et en tenant compte de la casse. C'est cet ordre de comparaison de chaînes qui est défini par les développeurs de la classe Stringcomme naturel. Pour une compréhension plus simple de ce qu'est l'ordre lexicographique, il suffit de rappeler comment les mots sont disposés dans les dictionnaires de langues. Lors de la comparaison de nombres, les objets sont classés par ordre croissant. Cette logique de comparaison est intégrée dans les classes Byte, Character, Long, Integer, Shor, Double, Float.

Implémentons la comparaison dans notre classe

Examinons un exemple de la façon dont vous pouvez développer la capacité de comparer des objets dans votre classe. Lors de l'implémentation d'une comparetométhode Java, nous pouvons spécifier un ou plusieurs critères de classement des objets, et également utiliser des méthodes comparetodes classes Stringet Integer. Par exemple, pour les objets de classe, Usernous définissons le tri par nom et, en cas d'égalité des noms, par âge. Les objets seront disposés dans leur ordre naturel (à mesure que la valeur augmente). 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 + '\'' +
                '}';
    }

Testons le fonctionnement de la méthode compareToimplémentée dans la classe Useren utilisant la méthode 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);
    }
}
 }
}

Résultat de la méthode 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'}

Alors, résumons. Si vous êtes partisan de l'ordre en tout et que vous souhaitez organiser vos objets dans un tableau ou une liste sans code inutile, utilisez l'interface Comparable. L'implémentation de sa méthode compareTo facilite la création d'un mécanisme permettant d'ordonner naturellement les objets de votre classe. Si vous devez travailler avec des collections et des tableaux d'objets de classes standard décrites dans la bibliothèque Java, utilisez des implémentations prêtes à l'emploi compareTodans ces classes.