Java——Stream 流的使用详解

Stream 　　是一个可以用于操作集合、数组等数据源的API，主要进行数据的转换、筛选、聚合等操作

这样做可以避免显式地使用迭代器或者循环来操作集合，提高代码的可读性和简洁性

特点 ： 

　　1、无存储性： 是基于数据源的对象，本身不存储元素，而是通过管道将数据源元素传递给操作

　　2、函数式编程：任何修改都不会修改背后的数据源，例如filter操作不会删除被过滤的元素，而是会产生一个不包含被过滤元素的新的Stream

　　3、可消费性：只能被消费一次，一旦遍历就会失效，类似于迭代器，想重新遍历需要重新生成

使用

　　中间操作 ：对流的一系列处理步骤，返回一个新的流，允许链式调用，通常对于数据进行过滤，映射，排除等操作

1. 1. filter（）：根据条件过滤元素
   2. map（）：将元素映射为新的值，有返回值
   3. sorted（）：对元素进行排序
   4. distinct（）：去重
   5. limit（Long maxSize）：限制元素的数量
   6. skip（long n）：跳过前n个元素
   7. flatMap（）：通常用于集合的扁平化
   8. peek（）：对流中元素执行指定操作，无返回值

举例如下：

public class IntermediateStream {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 5, 6, 6);
        //根据指定条件筛选元素
        //输出为[2,4,6]
        List<Integer> list1 = list.stream().filter(n -> n % 2 == 0).collect(Collectors.toList());
        System.out.println(list1);
        //将元素映射为新值或另一种类型
        List<Integer> list2 = list.stream().map(n -> n * 2).collect(Collectors.toList());
        System.out.println(list2);
        List<String> list3 = list.stream().map(n -> "Number" + n).collect(Collectors.toList());
        System.out.println(list3);
        //排序
        List<Integer> list4 = list.stream().sorted().collect(Collectors.toList());
        System.out.println(list4);
        //去重
        List<Integer> list5 = list.stream().distinct().collect(Collectors.toList());
        System.out.println(list5);
        //限制元素数量
        List<Integer> list6 = list.stream().limit(3).collect(Collectors.toList());
        System.out.println(list6);
        //跳过前n个元素
        List<Integer> list7 = list.stream().skip(3).collect(Collectors.toList());
        System.out.println(list7);
        //FlatMap()
        List<List<Integer>> list8=Arrays.asList(
                Arrays.asList(1,2),
                Arrays.asList(3,4,5),
                Arrays.asList(6,7,8,9,10)
        );
        List<Integer> flat=list8.stream().flatMap(Collection::stream).collect(Collectors.toList());
        System.out.println(flat);
        //peek()
        List<Integer> list9=list.stream().peek(n->System.out.println("Process element :"+n)).collect(Collectors.toList());
 
    }
}

　　终端操作：流的最后一个步骤，它会触发对流的计算并产生一个最终结果

1. forEach（）：对流中每个元素执行操作
2. collect（）：将流中的元素收集到一个容器中
3. toArray（）：将流中的元素收集到数组中
4. reduce（）：对流中的元素进行归约处理操作，返回一个值
5. count（）：返回流中元素的数量
6. min（）：返回流中的最小元素
7. max（）：返回流中的最大元素
8. findFirst（）：返回流中的第一个元素
9. findAny（）：返回流中的任意一个元素

举例如下：

public class TerminalStream {
    public static void main(String[] args) {
        //forEach
        List<String> list = Arrays.asList("Tom", "SuSan", "Lucy");
        list.stream().forEach(n -> System.out.println("Hello " + n));
        //toArray
        List<Integer> list1 = Arrays.asList(1, 2, 3, 4);
        Integer[] numArray = list1.stream().toArray(Integer[]::new);
        //reduce(identity,accumulator)
        List<Integer> list2 = Arrays.asList(1, 2, 3, 4, 5, 6);
        int sum = list2.stream().reduce(0, (a, b) -> a + b);
        System.out.println(sum);
        //collect
        List<String> list3 = list.stream().collect(Collectors.toList());
        Set<String> set = list.stream().collect(Collectors.toSet());
        Map<String, Integer> map = list.stream().collect(Collectors.toMap(n -> n, String::length));
        System.out.println(list3);
        System.out.println(set);
        System.out.println(map);
        //min(comparator) max(comparator)
        Optional<Integer> min = list1.stream().min(Integer::compareTo);
        Optional<Integer> max = list1.stream().max(Integer::compareTo);
        //输出1
        System.out.println(min.orElse(0));
        //输出6
        System.out.println(max.orElse(0));
        //findFirst()：返回流中的第一个元素
        //findAny()：返回流中的任意一个元素
        Optional<String> first2=list.stream().findFirst();
        Optional<String> any2=list.stream().findAny();
        System.out.println(first2.orElse(null));
        System.out.println(any2.orElse(null));
    }
}