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

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

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

@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 表達式實現(xiàn)如下

@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 方法
}

基礎(chǔ)數(shù)據(jù)

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)
);

普通實現(xiàn)

我們有兩個需求，一個是“獲取公司中年齡小于 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;
}

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

優(yōu)化方式一：策略設(shè)計模式

定義一個接口

public interface MyPredicate {

    public boolean test(T t);
    
}

/**
 * 策略設(shè)計模式
 *
 * @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;
}

/**
 * 根據(jù)不同的需求實現(xiàn)不同的策略
 */
@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);
    }
}

優(yōu)化方式二：匿名內(nèi)部類

/**
 * 匿名內(nèi)部類
 */
@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);
    }
}

優(yōu)化方式三：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);
}

優(yōu)化方式四：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 表達式拆分成兩部分：

左側(cè)：Lambda 表達式的參數(shù)列表（即接口抽象方法的參數(shù)列表）

右側(cè)：Lambda 表達式中所需執(zhí)行的功能， 即 Lambda 體（即接口的實現(xiàn)）

Lambda 表達式需要“函數(shù)式接口”的支持

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

函數(shù)式接口可以有默認方法和靜態(tài)方法。

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

() -> 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!");
}

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

@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("函數(shù)式接口");
        return Integer.compare(x, y);
    };
}

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

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

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

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