Java8新特性之——Stream API

已于 2023-10-11 18:05:13 修改
阅读量172 收藏
点赞数
分类专栏： Java 文章标签： java 开发语言
于 2023-08-25 22:00:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dongdong199033/article/details/132500796
版权

文章目录

一、简介

JDK 8 引入了 Stream API，它是用于处理集合数据的功能强大的库。Stream API 提供了一种更为简洁、灵活和函数式的方式来进行集合的操作和处理。

Stream API 有三大特性：

  • 不存储数据：Stream API 并不会在内存中存储数据，它仅仅是对源数据进行操作和处理的管道，当我们对一个集合或数组创建流时，流只是作为一种处理方式存在，并没有实际保存数据。
  • 不改变源数据：Stream API 的操作不会改变原始数据源中的元素，所有的中间操作（如过滤、映射、排序）都会产生一个新的流，而不是直接修改原始数据。这种特性确保了数据的不可变性。
  • 延时执行：Stream API 使用了延迟执行的概念。它并不会立即执行流的操作，而是等到需要结果时才进行计算。这样可以避免不必要的计算，提高效率并节省资源。只有在终端操作（如聚合、收集、计数）被调用时，流才会进行实际的计算。

二、操作分类

在使用 Stream API 进行集合操作时，一般会遵循以下步骤：

  1. 创建流：通过集合或数组创建一个流
  2. 中间操作：对流进行一系列的中间操作，例如过滤、映射、排序等。这些操作可以按照需求进行链式调用
  3. 结束操作：中间操作只是一种标记，只有结束操作才会触发实际计算

其中中间操作又分为，无状态和有状态，结束操作又分为短路操作和非短路操作

image-20230825170946157

创建流

通过集合

可以使用 Collection 接口中的 stream() 方法或者 parallelStream() 方法来创建一个流

List<String> list = Arrays.asList("a", "b", "c");
Stream<String> stream = list.stream();

通过数组

可以使用 Arrays 类中的静态方法 stream() 来创建一个数组的流

String[] array = {"a", "b", "c"};
Stream<String> stream = Arrays.stream(array);

通过Stream的of()方法

可以使用 Stream 类中的静态方法 of() 来根据指定的元素创建一个流

Stream<String> stream = Stream.of("a", "b", "c");

中间操作

无状态

元素的处理不受前一个元素影响

  • filter（过滤）：接收一个 Predicate 参数，根据 Predicate 的判断结果决定是否保留流中的元素， true 留下，false 丢弃
  • map、mapToInt、mapToLong、mapToDouble（转换）：map 方法接收一个 Function 参数，将流中的每个元素通过该函数进行转换，mapToInt、mapToLong、mapToDouble 和 map 差不多，只是强制指定了返回值必须是 int、long、double 类型
  • flatMap、flatMapToInt、flatMapToLong、flatMapToDouble（合并）：将一个或多个流合并成一个新流，flatMapToInt、flatMapToLong、flatMapToDouble 和 f latMap 差不多，只是返回的是对应的 IntStream、LongStream、DoubleStream 流
  • peek（监测）：接受一个Consumer 函数作为参数，该函数会在流的每个元素被处理时被调用。它可以用于在处理流的过程中观察每个元素的值，而不会改变流的内容
//filter
public static void main(String[] args) {
    String[] str = {"a", "b", "c"};
    Stream.of(str).filter(t -> t.equals("a")).forEach(System.out::println);
    //输出
    //a
}

//map、mapToInt、mapToLong、mapToDouble
public static void main(String[] args) {
    String[] str = {"a", "b", "c"};
    Stream.of(str).map(t -> t.toUpperCase()).forEach(System.out::println);
    Stream.of(str).mapToInt(t -> t.hashCode()).forEach(System.out::println);
    //输出
    //A
    //B
    //C
    //97
    //98
    //99
}

//flatMap、flatMapToInt、flatMapToLong、flatMapToDouble
public static void main(String[] args) {
    List<String> a = new ArrayList<>();
    a.add("a");
    a.add("b");
    List<String> b = new ArrayList<>();
    b.add("c");
    b.add("d");
    Stream.of(a, b).flatMap(u -> u.stream()).forEach(System.out::println);
    //输出
    //a
    //b
    //c
    //d
}

//peek
public static void main(String[] args) {
    String[] str = {"a", "b", "c"};
    Stream.of(str).peek(t -> System.out.println("this is " + t)).collect(Collectors.toList());
    //输出
    //this is a
    //this is b
    //this is c
}

有状态

必须等所有元素处理完毕之后才知道最终的结果

  • distinct（去重）：去除重复的元素
  • sorted（排序）：不传参数，会按照自然排序，也可以传一个比较器参数，会根据比较器定义的顺序排序
  • limit（限制）：截取前n个元素
  • skip（跳过）：跳过n个元素，返回之后的元素
//distinct
public static void main(String[] args) {
    String[] str = {"a", "a", "b", "b", "c"};
    Stream.of(str).distinct().forEach(System.out::println);
    //输出
    //a
    //b
    //c
}

//sorted
public static void main(String[] args) {
    String[] str = {"banana", "apple", "pineapple", "pear", "watermelon"};
    Stream.of(str).sorted().forEach(System.out::println);
    System.out.println("---------------");
    Stream.of(str).sorted(Comparator.comparing(String::length)).forEach(System.out::println);
    //输出
    //apple
    //banana
    //pear
    //pineapple
    //watermelon
    //---------------
    //pear
    //apple
    //banana
    //pineapple
    //watermelon
}

//limit
public static void main(String[] args) {
    String[] str = {"a", "b", "c", "d", "e"};
    Stream.of(str).limit(2).forEach(System.out::println);
    //输出
    //a
    //b
}

//skip
public static void main(String[] args) {
    String[] str = {"a", "b", "c", "d", "e"};
    Stream.of(str).skip(2).forEach(System.out::println);
    //输出
    //c
    //d
    //e
}

结束操作

非短路操作

需要处理完所有元素

  • forEach（循环）：循环操作Stream中数据
  • forEachOrdered（排序循环）：按照流的遭遇顺序来处理元素，在并行流中使用
  • toArray（转数组）：不传参数的话，返回的是对象数组，也可以接收一个 IntFunction<A[]> generator 参数来指定返回数据的类型
  • reduce（聚合）：聚合操作，一般用来做统计
  • collect（收集）：将元素收集到一个集合或其他数据结构里
  • min（最小值）：根据传入的比较器，找到最小的元素
  • max（最大值）：根据传入的比较器，找到最大的元素
  • count（总数量）：计数，统计元素数量
//forEach
public static void main(String[] args) {
    String[] str = {"a", "b", "c"};
    Stream.of(str).forEach(System.out::println);
    //输出
    //a
    //b
    //c
}

//toArray
public static void main(String[] args) {
    String[] str = {"1", "2", "3"};
    Object[] objectArray = Stream.of(str).toArray();
    String[] strArray = Stream.of(str).toArray(String[]::new);
}

//reduce
public static void main(String[] args) {
    Integer[] array = {1, 2, 3, 4, 5};
    Optional<Integer> optional = Stream.of(array).reduce((x, y) -> x + y);
    optional.ifPresent(System.out::println);
    //输出
    //15
}

//collect
public static void main(String[] args) {
    Integer[] array = {1, 2, 3, 4, 5};
    List<Integer> list = Stream.of(array).collect(Collectors.toList());
    System.out.println(list);
    //输出
    //[1, 2, 3, 4, 5]
}

//min
public static void main(String[] args) {
    Integer[] array = {1, 2, 3, 4, 5};
    Optional<Integer> min = Stream.of(array).min(Comparator.comparing(Integer::intValue));
    min.ifPresent(System.out::println);
    //输出
    //1
}

//max
public static void main(String[] args) {
    Integer[] array = {1, 2, 3, 4, 5};
    Optional<Integer> max = Stream.of(array).max(Comparator.comparing(Integer::intValue));
    max.ifPresent(System.out::println);
    //输出
    //5
}

//count
public static void main(String[] args) {
    String[] str = {"a", "b", "c"};
    long count = Stream.of(str).count();
    System.out.println(count);
    //输出
    //3
}

短路操作

一旦满足或不满足条件，就结束计算，不用处理完所有元素

  • anyMatch：只要有一个符合条件就返回 true
  • allMatch：所有都符合条件返回 true
  • noneMatch：所有数据都不符合条件返回true
  • findFirst：获取第一个元素
  • findAny：获取任一元素，一般用于并行流
//anyMatch
public static void main(String[] args) {
    String[] str = {"banana", "apple", "pineapple", "pear", "watermelon"};
    boolean b = Stream.of(str).anyMatch(t -> t.length() == 4);
    boolean b2 = Stream.of(str).anyMatch(t -> t.length() == 3);
    System.out.println(b);
    System.out.println(b2);
    //输出
    //true
    //false
}

//allMatch
public static void main(String[] args) {
    String[] str = {"banana", "apple", "pineapple", "pear", "watermelon"};
    boolean b = Stream.of(str).allMatch(t -> t.length() >= 4);
    boolean b2 = Stream.of(str).allMatch(t -> t.length() >= 5);
    System.out.println(b);
    System.out.println(b2);
    //输出
    //true
    //false
}

//noneMatch
public static void main(String[] args) {
    String[] str = {"banana", "apple", "pineapple", "pear", "watermelon"};
    boolean b = Stream.of(str).noneMatch(t -> t.length() >= 4);
    boolean b2 = Stream.of(str).noneMatch(t -> t.length() <= 3);
    System.out.println(b);
    System.out.println(b2);
    //输出
    //false
    //true
}

//findFirst
public static void main(String[] args) {
    String[] str = {"banana", "apple", "pineapple", "pear", "watermelon"};
    Optional<String> first = Stream.of(str).findFirst();
    first.ifPresent(System.out::println);
    //输出
    //banana
}

//findAny
public static void main(String[] args) {
    List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
    numbers.parallelStream()
        .filter(n -> n % 2 == 0)
        .findAny().ifPresent(System.out::println);
    //输出
    //2 or 4
}
每天进步亿点点的小码农
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java8stream源码-java8:Java8——函数式编程
06-04
java8流源码java8 Java 8 —— 函数式编程 介绍 该存储库包含例如 Java 8 In Action 和 Java 8 Lambdas Pragmatic Functional Programming 一书中的源代码。 同时自己也做了一些扩展使用，修复了源码中的bug。 例如 ...
【java8新特性】——Stream API详解（二）
qq_43842093的博客
10-09 466
一、简介 java8新添加了一个特性：流Stream。Stream让开发者能够以一种声明的方式处理数据源（集合、数组等），它专注于对数据源进行各种高效的聚合操作（aggregate operation）和大批量数据操作 (bulk data operation)。 Stream API将处理的数据源看做一种Stream（流），Stream（流）在Pipeline（管道）中传输和运算，支持的运算包含筛选、排序、聚合等，当到达终点后便得到最终的处理结果。 几个关键概念： 元素 Stream是一个来自数据源的元
java8新特性——StreamAPI
Mr_ZhouR的博客
11-08 1595
什么是Stream？ 是数据渠道，用于操作数据源（集合数组等）所生成的元素序列 “集合讲的是数据，流讲的是计算” 注意： Strram自己不会存储元素。 Stream不会改变源对象。相反，他们会返回一个持有结果的新Stream Stream操作时延迟执行的。这意味着他们会等到需要结果的时候才执行 Stream的三个操作步骤： 创建Stream 中间操作 终止操作（终端操作） 创建Strea...
Java8新特性——Stream API的终止操作
胜天半子祁同伟
11-08 8105
Java8新特性——Stream API的终止操作
Java8新特性——Stream API的简单应用
胜天半子祁同伟
11-09 6252
Java8新特性——Stream API的简单应用
Java 8 新特性——Stream
wenqi1992的博客
07-13 1454
Java 8 新特性之 Stream 的详细讲解，丰富的示例，通熟易懂
Java8新特性——Stream API的创建方式及中间操作
胜天半子祁同伟
11-08 7125
Java8新特性——Stream API的创建方式及中间操作
Java8新特性——Stream API
小薯条的博客
03-18 700
Java 8引入了Stream API，这是一种新的API，可让开发人员更轻松地处理集合数据。Stream API提供了丰富的操作，如过滤、映射、排序和规约。下面将对Stream API的基本语法、使用场景和示例进行介绍。Stream API是Java 8中引入的一个新的API，它可以让开发人员更轻松地处理集合数据。Stream API提供了丰富的操作，如过滤、映射、排序和规约。Stream API适用于处理大量数据，可以提高程序的执行效率。它可以简化代码，并提供更好的代码可读性和可维护性。
java 8 stream api_JDK8新特性——Stream API
weixin_39796533的博客
02-16 55
JDK8新特性——Stream API摘要：本文主要学习了JDK8的新特性中有关Stream API的使用。部分内容来自以下博客：https://blog.csdn.net/icarusliu/article/details/79495534概述Stream API(java.util.stream)把真正的函数式编程风格引入到Java中。这是目前为止对Java类库最好的补充，因为Stream A...
java8 (jdk 1.8) 新特性——Stream ApI
从零开始的博客
11-22 601
简单来说就是一个类库，里边有一些方法方便我们对集合数据进行操作，就好像使用 SQL 语句进行操作数据库一样优点就是，使我们代码简洁更高效的处理数据，高效！！官方java8 Api中文文档 在公众号内 回复关键字 【文档】 获取一个完成的stream 流操作包含以下内容一个数据源，数据源可以是集合，数组中间链的操作 （比如 过滤, 去重，排序 等等）终止操作，产生一个结果（比如重新收集成集合）userInfoList . add(new UserInfo(1 , "张三" , 23));
【Java8新特性】——Streams API 详解
我爱吃土豆
08-01 6339
一、为什么需要 Stream Stream 作为 Java 8 的一大亮点，它与 java.io 包里的 InputStream 和 OutputStream 是完全不同的概念。它也不同于 StAX 对 XML 解析的 Stream，也不是 Amazon Kinesis 对大数据实时处理的 Stream。Java 8 中的 Stream 是对集合（Collection）对象功能的增强，它专注于...
java8 Stream API及常用方法，java初级程序员面试（csdn）————程序.pdf
12-01
java8 Stream API及常用方法，java初级程序员面试（csdn）————程序
java8stream源码-streamsupport-snapshot:将Java8java.util.streamAPI向后移植到Java
06-04
java.util.stream（流）API 的后向移植，供 Java 6 或 7 的用户使用，并补充了 java.util.concurrent 中不存在的选定添加项在 Java 6 中。 由于 Java 8 之前的版本中缺少默认接口方法和静态接口方法，API 不得不在...
java8stream源码-java8-features:java8-功能
06-04
java8流源码java8-功能 一些重要的 Java 8 特性是 Java 流 API Iterable 接口中的 forEach() 方法 接口中的默认和静态方法 函数式接口和 Lambda 表达式 Java时间API 集合 API 改进 并发 API 改进 选修课 Java 中的 ...
JDK_API_1_6
03-01
Externalizable Externalizable 实例类的唯一特性是可以被写入序列化流中，该类负责保存和恢复实例内容。 FileFilter 用于抽象路径名的过滤器。 FilenameFilter 实现此接口的类实例可用于过滤器文件名。 ...
java jar包如何运行或调用
NLP与推荐算法
05-08 235
java服务启动
CMS垃圾回收器为什么被移除
最新发布
m0_54187478的博客
05-10 295
由于上述缺点，加上需要将资源投入到更现代垃圾回收器的开发和优化上，Oracle决定从Java 9开始标记CMS为废弃，并在后续版本中完全移除CMS。这些新的收集器旨在提供更低的停顿时间和更高的性能，同时减少配置和维护的复杂性。当它在垃圾收集周期内无法足够快地回收内存时，会退回到一种需要完全暂停所有应用线程的老年代收集模式，这与它设计的初衷相违背。：CMS使用的标记-清除算法会导致较多的内存碎片。：CMS需要更多的CPU资源来执行垃圾回收的并发阶段，而且它在运行时对系统资源的利用也较为激进。
C#(C Sharp)学习笔记_类【十五】
追求细节，成就完美
05-01 668
类（Class）是面向对象程序设计（OOP，Object-Oriented Programming）实现信息封装的基础。类是一种用户定义的引用数据类型，也称类类型。每个类包含数据说明和一组操作数据或传递消息的函数。类的实例称为对象。
《设计一款蓝牙热敏打印机》
唐顺才的博客
05-06 318
安卓apk用java + kotlin编写、上位机用Qt编写。主控芯片用易兆威蓝牙ic，通讯接口：蓝牙、串口、usb。
stream流倒序排序_Java8新特性——强大的Stream
05-24
Java 8 中的 Stream API 提供了很多方便的方法来处理集合数据，其中一个非常有用的功能就是对集合元素进行排序。要对 Stream 流进行倒序排序，可以使用 `sorted()` 方法，该方法接受一个 Comparator 参数，用于指定排序规则。 以下是一个示例代码，演示了如何使用 Java 8 中的 Stream 流对集合进行倒序排序： ```java import java.util.Arrays; import java.util.Comparator; import java.util.List; public class StreamTest { public static void main(String[] args) { List<String> list = Arrays.asList("apple", "banana", "orange", "pear"); list.stream() .sorted(Comparator.reverseOrder()) .forEach(System.out::println); } } ``` 在上面的代码中，我们首先定义了一个字符串列表 `list`，然后将其转换为一个 Stream 流，并使用 `sorted()` 方法对其进行排序。在 `sorted()` 方法中，我们传入了一个 `Comparator.reverseOrder()` 对象，该对象会根据字符串的自然顺序（从小到大）进行排序，并返回一个反向排序的 Comparator 对象。最后，使用 `forEach()` 方法对排好序的 Stream 流进行遍历输出。 执行以上代码，输出结果如下： ``` pear orange banana apple ``` 可以看到，输出结果是按照字符串的自然顺序的反向顺序输出的。这就是使用 Java 8 中的 Stream 流对集合进行倒序排序的方法。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

每天进步亿点点的小码农

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值