一篇文章带你总结 Lambada 表达式常见使用

一、语法概念

(parameters) -> expression 
 或 
(parameters) ->{ statements; }

（1）可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。

（2）可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。

（3）可选的大括号：如果主体包含了一个语句，就不需要使用大括号。

（4）可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表达式返回了一个数值。

public class Test {
    public static void main(String[] args) throws NoSuchMethodException {
        // 字符串数组
        String[] atp = {"Brandon", "Mason", "Elijah"};
        List<String> players = Arrays.asList(atp);
        // java8之前
        for (String player : players) {
            System.out.println(player + "; ");
        }
        // 使用 lambda 表达式以及函数操作
        players.forEach((player) -> System.out.println(player + "; "));
        // 在 Java 8 中使用双冒号操作符
        players.forEach(System.out::println);
    }
}

二、简单使用

（1）对比匿名内部类做为参数传递和Lambda表达式作为参数来传递：Runnable,Callable接口

// Runnable 接口使用
public class Test {
    public static void main(String[] args) throws NoSuchMethodException {

        //不使用lamba表达式，匿名内部类方式
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello,I am 匿名内部类");
            }
        }).start();

        //使用lambada表达式
        new Thread(() -> System.out.println("hello,I am lambada")).start();

        //lambada的执行代码有多行
        new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(1);
                System.out.println("I am also lambada");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }
}

（2）代替 Comparator 的使用

public class TestLambada {
    public static void main(String[] args) {
        List<TestDemo> lists = new ArrayList<>();
        lists.add(TestDemo.builder()
                .name("n1")
                .id(1)
                .build());
        lists.add(TestDemo.builder()
                .name("n333")
                .id(2)
                .build());
        lists.add(TestDemo.builder()
                .name("n22")
                .id(3)
                .build());
        // sorted 排序，以对象 name 的长度进行排序
        // 使用 lambada 表达式
        List<TestDemo> collect1 = lists.stream()
                .sorted((x, y) -> x.getName().length() - y.getName().length())
                .collect(Collectors.toList());
        // 不使用 lambada 表达式
        List<TestDemo> collect2 = lists.stream()
                .sorted(new Comparator<TestDemo>() {
                    @Override
                    public int compare(TestDemo o1, TestDemo o2) {
                        return o1.getName().length() - o2.getName().length();
                    }
                })
                .collect(Collectors.toList());
    }
}