Comparateur
Présenter
Étudions cette méthode
public static void sort (List list): triez les éléments de la collection selon les règles par défaut.
Ce qui est stocké ici est un type de chaîne.
public class CollectionsDemo2 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<String>();
list.add("cba");
list.add("aba");
list.add("sba");
list.add("nba");
//排序方法
Collections.sort(list);
System.out.println(list);
}
}
résultat:
[aba, cba, nba, sba]
Nous utilisons les règles par défaut pour trier les chaînes, alors comment les règles par défaut sont-elles définies?
En parlant de tri, en termes simples, la taille des deux objets est comparée. Ensuite, il y a deux façons d'implémenter la comparaison dans JAVA. L'une est l'implémentation plus rigide utilisant l'interface java.lang.Comparable, et l'autre est flexible. Quand J'ai besoin de trier, c'est fait dans l'interface java.util.Comparator pour sélectionner.
Ensuite, le tri effectué par la méthode public static void sort (List list) que nous utilisons nécessite en fait que le type trié ait besoin d'implémenter l'interface Comparable pour terminer la fonction de comparaison. Le type String est le suivant:
public final class String implements java.io.Serializable, Comparable<String>, CharSequence {
La classe String implémente cette interface et complète la définition des règles de comparaison, mais de cette façon les règles sont écrites à mort.
Par exemple, si je souhaite que la chaîne soit triée par ordre décroissant en fonction du premier caractère, il est impossible de modifier le code source de la chaîne.
Ensuite, à ce stade, nous pouvons utiliser la méthode de tri vide statique public (liste de liste, comparateur <? Super T>) pour le compléter de manière flexible
Il s'agit de l'interface Comparator, située dans le package java.util. Le tri est l'une des fonctions que le comparateur peut réaliser. Cette interface représente un comparateur, et le comparateur est comparable!
Comme son nom l'indique, c'est du tri. En termes simples, vous devez comparer deux objets qui sont classés en premier et qui sont classés en deuxième. Ensuite, la méthode de comparaison est la suivante:
public int compare(String o1, String o2) //比较其两个参数的顺序。
Démo
La comparaison de deux objets donne trois résultats: supérieur à, égal à et inférieur à.
Si vous voulez trier par ordre croissant,
alors o1 est inférieur à o2, retour (nombre négatif), retour égal 0, 01 est supérieur à 02 retour (nombre positif)
Si vous voulez trier par ordre décroissant
, o1 est inférieur à o2 , retour (nombre positif), retour égal 0, 01 supérieur à 02 retour (nombre négatif)
Le fonctionnement est le suivant:
public class CollectionsDemo3 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<String>();
list.add("cba");
list.add("aba");
list.add("sba");
list.add("nba");
//排序方法 按照第一个单词的降序
Collections.sort(list, new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o2.charAt(0) - o1.charAt(0);
}
});
System.out.println(list);
}
}
Les résultats sont les suivants:
[sba, nba, cba, aba]
Décrivez brièvement la différence entre les interfaces Comparable et Comparator
Comparable:
- Force pour réaliser les objets de chaque classe qui est un ordre total .
- Ce tri est appelé le tri naturel de la classe. La méthode compareTo de la classe est appelée sa méthode de comparaison naturelle .
- Vous ne pouvez implémenter compareTo () qu'une seule fois dans une classe et vous ne pouvez pas souvent modifier le code de la classe pour obtenir le tri souhaité.
- La liste des objets (et tableaux) qui implémentent cette interface peut être automatiquement triée via Collections.sort (et Arrays.sort) . Les objets peuvent être utilisés comme clés dans une carte ordonnée ou comme éléments dans une collection ordonnée sans spécifier de comparateur.
Exercer
Créez une classe d'élève et stockez-la dans la collection ArrayList pour terminer l'opération de tri spécifiée.
Classe initiale des étudiants
public class Student{
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
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;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
Catégorie de test:
public class Demo {
public static void main(String[] args) {
// 创建四个学生对象 存储到集合中
ArrayList<Student> list = new ArrayList<Student>();
list.add(new Student("rose",18));
list.add(new Student("jack",16));
list.add(new Student("abc",16));
list.add(new Student("ace",17));
list.add(new Student("mark",16));
/*
让学生 按照年龄排序 升序
*/
// Collections.sort(list);//要求 该list中元素类型 必须实现比较器Comparable接口
for (Student student : list) {
System.out.println(student);
}
}
}
发现，当我们调用Collections.sort()方法的时候 程序报错了。
原因：如果想要集合中的元素完成排序，那么必须要实现比较器Comparable接口。
于是我们就完成了Student类的一个实现，如下：
public class Student implements Comparable<Student>{
....
@Override
public int compareTo(Student o) {
return this.age-o.age;//升序
}
}
Testez à nouveau, le code est OK et l'effet est le suivant:
Student{
name='jack', age=16}
Student{
name='abc', age=16}
Student{
name='mark', age=16}
Student{
name='ace', age=17}
Student{
name='rose', age=18}
Développer
Si vous souhaitez utiliser des règles de définition indépendantes lorsque vous l'utilisez, vous pouvez utiliser la méthode Collections.sort (List list, Comparetor c) pour définir vos propres règles:
Collections.sort(list, new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
return o2.getAge()-o1.getAge();//以学生的年龄降序
}
});
effet:
Student{
name='rose', age=18}
Student{
name='ace', age=17}
Student{
name='jack', age=16}
Student{
name='abc', age=16}
Student{
name='mark', age=16}
Si vous voulez plus de règles, vous pouvez vous référer au code suivant:
Collections.sort(list, new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
// 年龄降序
int result = o2.getAge()-o1.getAge();//年龄降序
if(result==0){
//第一个规则判断完了 下一个规则 姓名的首字母 升序
result = o1.getName().charAt(0)-o2.getName().charAt(0);
}
return result;
}
});
L'effet est le suivant:
Student{
name='rose', age=18}
Student{
name='ace', age=17}
Student{
name='abc', age=16}
Student{
name='jack', age=16}
Student{
name='mark', age=16}