【Java 8 新特性】Java List sort() 排序示例 | 列表自定义排序

sort是java.util.List接口的默认方法。

List的排序方法在Java 8中被引入。

1. 排序方法接受比较器作为参数，并根据指定的比较器对这个列表进行排序。

default void sort(Comparator<? super E> c) 

2. 如果List中的元素是可比较的，即元素类实现了Comparable接口，那么我们可以把null传给sort方法，排序将按照自然排序进行。

3. 列表不能调整大小，尽管它可以修改。

带比较器的 sort() 函数

例1: 我们将使用Comparator.comparing方法创建一个比较器对象。

Comparator<Student> nameComparator = Comparator.comparing(Student::getName); 

我们将上述对象传递给List的sort方法。

students.sort(nameComparator); 

列表中的学生将根据指定的比较器引起的顺序对所有学生对象进行排序。

students.sort(nameComparator.reversed()); 

完整示例

ListSort1.java

import java.util.Comparator;
import java.util.List;
public class ListSort1 {
  public static void main(String[] args) {
	List<Student> students = Student.getStudents();

	System.out.println("--- Sort by name in ascending order ---");
	Comparator<Student> nameComparator = Comparator.comparing(Student::getName);
	students.sort(nameComparator);
	students.forEach(s -> System.out.println(s));
	
	System.out.println("--- Sort by name in descending order ---");
	students.sort(nameComparator.reversed());
	students.forEach(s -> System.out.println(s));
	
	System.out.println("--- Sort by age in ascending order ---");
	Comparator<Student> ageComparator = Comparator.comparing(Student::getAge);
	students.sort(ageComparator);
	students.forEach(s -> System.out.println(s));
	
	System.out.println("--- Sort by age in descending order ---");
	students.sort(ageComparator.reversed());
	students.forEach(s -> System.out.println(s));	
  }
} 

Student.java

import java.util.Arrays;
import java.util.List;
public class Student {
  private String name;
  private int age;
  public Student(String name, int age) {
	this.name = name;
	this.age = age;
  }

  //Setters and Getters

  public static List<Student> getStudents() {
	Student s1 = new Student("Lakshman", 25);
	Student s2 = new Student("Ram", 30);
	Student s3 = new Student("Shatrudhan", 23);
	Student s4 = new Student("Bharat", 28);

	return Arrays.asList(s1, s2, s3, s4);
  }
  @Override
  public String toString() {
	return name + " - " + age;
  }
} 

输出

--- Sort by name in ascending order ---
Bharat - 28
Lakshman - 25
Ram - 30
Shatrudhan - 23
--- Sort by name in descending order ---
Shatrudhan - 23
Ram - 30
Lakshman - 25
Bharat - 28
--- Sort by age in ascending order ---
Shatrudhan - 23
Lakshman - 25
Bharat - 28
Ram - 30
--- Sort by age in descending order ---
Ram - 30
Bharat - 28
Lakshman - 25
Shatrudhan - 23 

例2: 在这里，我们将通过实现Comparator接口来创建比较器类，并将它们与sort方法一起使用。

ListSort2.java

import java.util.Comparator;
import java.util.List;

class NameComparator implements Comparator<Student> {
  @Override
  public int compare(Student s1, Student s2) {
     return s1.getName().compareTo(s2.getName());
  }
}

class AgeComparator implements Comparator<Student> {
  @Override
  public int compare(Student s1, Student s2) {
     return s1.getAge() - s2.getAge();
  }
}

public class ListSort2 {
  public static void main(String[] args) {
	List<Student> students = Student.getStudents();

	System.out.println("--- Sort by name in ascending order ---");
	students.sort(new NameComparator());
	students.forEach(s -> System.out.println(s));
	
	System.out.println("--- Sort by age in Ascending order ---");
	students.sort(new AgeComparator());
	students.forEach(s -> System.out.println(s));
	
  }
} 

输出

--- Sort by name in ascending order ---
Bharat - 28
Lakshman - 25
Ram - 30
Shatrudhan - 23
--- Sort by age in Ascending order ---
Shatrudhan - 23
Lakshman - 25
Bharat - 28
Ram - 30 

具有可比较性的 sort() 函数

如果List的元素类实现了Comparable接口，我们可以使用List的sort方法对其进行排序，即自然排序。

要使用排序方法按照自然顺序对List的元素进行排序，我们可以将null或Comparator.naturalOrder()传递给排序方法。

employees.sort(null);
employees.sort(Comparator.naturalOrder())

在上述两种情况下，元素的排序都将按照其自然顺序进行。找到这个例子。

ListSort3.java

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
public class ListSort3 {
  public static void main(String[] args) {
	Employee e1 = new Employee(101, "Mohit");
	Employee e2 = new Employee(102, "Mahesh");
	Employee e3 = new Employee(103, "Jitendra");
	Employee e4 = new Employee(104, "Keshav");	
	List<Employee> employees = Arrays.asList(e1, e2, e3, e4);
	
	System.out.println("--- Sort by employee name in ascending order ---");
	employees.sort(null);
	//employees.sort(Comparator.naturalOrder());
	employees.forEach(s -> System.out.println(s));
	
	System.out.println("--- Sort by employee name in descending order ---");
	employees.sort(Comparator.reverseOrder());
	employees.forEach(s -> System.out.println(s));	
  }
}

class Employee implements Comparable<Employee> {
  private int empId;
  private String empName;
  public Employee(int empId, String empName) {
	this.empId = empId;
	this.empName = empName;
  }
  //Setters and Getters
  
  @Override
  public int compareTo(Employee e) {
	return empName.compareTo(e.getEmpName());
  }
  @Override  
  public String toString(){
	return empId + "-" + empName; 
  }  
} 

输出

--- Sort by employee name in ascending order ---
103-Jitendra
104-Keshav
102-Mahesh
101-Mohit
--- Sort by employee name in descending order ---
101-Mohit
102-Mahesh
104-Keshav
103-Jitendra 

参考文献

【1】Java doc: List
【2】Java List sort() Example