Comparador
Introducir
Estudiemos este método
public static void sort (List list): ordena los elementos de la colección de acuerdo con las reglas predeterminadas.
Lo que se almacena aquí es un tipo de cadena.
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);
}
}
resultado:
[aba, cba, nba, sba]
Usamos las reglas predeterminadas para ordenar las cadenas, entonces, ¿cómo se definen las reglas predeterminadas?
Hablando de ordenar, en términos simples, se compara el tamaño de los dos objetos. Luego, hay dos formas de implementar la comparación en JAVA. Una es la implementación más rígida usando la interfaz java.lang.Comparable, y la otra es flexible. Cuando Necesito ordenar, se hace en la interfaz java.util.Comparator para seleccionar.
Luego, la clasificación realizada por el método público de clasificación vacía estática (lista de lista) que usamos en realidad requiere que el tipo ordenado deba implementar la interfaz Comparable para completar la función de comparación. El tipo de cadena es el siguiente:
public final class String implements java.io.Serializable, Comparable<String>, CharSequence {
La clase String implementa esta interfaz y completa la definición de las reglas de comparación, pero de esta manera las reglas se escriben hasta la muerte.
Por ejemplo, si quiero que la cadena se clasifique en orden descendente de acuerdo con el primer carácter, entonces es imposible modificar el código fuente de la Cadena.
Entonces, en este momento, podemos usar el método public static void sort (List list, Comparator <? Super T>) para completarlo de manera flexible
Esto involucra la interfaz Comparator, ubicada en el paquete java.util. La clasificación es una de las funciones que puede lograr el comparador. Esta interfaz representa un comparador, ¡y el comparador es comparable!
Como sugiere el nombre, se trata de ordenar. En términos sencillos, es necesario comparar dos objetos que ocupan el primer lugar y el que ocupa el segundo lugar. Entonces, el método de comparación es:
public int compare(String o1, String o2) //比较其两个参数的顺序。
Manifestación
Hay tres resultados de comparar dos objetos: mayor que, igual a y menor que.
Si desea ordenar en orden ascendente,
entonces o1 es menor que o2, return (número negativo), igual retorno 0, 01 es mayor que 02 return (número positivo)
Si desea ordenar en orden descendente
, o1 es menor que o2 , retorno (número positivo), igual retorno 0, 01 mayor que 02 retorno (número negativo)
El funcionamiento es el siguiente:
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);
}
}
Los resultados son los siguientes:
[sba, nba, cba, aba]
Describa brevemente la diferencia entre las interfaces Comparable y Comparator
Comparable:
- Fuerza para lograr los objetos de cada clase que es un ordenamiento total .
- Este tipo se denomina tipo natural de la clase, mientras que el método compareTo de la clase se denomina método de comparación natural .
- Solo puede implementar compareTo () una vez en una clase y , a menudo, no puede modificar el código de la clase para lograr la clasificación que desea.
- La lista de objetos (y matrices) que implementan esta interfaz se puede ordenar automáticamente a través de Collections.sort (y Arrays.sort) . Los objetos se pueden usar como claves en un mapa ordenado o elementos en una colección ordenada sin especificar un comparador.
Ejercicio
Cree una clase de estudiante y guárdela en la colección ArrayList para completar la operación de clasificación especificada.
Clase inicial del estudiante
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 +
'}';
}
}
Categoría de prueba:
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;//升序
}
}
Prueba de nuevo, el código está bien y el efecto es el siguiente:
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}
Expandir
Si desea usar reglas de definición independientes cuando lo use, puede usar el método Collections.sort (List list, Comparetor c) para definir sus propias reglas:
Collections.sort(list, new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
return o2.getAge()-o1.getAge();//以学生的年龄降序
}
});
efecto:
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 desea más reglas, puede consultar el siguiente código:
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;
}
});
El efecto es el siguiente:
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}