lambda表示式

• 是一種函式式介面(一個介面中只有一個抽象方法)的寫法，可以簡化函式式介面的程式碼書寫量。

• 類似於Comparator就是函式式接口裡面只有一個compare抽象方法。

傳統方式建立一個儲存自定義的Student類的TreeSet集合需要通過匿名內部類的方式重寫Comparator中的compare方法。

public class Test {
    public static void main(String[] args) {
        TreeSet<Student> ts = new TreeSet<>(new Comparator<Student>() {
            //按年齡排序
 

            @Override
            public int compare(Student o1, Student o2) {
                return Integer.compare(o1.getAge(), o2.getAge());
            }
        });
    }
}

用lambda表示式完成上述程式碼相同功能

import java.util.TreeSet;

public class Test {
    public static void main(String[] args) {
        TreeSet<Student> ts = new
 
 TreeSet<>((x, y) -> Integer.compare(x.getAge(), y.getAge()));
        ts.add(new Student("張三", 18));
        ts.add(new Student("李四", 12));
        ts.add(new Student("王五", 21));
        ts.add(new Student("趙六", 17));
        for (Student s : ts) {
            System.out.println(s.toString())
 
;
        }
    }
}
/*Student [name=李四, age=12]
Student [name=趙六, age=17]
Student [name=張三, age=18]
Student [name=王五, age=21]*/

lambda表示式相當於簡化了匿名內部類的方式：

(x, y) -> Integer.compare(x.getAge(), y.getAge())

這段程式碼就相當於下面的程式碼：

new Comparator<Student>() {
            //按年齡排序
            @Override
            public int compare(Student o1, Student o2) {
                return Integer.compare(o1.getAge(), o2.getAge());
            }
        }

直接給出引數，用括號括起來 (引數1，引數2)然後加上箭頭->後面寫匿名內部類中的條件語句。

案例：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

//需求：過濾掉18歲以下的學生
//自定義一個過濾規則介面
interface MyPredicate<T> {
    // 定義一個抽象的過濾規則的方法
    public boolean test(T t);
}

public class Test {
    // 定義一個過濾的方法
    /**
     * @param list 需要被過濾的集合
     * @param m 過濾的規則
     * @return 過濾後的集合
     */
    public static List<Student> filterStudent(List<Student> list, MyPredicate<Student> mp) {
        // 定義最終返回結果
        List<Student> emps = new ArrayList<Student>();
        // 遍歷引數中傳入的d集合
        for (Student st : list) {
            //用過濾規則介面物件呼叫過濾方法
            if (mp.test(st)) {
                //如果過濾方法返回值是true則將元素新增到新集合中
                emps.add(st);
            }
        }
        //返回新集合
        return emps;
    }

    // 測試
    public static void main(String[] args) {
        // 通過Arrays工具類中的asList方法建立多個Student物件
        List<Student> list = Arrays.asList(
                new Student("張三", 18), 
                new Student("李四", 12), 
                new Student("王五", 21),
                new Student("趙六", 17));
        // 呼叫過濾的方法
        list = filterStudent(list, new MyPredicate<Student>() {
            //傳統方法通過重寫規則介面中的方法來過濾資料
            @Override
            public boolean test(Student t) {
                return t.getAge() >= 18;
            }
        });
        //遍歷
        for (Student s : list) {
            System.out.println(s.toString());
        }
    }
}
/*
Student [name=張三, age=18]
Student [name=王五, age=21]
*/

使用lambda表示式寫法如下：

list = filterStudent(list, (s) ->s.getAge()>=18);

括號中的引數s相當於是傳統方法中的匿名物件，在箭頭後面的表示式中直接寫判斷語句即可。