Comparable -java.lang.Comparable: int compareTo(Object o1)
Un objet comparable est capable de se comparer à un autre objet. La classe elle-même doit implémenter l'interface java.lang.Comparable afin de pouvoir comparer ses instances.
- Capable de comparer l'objet actuel avec l'objet fourni.
- En utilisant cela, nous pouvons implémenter en
only one sort sequencefonction des propriétés des instances. EX:Person.id
- Certaines des classes prédéfinies telles que String, Wrapper classes, Date, Calendar ont implémenté une interface Comparable.
Comparateur -java.util.Comparator: int compare(Object o1, Object o2)
Un objet comparateur est capable de comparer deux objets différents. La classe ne compare pas ses instances, mais certaines autres instances de la classe. Cette classe de comparateur doit implémenter l'interface java.util.Comparator.
- Capable de comparer deux objets du même type.
- En utilisant cela, nous pouvons implémenter
many sort sequenceet nommer chacun, en fonction des propriétés des instances. EX:Person.id, Person.name, Person.age
- Nous pouvons implémenter l'interface Comparator à nos classes prédéfinies pour un tri personnalisé.
Exemple:
public class Employee implements Comparable<Employee> {
private int id;
private String name;
private int age;
private long salary;
// Many sort sequences can be created with different names.
public static Comparator<Employee> NameComparator = new Comparator<Employee>() {
@Override
public int compare(Employee e1, Employee e2) {
return e1.getName().compareTo(e2.getName());
}
};
public static Comparator<Employee> idComparator = new Comparator<Employee>() {
@Override
public int compare(Employee e1, Employee e2) {
return Integer.valueOf(e1.getId()).compareTo(Integer.valueOf(e2.getId()));
}
};
public Employee() { }
public Employee(int id, String name, int age, long salary){
this.id = id;
this.name = name;
this.age = age;
this.salary = salary;
}
// setters and getters.
// Only one sort sequence can be created with in the class.
@Override
public int compareTo(Employee e) {
//return Integer.valueOf(this.id).compareTo(Integer.valueOf(e.id));
//return Character.toString(this.name.charAt(0)).compareToIgnoreCase(Character.toString(e.name.charAt(0)));
if (this.id > e.id) {
return 1;
}else if(this.id < e.id){
return -1;
}else {
return Character.toString(this.name.charAt(0)).compareToIgnoreCase(Character.toString(e.name.charAt(0)));
}
}
public static void main(String[] args) {
Employee e1 = new Employee(5, "Yash", 22, 1000);
Employee e2 = new Employee(8, "Tharun", 24, 25000);
List<Employee> list = new ArrayList<Employee>();
list.add(e1);
list.add(e2);
Collections.sort(list); // call @compareTo(o1)
Collections.sort(list, Employee.nameComparator); // call @compare (o1,o2)
Collections.sort(list, Employee.idComparator); // call @compare (o1,o2)
}
}
- Pour un tri personnalisé, nous optons pour le comparateur @compare (o1, o2) pour d'autres scénarios, nous optons pour un @compareTo (o1) comparable, sans changer de code si nous voulons trier plus d'un champ, nous utilisons le comparateur.
Pour Java 8 Lambda: Comparator, reportez-vous à mon article.