lambda表达式学习笔记

lambda表达式特点

函数式编程（接口中只有一个抽象方法）
参数类型自动推断
代码简洁

lambda应用场景

任何有函数式接口的地方

函数是接口

Supplier 代表一个输出
Consumer 代表一个输入
BiConsumer 代表两个输入
Function 代表一个输入，一个输出（一般输入和输出是不同类型的）
UnaryOperator 代表一个输入，一个输出（一般输入和输出是相同类型的）
BiFunction 代表两个输入，一个输出（一般输入和输出是不同类型的）
BinaryOperator 代表两个输入，一个输出（一般输入和输出是相同类型的）

@FunctionalInterface

作用于接口上，判断接口是否为函数式接口

方法引用

是用来直接访问类或者实例的已经存在的方法或者构造方法，方法引用提供了一种引用而不执行方法的方式，如果抽象方法的实现恰好可以使用调用另外一个方法来实现，就有可能可以使用方法的引用

使用lambda的意义

简化代码结构且意图明显，追随函数式编程趋势
多核友好

Stream特性

不是数据结构，没有内部存储
不支持索引访问
延迟计算（懒执行）
并行执行
很容易生成数组、集合
支持过滤，查找，转换，汇总，聚合等操作

Stream创建方式

通过数组
通过集合来
通过Stream.generate方法来创建
4 通过Stream.iterate方法来创建
其他API创建

实例：

//通过数组生成
    static void gen1(){
        String[] strs = {"1","2"};
        Stream<String> strs1 = Stream.of(strs);
        strs1.forEach(System.out::println);
    }
    //通过集合生成
    static void  gen2(){
        List<String> strings = Arrays.asList("1", "2", "3");
        Stream<String> stream = strings.stream();
        stream.forEach(System.out::println);
    }
    //generate
    static void gen3(){
        Stream<Integer> generate = Stream.generate(() -> 1);
        generate.limit(10).forEach(System.out::println);
    }
    //使用iterator
    static void  gen4(){
        Stream<Integer> iterate = Stream.iterate(1, x -> x + 1);
        iterate.limit(50).forEach(System.out::println);
    }
    //其他方式
    static void gen5(){
        String str = "asdfghj";
        IntStream chars = str.chars();
        chars.forEach(System.out::println);
    }

Stream常用实例：

        //取奇数
        Arrays.asList(1,2,3,4,5,6,7,8).stream().filter(x->(x+1)%2==0).forEach(System.out::println);
        //取奇数和
        int sum = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8).stream().filter(x -> (x + 1) % 2 == 0).mapToInt(x -> x).sum();
        //取最大值
        int max = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8).stream().max((a,b)->a-b).get();
        //取任何一个
        Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8).stream().findAny().get();
        //取第一个
        Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8).stream().findFirst().get();
        //取最大值，自定义
        Arrays.asList(1, 2, 3, 4, 5, 6, 7,8).stream().sorted((x1,x2)-> x2-x1).findFirst().get();
        //过滤后返回集合对象
        Arrays.asList(1, 2, 3, 4, 5, 6, 7,8).stream().filter(x->x%2==0).collect(Collectors.toList());
        //去重
        Arrays.asList(1, 2, 2, 4, 4, 6, 7,8).stream().distinct().collect(Collectors.toList());
        Arrays.asList(1, 2, 2, 4, 4, 6, 7,8).stream().collect(Collectors.toSet());
        //获取20-30数字
        Stream.iterate(1,x->x+1).skip(20).limit(10);
        //字符串求和
        String str = "11,,22,33,44,55,66";
        Stream.of(str.split(",")).mapToInt(x->Integer.valueOf(x)).sum();
        Stream.of(str.split(",")).map(x->Integer.valueOf(x)).mapToInt(x->x).sum();
        Stream.of(str.split(",")).mapToInt(Integer::valueOf).sum();
        //将str中所有数值求和并打印
        Stream.of(str.split("")).peek(System.out::println).mapToInt(Integer::valueOf).sum();
        //误区(不会有任何输出，没有终止函数，不会执行，中间过程不存储！！)
        Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8).stream().filter(x -> {
            System.out.println("代码运行");
            return (x + 1) % 2 == 0;
            }
        );