Différence entre l’interface Comparable et Comparator

novembre 28, 2018février 27, 2020 Thomas Aucun commentaire comparable, comparator, définition, Différence entre, interface, vs

En Java, quand il s’agit de trier des collections, « Comparable » et « Comparator » viennent à l’esprit. « Comparable » et « Comparator » sont des interfaces fournies par l’API de Java Core. Ici, nous allons voir pourquoi « Comparable » et « Comparator » sont utilisés pour le tri alors qu’il existe des méthodes intégrées dans l’API Java. Quels sont les cas où on doit choisir « Comparable » pour le tri et dans quel cas « Comparator » doit être utilisé. Nous allons voir comment utiliser « Comparator » et « Comparable » en Java avec des exemples.

Table de comparaison

	Comparable	Comparator
Séquence de tri	Comparable fournit une séquence de tri unique. En d’autres termes, nous pouvons trier une collection sur la base d’un seul élément, tel que l’identifiant, le nom et l’adresse.	Comparator fournit plusieurs séquences de tri. En d’autres termes, nous pouvons trier la collection en fonction de plusieurs éléments tels que l’identifiant, le nom, l’adresse, etc.
La méthode	Comparable fournit la méthode compareTo() pour trier les éléments.	Comparator fournit la méthode compare() pour trier les éléments.
Package	Comparable existe dans le package java.lang.	Comparator existe dans le package java.util.
Trier	Nous pouvons trier les éléments d’une liste de type Comparable avec la méthode `Collections.sort(List)`.	Nous pouvons trier les éléments d’une liste de type Comparator avec la méthode `Collections.sort(List, Comparator)`

Exemple de Comparable en Java

Ici, la classe « Student » implémente « Comparable » et redéfinie sa méthode « compareTo() » pour trier l’objet student en fonction de son nom.

public class Student implements Comparable<employee>{
	
	private String name;
	private int age;
	
	public Student(){}
	
	public Student(String name, int age) {
		this.age = age;
		this.name = name;
	}
	
	public String getName() {
		return name;
	}
	
	public void setName(String name) {
		this.name = name;
	}
	
	public int getAge() {
		return age;
	}
	
	public void setAge(int age) {
		this.age = age;
	}
	
	//Redéfinir la méthode compareTo()
	@Override
	public int compareTo(Student s) {
		return name.compareTo(s.getName());
	}
}

Maintenant, si vous avez une collection d’objets nommé Student, vous pouvez l’utiliser comme suit pour le tri:

// Création d'une classe de test pour trier les éléments
public class TestSort{  
	public static void main(String args[]){
		//ajouter des éléments dans la liste studentList
		List<Student> studentList = new ArrayList<Student>();
		studentList.add(new Student("Alex", 23));
		studentList.add(new Student("Bob", 25));
		studentList.add(new Student("Ali", 33)); 

		//Triez la liste en ordre croissant en fonction du nom
		Collections.sort(studentList);
	}  
}

Maintenant que se passe-t-il si nous souhaitons trier notre collection « Student » en fonction de l’âge. Depuis que nous avons trié notre ArrayList en implémentant la méthode compareTo(), nous somme bloqués. Nous ne pouvons implémenter compareTo() qu’une seule fois dans la classe Student, alors comment trier à nouveau la liste en fonction de d’autres attributs. C’est le cas dans lequel nous aurons besoin de l’interface Comparator.

Exemple de Comparator en Java

L’interface Comparator nous permet de trier une collection donnée de différentes façons.

public class Student {
	
	private String name;
	private int age;
	
	public Student(){}
	
	public Student(String name, int age) {
		this.age = age;
		this.name = name;
	}
	
	public String getName() {
		return name;
	}
	
	public void setName(String name) {
		this.name = name;
	}
	
	public int getAge() {
		return age;
	}
	
	public void setAge(int age) {
		this.age = age;
	}
	
    //Trier les étudiants par son nom
	public static class SortName implements Comparator<Student> {

		@Override
		public int compare(Student s1, Student s2) {
			return s1.getName().compareTo(s2.getName());
		}
		
	}
	
	//Trier les étudiants par son age
	public static class SortAge implements Comparator<Student> {

		@Override
		public int compare(Student s1, Student s2) {
			return s1.getAge().compareTo(s2.getAge());
		}
		
	} 
}

Pour trier la collection « studentList », on utilise la classe de test suivante:

// Création d'une classe de test pour trier les éléments
public class TestSort{  
	public static void main(String args[]){
		//Remplir la liste des étudiants
		List<Student> studentList = new ArrayList<Student>();
		studentList.add(new Student("Alex",23));
		studentList.add(new Student("Bob",25));
		studentList.add(new Student("Ali",33)); 

		//Trier studentList selon le nom
		Collections.sort(studentList, new Student.NameSort());

		//Trier studentList selon l'age
		Collections.sort(studentList, new Student.DeptNameSort());
	}  
}

Conclusion

Si le tri des objets doit être basé sur l’ordre naturel, utilisez « Comparable » alors que si vous devez effectuer le tri sur des attributs de différents objets, utilisez « Comparator ».