摘要：概述簡介是一個匿名函數，我們可以把表達式理解為是一段可以傳遞的代碼將代碼像數據一樣進行傳遞。作為一種更緊湊的代碼風格，使的語言表達能力得到了提升。任何滿足單一抽象方法法則的接口，都會被自動視為函數接口。

Lambda 是一個匿名函數，我們可以把 Lambda 表達式理解為是一段可以傳遞的代碼（將代碼像數據一樣進行傳遞）。可以寫出更簡潔、更靈活的代碼。作為一種更緊湊的代碼風格，使 Java 的語言表達能力得到了提升。

比如說我們要為 TreeSet 添加一個比價器，如果用原來的匿名內部類實現如下

@Test
public void test1() {
    Comparator com = new Comparator() {
        @Override
        public int compare(Integer o1, Integer o2) {
            return Integer.compare(o1, o2);
        }
    };

    TreeSet ts = new TreeSet<>(com);

    TreeSet ts2 = new TreeSet<>(new Comparator() {
        @Override
        public int compare(Integer o1, Integer o2) {
            return Integer.compare(o1, o2);
        }
    });

    ts2.addAll(Arrays.asList(4, 5, 7, 3, 2, 1, 8, 6, 9));
    System.out.println(ts2.toString());
}

Lambda 表達式實現如下

@Test
public void test2() {
    Comparator com = (x, y) -> Integer.compare(x, y);
    TreeSet ts = new TreeSet<>(com);
    ts.addAll(Arrays.asList(4, 5, 7, 3, 2, 1, 8, 6, 9));
    System.out.println(ts.toString());
}

對一個 List 里面的對象進行操作

實體類

public class Employee implements Serializable {

    private int id;
    private String name;
    private int age;
    private double salary;
    
    // 省略 getter 和 setter 方法
}

基礎數據

List emps = Arrays.asList(
        new Employee(1, "張三", 18, 9999.99),
        new Employee(2, "李四", 59, 6666.66),
        new Employee(3, "王五", 28, 3333.33),
        new Employee(4, "趙六", 8, 7777.77),
        new Employee(5, "田七", 38, 5555.55)
);

普通實現

我們有兩個需求，一個是“獲取公司中年齡小于 35 的員工信息”，一個是“獲取公司中工資大于 5000 的員工信息”

/**
 * 需求：獲取公司中年齡小于 35 的員工信息
 *
 * @param emps
 * @return
 */
public List filterEmployeeAge(List emps) {
    List list = new ArrayList<>();
    for (Employee emp : emps) {
        if (emp.getAge() <= 35) {
            list.add(emp);
        }
    }
    return list;
}

@Test
public void test3() {
    List list = filterEmployeeAge(emps);

    for (Employee employee : list) {
        System.out.println(employee);
    }
}

/**
 * 需求：獲取公司中工資大于 5000 的員工信息
 *
 * @param emps
 * @return
 */
public List filterEmployeeSalary(List emps) {
    List list = new ArrayList<>();
    for (Employee emp : emps) {
        if (emp.getSalary() >= 5000) {
            list.add(emp);
        }
    }
    return list;
}

這樣的話我要神隊每個需求都寫個方法，如果再增加需求，還需要再寫

優化方式一：策略設計模式

定義一個接口

public interface MyPredicate {

    public boolean test(T t);
    
}

/**
 * 策略設計模式
 *
 * @param emps
 * @param mp
 * @return
 */
public List filterEmployee(List emps, MyPredicate mp) {
    List list = new ArrayList<>();
    for (Employee employee : emps) {
        if (mp.test(employee)) {
            list.add(employee);
        }
    }
    return list;
}

/**
 * 根據不同的需求實現不同的策略
 */
@Test
public void test4() {
    List list = filterEmployee(emps, new FilterEmployeeForAge());
    for (Employee employee : list) {
        System.out.println(employee);
    }

    System.out.println("---------------------------------------");

    List list2 = filterEmployee(emps, new FilterEmployeeForSalary());
    for (Employee employee : list2) {
        System.out.println(employee);
    }
}

優化方式二：匿名內部類

/**
 * 匿名內部類
 */
@Test
public void test5() {
    List list = filterEmployee(emps, new MyPredicate() {
        @Override
        public boolean test(Employee t) {
            return t.getId() <= 103;
        }
    });

    for (Employee employee : list) {
        System.out.println(employee);
    }
}

優化方式三：Lambda 表達式

/**
 * Lambda 表達式
 */
@Test
public void test6() {
    List list = filterEmployee(emps, (e) -> e.getAge() <= 35);
    list.forEach(System.out::println);

    System.out.println("------------------------------------------");

    List list2 = filterEmployee(emps, (e) -> e.getSalary() >= 5000);
    list2.forEach(System.out::println);
}

優化方式四：Stream API

/**
 * Stream API
 */
@Test
public void test7() {
    emps.stream()
            .filter((e) -> e.getAge() <= 35)
            .forEach(System.out::println);

    System.out.println("----------------------------------------------");

    emps.stream()
            .map(Employee::getName)
            .limit(3)
            .sorted()
            .forEach(System.out::println);
}

Java8 中引入了一個新的操作符 -> 該操作符稱為箭頭操作符或 Lambda 操作符，箭頭操作符將 Lambda 表達式拆分成兩部分：

左側：Lambda 表達式的參數列表（即接口抽象方法的參數列表）

右側：Lambda 表達式中所需執行的功能， 即 Lambda 體（即接口的實現）

Lambda 表達式需要“函數式接口”的支持

函數式接口：接口中只有一個抽象方法的接口，稱為函數式接口。可以使用注解 @FunctionalInterface 修飾，可以檢查是否是函數式接口

函數式接口可以有默認方法和靜態方法。

任何滿足單一抽象方法法則的接口，都會被自動視為函數接口。這包括 Runnable 和 Callable 等傳統接口，以及您自己構建的自定義接口。

() -> System.out.println("Hello Lambda!");

@Test
public void t1(){
    Runnable r1 = () -> System.out.println("Hello Lambda!");
    r1.run();
}

(x) -> System.out.println(x)

@Test
public void t2(){
    Consumer con = (x) -> System.out.println(x);
    con.accept("Hello Lambda!");
}

如果只有一個參數的情況下小括號是可以省略的

@Test
public void t3(){
    Consumer con = x -> System.out.println(x);
    con.accept("Hello Lambda!");
}

@Test
public void t4() {
    Comparator com = (x, y) -> {
        System.out.println("函數式接口");
        return Integer.compare(x, y);
    };
}

@Test
public void t5(){
    Comparator com = (x, y) -> Integer.compare(x, y);
}

Lambda 表達式的參數列表的數據類型可以省略不寫，因為JVM編譯器通過上下文推斷出，數據類型，即“類型推斷”，如果寫類型的話如下

@Test
public void t6(){
    Comparator com = (Integer x,Integer y) -> Integer.compare(x, y);
}

本文首發于凌風博客：Java 8 新特性之Lambda表達式
作者：凌風