Lambda 表达式

上一篇	下一篇
无	Stream 流

1、无类型参数

表达式基本结构：

f -> {}

相当于一个匿名函数，参数变量是形参，语句块是函数体。

并且可以传入 多个参数 或 无参：

1.1、多参数

(f1,  f2) -> {}

1.2、无参数

() -> {}

1.3、单条执行语句

f -> System.out.println(f)

只有一条语句时可不加括号（但还是建议都加上括号，这样代码块边界明确）

---

到这里来个例子：
给三个学生排个序

名字	年龄
张三	20
李四	18
王五	19

Student 类：

public class Student {
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String toString() {
        return this.name + " " + this.age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

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

ListSort 类：

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class ListSortTest {
    public static void main(String[] args) {
        List<Student> students = new ArrayList<>();
        students.add(new Student("张三", 20));
        students.add(new Student("李四", 18));
        students.add(new Student("王五", 19));

        System.out.println("排序前：");
        students.forEach(student -> {
            System.out.println(student.toString());
        });
		
		//排序
        Collections.sort(students, (student1, student2) -> {
            return student2.getAge() - student1.getAge();
        });	

        System.out.println("排序后：");
        students.forEach(student -> {
            System.out.println(student.toString());
        });

    }
}

forEach()是java集合循环遍历的方法
输出结果：

排序前：
张三 20
李四 18
王五 19
排序后：
张三 20
王五 19
李四 18

2、有类型参数

大多数情况下使用 Lambda 表达式是为了让代码更加简洁，所以忽略参数变量类型（无标明类型时系统会根据上下文识别）。
如果代码比较复杂，为了易于阅读和维护，可以为参数变量指定类型：

forEach((Student student) ->{
	System.out.println(student.getName());
});

3、引用外部变量

就是 Lambda 表达式的语句块 {} 里可以引用外部的变量。
但有个条件：引用的局部变量不允许被修改，至少从 Lambda 表达式开始之后不能修改，包括之后的外部区域。
还是用前面的 Student 类，加上个 ExternalTest 类：

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

public class ExternalTest {
    public static void main(String[] args) {
        List<Student> students = new ArrayList<>();
        students.add(new Student("张三", 20));
        students.add(new Student("李四", 18));
        students.add(new Student("王五", 19));

        String testString;
        testString = "测试信息";
        students.forEach(f -> {
            System.out.println(testString + f.getName());
        });
        testString = "修改一下";		//这行修改了，会报错
    }
}

运行后发现报错：

java: 从lambda 表达式引用的本地变量必须是最终变量或实际上的最终变量

意思就是在lambda 表达式引用的外部变量的值必须是最终值。

现在把修改的那一行注释掉：

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

public class ExternalTest {
    public static void main(String[] args) {
        List<Student> students = new ArrayList<>();
        students.add(new Student("张三", 20));
        students.add(new Student("李四", 18));
        students.add(new Student("王五", 19));

        String testString;
        testString = "测试信息";
        students.forEach(f -> {
            System.out.println(testString + f.getName());
        });
//        testString = "修改一下";		//这行修改了，会报错
    }
}

就可以正常运行了：

测试信息张三
测试信息李四
测试信息王五

4、双冒号（::）操作符

java8 支持了一种新语法"::"，这也是一种 Lambda 写法，其实也可以理解成 C++ 里的域解析符。
语法：

个人理解就是取某个域内的某个方法

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

public class lambdaTest {
    public static void main(String[] args) {
        List<String> students = Arrays.asList("张三", "李四", "王五");

        students.forEach(student -> System.out.println(student));

        System.out.println("用\"::\"：");
        students.forEach(System.out::println);
    }

}

输出结果：

张三
李四
王五
用"::"：
张三
李四
王五

上一篇	下一篇
无	Stream 流