Stream流对使用Java开发的伙计来说都不陌生,有了它从此就告别了繁琐的for循环😎。说实话作为开发,我对使用Stream流的掌握情况还不是很好🤷‍♂️,所以学习JDK中的API同时记录相应的API操作,并通过相应的实例快速掌握Stream的使用🐱‍🏍。

  老规矩,先了解什么是什么?(一到学习看英文文档我就头大!😒)

Stream 是什么?

  JDK文档中原述是这样的支持顺序和并行聚合操作的一系列元素,从文档中就能看出Stream 流管线 由源(其可以是阵列,集合,生成函数,I / O通道等)组成,零个或多个中间操作 (其将流转换成另一个流,例如filter(Predicate) )以及终端操作 (产生结果或副作用,如count()forEach(Consumer) ), 流懒惰 源数据上的计算仅在终端操作启动时执行,源元素仅在需要时才被使用(这可以理解为,取值是不会像普通集合一样立即获取值,当真正需要结果是才会执行)。 从Stream的实现中也能看到Stream实现了Collection接口,但Stream做了更高效的处理能 让代码更加简洁,极大地简化了集合的处理操作,提高了开发的效率和生产力。你可以使用相应的API对数据进行查找、过滤、组合、计算、操作、分组等过程。

Stream API接口

Modifier and TypeMethod and Description
booleanallMatch(Predicate<? super T> predicate) 返回此流的所有元素是否与提供的谓词匹配。
booleananyMatch(Predicate<? super T> predicate) 返回此流的任何元素是否与提供的谓词匹配。
static <T> Stream.Builder<T>builder() 返回一个 Stream的构建器。
<R,A> Rcollect(Collector<? super T,A,R> collector) 使用 Collector对此流的元素执行 mutable reduction Collector
<R> Rcollect(Supplier<R> supplier, BiConsumer<R,? super T> accumulator, BiConsumer<R,R> combiner) 对此流的元素执行 mutable reduction操作。
static <T> Stream<T>concat(Stream<? extends T> a, Stream<? extends T> b) 创建一个懒惰连接的流,其元素是第一个流的所有元素,后跟第二个流的所有元素。
longcount() 返回此流中的元素数。
Stream<T>distinct() 返回由该流的不同元素(根据 Object.equals(Object) )组成的流。
static <T> Stream<T>empty() 返回一个空的顺序 Stream
Stream<T>filter(Predicate<? super T> predicate) 返回由与此给定谓词匹配的此流的元素组成的流。
Optional<T>findAny() 返回描述流的一些元素的Optional如果流为空,则返回一个空的Optional
Optional<T>findFirst() 返回描述此流的第一个元素的Optional如果流为空,则返回一个空的Optional
<R> Stream<R>flatMap(Function<? super T,? extends Stream<? extends R>> mapper) 返回由通过将提供的映射函数应用于每个元素而产生的映射流的内容来替换该流的每个元素的结果的流。
DoubleStreamflatMapToDouble(Function<? super T,? extends DoubleStream> mapper) 返回一个 DoubleStream ,其中包含将该流的每个元素替换为通过将提供的映射函数应用于每个元素而产生的映射流的内容的结果。
IntStreamflatMapToInt(Function<? super T,? extends IntStream> mapper) 返回一个 IntStream ,其中包含将该流的每个元素替换为通过将提供的映射函数应用于每个元素而产生的映射流的内容的结果。
LongStreamflatMapToLong(Function<? super T,? extends LongStream> mapper) 返回一个 LongStream ,其中包含将该流的每个元素替换为通过将提供的映射函数应用于每个元素而产生的映射流的内容的结果。
voidforEach(Consumer<? super T> action) 对此流的每个元素执行操作。
voidforEachOrdered(Consumer<? super T> action) 如果流具有定义的遇到顺序,则以流的遇到顺序对该流的每个元素执行操作。
static <T> Stream<T>generate(Supplier<T> s) 返回无限顺序无序流,其中每个元素由提供的 Supplier
static <T> Stream<T>iterate(T seed, UnaryOperator<T> f) 返回有序无限连续 Stream由函数的迭代应用产生 f至初始元素 seed ,产生 Stream包括 seedf(seed)f(f(seed)) ,等
Stream<T>limit(long maxSize) 返回由此流的元素组成的流,截短长度不能超过 maxSize
<R> Stream<R>map(Function<? super T,? extends R> mapper) 返回由给定函数应用于此流的元素的结果组成的流。
DoubleStreammapToDouble(ToDoubleFunction<? super T> mapper) 返回一个 DoubleStream ,其中包含将给定函数应用于此流的元素的结果。
IntStreammapToInt(ToIntFunction<? super T> mapper) 返回一个 IntStream ,其中包含将给定函数应用于此流的元素的结果。
LongStreammapToLong(ToLongFunction<? super T> mapper) 返回一个 LongStream ,其中包含将给定函数应用于此流的元素的结果。
Optional<T>max(Comparator<? super T> comparator) 根据提供的 Comparator返回此流的最大元素。
Optional<T>min(Comparator<? super T> comparator) 根据提供的 Comparator返回此流的最小元素。
booleannoneMatch(Predicate<? super T> predicate) 返回此流的元素是否与提供的谓词匹配。
static <T> Stream<T>of(T... values) 返回其元素是指定值的顺序排序流。
static <T> Stream<T>of(T t) 返回包含单个元素的顺序 Stream
Stream<T>peek(Consumer<? super T> action) 返回由该流的元素组成的流,另外在从生成的流中消耗元素时对每个元素执行提供的操作。
Optional<T>reduce(BinaryOperator<T> accumulator) 使用 associative累积函数对此流的元素执行 reduction ,并返回描述减小值的 Optional (如果有)。
Treduce(T identity, BinaryOperator<T> accumulator) 使用提供的身份值和 associative累积功能对此流的元素执行 reduction ,并返回减小的值。
<U> Ureduce(U identity, BiFunction<U,? super T,U> accumulator, BinaryOperator<U> combiner) 执行 reduction在此流中的元素,使用所提供的身份,积累和组合功能。
Stream<T>skip(long n) 在丢弃流的第一个 n元素后,返回由该流的 n元素组成的流。
Stream<T>sorted() 返回由此流的元素组成的流,根据自然顺序排序。
Stream<T>sorted(Comparator<? super T> comparator) 返回由该流的元素组成的流,根据提供的 Comparator进行排序。
Object[]toArray() 返回一个包含此流的元素的数组。
<A> A[]toArray(IntFunction<A[]> generator) 使用提供的 generator函数返回一个包含此流的元素的数组,以分配返回的数组,以及分区执行或调整大小可能需要的任何其他数组。

Stream 操作(仅仅介绍常用API)

anyMatch() - 其中有一个元素满足条件则为true

/**
 * anyMatch
 * 其中有一个元素大于满足条件则为true
 */
public static void anyMatch(ArrayList<Integer> list){
    boolean b = list.stream().anyMatch(p -> p > 3);
    System.out.println(b);
}

allMatch() - 所有元素必须满足条件才能为true,否则为false。

/**
 * 所有元素必须满足条件才能为true,否则为false。
 * allMatch
 */
public static void allMatch(ArrayList<Integer> list){
    boolean b = list.stream().allMatch(p -> p > 0);
    System.out.println(b);
}

concat() - 进行两个流的连接

/**
 * 进行两个流的连接
 * concat
 */
public static void concat(Stream<Integer> s1,Stream<Integer> s2){
    Stream<Integer> concat = Stream.concat(s1, s2);
    System.out.println(Arrays.toString(concat.toArray()));
}

count() - 统计流中的元素数

/**
 * count
 * 统计流中的元素数
 */
public static void count(Stream<Integer> stream){
    System.out.println(stream.count());
}

distinct() - 返回由该流的不同元素

 ArrayList<Integer> arr1 = new ArrayList<>();
        arr1.add(1);
        arr1.add(1);
        arr1.add(3);
        arr1.add(4);
        distinct(arr1.stream());
/**
 * distinct
 * 返回不同的元素
 */
public static void distinct(Stream<Integer> stream){
    System.out.println(Arrays.toString(stream.distinct().toArray()));
}

filter() - 返回由与此给定谓词匹配的此流的元素组成的流

/**
 * filter
 * 根据条件过滤
 */
public static void filter(Stream<Integer> stream){
    List<Integer> collect = stream.filter(p -> p > 0)
            .collect(Collectors.toList());
    System.out.println(collect);
}

map() - 返回由给定函数应用于此流的元素的结果组成的流。

/**
 * map
 * 给定函数返回,返回组成新的流
 */
public static void map(Stream<Employee> s1) {
    s1.map(Employee::getName)
            .forEach(System.out::println);
}

 Stream.of-用于给定元素返回元素顺序流,可以传递一个或者多个。

 flatMap -返回由通过将提供的映射函数应用于每个元素而产生的映射流的内容来替换该流的每个元素的结果的流。

/**
 * flatMap
 * 给定流,返回按指定值的顺序排序的流
 */
public static void flatMap(List<Employee> s1) {
    List<Employee> newList = new ArrayList<>();
    newList.add(new Employee("新人", 18, "女",
            5000.7D, "浙江金华", "浙江金华", "售前", null));

    Stream.of(s1,newList)
            .flatMap(employee -> employee.stream().filter(f -> f.getAge()  == 18))
            .forEach(System.out::println);
}

除此之外,使用Stream有原型链,可以使用原型链的特性,自由进行发挥,使Stream流应用更加扎实。

最后修改:2023 年 02 月 13 日
如果觉得我的文章对你有用,请随意赞赏