「收藏版」JDK1.8工作中最常用的14个Stream详细小示例

IT实战联盟 2020-10-16 09:33:36 ⋅ 979 阅读

一：简介

java.util.Stream 表示能应用在一组元素上一次执行的操作序列。Stream 操作分为中间操作或者最终操作两种，最终操作返回一特定类型的计算结果，而中间操作返回Stream本身，这样就可以将多个操作依次串起来。Stream 的创建需要指定一个数据源，比如 java.util.Collection的子类，List或者Set， Map不支持。Stream的操作可以串行stream()执行或者并行parallelStream()执行。

纯干货 |JDK1.8工作中最常用的14个Stream详细小示例（建议收藏）

 

二：Stream

 

纯干货 |JDK1.8工作中最常用的14个Stream详细小示例（建议收藏）

 

纯干货 |JDK1.8工作中最常用的14个Stream详细小示例（建议收藏）

 

纯干货 |JDK1.8工作中最常用的14个Stream详细小示例（建议收藏）

 

package java.util.stream;

public interface Stream<T> extends BaseStream<T, Stream<T>> {
    Stream<T> filter(Predicate<? super T> predicate);

    IntStream mapToInt(ToIntFunction<? super T> mapper);

    LongStream mapToLong(ToLongFunction<? super T> mapper);

    DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper);

    <R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);

    IntStream flatMapToInt(Function<? super T, ? extends IntStream> mapper);

    LongStream flatMapToLong(Function<? super T, ? extends LongStream> mapper);

    DoubleStream flatMapToDouble(Function<? super T, ? extends DoubleStream> mapper);

    Stream<T> distinct();

    Stream<T> sorted();

    Stream<T> sorted(Comparator<? super T> comparator);

    Stream<T> peek(Consumer<? super T> action);

    Stream<T> limit(long maxSize);

    Stream<T> skip(long n);

    void forEach(Consumer<? super T> action);

    void forEachOrdered(Consumer<? super T> action);

    Object[] toArray();

    <A> A[] toArray(IntFunction<A[]> generator);

    T reduce(T identity, BinaryOperator<T> accumulator);

    Optional<T> reduce(BinaryOperator<T> accumulator);

    <U> U reduce(U identity, BiFunction<U, ? super T, U> accumulator,
                 BinaryOperator<U> combiner);

    <R> R collect(Supplier<R> supplier, BiConsumer<R, ? super T> accumulator,
                  BiConsumer<R, R> combiner);

    <R, A> R collect(Collector<? super T, A, R> collector);

    Optional<T> min(Comparator<? super T> comparator);

    Optional<T> max(Comparator<? super T> comparator);

    long count();

    boolean anyMatch(Predicate<? super T> predicate);

    boolean allMatch(Predicate<? super T> predicate);

    boolean noneMatch(Predicate<? super T> predicate);

    Optional<T> findFirst();

    Optional<T> findAny();

    public static<T> Builder<T> builder() {
        return new Streams.StreamBuilderImpl<>();
    }

    public static<T> Stream<T> empty() {
        return StreamSupport.stream(Spliterators.<T>emptySpliterator(), false);
    }

    public static<T> Stream<T> of(T t) {
        return StreamSupport.stream(new Streams.StreamBuilderImpl<>(t), false);
    }


    @SafeVarargs
    @SuppressWarnings("varargs") // Creating a stream from an array is safe
    public static<T> Stream<T> of(T... values) {
        return Arrays.stream(values);
    }

    public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f) {
        Objects.requireNonNull(f);
        final Iterator<T> iterator = new Iterator<T>() {
            @SuppressWarnings("unchecked")
            T t = (T) Streams.NONE;

            @Override
            public boolean hasNext() {
                return true;
            }

            @Override
            public T next() {
                return t = (t == Streams.NONE) ? seed : f.apply(t);
            }
        };
        return StreamSupport.stream(Spliterators.spliteratorUnknownSize(
                iterator,
                Spliterator.ORDERED | Spliterator.IMMUTABLE), false);
    }


    public static<T> Stream<T> generate(Supplier<T> s) {
        Objects.requireNonNull(s);
        return StreamSupport.stream(
                new StreamSpliterators.InfiniteSupplyingSpliterator.OfRef<>(Long.MAX_VALUE, s), false);
    }


    public static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b) {
        Objects.requireNonNull(a);
        Objects.requireNonNull(b);

        @SuppressWarnings("unchecked")
        Spliterator<T> split = new Streams.ConcatSpliterator.OfRef<>(
                (Spliterator<T>) a.spliterator(), (Spliterator<T>) b.spliterator());
        Stream<T> stream = StreamSupport.stream(split, a.isParallel() || b.isParallel());
        return stream.onClose(Streams.composedClose(a, b));
    }


    public interface Builder<T> extends Consumer<T> {
        @Override
        void accept(T t);

        default Builder<T> add(T t) {
            accept(t);
            return this;
        }

        Stream<T> build();
    }
}

三：示例

1. forEach 循环

@Test
public void forEach(){
    // 你不鸟我,我也不鸟你
    List<String> list = Arrays.asList("you", "don't", "bird", "me", ",", 
                                       "I", "don't", "bird", "you");

    // 方式一：JDK1.8之前的循环方式
    for (String item: list) {
        System.out.println(item);
    }

    // 方式二：使用Stream的forEach方法
    // void forEach(Consumer<? super T> action)
    list.stream().forEach(item -> System.out.println(item));

    // 方式三：方式二的简化方式
    // 由于方法引用也属于函数式接口，所以方式二Lambda表达式也可以使用方法引用来代替
    // 此种方式就是方式一、方式二的简写形式
    list.stream().forEach(System.out::println);
}

2. filter 过滤

public class User {
    private Long id;
    private String phone;
    private Integer age;

    public User(){}
    public User(Long id, String username, Integer age) {
        this.id = id;
        this.username = username;
        this.age = age;
    }
    // Getter & Setter & toString
}


@Test
public void filter(){
    List<User> users = Arrays.asList(
            new User(1L, "mengday", 28),
            new User(2L, "guoguo", 18),
            new User(3L, "liangliang", 17)
    );

    // Stream<T> filter(Predicate<? super T> predicate);
    users.stream().filter(user -> user.getAge() > 18).forEach(System.out::println);
}

3. map 映射

@Test
public void map(){
    List<String> list = Arrays.asList("how", "are", "you", "how", "old", "are", "you", "?");
    // <R> Stream<R> map(Function<? super T, ? extends R> mapper);
    list.stream().map(item -> item.toUpperCase()).forEach(System.out::println);
}

4. flatMap

@Test
public void flatMap(){
    List<Integer> a = Arrays.asList(1, 2, 3);
    List<Integer> b = Arrays.asList(4, 5, 6);

    // <R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper)
    List<List<Integer>> collect = Stream.of(a, b).collect(Collectors.toList());
    // [[1, 2, 3], [4, 5, 6]] 
    System.out.println(collect);

    // 将多个集合中的元素合并成一个集合
    List<Integer> mergeList = Stream.of(a, b).flatMap(list -> list.stream()).collect(Collectors.toList());
    // [1, 2, 3, 4, 5, 6]
    System.out.println(mergeList);

    // 通过Builder模式来构建
    Stream<Object> stream = Stream.builder().add("hello").add("hi").add("byebye").build();
}

5. sorted 排序

@Test
public void sort(){
    List<String> list = Arrays.asList("c", "e", "a", "d", "b");
    // Stream<T> sorted(Comparator<? super T> comparator);
    // int compare(T o1, T o2);
    list.stream().sorted((s1, s2) -> s1.compareTo(s2)).forEach(System.out::println);
}

6. distinct 去重复

@Test
public void distinct(){
    // 知之为知之,不知为不知
    Stream<String> stream = Stream.of("know", "is", "know", "noknow", "is", "noknow");
    stream.distinct().forEach(System.out::println); // know is noknow
}

7. count 总数量

@Test
public void count(){
    Stream<String> stream = Stream.of("know", "is", "know", "noknow", "is", "noknow");
    long count = stream.count();
    System.out.println(count);
}

8. min、max

@Test
public void min(){
    List<String> list = Arrays.asList("1", "2", "3", "4", "5");
    // Optional<T> min(Comparator<? super T> comparator);
    Optional<String> optional = list.stream().min((a, b) -> a.compareTo(b));
    String value = optional.get();
    System.out.println(value);
}

9. skip、limit

@Test
public void skip(){
    List<String> list = Arrays.asList("a", "b", "c", "d", "e");
    // Stream<T> skip(long n)
    list.stream().skip(2).forEach(System.out::println);  // c、d、e
}

@Test
public void limit(){
    List<String> list = Arrays.asList("a", "b", "c", "d", "e");
    list.stream().skip(2).limit(2).forEach(System.out::println);    // c、d
}

10. collect

@Test
public void collect(){
    List<String> list = Arrays.asList("a", "b", "c", "d", "e");
    // Stream -> Collection
    List<String> collect = list.stream().collect(Collectors.toList());

    // Stream -> Object[]
    Object[] objects = list.stream().toArray();
}

11. concat

@Test
public void concat(){
    List<String> list = Arrays.asList("a", "b");
    List<String> list2 = Arrays.asList("c", "d");
    Stream<String> concatStream = Stream.concat(list.stream(), list2.stream());
    concatStream.forEach(System.out::println);
}

12. anyMatch、allMatch

@Test
public void match(){
    // 你给我站住
    List<String> list = Arrays.asList("you", "give", "me", "stop");
    // boolean anyMatch(Predicate<? super T> predicate);
    // parallelStream可以并行计算，速度比stream更快
    boolean result = list.parallelStream().anyMatch(item -> item.equals("me"));
    System.out.println(result);
}

/**
* anyMatch伪代码
 * 如果集合中有一个元素满足条件就返回true
 * @return
 */
public  boolean anyMatch() {
    List<String> list = Arrays.asList("you", "give", "me", "stop");
    for (String item : list) {
        if (item.equals("me")) {
            return true;
        }
    }

        return false;
    }

13. reduce 归纳

@Test
public void reduce(){
    Stream<String> stream = Stream.of("you", "give", "me", "stop");
    // Optional<T> reduce(BinaryOperator<T> accumulator);
    Optional<String> optional = stream.reduce((before, after) -> before + "," + after);
    optional.ifPresent(System.out::println);    // you,give,me,stop
}

BigDecimal求和

public static void main(String[] args) {
    List<BigDecimal> list = Arrays.asList(
            new BigDecimal("11.11"),
            new BigDecimal("22.22"),
            new BigDecimal("33.33")
    );
    // 66.66
    BigDecimal sum = list.stream().reduce(BigDecimal.ZERO, BigDecimal::add);
    System.out.println(sum);
}

14. findFirst、findAny

@Test
public void findFirst(){
    Stream<String> stream = Stream.of("you", "give", "me", "stop");
    String value = stream.findFirst().get();
    System.out.println(value);
}

@Test
public void findAny(){
    Stream<String> stream = Stream.of("you", "give", "me", "stop");
    String value2 = stream.findAny().get();
    System.out.println(value2);
}

注意：本文归作者所有，未经作者允许，不得转载

#Stream
阅读全部

全部评论: 0 条

    我有话说:

    Java 14 有了这几个新特性，开发直接飞起来！

    内容介绍： Record -- 简化了简单 Java 类的创建。 Pattern Matching -- 简化了 instanceof 。 Switch 表达式 -- 简化了

    【收藏】18 个 Java8 日期处理的实践，太有用了！

    来源：https://juejin.im/post/5a795bad6fb9a0634f407ae5 Java 8 日期处理 Java 8 推出了全新的日期时间API，在教程中我们将通过一些简单的

    Druid 1.2.4 版本发布，增强 SQL Parser，支持 JDK8 日期类型

    Druid 1.2.4 版本现已发布，这个是一个小的 bug 修复版本，修复了一系列 SQL Parser 的问题，增强对 JDK 8 的支持。 Issues SQL Parser 增强对

    VUE 开源库收藏版（一）：史上最全面的学习资源 ，附GitHub源码地址

    VUE 开源库收藏版（一）：史上最全面的学习资源 ，附GitHub源码地址

    10个最“优秀”的代码注释

    致终于来到这里的勇敢的人。神奇。勿动。

    版本帝Java 12 / JDK 12 正式发布，八大重大更新及部分代码示例

    多种新特性了解，及部分代码示例

    能够替代 Jenkins 的13个解决方案，了解下！

    Jenkins 是目前最常用的持续集成工具，拥有近 50% 的市场份额，它还是很多技术团队的第一个使用的自动化工具。但是随着自动化领域的持续发展，Jenkins 逐渐暴露出了一些问题，例如缺乏功能

    微信小程序电商实战-商品详情（上）

    先看一下今天要实现的小程序商品详情页吧！

    微信小程序微商城（四）：动态API实现商品详情页（上）

    1、实现商品详情页面布局（这篇实现3个模块，头部商品图片轮播、商品价格和商品描述、商品详情展示） 2、根据用户点击不同的商品请求API动态加载数据

    最全Mac工具集

      MacTool Mac 开源免费工具汇总, 只罗列开源好用的。更全列表请参考awesome-mac 必备 Homebrew - 体验通过命令行安装 Mac 软件的工具(大部分是

    最大公约数和最小公倍数

    一. 基本概念： 如果数a能被数b整除，a就叫做b的倍数，b就叫做a的约数。约数和倍数都表示两个整数的关系，不能单独存在。 几个整数中公有的约束，叫做这几个数的公约数；其中最大的一个，叫做这几个

    SQLite 3.35.3 发布，最常用的数据库引擎

    为数众多的其它应用中，是世界上使用量最大的数据库引擎...

    全网最详细的一篇SpringCloud总结

    什么是Spring cloud 构建分布式系统不需要复杂和容易出错。Spring Cloud 为最常见的分布式系统模式提供了一种简单且易于接受的编程模型，帮助开发人员构建有弹性的、可靠的、协调的

    DDDplus 1.0.2 发布，轻量级业务中台开发框架

    DDDplus 简介 一套轻量级业务中台开发框架，以DDD思想为本，致力于业务资产的可沉淀可传承，全方位解决复杂业务场景的扩展问题，实现中台核心要素，赋能中台建设。 融合了前中台复杂生态协作方法论

    精品推荐：微信小程序常见的UI框架/组件库

    想要开发出一套高质量的小程序，运用框架，组件库是省时省力省心必不可少一部分，随着小程序日渐火爆，各种不同类型

    GitHub精选：2018年11月份最热门的Java开源项目

    又到了揭晓 11 月份最热门 Java 开源项目排名的时候了，在本月的名单中，出现了几个新面孔，如Java 核心知识库、轻量级容错组件Resilience4j .....

    微信小程序-Image的widthFix属性和rpm尺寸的使用

    在做微信小程序的商品详情页，商品的详情是图片集合，渲染完成后发现图片加载的很不自然

    pgAdmin 4 v4.29 发布，PostgreSQL 的开源图形化管理工具

    pgAdmin开发团队近期宣布pgAdmin 4的小版本v4.29发布。该版本的pgAdmin 4包含18个bug修复和新特性。想要获取详细的更新列表，请访问版本发布公告。 pgAdmin是一款针对

    Docker 20.10.0 发布， K8s 宣布将弃用 Docker 容器进行时之后发布的首个 版本

    Docker 20.10.0  发布了，这是自 K8s 宣布将弃用 Docker 容器进行时之后发布的首个 Docker 版本。 本次更新内容包括： 弃用/移除 当 docker 从不