Stream流：基本API操作详细笔记

目录

1.Stream流基础介绍

1.1 Stream流有一些特性：

1.2 流的操作可以分为两种类型：

2.创建流

2.1 串行流：

2.2 并行流 

3.操作流

3.1 过滤

3.2 映射

3.3 匹配

3.4 归约

4.转换流（终止操作）

---

1.Stream流基础介绍

1.1 Stream流有一些特性：

1. Stream流不是一种数据结构，不保存数据，它只是在原数据集上定义了一组操作。
2. 这些操作是惰性的，即每当访问到流中的一个元素，才会在此元素上执行这一系列操作。
3. Stream不保存数据，故每个Stream流只能使用一次。

1.2 流的操作可以分为两种类型：

1）中间操作，可以有多个，每次返回一个新的流，可进行链式操作。

2）终止操作，只能有一个，每次执行完，这个流也就用光光了，无法执行下一个操作，因此只能放在最后。

2.创建流

2.1串行流：

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

public class CreateStreamDemo {
    public static void main(String[] args) {
        String[] arr = new String[]{"学习", "游戏", "看书"};
        Stream<String> stream = Arrays.stream(arr);

        stream = Stream.of("学习", "游戏", "看书");

        List<String> list = new ArrayList<>();
        list.add("学习");
        list.add("游戏");
        list.add("看书");
        stream = list.stream();
    }
}

查看 Stream 源码的话，你会发现 of() 方法内部其实调用了 Arrays.stream() 方法。

public static<T> Stream<T> of(T... values) {
    return Arrays.stream(values);
}

2.2并行流 

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

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

3.操作流

3.1 过滤

通过 filter() 方法可以从流中筛选出我们想要的元素。

public class FilterStreamDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("周杰伦");
        list.add("王力宏");
        list.add("陶喆");
        list.add("林俊杰");
        Stream<String> stream = list.stream().filter(element -> element.contains("王"));
        stream.forEach(System.out::println);
    }
}

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

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

stream.forEach(System.out::println); 相当于在 for 循环中打印。

3.2 映射

如果想通过某种操作把一个流中的元素转化成新的流中的元素，可以使用 map() 方法。

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

public class MapStreamDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("周杰伦");
        list.add("王力宏");
        list.add("陶喆");
        list.add("林俊杰");
        Stream<Integer> stream = list.stream().map(String::length);
        stream.forEach(System.out::println);
    }
}

程序输出的结果如下所示：

3
3
2
3

3.3 匹配

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

anyMatch()，只要有一个元素匹配传入的条件，就返回 true。

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

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

public class MatchStreamDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("周杰伦");
        list.add("王力宏");
        list.add("陶喆");
        list.add("林俊杰");

        boolean  anyMatchFlag = list.stream().anyMatch(element -> element.contains("王"));
        boolean  allMatchFlag = list.stream().allMatch(element -> element.length() > 1);
        boolean  noneMatchFlag = list.stream().noneMatch(element -> element.endsWith("沉"));
        System.out.println(anyMatchFlag);
        System.out.println(allMatchFlag);
        System.out.println(noneMatchFlag);
    }
}

因为“王力宏”以“王”字开头，所以 anyMatchFlag 应该为 true；

因为“周杰伦”、“王力宏”、“陶喆”、“林俊杰”的字符串长度都大于 1，所以 allMatchFlag 为 true；

因为 4 个字符串结尾都不是“沉”，所以 noneMatchFlag 为 true。
 

3.4 归约

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

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

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

来看下面这个例子。

public class ReduceStreamDemo {
    public static void main(String[] args) {
        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)); 6
        System.out.println(optional1.orElse(0)); 6

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

流的Intermediate方法(中间操作)

1.filter(Predicate) 将结果为false的元素过滤掉
2.map(fun) 转换元素的值，可以用方法引元或者lambda表达式
3.flatMap(fun) 若元素是流，将流摊平为正常元素，再进行元素转换
4.limit(n) 保留前n个元素
5.skip(n) 跳过前n个元素
6.distinct() 剔除重复元素
7.sorted() 将Comparable元素的流排序
8.sorted(Comparator) 将流元素按Comparator排序
9.peek(fun) 流不变，但会把每个元素传入fun执行，可以用作调试

4.转换流（终止操作）

既然可以把集合或者数组转成流，那么也应该有对应的方法，将流转换回去—— collect() 方法就满足了这种需求。

public class CollectStreamDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("周杰伦");
        list.add("王力宏");
        list.add("陶喆");
        list.add("林俊杰");

        /**
        *String[]::new 是一个 IntFunction，一个可以产生所需的新数组的函数，也就是相当于返回                
        *了一个指定长度的字符串数组。
        */
        String[] strArray = list.stream().toArray(String[]::new);
        System.out.println(Arrays.toString(strArray));

        List<Integer> list1 = list.stream().map(String::length).collect(Collectors.toList());
        List<String> list2 = list.stream().collect(Collectors.toCollection(ArrayList::new));
        System.out.println(list1);
        System.out.println(list2);

        String str = list.stream().collect(Collectors.joining(", ")).toString();
        System.out.println(str);
    }
}

[周杰伦, 王力宏, 陶喆, 林俊杰]
[3, 3, 2, 3]
[周杰伦, 王力宏, 陶喆, 林俊杰]
周杰伦, 王力宏, 陶喆, 林俊杰