Java高阶进阶之Java函数式编程-Stream流-Lambda表达式

简介

jdk1.8中新增了流Stream,和Lambda表达式
Stream流、Lambda表达式是函数式编程思想，可以让我们不用关注什么对象，而是关注对数据进行了什么操作，
Stream可以很方便对我们的集合数组进行操作。并且在大数据下处理效果高，列如有大数据量集合可以使用
我们的并行流进行操作。可以消灭嵌套地狱的if。让代码简洁、易理解，并且、快速开发。

常用操作:

常用操作(中间操作)
1. distinct()：去除流中的重复元素
2. filter()：对流中的元素进行条件过滤，符合过滤条件的才能继续留在流中
3. map()：对流中的元素进行计算或转换
4. sorted()：对流中的元素进行排序
5. limit()：可以设置流的最大长度，超出的部分将被抛弃。
6. skip()：跳过流中的前n个元素，返回剩下的元素
7. flatMap()：map只能把一个对象转换成另一个对象来作为流中的元素。而flatMap可以把一个对象转换成多个对象作为流中的元素
9. 常用操作:(终结操作)
10. foreach()：对流中的元素进行遍历操作，我们通过传入的参数去指定对遍历到的元素进行什么具体操作。
11. count();获取元素的个数
12. max&min():获取流中最大最小值
13. collect():把当前流转换一个集合
14. anyMatch():判断是否有任意符合匹配条件的元素，结果为boolean
15. allMatch():用来判断是否都符合匹配条件，结果为boolean类型
16. noneMatch():判断流中的元素是否都不符合匹配条件，结果为boolean类型
17. findAny():获取流中的任意一个元素。该方法没有办法保证获取的一定是流中的第一个元素。
18. findFirst()：获取流中的第一个元素。
19. parallel()：将字符流转为并行流
20. peek():查看线程执行的信息

案列：

 /**
     * 打印年龄小于18，并且去重
     */
    public static void test1(List<Author> authors) {
   
//        List<Author> authors1 = new ArrayList<>();
        authors.stream()
                .distinct()
                .filter(author -> author.getAge() < 18)
                .forEach(author -> System.out.println("年龄小于18岁的作家为：" + author.getName()));
    }

    /**
     * 打印名字长度大于1的作家名称
     */
    public static void testAuthors() {
   
        Stream<Author> stream = getAuthors().stream();
        stream.filter(author -> author.getName().length() > 1)
                .forEach(author -> System.out.println(author.getName()));
    }

    /**
     * 去重，并且排序，输出年龄
     */
    public static void test5() {
   
        List<Author> authors = getAuthors();
//        对流中的元素按照年龄进行降序排序，并且要求不能有重复的元素。
        authors.stream()
                .distinct()
                .sorted((o1, o2) -> o2.getAge() - o1.getAge())
                .forEach(author -> System.out.println(author.getAge()));
    }

    /**
     * 去重，按照年龄排序，输出前两位的作家名称
     */
    public static void test6() {
   
        List<Author> authors = getAuthors();
        authors.stream().distinct()
                .sorted()
                .limit(2)
                .forEach(author -> System.out.println(author.getName()));
    }

    /**
     * 打印除了年龄最大的作家外的其他作家，要求不能有重复元素，并且按照年龄降序排序。
     */
    public static void test7() {
   
        List<Author> authors = getAuthors();
        authors.stream()
                .distinct()
                .sorted((o1, o2) -> o2.getAge() - o1.getAge())
                .skip(1)
                .forEach(author -> System.out.println(author.getName()));
    }

    /**
     * 打印所有书籍的名字。要求对重复的元素进行去重。
     */
    public static void test8() {
   
        List<Book> books = new ArrayList<>();
        List<Author> authors = getAuthors();
        authors.stream()
                .flatMap(author -> author.getBooks().stream())
                .distinct()
                .forEach(book -> books.add(book));
        System.out.println(books);
    }

    /**
     * 使用map去重输出姓名
     */
    public static void test9() {
   
        List<Author> authors = getAuthors();
        authors.stream()
                .map(author -> author.getBooks())
                .distinct()
                .forEach(s -> System.out.println(s));
    }

    /**
     * 打印所有书籍的名字。要求对重复的书名进行去重。
     */
    public static void test10() {
   
        List<Author> authors = getAuthors();
        authors.stream()
                .flatMap(author -> author