Lambda表达式以及Stream流式处理

一、Lambda表达式的优点

1）JDK8开始支持Lambda表达式，用来让程序编写更优雅

2）利用Lambda可以更简洁的实现匿名内部类和函数声明与调用

3）基于Lambda提供stream流式处理极大简化对集合的操作

        实现集合排序传统代码

        List<String> names = Arrays.asList("peter","anna","mike");
        Collections.sort(names, new Comparator<String>() {
            @Override
            public int compare(String a, String b) {
                return b.compareTo(a);
            }
        });

        使用Lambda表达式实现上述功能

        List<String> names = Arrays.asList("peter","anna","mike");
        Collections.sort(names, (a, b) -> b.compareTo(a));

二、Lambda表达式语法格式

        Lambda表达式只能实现有且仅有一个抽象方法的接口，称之为函数式接口 

三、函数式编程

        函数式编程是基于函数式接口并使用lambda表达的编程方式。

        函数式编程理念是将代码作为可重用数据带入到程序运行中。函数式编程强调“你想做什么”而不是“你想怎么做”。如下

    public void test(){
        List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9);
        filter(list, n -> n%2 == 1);
        filter(list, n -> n%2 == 0);
    }
    public static void filter(List<Integer> list, Predicate<Integer> predicate) {
        for (Integer num: list) {
            if(predicate.test(num)){
                System.out.printf(num+"");
            }
        }
    }

        函数式接口是有且仅有一个抽象方法的接口。Java中有大量的函数式接口，如java.lang.Runnable。Java8提供一系列新的函数式接口，位于java.util.function。

        Predicate<T>: 接收一个参数，返回布尔值，用于测试传入的数据是否满足判断要求。Predicate需要实现test()方法进行逻辑判断。

        Consumer<T>：接收一个参数，不返回结果，有一个accept方法。

        IntConsumer: 参数是整数的Consumer

        Function<T,R>: 接收一个参数且需要返回数据，有一个apply方法

        自定义函数式接口时可以使用@FunctionalInterface注解， 通知编译器这是函数式接口，进行抽象方法检查，也可以不加。

四、函数式编程与面向对象编程对比

五、Stream流式处理

        Stream流式处理是建立在Lambda基础上的多数据处理技术，Stream对集合数据处理进行高度抽象，极大简化代码量。Stream可对集合进行迭代、去重、筛选、排序、聚合等一系列处理。

//        获取List集合中最大的偶数
        Optional<Integer> op = Arrays.asList(1,2,3,4,5,6,7,8,9).stream()
                .filter(x -> x%2 == 0)
                .sorted((a,b) -> b-a)
                .findFirst();
        System.out.println(op.get());

        流式处理常用方法

 collect: 对流数据进行收集，生成新的List/Set 

        方法使用实例

        // 偶数求和        
        List<String> list = Arrays.asList("1","2","3","4");
        int sum = list.stream()
                .mapToInt(s -> Integer.parseInt(s))
                .filter(num -> num%2 == 0)
                .sum();

        // 首字母转大写
        List<String> list = Arrays.asList("lily","andy","jack","smith");
        List<String> result = list.stream()
                .map(s -> s.substring(0,1).toUpperCase() + s.substring(1))
                .collect(Collectors.toList());

         // 将所有奇数从小到大排序，且不许出现重复
        List<Integer> list = Arrays.asList(11, 2, 38, 4, 52, 6, 7, 11);
        List<Integer> result = list.stream()
                .distinct()     //去除重复流数据
                .filter( n -> n%2 == 1)
                .sorted((a,b) -> b-a)       //排序
                .collect(Collectors.toList());

六、流对象的五种创建方式

1）基于数组进行创建

String[] arr = {"Lily", "Andy", "Jackson"};
Stream<String> stream = Stream.of(arr);
stream.forEach(s -> System.out.println(s));

2）基于集合进行创建 

List<String> list = new ArrayList<>();
list.add("Lily");
list.add("Andy");
Stream stream = list.stream();

3）利用generate方式创建无限长度流

Stream<Integer> stream = Stream.generate(() -> new Random().nextInt(100000));
stream.limit(10).forEach(i -> System.out.println(i));

4）基于迭代器创建流

Stream<Integer> stream = Stream.iterate(1, n -> n+1).limit(100);

5）基于字符序列创建流 

// 可以处理汉字，会自动转为unicode码
String str = "abcdefg嘿嘿";
IntStream stream = str.chars();
stream.forEach(c -> System.out.println((char)c));