Différence entre comparable et comparateur

En Java, vous pouvez écrire vos propres programmes si vous souhaitez trier une liste d'éléments. Vous pouvez avoir une classe de collection telle que ArrayList ou HashSet. Dans ce cas, si vous voulez trier les objets stockés dans les classes, cela peut être difficile en écrivant des programmes complexes.

Pour vous aider à trier les éléments d'une collection, Java fournit deux interfaces. Ils sont comparables et comparateurs. L'interface Comparable vous fournira une technique unique pour trier les éléments. D'autre part, l'interface du comparateur vous propose différentes manières de trier les éléments.

Dans cet article, nous aborderons les applications et les différences entre les deux interfaces.

Qu'est-ce qui est comparable en Java ?

Avant de trier certains éléments, il faut les comparer individuellement. Ainsi, pour qu'une classe compare ses membres de données, elle doit implémenter l'interface java.lang.Comparable. L'objet comparable est capable de comparer un autre objet avec lui-même.

L'interface Comparable est couramment utilisée pour trier l'ordre des éléments dans des classes définies par l'utilisateur. Vous pouvez utiliser cette interface pour trier lesobjets suivants :

• Objets d'une classe Wrapper
• Objets chaîne
• Objets d'une classe définie par l'utilisateur

Par défaut, les classes String et Wrapper implémentent l'interface Comparable. Par conséquent, si vous stockez un objet de classe String ou Wrapper dans un ensemble, une carte ou une liste, ils seront comparables.

Par exemple, nous avons une classe qui contient des informations sur les livres. Les données membres sont le nom, l'auteur, l'année de sortie et le classement. Pour cela, l'interface Comparable dispose d'une méthode appelée compareTo(T obj). Cela sera utilisé par les méthodes de tri pour obtenir le résultat souhaité.

Dans ce cas, vous devez remplacer la méthode compareTo() de manière à ce qu'elle renvoie :

• Entier négatif si un objet est inférieur à l'autre
• Entier positif si un objet est supérieur à l'autre
• Zéro s'ils sont égaux

Mais lorsque vous rendez un élément d'une collection comparable, vous n'aurez qu'une seule occasion d'implémenter la méthode compareTo(). Ainsi, vous pouvez trier les éléments selon un seul critère, tel que Auteur du livre.

Exemple :

//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 declartion 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());
    }
  }
}

SORTIE :

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'est-ce que Comparator en Java ?

Les objets d'une classe définie par l'utilisateur peuvent être triés à l'aide de l'interface Comparator. Le principal avantage entre cette interface et Comparable est que Comparator vous offre la possibilité de comparer plusieurs membres de données.

Le package java.util contient l'interface Comparator. Le comparateur a deux méthodes :

• public int compare (Object obj1, Object obj2) - Il compare le premier et le deuxième objet qui lui sont passés
• public boolean equals (Object element) - Cette méthode compare l'objet actuel avec l'autre objet spécifié dans la méthode

Lorsque vous utilisez la méthode de comparaison, elle doit renvoyer ce qui suit :

• Vous obtiendrez un entier négatif si l'autre argument est supérieur au premier argument
• Un entier positif, si le premier argument passé est supérieur au deuxième argument
• Si les deux arguments sont égaux, vous obtenez un zéro

Dans le cas de la méthode equals, vérifie si le comparateur appelant et l'objet sont égaux. Ici, l'argument obj est utilisé pour tester l'égalité. Si l'argument obj et les objets appelants sont des objets Comparator, la méthode renverra true. L'ordre des objets doit être le même. Sinon, la méthode renverra une valeur fausse.

Vous pouvez utiliser l'interface Comparator dans les cas suivants :

• Pour trier une liste d'objets ou un tableau en utilisant un ordre personnalisé
• Vous pouvez trier la même liste d'objets ou tableau sur différents champs
• Pour trier une liste d'objets ou un tableau dont le code source ne peut pas être modifié pour implémenter l'interface Comparable
• L'interface Comparator est utile lors de l'utilisation d'un groupe en triant une liste d'objets ou un tableau pour différents champs

La classe Collections a une méthode sort pour organiser les éléments d'un type Comparator et une liste. Vous pouvez trier les éléments de liste ayant le type Comparator par Collections.sort(List, Comparator).

Exemple :

//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 declartion 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());
  }
}

SORTIE :

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 

Comparateur vs Comparable

Base de comparaison	Comparable	Comparateur
Nombre de techniques de tri	Il vous propose une technique de tri unique. Par exemple, vous pouvez trier les éléments en fonction d'une seule propriété comme l'ID ou le nom.	Cette interface vous donne plusieurs techniques pour trier les éléments.
Commander	Il est utile pour les objets qui ont un ordre naturel. Par exemple, le numéro de série des employés.	Il est utile pour les objets qui peuvent ne pas avoir un ordre naturel.
Forfait	L'interface est présente dans le package java.lang	Ceci est présent dans le package java.util
Méthodes	Cette interface a le public int compareTo() pour trier les éléments	Cette interface a la méthode public int compare() et boolean equals()
Procédure de comparaison	Dans le compareTo(Object obj), l'objet qui invoque la méthode est comparé à l'objet passé dans la méthode	Ici, dans la méthode compare(Object obj1, Object obj2), les deux objets sont comparés et passés à cette méthode
Effet sur la classe d'origine	Ici, la classe d'origine est affectée et elle est modifiée. En effet, l'interface est implémentée par la classe dont vous souhaitez comparer les objets	Cette interface ne modifie pas la classe d'origine. Ici, l'interface est implémentée par une classe distincte au lieu de celle d'origine.
Liste des éléments	La classe Collection vous fournit un Collections.sort(List) pour comparer les éléments de liste de type Comparable	La classe Collection vous fournit Collections.sort(List, Comparator) pour trier les éléments de liste qui ont le type Comparator

Conclusion

Les interfaces Comparable et Comparator ont des applications légèrement différentes. Vous devez les utiliser en fonction de vos besoins. L'interface Comparable est utilisée lorsque vous souhaitez trier une collection d'éléments en fonction d'un seul élément. D'autre part, vous pouvez utiliser l'interface Comparateur pour trier les éléments en fonction de plusieurs critères.

Pour la méthode Comparable, Collection.sort() et Arrays.sort() utilisent la méthode compareTo(). Mais dans le cas de l'interface Comparator, vous pouvez utiliser la méthode compare() en fournissant la classe Comparator.

Si vous souhaitez trier les éléments en fonction de leur ordre de tri naturel, vous devez utiliser Comparable. Pour trier les éléments selon un ordre de tri personnalisé, utilisez le Comparateur.