Stream的使用-526互联

创建流

如果是数组的话，可以使用 Arrays.stream() 或者 Stream.of() 创建流；如果是集合的话，可以直接使用 stream() 方法创建流，因为该方法已经添加到 Collection 接口中。

    public static void main(String[] args) {
        String[] array = {"spring", "summer", "autumn", "winter"};
        Stream<String> stream = Arrays.stream(array);
        stream = Stream.of("spring", "summer", "autumn", "winter");
        List<String> list = new ArrayList<>();
        list.add("spring");
        list.add("summer");
        list.add("autumn");
        list.add("winter");
        stream = list.stream();<details>

    }

另外，集合还可以调用 parallelStream() 方法创建并发流，默认使用的是 ForkJoinPool.commonPool()线程池。

List<Long> aList = new ArrayList<>();
Stream<Long> parallelStream = aList.parallelStream();

操作流

1、filter方法可以过滤元素

        String[] array = {"spring", "summer", "autumn", "winter"};
        Stream<String> stream = Arrays.stream(array);
        stream = stream.filter(element -> element.contains("s"));
        stream.forEach(System.out::println);

filter() 方法接收的是一个 Predicate（Java 8 新增的一个函数式接口，接受一个输入参数返回一个布尔值结果）类型的参数，因此，我们可以直接将一个 Lambda 表达式传递给该方法，比如说 element -> element.contains("s") 就是筛选出带有“s”的字符串。

forEach() 方法接收的是一个 Consumer（Java 8 新增的一个函数式接口，接受一个输入参数并且无返回的操作）类型的参数，类名 :: 方法名是 Java 8 引入的新语法，System.out 返回 PrintStream 类，println 方法你应该知道是打印的。

2、使用map映射

把流中的元素映射成另外一种元素

        String[] array = {"spring", "summer", "autumn", "winter"};
        Stream<String> stream = Arrays.stream(array);
        Stream<Integer> integerStream = stream.map(String::length);
        integerStream.forEach(System.out::println);

map() 方法接收的是一个 Function（Java 8 新增的一个函数式接口，接受一个输入参数 T，返回一个结果 R）类型的参数，此时参数为 String 类的 length 方法，也就是把 Stream 的流转成一个 Stream 的流。

3、匹配

Stream 类提供了三个方法可供进行元素匹配，它们分别是：

anyMatch()，只要有一个元素匹配传入的条件，就返回 true。
allMatch()，只有有一个元素不匹配传入的条件，就返回 false；如果全部匹配，则返回 true。
noneMatch()，只要有一个元素匹配传入的条件，就返回 false；如果全部不匹配，则返回 true。

        List<String> list = new ArrayList<>();
        list.add("spring");
        list.add("summer");
        list.add("autumn");
        list.add("winter");
        boolean b1 = list.stream().anyMatch(element -> element.contains("s"));
        boolean b2 = list.stream().allMatch(element -> element.length() > 1);
        boolean b3 = list.stream().noneMatch(element -> element.endsWith("a"));
        System.out.println(b1);
        System.out.println(b2);
        System.out.println(b3);

4、组合

reduce() 方法的主要作用是把 Stream 中的元素组合起来，它有两种用法：

Optional reduce(BinaryOperator accumulator)
没有起始值，只有一个参数，就是运算规则，此时返回 Optional。

T reduce(T identity, BinaryOperator accumulator)
有起始值，有运算规则，两个参数，此时返回的类型和起始值类型一致。

来看下面这个例子。

        Integer[] ints = {0, 1, 2, 3};
        List<Integer> list = Arrays.asList(ints);

        Optional<Integer> optional = list.stream().reduce((a, b) -> a + b);
        Optional<Integer> optional1 = list.stream().reduce(Integer::sum);
        System.out.println(optional.orElse(0));
        System.out.println(optional1.orElse(0));

        int reduce = list.stream().reduce(6, (a, b) -> a + b);
        System.out.println(reduce);
        int reduce1 = list.stream().reduce(6, Integer::sum);
        System.out.println(reduce1);

程序运行的结果如下所示：

0、1、2、3 在没有起始值相加的时候结果为 6；有起始值 6 的时候结果为 12。