En algunos escenarios especiales, necesitamos ordenar la colección List en el programa Java. Por ejemplo, la lista de todos los usuarios se obtiene de la interfaz de terceros, pero la lista está ordenada por número de usuario de menor a mayor de forma predeterminada, y nuestro sistema necesita ordenar según la edad del usuario de mayor a menor. tiempo, necesitamos ordenar la Lista La colección realiza una operación de ordenación personalizada.
Hay tres métodos comunes de clasificación de listas:
-
Use Comparable para ordenar;
-
Use Comparator para clasificar;
-
Si se trata de un entorno superior a JDK 8, también puede utilizar Stream para ordenar.
Echemos un vistazo a la implementación específica de varios métodos de clasificación.
1. Usar clasificación comparable
De acuerdo con el escenario diseñado en este artículo, debemos crear una colección de listas que contenga una lista de usuarios y clasificar a los usuarios según su edad, de mayor a menor. El código de implementación específico es el siguiente:
public class ListSortExample {
public static void main(String[] args) {
// 创建并初始化 List
List<Person> list = new ArrayList<Person>() {
{
add(new Person(1, 30, "北京"));
add(new Person(2, 20, "西安"));
add(new Person(3, 40, "上海"));
}};
// 使用 Comparable 自定的规则进行排序
Collections.sort(list);
// 打印 list 集合
list.forEach(p -> {
System.out.println(p);
});
}
}
// 以下 set/get/toString 使用的是 lombok 的注解
@Getter
@Setter
@ToString
class Person implements Comparable<Person> {
private int id;
private int age;
private String name;
public Person(int id, int age, String name) {
this.id = id;
this.age = age;
this.name = name;
}
@Override
public int compareTo(Person p) {
return p.getAge() - this.getAge();
}
}
El resultado de la ejecución del código anterior se muestra en la siguiente figura: 
El código central de este método es el siguiente:
2. Usa Comparator para ordenar
Comparable es un método de comparación dentro de la clase, mientras que Comparator es un comparador fuera de la clase de clasificación. Para usar el Comparador, no es necesario modificar la clase Persona original, solo es necesario expandir un Comparador de la clase Persona. Hay dos formas de implementar el Comparador:
-
Crear un nuevo comparador Comparator;
-
Utilice el comparador de clases anónimo Comparator.
Entre ellos, el segundo método de implementación es más conciso, observemos la diferencia entre los dos a través del siguiente código específico.
2.1 Crear un nuevo comparador Comparator
public class ListSortExample2 {
public static void main(String[] args) {
// 创建并初始化 List
List<Person> list = new ArrayList<Person>() {
{
add(new Person(1, 30, "北京"));
add(new Person(2, 20, "西安"));
add(new Person(3, 40, "上海"));
}};
// 使用 Comparator 比较器排序
Collections.sort(list, new PersonComparator());
// 打印 list 集合
list.forEach(p -> {
System.out.println(p);
});
}
}
/**
* 新建 Person 比较器
*/
class PersonComparator implements Comparator<Person> {
@Override
public int compare(Person p1, Person p2) {
return p2.getAge() - p1.getAge();
}
}
@Getter
@Setter
@ToString
class Person {
private int id;
private int age;
private String name;
public Person(int id, int age, String name) {
this.id = id;
this.age = age;
this.name = name;
}
}
El resultado de la ejecución del código anterior se muestra en la siguiente figura: 
El código de implementación principal de este método es el siguiente:
2.2 Comparador de clases anónimo
El comparador Comparator puede usar una clase anónima más concisa para implementar la función de clasificación. El código de implementación específico es el siguiente:
public class ListSortExample2 {
public static void main(String[] args) {
// 创建并初始化 List
List<Person> list = new ArrayList<Person>() {
{
add(new Person(1, 30, "北京"));
add(new Person(2, 20, "西安"));
add(new Person(3, 40, "上海"));
}};
// 使用匿名比较器排序
Collections.sort(list, new Comparator<Person>() {
@Override
public int compare(Person p1, Person p2) {
return p2.getAge() - p1.getAge();
}
});
// 打印 list 集合
list.forEach(p -> {
System.out.println(p);
});
}
}
@Getter
@Setter
@ToString
class Person {
private int id;
private int age;
private String name;
public Person(int id, int age, String name) {
this.id = id;
this.age = age;
this.name = name;
}
}
El resultado de la ejecución del código anterior se muestra en la siguiente figura:
3. Usa Stream para ordenar
Después de JDK 8, puede usar el método Stream más simple para implementar la función de clasificación. Su implementación solo requiere una línea de código. La implementación específica es la siguiente:
public class ListSortExample3 {
public static void main(String[] args) {
// 创建并初始化 List
List<Person> list = new ArrayList<Person>() {
{
add(new Person(1, 30, "北京"));
add(new Person(2, 20, "西安"));
add(new Person(3, 40, "上海"));
}};
// 使用 Stream 排序
list = list.stream().sorted(Comparator.comparing(Person::getAge).reversed())
.collect(Collectors.toList());
// 打印 list 集合
list.forEach(p -> {
System.out.println(p);
});
}
@Getter
@Setter
@ToString
static class Person {
private int id;
private int age;
private String name;
public Person(int id, int age, String name) {
this.id = id;
this.age = age;
this.name = name;
}
}
}
Entre ellos, reversed() significa orden inverso, si no se usa este método, es orden positivo.
El resultado de la ejecución del código anterior se muestra en la siguiente figura:
Extensión: el campo de clasificación es nulo
Al usar Stream para ordenar, si hay un valor nulo en el campo ordenado, se producirá una excepción. El ejemplo específico es el siguiente:
public class ListSortExample4 {
public static void main(String[] args) {
// 创建并初始化 List
List<Person> list = new ArrayList<Person>() {
{
add(new Person(30, "北京"));
add(new Person(10, "西安"));
add(new Person(40, "上海"));
add(new Person(null, "上海")); // 年龄为 null 值
}};
// 按照[年龄]正序,但年龄中有一个 null 值
list = list.stream().sorted(Comparator.comparing(Person::getAge))
.collect(Collectors.toList());
// 打印 list 集合
list.forEach(p -> {
System.out.println(p);
});
}
}
@Getter
@Setter
@ToString
class Person {
private Integer age;
private String name;
public Person(Integer age, String name) {
this.age = age;
this.name = name;
}
}
El resultado de la ejecución del código anterior se muestra en la siguiente figura: 
Para resolver el problema anterior, debe pasar el segundo parámetro a Comparator.comparing: Comparator.nullsXXX, como se muestra en el siguiente código:
public class ListSortExample4 {
public static void main(String[] args) {
// 创建并初始化 List
List<Person> list = new ArrayList<Person>() {
{
add(new Person(30, "北京"));
add(new Person(10, "西安"));
add(new Person(40, "上海"));
add(new Person(null, "上海"));
}};
// 按照[年龄]正序,但年龄中有一个 null 值
list = list.stream().sorted(Comparator.comparing(Person::getAge,
Comparator.nullsFirst(Integer::compareTo)))
.collect(Collectors.toList());
// 打印 list 集合
list.forEach(p -> {
System.out.println(p);
});
}
}
@Getter
@Setter
@ToString
class Person {
private Integer age;
private String name;
public Person(Integer age, String name) {
this.age = age;
this.name = name;
}
}
Comparator.nullsFirst significa poner el valor nulo en el campo de clasificación al principio de la colección. Si desea poner el valor nulo al final de la colección, puede usar Comparator.nullsLast.
El resultado de la ejecución del código anterior se muestra en la siguiente figura:
Resumir
Este artículo presenta tres métodos de clasificación de listas. Los primeros dos métodos se usan comúnmente en versiones anteriores a JDK 8, donde el comparador Comparator tiene dos implementaciones, y en versiones posteriores a JDK 8, puede usar Comparator.comparing para implementar la clasificación, si los valores son nulos. puede aparecer en el campo de clasificación, use Comparator.nullsXXX para clasificar (de lo contrario, se informará un error)