java8 -函数式编程之Stream

于 2018-12-24 23:05:00 发布
阅读量96 收藏 1
点赞数
CC 4.0 BY-SA版权
文章标签： java python 数据结构与算法
原文链接：https://my.oschina.net/thinwonton/blog/2992751
本文深入探讨Java8中的Stream流式操作，讲解其特点、构造方式及常见操作，包括中间操作与终断操作，如map、filter、reduce等，并提供实例说明。

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

        在 java8 -函数式编程之Lambda表达式、 java8 -函数式编程之四个基本接口 、java8 -函数式编程之Optional 三篇文章中，我们已经对函数式编程有了充分的了解，接下来，我们将会运用之前学到的知识学习项目中常用到的 java8 Stream 流式操作。

什么是Stream

        Stream API 借助于 Lambda 表达式，极大的提高编程效率和程序可读性。同时它提供串行和并行两种模式进行汇聚操作，并发模式能够充分利用多核处理器的优势，使用 fork/join 并行方式来拆分任务和加速处理过程。通常编写并行代码很难而且容易出错, 但使用 Stream API 无需编写一行多线程的代码，就可以很方便地写出高性能的并发程序。

        流主要有三部分构成：获取一个数据源（source）→ 数据转换 → 执行操作获取想要的结果。每次转换原有 Stream 对象不改变，返回一个新的 Stream 对象（可以有多次转换），这就允许对其操作可以像链条一样排列，变成一个管道。

    272b539e6b8d16a00311f80696800bb2234.jpg

Stream的特点

无存储性：

    流不是存储元素的数据结构；相反，它需要从数据结构，数组，生成器函数或IO管道中获取数据并通过流水线地(计算)操作对这些数据进行转换。

函数式编程：

    Stream上操作会产生一个新结果，而不会去修改原始数据。比如filter过滤操作它只会根据原始集合中将未被过滤掉的元素生成一个新的Stream，而不是真的去删除集合中的元素。

惰性求值：

    很多Stream操作(如filter,map,distinct等)都是惰性实现，这样做为了优化程序的计算。比如说，要从一串数字中找到第一个能被10整除的数，程序并不需要对这一串数字中的每个数字进行测试。流操作分为两种：中间操作(返回值仍为Stream，仍可执行操作)，终断操作(结束Stream操作)。中间操作都是惰性操作。

无限数据处理：

    集合的大小是有限的，但是流可以对无限的数据执行操作。比如可以使用limit或findFirst这样的操作让Stream操作在有限的时间内结束。

一次性消费：

    流只能使用(“消费”)一次，一旦调用终断操作，流就不能再次使用，必须重新创建一个流。就像迭代器一样，遍历一遍后，想要再次遍历需要重新创建一个迭代器。

Stream的源的构建

有多种方式可以构建流：

（1）静态工厂

  • Stream.of()
  • IntStream.of()
  • LongStream.of()
  • DoubleStream.of()

（2）Collection 和数组

  • Collection.stream()
  • Collection.parallelStream()
  • Arrays.stream(T array) or Stream.of()

（3）字符流

  • BufferdReader.lines()

（4）文件路径

  • Files.walk()
  • Files.lines()
  • Files.find()

（5）其它

  • Random.ints()
  • BitSet.stream()
  • Pattern.splitAsStream(java.lang.CharSequence)
  • JarFile.stream()

生成流的时候，除了可以生成串行流，也可以生成并行流，即并行处理流的操作。

        final List<String> strings = Arrays.asList("ab", "a", "abc", "b", "bc");

        //串行流
        long count1 = strings.stream()
                .filter(s -> {
                    System.out.println("thread:" + Thread.currentThread().getId());
                    return s.startsWith("a");
                })
                .count();
        System.out.println(count1);

        //并行流
        long count2 = strings.parallelStream()
                .filter(s -> {
                    System.out.println("thread:" + Thread.currentThread().getId());
                    return s.startsWith("a");
                })
                .count();
        System.out.println(count2);

Stream操作的分类

 Stream操作分类 
中间操作(Intermediate operations)无状态(Stateless)

unordered(), filter(), map(), mapToInt(), mapToLong(), mapToDouble(), flatMap(), flatMapToInt(), flatMapToLong(), flatMapToDouble(), peek();

 有状态(Stateful)distinct();  sorted();  limit(), skip()
终断操作(Terminal operations)非短路操作forEach(), forEachOrdered(); reduce(), collect(), max(), min(), count(); toArray()
 短路操作(short-circuiting)anyMatch(), allMatch(), noneMatch(); findFirst(), findAny()

中间操作：

    返回一个新的Stream。中间操作都是惰性的，它们不会对数据源执行任何操作，仅仅是创建一个新的Stream。在终断操作执行之前，数据源的遍历不会开始。

终断操作：

    遍历流并生成结果或者副作用。执行完终断操作后，Stream就会被“消费”掉，如果想再次遍历数据源，则必须重新创建新的Stream。大多数情况下，终断操作的遍历都是即时的——在返回之前完成数据源的遍历和处理，只有iterator()和spliterator()不是，这两个方法用于提供额外的遍历功能——让开发者自己控制数据源的遍历以实现现有Stream操作中无法满足的操作(实际上现有的Stream操作基本能满足需求，所以这两个方法目前用的不多)。

 

Stream的操作

中间操作

  • map

    使用传入的Function对象对Stream中的所有元素进行处理，返回的Stream对象中的元素为原元素处理后的结果。

141f491e7a550fc4c4badc6df99248ba489.jpg

        //map，平方数
        List<Integer> nums = Arrays.asList(1, 2, 3, 4);
        Stream<Integer> integerStream = nums.stream().map(n -> n * n);
        Collection<Integer> squareNums = integerStream.collect(Collectors.toList());
        squareNums.forEach(integer -> System.out.println(integer));

 

  • flatMap

    map 生成的是个 1:1 映射，每个输入元素，都按照规则转换成为另外一个元素。flatMap，则是一对多映射关系的。

e2c812d8d4eaa476a28d267eb5825000850.jpg

        Stream<List<Integer>> inputStream = Stream.of(
                Arrays.asList(1),
                Arrays.asList(2, 3),
                Arrays.asList(4, 5, 6)
        );
        Stream<Integer> integerStream1 = inputStream.flatMap(list -> list.stream());
        List<Integer> squareNums2 = integerStream1.map(n -> n * n).collect(Collectors.toList());
        squareNums2.forEach(integer -> System.out.println(integer));

 

  • filter

    filter 对原始 Stream 进行某项测试，通过测试的元素被留下来生成一个新 Stream

4c4618a5a3c7b236b774044dcd8eca1d124.jpg

        final List<String> strings = Arrays.asList("ab", "a", "abc", "b", "bc");
        strings.stream()
                .filter(s -> s.startsWith("a"))
                .forEach(System.out::println);

 

  • peek

        peek，遍历Stream中的元素，和forEach类似，区别是peek不会“消费”掉Stream，而forEach会消费掉Stream；peek是中间操作所以也是惰性的，只有在Stream“消费”的时候生效。

        //peek
        Stream.of("one", "two", "three", "four")
                .peek(e -> System.out.println("原来的值: " + e))
                .map(String::toUpperCase)
                .peek(e -> System.out.println("转换后的值: " + e))
                .collect(Collectors.toList());

 

  • limit 和 skip

    limit取头部的数据(或者说截取前面的元素)，skip取尾部的数据(跳过前面的元素)

7e3726bd909e844b9a4f3300d40d5ad06d3.jpg

        //limit, 返回 Stream 的前面 n 个元素
        final List<String> strings = Arrays.asList("ab", "a", "abc", "b", "bc");
        strings.stream()
                .limit(3)
                .forEach(System.out::println);
        System.out.println("==============");

        //skip 则是扔掉前 n 个元素（
        strings.stream()
                .skip(3)
                .forEach(System.out::println);
        System.out.println("==============");

 

  • distinct

    去除重复的元素

483c91783d31c7302e630042a5462e62c5f.jpg

        Stream<String> distinctString = Stream.of("a","b","b","c")
                .distinct();//去重
        distinctString.forEach(System.out::println);

 

  • sorted

    对Stream中的元素进行排序。有两个重载方法，其中 Stream<T> sorted() 需要元素实现了Comparable接口。

        Arrays.asList("ab", "a", "abc", "b", "bc").stream()
                .sorted()
                .forEach(System.out::println);

        Arrays.asList("ab", "a", "abc", "b", "bc").stream()
                .sorted((o1, o2) -> {
                    return o1.compareTo(o2);
                })
                .forEach(System.out::println);

 

终端操作

短路操作

    短路操作其实就和我们日常编程用到的&&和||运算符处理过程类似，遇到一个满足条件的就立即停止判断。

  • anyMatch

    只要其中有一个元素满足传入的Predicate时返回True，否则返回False。前面的中间操作只要anyMatch中的条件成立后，就不再执行。与逻辑运算符 || 类似。

        //anyMatch
        boolean anyMatchReturn = Arrays.asList("ab", "a", "abc", "b", "bc").stream()
                .peek(s -> System.out.println(s))
                .anyMatch(s -> s.startsWith("b"));
        System.out.println(anyMatchReturn);

它的执行结果

ab
a
abc
b
true

 

  • allMatch

    所有元素均满足传入的Predicate时返回True，否则False。只要allMatch条件有一个为false，中间操作将终止执行。与逻辑运算符&&类似

        boolean allMatchReturn = Arrays.asList("ab", "a", "abc", "b", "bc").stream()
                .peek(s -> System.out.println(s))
                .allMatch(s -> s.startsWith("b"));
        System.out.println(allMatchReturn);

运行结果：

ab
false

 

  • noneMatch

    所有元素均不满足传入的Predicate时返回True，否则False。只要allMatch条件有一个为true，中间操作将终止执行。

        boolean noneMatchReturn = Arrays.asList("ab", "a", "abc", "b", "bc").stream()
                .peek(s -> System.out.println(s))
                .noneMatch(s -> s.startsWith("b"));
        System.out.println(noneMatchReturn);

结果：

ab
a
abc
b
false

 

非短路操作

  • forEach

    对所有元素进行迭代处理，无返回值

        Arrays.asList("ab", "a", "abc", "b", "bc").forEach(s -> {
            System.out.println(s);
        });

 

  • reduce

    计算机术语：规约，通过累加器accumulator，对前面的序列进行累计操作，并最终返回一个值。累加器accumulator有两个参数，第一个是前一次累加的结果，第二个是前面集合的下一个元素。通过reduce，可以实现 average, sum, min, max, count。reduce有三个重载方法：

    （1）T reduce(T identity, BinaryOperator<T> accumulator) ：这里的identity是初始值。下面将会把几个字符组装成一个字符串

        String concat = Stream.of("A", "B", "C", "D").reduce("H",
                (x, y) -> {
                    System.out.println("x=" + x + ", y=" + y);
                    return x.concat(y);
                });
        System.out.println(concat);

    输出结果：

x=H, y=A
x=HA, y=B
x=HAB, y=C
x=HABC, y=D
HABCD

        

（2）Optional<T> reduce(BinaryOperator<T> accumulator)：由于没有初始值，这里输出Optional类型，避免空指针

        Optional<String> concat2Optional = Stream.of("A", "B", "C", "D").reduce(
                (x, y) -> {
                    System.out.println("x=" + x + ", y=" + y);
                    return x.concat(y);
                });
        System.out.println(concat2Optional.orElse("default"));

输出结果：

x=A, y=B
x=AB, y=C
x=ABC, y=D
ABCD

 

    （3）<U> U reduce(U identity,  BiFunction<U, ? super T, U> accumulator,  BinaryOperator<U> combiner)：

    这个方法非常复杂，如果感兴趣可以参考其它文章： Java8新特性学习-Stream的Reduce及Collect方法详解

 

  • collect

    collect方法可以通过收集器collector将流转化为其他形式，比如字符串、list、set、map。collect有两个重载方法，其中一个是最常用的：

    <R, A> R collect(Collector<? super T, A, R> collector)。官方为了我们转换方便，已经在Collectors类中封装了各种各样的collector。下面看一些常用的收集器。

 

拼接字符串

        //collect，拼接字符串
        String collect1 = Stream.of("A", "B", "C", "D")
                .collect(Collectors.joining());
        System.out.println(collect1);

转成List

     //collect，转成arrayList
        List<String> collect2 = Stream.of("A", "B", "C", "D")
                .collect(Collectors.toList());

转成set

        Set<String> collect3 = Stream.of("A", "B", "C", "D")
                .collect(Collectors.toSet());

 

转成map

Collectors的toMap方法签名如下所示，前一个mapper转换成map中的key,后一个mapper转换成map中的value

Collector<T, ?, Map<K,U>> toMap(Function<? super T, ? extends K> keyMapper,
                                Function<? super T, ? extends U> valueMapper)

        Map<String, String> collect3 = Stream.of("A", "B", "C", "D")
                .collect(Collectors.toMap(
                        s -> s,
                        s -> s
                ));

 

相关资料

Java 8 函数式编程系列

    java8 -函数式编程之Lambda表达式

    java8 -函数式编程之四个基本接口

    java8 -函数式编程之Optional

    java8 -函数式编程之Stream

 

参考资料：

Java函数式编程与Lambda表达式

转载于:https://my.oschina.net/thinwonton/blog/2992751

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值