Java中使用Stream流

首先，创建流的方式有三种。

创建流
单列集合： 集合对象.stream()
        List<Author> authors = getAuthors();
        Stream<Author> stream = authors.stream();
数组：Arrays.stream(数组)或者使用Stream.of来创建     
        Integer[] arr = {1,2,3,4,5};
        Stream<Integer> stream = Arrays.stream(arr);
        Stream<Integer> stream2 = Stream.of(arr);  
双列集合：转换成单列集合后再创建
        Map<String,Integer> map = new HashMap<>();
        map.put("蜡笔小新",19);
        map.put("黑子",17);
        map.put("日向翔阳",16);
        Stream<Map.Entry<String, Integer>> stream = map.entrySet().stream();

流有中间操作，终结操作。

filter 可以对流中的元素进行条件过滤，符合过滤条件的才能继续留在流中。

map 可以把对流中的元素进行计算或转换。

distinct 可以去除流中的重复元素 （distinct方法是依赖Object的equals方法来判断是否是相同对象的。所以需要注意重写equals方法。）

sorted 可以对流中的元素进行排序。

limit 可以设置流的最大长度，超出的部分将被抛弃。

skip 跳过流中的前n个元素，返回剩下的元素。

flatMap map只能把一个对象转换成另一个对象来作为流中的元素。而flatMap可以把一个对象转换成多个对象作为流中的元素。

flatMap举个例子

 例一：
打印所有书籍的名字。要求对重复的元素进行去重。
//        打印所有书籍的名字。要求对重复的元素进行去重。
        List<Author> authors = getAuthors();
        authors.stream()
                .flatMap(author -> author.getBooks().stream())
                .distinct()
                .forEach(book -> System.out.println(book.getName()));  
   例二：
打印现有数据的所有分类。要求对分类进行去重。不能出现这种格式：哲学,爱情
//        打印现有数据的所有分类。要求对分类进行去重。
        List<Author> authors = getAuthors();
        authors.stream()
                .flatMap(author -> author.getBooks().stream())
                .distinct()
                .flatMap(book -> Arrays.stream(book.getCategory().split(",")))
                .distinct()
                .forEach(category-> System.out.println(category));

终结操作

forEach 对流中的元素进行遍历操作，我们通过传入的参数去指定对遍历到的元素进行什么具体操作。

count 可以用来获取当前流中元素的个数。

max&min 可以用来或者流中的最值。

这个举个例子：

//        分别获取这些作家的所出书籍的最高分和最低分并打印。
        //Stream<Author>  -> Stream<Book> ->Stream<Integer>  ->求值
        List<Author> authors = getAuthors();
        Optional<Integer> max = authors.stream()
                .flatMap(author -> author.getBooks().stream())
                .map(book -> book.getScore())
                .max((score1, score2) -> score1 - score2);
        Optional<Integer> min = authors.stream()
                .flatMap(author -> author.getBooks().stream())
                .map(book -> book.getScore())
                .min((score1, score2) -> score1 - score2);
        System.out.println(max.get());
        System.out.println(min.get()); 

collect 把当前流转换成一个集合。

 获取一个Map集合，map的key为作者名，value为List<Book>
//        获取一个Map集合，map的key为作者名，value为List<Book>
        List<Author> authors = getAuthors();
        Map<String, List<Book>> map = authors.stream()
                .distinct()
                .collect(Collectors.toMap(author -> author.getName(), author -> author.getBooks()));
        System.out.println(map);     

reduce归并 

 reduce归并
   reduce两个参数的重载形式内部的计算方式如下：
T result = identity;
for (T element : this stream)
 result = accumulator.apply(result, element)
return result;    

使用reduce求所有作者年龄的和
//        使用reduce求所有作者年龄的和
        List<Author> authors = getAuthors();
        Integer sum = authors.stream()
                .distinct()
                .map(author -> author.getAge())
                .reduce(0, (result, element) -> result + element);
        System.out.println(sum);

另外，这些操作都是基于函数式接口的

常见函数式接口
Consumer 消费接口
根据其中抽象方法的参数列表和返回值类型知道，我们可以在方法中对传入的参数进行消费。
Function 计算转换接口
根据其中抽象方法的参数列表和返回值类型知道，我们可以在方法中对传入的参数计算或转换，把结果返回
Predicate 判断接口
根据其中抽象方法的参数列表和返回值类型知道，我们可以在方法中对传入的参数条件判断，返回判断结果
Supplier 生产型接口
根据其中抽象方法的参数列表和返回值类型知道，我们可以在方法中创建对象，把创建好的对象返回