Lambda表达式

Lambda介绍

   1.1 何为lambda

咱们首先来说说 Lambda 这个名字，Lambda 并不是一个什么的缩写，它是希腊第十一个字母 λ 的读音，同时它也是微积分函数中的一个概念，所表达的意思是一个函数入参和出参定义，在编程语言中其实是借用了数学中的 λ，并且多了一点含义，在编程语言中功能代表它具体功能的叫法是匿名函数（Anonymous Function），接着再来说说Lambda 的历史，虽然它在 JDK1.8 发布之后才正式出现，但是在编程语言界，它是一个具有悠久历史的东西，最早在 1958 年在Lisp 语言中首先采用，而且虽然Java脱胎于C++，但是C++在2011年已经发布了Lambda 了，但是 JDK8 的 LTS 在2014年才发布，所以 Java 被人叫做老土不是没有原因的，现代编程语言则是全部一出生就自带 Lambda 支持，所以Lambda 其实是越来越火的一个节奏~

  1.2 Lambda语法

[1]：Lambda表达式的引入标志，在‘[]’里面可以填入‘=’或‘&’表示该lambda表达式“捕获”（lambda表达式在一定的scope可以访问的数据）的数据时以什么方式捕获的，‘&’表示一引用的方式；‘=’表明以值传递的方式捕获，除非专门指出。

[2]：Lambda表达式的参数列表

[3]：Mutable 标识

[4]：异常标识

[5]：返回值

[6]：“函数”体，也就是lambda表达式需要进行的实际操作。

  1.3 初识Lambda表达式

public class LambdaDemo1 {

    public static void main(String[] args) {
        Person p = new Student();
        p.speak("lan");
        //接口是函数式接口才能转换为lambda表达式
        //在只有一行代码的情况下可以将块简化为行
        //单个参数可以去掉参数类型，括号可选
        //多个参数可以同时去掉参数类型，必须括号包裹
        p = (language) -> System.out.println("lambda 表达式---单行代码" + language);
        p.speak("lan");

        p = (language) -> {
            System.out.println("lambda 表达式---块代码1" + language);
            System.out.println("lambda 表达式---块代码2" + language);
        };
        p.speak("lan");
    }
}

interface Person {
    void speak(String language);
}

class Student implements Person {
    @Override
    public void speak(String language) {
        System.out.println("外部类" + language);
    }
}

  1.4 Stream表达式

Stream，就是JDK8又依托于函数式编程特性为集合类库做的一个类库，它其实就是jdk提供的函数式接口的最佳实践。它能让我们通过lambda表达式更简明扼要的以流水线的方式去处理集合内的数据，可以很轻松的完成诸如：过滤、分组、收集、归约这类操作。其中Stream的操作大致分为两类：

中间型操作

public class LambdaDemo2 {

    public static void main(String[] args) {

        List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd", "", "jkl");

        List<String> strings1 = Arrays.asList("yzc", "htz", "boss");

        // filter demo
        List<String> filter = strings.stream()
                .filter(string -> !string.isEmpty())
                .collect(Collectors.toList());

        // map demo
        Map<String, String> map1 = strings.stream()
                .collect(Collectors.toMap(e -> e, Function.identity()));

        // map key 重复
        Map<String, String> map2 = strings.stream()
                .collect(Collectors.toMap(e -> e, Function.identity(), (key1, key2) -> key2));

        // map 指定map类型
        LinkedHashMap<String, String> map3 = strings.stream()
                .collect(Collectors.toMap(e -> e, Function.identity(), (key1, key2) -> key2, LinkedHashMap::new));
        
        Map<Long, List<User>> map = users.stream().collect(Collectors.groupingBy(User::getDeptId));
        /**
         * peek
         * 如果想打印流经的每个元素的状态（日志或 debug），这时应该用 peek()
         */
        strings.stream().peek(e -> System.out.println(e));

        // flatMap 集合套集合数据合并
        List<String> flatMap = strings.stream()
                .flatMap(x -> Arrays.asList(x.split(" ")).stream())
                .collect(Collectors.toList());

        // limited demo
        List<String> limited = strings.stream().limit(3).collect(Collectors.toList());

        // skiped demo
        List<String> skiped = strings.stream().skip(3).collect(Collectors.toList());

        // concat demo
        List<String> concat = Stream.concat(strings.stream(), strings1.stream()).collect(Collectors.toList());

        // distincted demo
        List<String> distincted = strings.stream().distinct().collect(Collectors.toList());

        // sorted demo
        List<String> sorted = strings.stream().sorted().collect(Collectors.toList());
    }
}

终结型操作

public class LambdaDemo3 {

    public static void main(String[] args) {
        
        List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd", "", "jkl");
        // foreach
        strings.stream().forEach(System.out::println);

        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6);
        // max
        Integer max = list.stream().max(Comparator.comparingInt(a -> a)).get();
        // min
        Integer min = list.stream().min(Comparator.comparingInt(a -> a)).get();
        // count
        long count = list.stream().count();
        // sum
        int sum = list.stream().mapToInt(Integer::intValue).sum();

        // allMatch 当流中每个元素都符合该断言时才返回true，否则返回false
        boolean allMatch = list.stream().allMatch(x -> x >= 0);

        // noneMatch 当流中每个元素都不符合该断言时才返回true，否则返回false
        boolean noneMatch = list.stream().noneMatch(x -> x > 5);

        // anyMatch 只要流中有一个元素满足该断言则返回true，否则返回false
        boolean anyMatch = list.stream().anyMatch(x -> x > 4);

        //findFirst 取第一个偶数
        Optional<Integer> findFirst = list.stream().filter(x -> x % 10 == 6).findFirst();
        if (findFirst.isPresent()) {
            Integer value = findFirst.get();
        }

        //findAny 任意取一个偶数
        Optional<Integer> findAny = list.stream().filter(x -> x % 2 == 0).findAny();
        if (findFirst.isPresent()) {
            Integer value = findAny.get();
        }
        
    }
}