为了方便演示流的各种操作，这里数据统一用如下的 arr 集合
List<Integer> arr = Arrays.asList(5, 4, 3, 6, 6, 9, 8, 7, 1, 2);1.forEach 遍历
函数原型：void forEach(Consumer<? super T> action)
描述：遍历所有元素，并执行相应操作
如：遍历所有元素 并打印
arr.stream().forEach( e -> {System.out.println(e); });2.filter 过滤
函数原型：Stream<T> filter(Predicate<? super T> predicate)
描述：用参数（函数式接口，可以用lambda表达式）指定一个过滤条件，将过滤之后的数据放到一个新的Stream流中
如：利用filter将 大于等于5 的数据过滤出来，收集到list集合中
List<Integer> res = arr.stream().filter(e -> e >= 5).toList();3.distinct 元素去重
函数原型：Stream<T> distinct()
描述：去除重复数据，将去重后的数据放到一个新的Stream流中
如：利用distinct对元素进行 去重，收集到list集合中
List<Integer> res = arr.stream().distinct().toList();4.sorted 排序
函数原型：Stream<T> sorted(Comparator<? super T> comparator)
描述：根据指定的比较方式，对元素进行排序
如：对流中的元素进行 从小到大 排序，排序后的结果收集到list集合中
List<Integer> res = arr.stream().sorted((a, b) -> a - b).toList();5.max 与 min
函数原型：Optional<T> max(Comparator<? super T> comparator)
Optional<T> min(Comparator<? super T> comparator)
描述：根据指定的比较方式，拿到最大值或最小值封装到Optional对象中
如：利用max与min获取最大值，最小值
Integer max = arr.stream().max((a, b) -> a - b).get();
Integer min = arr.stream().min((a, b) -> a - b).get();6.skip 跳过前几个
函数原型：Stream<T> skip(long n)
描述：跳过流中的前几个数据，将剩下的数据放到一个新的Stream流中
如：利用skip 跳过前3个元素，将剩余的元素放到list集合中
List<Integer> res = arr.stream().skip(3).toList();7.limit 长度限制
函数原型：Stream<T> limit(long maxSize)
描述：从流中取出元素的个数不能超过maxSize
如：从流中 取出前五个元素
List<Integer> res = arr.stream().limit(5).toList();8.collect 收集
函数原型：<R, A> R collect(Collector<? super T, A, R> collector)
描述：将流中的元素收集到指定类型的集合中（可以通过Collectors类中的静态方法指定，如toSet()，toList()等）
如：将流中的元素 收集到Set 集合中
Set<Integer> res = arr.stream().collect(Collectors.toSet());9.map 数据映射
函数原型：<R> Stream<R> map(Function<? super T, ? extends R> mapper)
描述：对流中的每一个元素进行数据映射，将映射后的数据放到一个新的Stream流中
如：利用map进行将数据类型进行映射，将所有的数据都 映射为String 类型
List<String> res = arr.stream().map(e -> String.valueOf(e)).toList();10.条件判断
① allMatch 全满足
函数原型：boolean allMatch(Predicate<? super T> predicate)
描述：判断所有的元素是否都满足指定条件
如：判断所有的元素 是否都大于5
if (arr.stream().allMatch(e -> e > 5)){System.out.println("所有元素都大于5");
}② anyMatch 存在一个满足
函数原型：boolean anyMatch(Predicate<? super T> predicate)
描述：流中的所有元素，只要存在一个满足条件的，则返回true
如：判断 是否存在大于100 的元素
if (arr.stream().anyMatch(e -> e > 100)) {System.out.println("存在元素大于100");
}③ noneMatch 都不满足
函数原型：boolean noneMatch(Predicate<? super T> predicate)
描述：如果所有元素都不满足条件，则返回true
如：判断所有元素 是否都不小于0
if (arr.stream().noneMatch(e -> e < 0)) {System.out.println("arr中的元素都不小于0");
}11.reduce 合并元素
函数原型：Optional<T> reduce(BinaryOperator<T> accumulator)
描述：通过指定的操作对元素进行合并（如相加）
如：将所有的元素进行 相加，获取相加后的结果
Integer sum = arr.stream().reduce((a, b) -> a + b).get();12.dropWhile 一直删除
函数原型：Stream<T> dropWhile(Predicate<? super T> predicate)
描述：指定一个条件，遇到第一个不满足条件的元素之前一直删除
如：删除前面 连续小于3的前缀
List<Integer> res = arr.stream().dropWhile(e -> e < 3).collect(Collectors.toList());13.takeWhile 拿出
函数原型：Stream<T> takeWhile(Predicate<? super T> predicate)
描述：指定一个条件，遇到第一个不满足条件的元素之前一直取出
如：取出 连续大于3的前缀
List<Integer> res = arr.stream().takeWhile(e -> e > 3).collect(Collectors.toList());14.flatMap 将流压平
函数原型：<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper)
描述：指定一个操作元素函数（该函数会遍历所有元素），返回操作后的结果流
如：将二维数组转为一维数组，将 许多流压成一个流
Integer[][]arr2D = {{1,1,1},{2,2,2},{3,3,3}
};// [1, 1, 1, 2, 2, 2, 3, 3, 3]
Object[] res = Arrays.stream(arr2D).flatMap(a -> Arrays.stream(a)).toArray();