一、为什么引入Stream流

流是一系列与特定存储机制无关的元素——实际上,流并没有“存储”之说。使用流,无需迭代集合中的元素,就可以从管道提取和操作元素。这些管道通常被组合在一起,形成一系列对流进行操作的管道。

在大多数情况下,将对象存储在集合中是为了处理他们,因此你将会发现你将编程的主要焦点从集合转移到了流上,流的一个核心的好处是,它使得程序更加短小并且更易理解。当Lambda表达式和方法引用和流一起使用的时候会让人感觉自成一体。

二、如何使用Stream流

流操作的类型有三种:创建流修改流元素(中间操作 Intermediate Operations)消费流元素(终端操作 Terminal Operations)

创建Stream流

  1. 使用Arrays.stream()方法创建

    Integer[] arr = new Integer[]{1,2,3,4,5};
    Arrays.stream(arr).filter(num -> num > 3);
  2. 使用Stream.of ()方法创建

    Integer[] arr = new Integer[]{1,2,3,4,5};
    Stream.of(arr).filter(num -> num > 3);

    查看of()的源码中得知,该方法也是调用了Arrays.stream()方法实现的

    /**
    * Returns a sequential ordered stream whose elements are the specified values.
    *
    * @param <T> the type of stream elements
    * @param values the elements of the new stream
    * @return the new stream
    */
    @SafeVarargs
    @SuppressWarnings("varargs") // Creating a stream from an array is safe
    public static<T> Stream<T> of(T... values) {
    return Arrays.stream(values);
    }
  3. 使用Collection.stream()方法创建

    List<String> list = new ArrayList<>(1);
    list.stream().forEach(str -> System.out.println(str));
  4. 使用Stream.iterate()方法创建

    Stream.iterate(1, num -> num + 2).limit(10).forEach(num -> System.out.println(num));
  5. 使用Stream.generate()方法创建

    Stream.generate(() -> Arrays.asList(arr)).limit(1).forEach(num -> System.out.println(num));

修改流元素(中间操作 Intermediate Operations)

中间操作用于从一个流中获取对象,并将对象作为另一个流从后端输出,以连接到其他操作。

1、跟踪和调试

peek() 操作的目的是帮助调试,允许你无修改地查看流中的元素

// streams/Peeking.java
class Peeking {
public static void main(String[] args) throws Exception {
FileToWords.stream("Cheese.dat")
.skip(21)
.limit(4)
.map(w -> w + " ")
.peek(System.out::print)
.map(String::toUpperCase)
.peek(System.out::print)
.map(String::toLowerCase)
.forEach(System.out::print);
}
}

输出结果:

Well WELL well it IT it s S s so SO so

因为 peek() 符合无返回值的 Consumer 函数式接口,所以我们只能观察,无法使用不同的元素来替换流中的对象。

2、流元素排序

sorted()方法是需要遍历整个流的,并在产生任何元素之前对它进行排序。因为有可能排序后集合的第一个元素会在未排序集合的最后一位。

@Test
public void sortedTest() {
List<Integer> numList = Lists.newArrayList();
numList.add(8);
numList.add(2);
numList.add(6);
numList.add(9);
numList.add(1);
List<Integer> sortList = numList.stream().sorted(Integer::compareTo).collect(Collectors.toList());
System.out.println(sortList);
}

输出结果:

[1, 2, 6, 8, 9]
3、移除元素
  • distinct() 可用于消除流中的重复元素。相比创建一个 Set 集合,该方法的工作量要少得多。

    @Test
    public void distinctTest() {
    Stream.of(6, 8, 9, 6, 2, 8).distinct().forEach(i -> System.out.print(i + ", "));
    }

    输出结果:

    6, 8, 9, 2,
  • filter(Predicate):若元素传递给过滤函数产生的结果为true ,则过滤操作保留这些元素。

    @Test
    public void filterTest() {
    Stream.of(6, 9, 2, 8).filter(num -> num > 5).sorted().forEach(i -> System.out.print(i + ", "));
    }

    输出结果:

    6, 8, 9,
4、映射,应用函数到元素
  • map(Function):将函数操作应用在输入流的元素中,对一个流中的值进行某种形式的转换,并将返回值传递到输出流中

    @Test
    public void mapTest() {
    Stream.of("abc", "qw", "mnkh").map(String::length).forEach(n -> System.out.format("%d ", n));
    }

    输出结果:

    3 2 4
  • mapToInt(ToIntFunction):操作同上,但结果是 IntStream

    Stream.of("5", "7", "9").mapToInt(Integer::parseInt).forEach(n -> System.out.format("%d ", n));
  • mapToLong(ToLongFunction):操作同上,但结果是 LongStream

    Stream.of("17", "19", "23").mapToLong(Long::parseLong).forEach(n -> System.out.format("%d ", n));
  • mapToDouble(ToDoubleFunction):操作同上,但结果是 DoubleStream

    Stream.of("17", "1.9", ".23").mapToDouble(Double::parseDouble).forEach(n -> System.out.format("%f ", n));
  • flatMap() 做了两件事:将产生流的函数应用在每个元素上(与 map() 所做的相同),然后将每个流都扁平化为元素,因而最终产生的仅仅是元素。

    List<Integer> listA = Lists.newArrayList();
    listA.add(1);
    listA.add(6);
    List<Integer> listB = Lists.newArrayList();
    listB.add(10);
    listB.add(2);
    Map<String, List<Integer>> abMap = Maps.newHashMap();
    abMap.put("A", listA);
    abMap.put("B", listB);
    // 需获取A和B集合中大于5的元素
    abMap.values().stream().flatMap(num -> num.stream().filter(n -> n > 5)).collect(Collectors.toList())
    .forEach(System.out::println);

    输出结果:

    6
    10
  • flatMapToInt(Function):当 Function 产生 IntStream 时使用。

  • flatMapToLong(Function):当 Function 产生 LongStream 时使用。

  • flatMapToDouble(Function):当 Function 产生 DoubleStream 时使用。

5、集合流切片,可实现分页
  • limit(n)方法会返回一个包含n个元素的新的流(若总长小于n则返回原始流)。

  • skip(n)方法正好相反,它会丢弃掉前面的n个元素。

    // 查询第二页的数据
    Integer pageNumber = 2;
    Integer pageSize = 10;
    Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12).skip((pageNumber - 1) * pageSize).limit(pageSize)
    .forEach(System.out::println);

    输出结果:

    11
    12

消费流元素(终端操作 Terminal Operations)

终端操作总是我们在流管道中所做的最后一件事,该操作将会获取流的最终结果。

1、数组结果输出
  • toArray():将流转换成适当类型的数组。
  • toArray(generator):在特殊情况下,生成自定义类型的数组。
2、循环结果输出
  • forEach(Consumer)常见如 System.out::println 作为 Consumer 函数。

  • forEachOrdered(Consumer): 保证 forEach 在并行流处理时按照原始流顺序操作。

    Arrays.stream(new Random(45).ints(0, 1000).limit(100).toArray()).limit(10).parallel().forEachOrdered(n -> 						System.out.format("%d ", n));
3、collect收集结果
  • collect(Collector):使用 Collector 收集流元素到结果集合中。

  • collect(Supplier, BiConsumer, BiConsumer):同上,第一个参数 Supplier 创建了一个新的结果集合,第二个参数 BiConsumer 将下一个元素收集到结果集合中,第三个参数 BiConsumer 用于将两个结果集合合并起来。

    Collectorts类为我们提供了常用的收集类的各个工厂方法:

  1. 将一个流收集到一个List中可以这样用

    Lists.newArrayList().stream().collect(Collectors.toList());
  2. 收集到Set中可以这样用

    Lists.newArrayList().stream().collect(Collectors.toSet());
  3. 收集到Map中可以这样用

    Lists.newArrayList(new User("Johnson", "重庆")).stream().collect(Collectors.toMap(User::getName, User::getAddress));
  4. 收集到Set时,控制Set的类型可以这样用

    Lists.newArrayList().stream().collect(Collectors.toCollection(TreeSet::new));
  5. 将字流中的字符串连接并收集起来

    Lists.newArrayList().stream().collect(Collectors.joining(","));
  6. 各种聚合操作

    // 获取流中的总和,平均值,最大值,最小值,一次性收集流中的结果
    List<Integer> listA = Lists.newArrayList(1, 2, 3, 4, 5);
    listA.stream().collect(Collectors.summingInt(Integer::intValue));
    listA.stream().collect(Collectors.averagingInt(Integer::intValue));
    listA.stream().collect(Collectors.maxBy(Integer::compareTo));
    listA.stream().collect(Collectors.minBy(Integer::compareTo));
    listA.stream().collect(Collectors.summarizingInt(Integer::intValue));
    // 分组分片,返回结果:{"重庆渝北":[{"address":"重庆渝北","name":"Johnson"},{"address":"重庆渝北","name":"Jack"}],"重庆江北":[{"address":"重庆江北","name":"Tom"}]}
    List<User> listB = Lists.newArrayList(new User("Johnson", "重庆渝北"), new User("Tom", "重庆江北"), new User("Jack", "重庆渝北"));
    System.out.println(JSON.toJSONString(listB.stream().collect(Collectors.groupingBy(User::getAddress))));
4、组合流中元素
  • reduce(BinaryOperator):使用 BinaryOperator 来组合所有流中的元素。因为流可能为空,其返回值为 Optional

    // 结果为15
    System.out.println(Stream.of(1, 2, 3, 4, 5).reduce((x, y) -> x + y).get());
  • reduce(identity, BinaryOperator):功能同上,但是使用 identity 作为其组合的初始值。因此如果流为空,identity 就是结果

    // 设置初始值为10则结果为25
    System.out.println(Stream.of(1, 2, 3, 4, 5).reduce(10, (x, y) -> x + y));
    // 集合流为空,则结果默认为初始值a
    List<String> list = Lists.newArrayList();
    System.out.println(list.stream().reduce("a", (x, y) -> x.length() > 1 ? x : y));
  • reduce(identity, BiFunction, BinaryOperator):在串行流(stream)中,该方法跟第二个方法一样,即第三个参数不会起作用。在并行流中,我们知道流被fork join出多个线程进行执行,此时每个线程的执行流程就跟第二个方法reduce(identity,BiFunction)一样,而第三个参数BinaryOperator函数,则是将每个线程的执行结果当成一个新的流,然后使用第一个方法reduce(BinaryOperator)流程进行规约

    // 第三个参数在并行流中起效,将每个线程的执行结果当成一个新的流
    List<Integer> listA = Lists.newArrayList(1, 2, 3, 4, 5);
    // 串行流运行结果:15
    System.out.println(listA.stream().reduce(0, (x, y) -> x + y, (i, j) -> i * j));
    // 并行流运行结果:120
    System.out.println(listA.parallelStream().reduce(0, (x, y) -> x + y, (i, j) -> i * j));
5、流中元素匹配
  • allMatch(Predicate) :如果流的每个元素提供给 Predicate 都返回 true ,结果返回为 true。在第一个 false 时,则停止执行计算。

    // 数组中第一个元素小于2,则停止匹配返回结果:flase
    System.out.println(Stream.of(1, 2, 3, 4, 5).allMatch(n -> n > 2));
    // 数组中所有元素都大于0,则停止匹配返回结果:true
    System.out.println(Stream.of(1, 2, 3, 4, 5).allMatch(n -> n > 0));
  • anyMatch(Predicate):如果流的任意一个元素提供给 Predicate 返回 true ,结果返回为 true。在第一个 true 是停止执行计算。

    // 数组中第三个元素大于2,则停止匹配返回结果:true
    System.out.println(Stream.of(1, 2, 3, 4, 5).anyMatch(n -> n > 2));
  • noneMatch(Predicate):如果流的每个元素提供给 Predicate 都返回 false 时,结果返回为 true。在第一个 true 时停止执行计算。

    // 数组中第三个元素大于2,则停止匹配返回结果:true
    System.out.println(Stream.of(1, 2, 3, 4, 5).noneMatch(n -> n > 2));
6、流中元素查找
  • findFirst():返回第一个流元素的 Optional,如果流为空返回 Optional.empty

    // 根据条件过滤后取第一个元素
    System.out.println(Stream.of(1, 2, 3, 4, 5).filter(n -> n > 2).findFirst().get());
  • findAny():返回含有任意流元素的 Optional,如果流为空返回 Optional.empty

    // 根据条件过滤后找到任何一个所匹配的元素,就返回,此方法在对流并行执行时效率高
    System.out.println(Stream.of(1, 2, 3, 4, 5).parallel().filter(n -> n > 2).findAny().get());
7、收集流信息
  • count():流中的元素个数。

  • max(Comparator):根据所传入的 Comparator 所决定的“最大”元素。

  • min(Comparator):根据所传入的 Comparator 所决定的“最小”元素。

  • average() :求取流元素平均值。

  • sum():对所有流元素进行求和。

  • summaryStatistics():生成有关此流元素的各种摘要数据。

    // 获取流中元素数量,返回结果:5
    System.out.println(Stream.of(1,2,3,4,5).count());
    // 获取流中最大值,返回结果:5
    System.out.println(Stream.of(1,2,3,4,5).max(Integer::compareTo).get());
    // 获取流中最小值,返回结果:1
    System.out.println(Stream.of(1,2,3,4,5).min(Integer::compareTo).get());
    // 获取流中元素平均值,返回结果:3.0
    System.out.println(Stream.of(1,2,3,4,5).mapToInt(Integer::intValue).average().getAsDouble());
    // 获取流中各种摘要数据,返回结果:IntSummaryStatistics{count=5, sum=15, min=1, average=3.000000, max=5}
    System.out.println(Stream.of(1,2,3,4,5).mapToInt(Integer::intValue).summaryStatistics());
    // 获取流中元素总和,返回结果:15
    System.out.println(Stream.of(1,2,3,4,5).mapToInt(Integer::intValue).sum());

三、总结

流式操作改变并极大地提升了 Java 语言的可编程性,并可能极大地阻止了 Java 编程人员向诸如 Scala 这种函数式语言的流转。

Java8新特性探索之Stream接口的更多相关文章

  1. Java8新特性探索之函数式接口

    一.为什么引入函数式接口 作为Java函数式编程爱好者,我们都知道方法引用和 Lambda 表达式都必须被赋值,同时赋值需要类型信息才能使编译器保证类型的正确性. 我们先看一个Lambda代码示例: ...

  2. 零基础学习java------21---------动态代理,java8新特性(lambda, stream,DateApi)

    1. 动态代理 在一个方法前后加内容,最简单直观的方法就是直接在代码上加内容(如数据库中的事务),但这样写不够灵活,并且代码可维护性差,所以就需要引入动态代理 1.1 静态代理实现 在讲动态代理之前, ...

  3. java8新特性学习:函数式接口

    本文概要 什么是函数式接口? 如何定义函数式接口? 常用的函数式接口 函数式接口语法注意事项 总结 1. 什么是函数式接口? 函数式接口其实本质上还是一个接口,但是它是一种特殊的接口:SAM类型的接口 ...

  4. java8新特性学习:stream与lambda

    Streams api 对 Stream 的使用就是实现一个 filter-map-reduce 过程,产生一个最终结果,或者导致一个副作用(side effect). 流的操作类型分为两种: Int ...

  5. java8新特性Lambda和Stream

    Java8出来已经4年,但还是有很多人用上了jdk8,但并没用到里面的新东西,那不就等于没用?jdk8有许多的新特性,详细可看下面脑图 我只讲两个最重要的特性Lambda和Stram,配合起来用可以极 ...

  6. Java8新特性第2章(接口默认方法)

    在Java中一个接口一旦发布就已经被定型,除非我们能够一次性的更新所有该接口的实现,否者在接口的添加新方法将会破坏现有接口的实现.默认方法就是为了解决这一问题的,这样接口在发布之后依然能够继续演化. ...

  7. Java8新特性探索之新日期时间库

    一.为什么引入新的日期时间库 Java对日期,日历及时间的处理一直以来都饱受诟病,尤其是它决定将java.util.Date定义为可修改的以及将SimpleDateFormat实现成非线程安全的. 关 ...

  8. Java8新特性之三:Stream API

    Java8的两个重大改变,一个是Lambda表达式,另一个就是本节要讲的Stream API表达式.Stream 是Java8中处理集合的关键抽象概念,它可以对集合进行非常复杂的查找.过滤.筛选等操作 ...

  9. java8新特性- 默认方法 在接口中有具体的实现

    案例分析 在java8中在对list循环的时候,我们可以使用forEach这个方法对list进行遍历,具体代码如下demo所示 public static void main(String[] arg ...

随机推荐

  1. 万字长文 | 23 个问题 TCP 疑难杂症全解析

    每个时代,都不会亏待会学习的人. 在进入今天主题之前我先抛几个问题,这篇文章一共提出 23 个问题. TCP 握手一定是三次?TCP 挥手一定是四次? 为什么要有快速重传,超时重传不够用?为什么要有 ...

  2. Python-迭代协议-__iter__ __next__ iter next yield

    iter 本质是for循环调用的实质,for循环通过调用这个函数返回可迭代对象生成器形式,开始迭代取值捕获StopIteration错误退出循环 for循环首先找__iter__方法,然后再找 __g ...

  3. Book of Shaders 03 - 学习随机与噪声生成算法

    0x00 随机 我们不能预测天空中乌云的样子,因为它的纹理总是具有不可预测性.这种不可预测性叫做随机 (random). 在计算机图形学中,我们通常使用随机来模拟自然界中的噪声.如何获得一个随机值呢, ...

  4. [iTyran原创]iPhone中OpenGL ES显示3DS MAX模型之二:lib3ds加载模型

    [iTyran原创]iPhone中OpenGL ES显示3DS MAX模型之二:lib3ds加载模型 作者:u0u0 - iTyran 在上一节中,我们分析了OBJ格式.OBJ格式优点是文本形式,可读 ...

  5. 如何确定芯片pin1的位置

    来源:https://www.raviyp.com/embedded/150-identifying-pin-no-1-on-an-ic Identifying pin no 1 on an IC R ...

  6. Trie树【字典树】浅谈

    最近随洛谷日报看了一下Trie树,来写一篇学习笔记. Trie树:支持字符串前缀查询等(目前我就学了这些qwq) 一般题型就是给定一个模式串,几个文本串,询问能够匹配前缀的文本串数量. 首先,来定义下 ...

  7. Docker入门手册

    20.Docker 20.1 Docker的起源 2010年,几个搞IT的年轻人,在美国旧金山成立了一家名叫"dotCloud"的公司,这家公司主要提供基于PaaS的云计算技术服务 ...

  8. 利用Python+pyecharts+tushare图形化展示股票历史财务信息

    在微信或其他平台上,经常能看到别人推荐股票,分析的头头是道,让自己懊恼于没有早点关注到这只股票,好像错失了几个亿.但是投资股票又忌讳听消息跟风,总不能看到别人推荐自己就无脑买入. 看到了一只股票,自己 ...

  9. 编程体系结构(07):JavaEE之Web开发

    本文源码:GitHub·点这里 || GitEE·点这里 一.基础概念 1.CS与BS架构 CS架构模式 客户端/服务器(Client/Server)模式,既要编写服务器端程序,也要开发客户端程序,软 ...

  10. 一、Vuforia_AR

    一.AR概念: 增强现实(Augmented Reality,简称AR),是一种将虚拟信息与真实世界巧妙融合的技术,广泛运用了多媒体.三维建模.实时跟踪及注册.智能交互.传感等多种技术手段,将计算机生 ...