Java8 特性详解 --Lambda 表达式之排序

时间：2025-03-27 13:26:07

创建测试类：

public class Student implements Comparable<Student> {
    private int age;
    private String nameEn;
    private int grade;

    public Student(int age, String nameEn, int grade) {
         = age;
         = nameEn;
         = grade;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
         = age;
    }

    public String getNameEn() {
        return nameEn;
    }

    public void setNameEn(String nameEn) {
         = nameEn;
    }

    public int getGrade() {
        return grade;
    }

    public void setGrade(int grade) {
         = grade;
    }

    public static int compare(Student s1, Student s2) {
        return ((), ());
    }

    @Override
    public int compareTo(Student s) {
        return ((), ());
    }
}

    /**
     * 初始化数据
     *
     * @return
     */
    public static List<Student> initData() {
        List<Student> list = new ArrayList<>();
        (new Student(11, "zhangsan", 5));
        (new Student(12, "lisi", 5));
        (new Student(9, "wangwu", 6));
        (new Student(13, "zhaoliu", 6));
        (new Student(8, "tianqi", 3));
        (new Student(6, "wangba", 1));
        (new Student(8, "jiujiu", 2));
        return list;
    }

传统排序方式

1.在 Java 8 之前,对集合进行排序要为 Comparator 创建一个匿名内部类用来排序,比如,按照 age 字段从小到大排序：

/** * 传统匿名内部类比较器 */ 
@Test 
public void soreted1() { 
    List<Student> list = (); 
    (new Comparator<Student>() { 
        @Override 
        public int compare(Student s1, Student s2) { 
            return ((), ()); } 
        }); 
    ((0).getNameEn(), "wangba"); 
}

2.或者让 Student 实现 Comparable 接口,复写 compareTo 方法,同样按照 age 字段从小到大排序:

@Override 
public int compareTo(Student s) { 
    return ((), ()); 
} 
/** * 实现Comparable接口 */ 
@Test 
public void soreted2() { 
    List<Student> list = (); 
    (list); 
    ((0).getNameEn(), "wangba"); 
}

java8 排序方式

3.在 java8 中引入了重要的特性之一 lambda,根据 Lambda 表达式的介绍,我们现在可以不使用匿名内部类,只使用简单实用的语义就可以得到相同的结果,按照 age 字段从小到大排序:

/** * java8的Lambda,显式指定比较类型 */ 
@Test 
public void soreted3() { 
   List<Student> list = (); 
   ((Student s1, Student s2) -> ((), ())); 
   ((0).getNameEn(), "wangba"); 
}

4.我们甚至可以省略类型,让编译器自行推测,按照 age 字段从小到大排序:

/** * java8的Lambda,不指定比较类型 */ 
@Test 
public void soreted4() { 
    List<Student> list = (); 
    ((s1, s2) -> ((), ()));         
    ((0).getNameEn(), "wangba"); 
}

5.我们还可以使用静态方法排序,按照 age 字段从小到大排序:

public static int compare(Student s1, Student s2) { 
    return ((), ()); 
} 
/** * 自定义静态方法 */ 
@Test 
public void soreted5() { 
    List<Student> list = (); 
    (Student::compare); 
    ((0).getNameEn(), "wangba");
}

6.当然,java8 为我们准备好了通用的 方法,按照 age 字段从小到大排序:

/** * Comparator提供的静态方法 */ 
@Test 
public void soreted6() { 
    List<Student> list = ();         
    ((Student::getAge)); 
    ((0).getNameEn(), "wangba"); 
}

java8 排序方法拓展:

java8 同样让我们具备编写更复杂逻辑排序的方法表达式,

7.比如,反转排序,按照 age 字段从大到小排序:

/** * 反转排序 */ 
@Test 
public void soreted7() { 
    List<Student> list = ();             
    ((Student::getAge).reversed());         
    ((0).getNameEn(), "zhaoliu"); 
}

8.比如,多字段组合排序,先按照 grade 从大到小,相同则按照 age 从大到小排序:

/** * 多字段组合排序(匿名类方式) */
 @Test 
public void soreted8() { 
List<Student> list = (); 
    ((s1, s2) -> { 
        if (((), ()) != 0) { 
            return ((), ()); 
        } 
        return ((), ()); 
    }); 
    ((0).getNameEn(), "zhaoliu"); 
}

9.java8 的 Comparator 为我们准备了更便利的链式风格组合排序方式,先按照 grade 从大到小,相同则按照 age 从小到大排序:

 /**
     * 多字段组合排序(链式接口)
     */
    @Test
    public void soreted9() {
        List<Student> list = ();
        ((Student::getGrade).reversed().thenComparing(Student::getAge));
        ((0).getNameEn(), "wangwu");
    }

相关文章