【Java基础教程】(三十)Java新特性篇 · 第十讲: Stream流——释放流式编程的效率与优雅,狂肝万字只为透彻讲清 Stream流!~

这篇具有很好参考价值的文章主要介绍了【Java基础教程】(三十)Java新特性篇 · 第十讲: Stream流——释放流式编程的效率与优雅,狂肝万字只为透彻讲清 Stream流!~。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

java 流的效率,# Java基础教程,java,开发语言,jvm,java-ee,大数据

1️⃣ 概念及特征

Java的Stream流是在Java 8中引入的一种用于处理集合数据的功能强大且易于使用的工具,旨在简化集合框架的操作。它的设计目的是为了提供一种更简洁、更灵活和更可读的方式来处理集合数据。

在之前,我们通常使用迭代器或循环来遍历和操作集合元素,这种方式容易出错且代码冗长。Java 8通过引入Stream流来解决这个问题,提供了一种函数式编程风格的集合操作方法。

Stream流是对集合进行操作的高级抽象,可以将集合看作是一种源(source),而Stream表示这个源上进行的计算操作序列。 通过使用Stream API,我们可以以流水线方式处理数据,并进行各种转换和聚合操作。

在Java中,Stream流分为两种类型:

  • 流(Stream):表示顺序流,按照数据源的顺序进行操作,适用于串行操作。
  • 并行流(ParallelStream):表示并行流,可以同时对数据源的多个元素进行操作,适用于并行计算。

Stream流具有以下特点:

  • 流是一次性的:流不会保存元素,它仅仅描述了操作的序列,并且在执行聚合操作之后就被消耗掉了。即使我们对一个流执行多个操作,每个操作也只会在需要输出结果时才会执行,并且在执行完毕后,流不能再次使用。这与传统的集合不同,集合可以随时进行增删元素的操作;
  • 流是无状态的:流的操作不会修改原始数据结构,而是通过创建一个新的流来执行操作,并最终返回一个结果。原始数据结构保持不变。这种无状态的特性使得流操作可以并行处理数据,不用担心多线程下的数据竞争问题;
  • 流是延迟执行的:流的操作被称为延迟执行,也就是说,在流的聚合操作被触发之前,中间操作不会立即执行。这意味着我们可以先构建一个复杂的流操作链,然后在需要结果的时候才触发最终的操作。这种延迟执行的机制有助于优化性能,避免不必要的计算。

Stream流的实现原理主要基于迭代器和函数式编程的思想。在内部迭代的过程中,流通过一系列操作进行链式处理,将每个元素传递给下一个操作,并最终生成结果。

在并行流的情况下,流将输入数据分成多个小块,分配给不同的线程并行处理。处理完后,再合并结果并返回。

2️⃣ 优势和缺点

Stream流具有以下优点:

  • 简洁:使用流的聚合操作可以极大地减少代码量;
  • 高效:流的并行操作可以利用多核处理器提高运行效率;
  • 函数式编程:流的操作方法遵循函数式编程的思想,使代码更加简洁、易读和可维护;
  • 可复用:可以使用复合操作将多个流操作链在一起。

然而,Stream流也有一些缺点:

  • 可读性降低:对于复杂的操作,使用Stream可能比传统的循环方式可读性稍差;
  • 一次性使用:一旦流被使用过,就不能再次使用,需要重新创建一个新的流;
  • 可能会影响性能:虽然并行流可以提高运行效率,但在某些情况下,额外的分组和合并操作可能会造成性能下降。

3️⃣ 使用

3.1 语法

Stream提供了两种类型的操作:中间操作和终端操作。中间操作用于链式调用,并可以有多个,而终端操作是触发计算的地方。

而使用Stream主要分为三个步骤:

  • 创建流:也即获取一个Stream对象,可以通过集合、数组或者其他方式创建一个Stream。如可以使用Stream.of()方法创建流;
  • 进行中间操作:对Stream进行连续的中间操作,包括过滤、映射、排序、去重等处理。如可以使用forEach()方法遍历流中的元素,并使用filter()map()sorted()等方法对流进行操作;
  • 执行终结操作:最后使用一个终结操作来触发计算并产生结果,如收集、聚合、遍历等。如可以使用reduce()方法进行元素的归约操作,使用collect()方法进行元素的收集操作。

3.2 常用API详解

Stream API提供了丰富的操作方法,可根据不同的需求灵活选择。常用的操作API有:

  • Intermediate操作:如filter()map()sorted(),用于对元素进行筛选、映射、排序等操作。
  • Terminal操作:如forEach()count()collect(),用于对流进行最终的输出、统计和收集操作。
  • Short-circuiting操作:如findFirst()anyMatch()allMatch(),用于在满足条件时立即终止流的操作。

以下是一些Stream操作API详情列表:

类型 方法 作用
中间操作 filter(Predicate) 过滤符合条件的元素
map(Function) 对每个元素应用转换函数
flatMap(Function) 将每个元素转换成Stream对象,然后将所有的Stream连接成一个Stream
distinct() 去除重复的元素
sorted([Comparator]) 排序元素,默认为自然排序
limit(n) 截取指定数量的元素
skip(n) 跳过指定数量的元素
peek(Consumer) 对每个元素执行操作,不影响流中的其他元素
takeWhile(Predicate) 从开头开始连续取元素满足指定条件,直到遇到不满足条件的元素
dropWhile(Predicate) 从开头开始连续跳过元素满足指定条件,直到遇到不满足条件的元素
终结操作 collect(Collector) 将流转换为集合或其他数据结构
forEach(Consumer) 遍历流中的元素,并对其执行操作
reduce(BinaryOperator) 使用给定的二元操作符将元素归约成一个值
max([Comparator]) 找出流中的最大值
min([Comparator]) 找出流中的最小值
toArray() 将流中的元素转换为数组
count() 统计流中的元素数量
findFirst() 返回满足条件的第一个元素
findAny() 返回任意满足条件的元素
anyMatch(Predicate) 判断流中是否存在任意一个元素满足给定条件
allMatch(Predicate) 判断流中所有元素是否都满足给定条件
noneMatch(Predicate) 判断流中是否没有任何元素满足给定条件

3.3 案例

下面是一个简单的Java程序,演示了上述所有方法的使用:

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class StreamOperationsDemo {
    public static void main(String[] args) {
        // 创建一个包含整数的集合
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 1, 2, 3, 4, 5);

        // filter: 过滤掉大于3的元素
        List<Integer> filteredList = numbers.stream()
                .filter(num -> num <= 3)
                .collect(Collectors.toList());
        System.out.println("Filtered List: " + filteredList);

        // map: 将每个元素乘以2
        List<Integer> mappedList = numbers.stream()
                .map(num -> num * 2)
                .collect(Collectors.toList());
        System.out.println("Mapped List: " + mappedList);
        
        // flatMap: 将每个元素转换成Stream对象,然后将所有的Stream连接成一个Stream
        List<String> words = Arrays.asList("Hello", "World");
        List<String> flatMappedList = words.stream()
                .flatMap(word -> Arrays.stream(word.split("")))
                .collect(Collectors.toList());
        System.out.println("FlatMapped List: " + flatMappedList);

        // distinct: 去除重复的元素
        List<Integer> distinctList = numbers.stream()
                .distinct()
                .collect(Collectors.toList());
        System.out.println("Distinct List: " + distinctList);

        // sorted: 对元素进行排序
        List<Integer> sortedList = numbers.stream()
                .sorted()
                .collect(Collectors.toList());
        System.out.println("Sorted List: " + sortedList);

        // limit: 截取指定数量的元素
        List<Integer> limitedList = numbers.stream()
                .limit(3)
                .collect(Collectors.toList());
        System.out.println("Limited List: " + limitedList);

        // skip: 跳过指定数量的元素
        List<Integer> skippedList = numbers.stream()
                .skip(3)
                .collect(Collectors.toList());
        System.out.println("Skipped List: " + skippedList);

        // peek: 对每个元素执行操作,不影响流中的其他元素
        List<Integer> peekedList = numbers.stream()
                .peek(num -> System.out.println("Peeking element: " + num))
                .collect(Collectors.toList());

        // takeWhile: 从开头开始连续取元素满足条件,直到遇到不满足条件的元素
        List<Integer> takenList = numbers.stream()
                .takeWhile(num -> num < 4)
                .collect(Collectors.toList());
        System.out.println("Taken List: " + takenList);

        // dropWhile: 从开头开始连续跳过元素满足条件,直到遇到不满足条件的元素
        List<Integer> droppedList = numbers.stream()
                .dropWhile(num -> num < 4)
                .collect(Collectors.toList());
        System.out.println("Dropped List: " + droppedList);

        // collect: 将流转换为集合或其他数据结构
        List<Integer> collectedList = numbers.stream()
                .collect(Collectors.toList());
        System.out.println("Collected List: " + collectedList);

        // forEach: 遍历流中的元素,并对其执行操作
        numbers.stream()
                .forEach(System.out::println);

        // reduce: 使用给定的二元操作符将元素归约成一个值
        int sum = numbers.stream()
                .reduce(0, Integer::sum);
        System.out.println("Sum: " + sum);

        // max: 找出流中的最大值
        int max = numbers.stream()
                .max(Integer::compare)
                .orElse(-1);
        System.out.println("Max: " + max);

        // min: 找出流中的最小值
        int min = numbers.stream()
                .min(Integer::compare)
                .orElse(-1);
        System.out.println("Min: " + min);

        // toArray: 将流中的元素转换为数组
        Integer[] array = numbers.stream()
                .toArray(Integer[]::new);
        System.out.println("Array: " + Arrays.toString(array));

        // count: 统计流中的元素数量
        long count = numbers.stream()
                .count();
        System.out.println("Count: " + count);

        // findFirst: 返回满足条件的第一个元素
        int first = numbers.stream()
                .findFirst()
                .orElse(-1);
        System.out.println("First: " + first);

        // findAny: 返回任意满足条件的元素
        int any = numbers.stream()
                .findAny()
                .orElse(-1);
        System.out.println("Any: " + any);

        // anyMatch: 判断流中是否存在任意一个元素满足给定条件
        boolean anyMatch = numbers.stream()
                .anyMatch(num -> num % 2 == 0);
        System.out.println("Any Match: " + anyMatch);

        // allMatch: 判断流中所有元素是否都满足给定条件
        boolean allMatch = numbers.stream()
                .allMatch(num -> num % 2 == 0);
        System.out.println("All Match: " + allMatch);

        // noneMatch: 判断流中是否没有任何元素满足给定条件
        boolean noneMatch = numbers.stream()
                .noneMatch(num -> num > 10);
        System.out.println("None Match: " + noneMatch);
    }
}

这个程序演示了如何使用Stream的中间操作和终端操作。

程序的运行结果如下:

Filtered List: [1, 2, 3, 1, 2, 3]
Mapped List: [2, 4, 6, 8, 10, 2, 4, 6, 8, 10]
FlatMapped List: [H, e, l, l, o, W, o, r, l, d]
Distinct List: [1, 2, 3, 4, 5]
Sorted List: [1, 1, 2, 2, 3, 3, 4, 4, 5, 5]
Limited List: [1, 2, 3]
Skipped List: [4, 5, 1, 2, 3, 4, 5]
Peeking element: 1
Peeking element: 2
Peeking element: 3
Peeking element: 4
Peeking element: 5
Peeking element: 1
Peeking element: 2
Peeking element: 3
Peeking element: 4
Peeking element: 5
Taken List: [1, 2, 3]
Dropped List: [4, 5, 1, 2, 3, 4, 5]
Collected List: [1, 2, 3, 4, 5, 1, 2, 3, 4, 5]
1
2
3
4
5
1
2
3
4
5
Sum: 30
Max: 5
Min: 1
Array: [1, 2, 3, 4, 5, 1, 2, 3, 4, 5]
Count: 10
First: 1
Any: 1
Any Match: true
All Match: false
None Match: true

4️⃣ 应用场景

Stream流广泛应用于数据处理、集合操作、并行计算等场景。它可以使代码更简洁、易读和具有可维护性,同时充分发挥多核处理器的计算能力。如下:

  • 数据分析:根据条件过滤出需要的数据,并进行统计、汇总或生成报表;
  • 数据处理:对大规模、复杂的数据集合进行筛选、转换、排序以及聚合和分组等;
  • 数据查询:通过多个中间操作构建复杂的查询条件,获取符合要求的数据;
  • 并行处理:在多核处理器上可利用parallel方法实现并行处理大批量数据,提高系统的处理性能。

例如,对于一个电商平台的订单数据,我们可以使用流来实现以下功能:

  • 筛选出所有金额大于1000的订单;
  • 将订单按照金额从高到低进行排序;
  • 获取前5个订单的信息;


5️⃣ 使用技巧

要使用流,首先需要从数据源创建一个流,然后通过一系列的中间操作和终端操作来对流进行处理和操作。

在使用流时,可以注意以下几点优化技巧:

  • 合理选择流的类型,根据实际情况选择顺序流或并行流,对于大数据集合,考虑使用并行流以提高性能;
  • 尽量减少中间操作的数量,合并多个操作可以减少迭代次数;
  • 尽量避免使用短路操作,以充分发挥并行流的优势;
  • 使用延迟执行的特性,只在需要获取结果时触发终端操作。

6️⃣ 并行流 ParallelStream

并行流(ParallelStream)允许在多线程环境下并发地执行操作,从而提高处理大数据集的效率。

ParallelStream类在Java中没有特有的方法。它与普通的Stream类具有相同的操作方法,可以使用 filtermapflatMapdistinctsortedlimitskippeek 等方法。这些方法可以在并行流上执行,并发地处理数据。并行流会自动将数据分成多个部分,并在多个线程上同时进行处理,加快了处理速度。

需要注意的是,在使用并行流时,应该要注意线程安全和性能问题。如果并行执行的操作具有共享状态、副作用或依赖于元素之间的顺序,那么可能会导致不正确的结果。并行流适用于对大量元素进行计算密集型操作,但并不适用于有状态或依赖前后元素的操作。因此,在使用并行流时,需要确保操作的可靠性,并在必要时使用同步措施来保证线程安全。

除了以上普通的Stream操作方法,在并行流中还可以使用.parallel().sequential()方法切换并行流和顺序流的操作模式。.parallel()方法将流转换为并行流,允许并发地对元素进行操作。而.sequential()方法则将并行流转回为顺序流,仅使用单线程顺序地处理元素。

🌾 总结

Java Stream流为我们提供了一种简洁而强大的方式来操作数据集合。它具有许多优点,如简化操作、惰性求值和并行处理。同时也有一些缺点,如学习成本稍高和可读性稍差。然而,在正确使用和优化Stream的情况下,可以极大地提高代码的可读性和维护性,并实现更高效的数据处理与计算。

通过使用流,我们可以以更直观、简洁的方式对数据进行处理和操作,并发挥多核处理器的计算能力。

然而,使用流也需要注意数据量、性能和适用场景等因素。最重要的是根据具体情况选择合适的流类型,并根据实际需求合理组合流的操作,以实现更高效、可读性更好的代码。


温习回顾上一篇(点击跳转)《【Java基础教程】(二十九)Java新特性篇 · 第九讲:函数式接口——概念及优缺点、语法形式及实战技巧、 内置函数式接口与应用场景~》

继续阅读下一篇(点击跳转)《【Java基础教程】(三十一)常用类库篇 · 第一讲:Optional类——解锁Java的Optional操作,消灭那些隐匿的空指针,还程序世界一个安稳!~》
文章来源地址https://www.toymoban.com/news/detail-592504.html

java 流的效率,# Java基础教程,java,开发语言,jvm,java-ee,大数据

到了这里,关于【Java基础教程】(三十)Java新特性篇 · 第十讲: Stream流——释放流式编程的效率与优雅,狂肝万字只为透彻讲清 Stream流!~的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 人工智能专栏第十讲——马尔可夫决策过程

    马尔可夫决策过程(Markov Decision Process, MDP)是一类用于描述决策问题的数学模型。该模型可以将决策问题的状态、决策、动作、收益等概念进行形式化,并通过数学方法进行求解,得到一个最优的决策策略。马尔可夫决策过程广泛应用于智能控制、机器学习、人工智能等领域

    2024年02月08日
    浏览(42)
  • JDK1.8新特性之stream流基础

    1.生成stream三中方式 1.1ListStudentlist=new ArrayList (); Stream stream1=list.stream(); 1.2Stream stream2=Stream.of(\\\"hello\\\",\\\"hi",\\\"hello\\\"); 1.3Stream stream3=Arrays.asList(\\\"hello\\\",\\\"hi",\\\"good\\\").stream();   2.stram流常用函数 2.1distinct:去从 lstream2.distint().foreach(System.out.println;) 结果: hello hi   2.2filter:过滤(筛选) List Stude

    2024年04月28日
    浏览(34)
  • Java新特性:Stream流式编程

    Java新特性:Stream流式编程 Stream 流是 Java8 提供的新功能,是对集合对象功能的增强,能对集合对象进行各种非常便利、高效的聚合操作,或大批量数据操作。Stream 流以一种声明性方式处理数据集合,它提供串行和并行两种模式进行汇聚操作,并发模式能够充分利用多核处理

    2024年02月15日
    浏览(44)
  • SQL入门之第十讲——INNER JOIN 内连接

    在实际的业务当中,往往需要多张表连接查询,这就会涉及到JOIN 连接 1. JOIN 连接的类型 INNER JOIN :内连接, 可以只写JOIN ,只有连接的两个表中,都存在连接标准的数据才会保留下来,相当于两个表的交集。如果前后连接的是同一个表,也叫自连接。 LEFT JOIN :左连接,也叫左

    2024年02月02日
    浏览(52)
  • 【Java基础教程】(三十三)常用类库篇 · 第三讲:可变字符串支持类——解析 StringBuffer与 StringBuilder类~

    在Java 中,字符串使用 String 类进行表示,但是 String 类所表示的字符串有一个最大的问题:“字符串常量一旦声明则不可改变,而字符串对象可以改变,但是 改变的是其内存地址的指向”。所以 String 类不适合于被频繁修改的字符串操作, 所以在这种情况下,往往可以使用

    2024年02月15日
    浏览(40)
  • Java Stream 实用特性:排序、分组和 teeing

    基本数据类型排序 基本数据类型就是字符串、整型、浮点型这些,也就是要排序的列表中的元素都是这些基本类型的,比如 ListInteger 的。 下面就用一个整型列表举例说明。 正序排序 正序排序,也可以叫做按照自然顺序排序,对于整型来说就是从小到大的。 输出结果是 [0

    2024年02月03日
    浏览(51)
  • Git第十讲 Git如何正确使用log快速查找内容/提交

    在Git中,你可以使用不同的命令来快速查找指定内容或指定提交。下面我将介绍两种常用的方法。 要快速查找包含特定内容的文件或代码行,可以使用 git grep 命令。它类似于常见的 grep 命令,但是专门用于搜索Git仓库中的文件。 以下是使用 git grep 命令的示例: 在上述命令

    2024年02月09日
    浏览(45)
  • 【Java基础教程】(三十八)常用类库篇 · 第八讲:数组操作类——解析Arrays类中的全部操作方法,解锁Java数组操作技巧~

    前言:在学习本文之前,应该先学习并清楚了解Java基础部分的数组相关的概念和知识。 若还不具备学习条件,请先前往学习数组部分的基础知识: 《【Java基础教程】(八)面向对象篇 · 第二讲:Java 数组全面解析——动态与静态初始化、二维数组、方法参数传递、排序与转

    2024年02月15日
    浏览(62)
  • 【Java基础教程】(三十六)常用类库篇 · 第六讲:数学运算类——全面讲解Java数学计算支持类库,BigDecimal、Math、Random、DecimalFormat...~

    在现代软件开发中,数学计算是不可或缺的一部分。为了满足企业及开发人员对数学运算的需求,Java 提供了一系列强大而丰富的数学计算相关类,其中包括 Math 、 Random 、 BigDecimal 等等。这些类旨在提供高度精确和可靠的数学操作,使开发人员能够处理任何规模和复杂度的定

    2024年02月16日
    浏览(36)
  • 第十讲 单片机驱动彩色液晶屏 控制RA8889软件:图像运算

    目录 第一讲 单片机最小系统STM32F103C6T6通过RA8889驱动彩色液晶屏播放视频 第二讲 单片机最小系统STM32F103C6T6控制RA8889驱动彩色液晶屏硬件框架 第三讲 单片机驱动彩色液晶屏 控制RA8889软件:如何初始化 第四讲 单片机驱动彩色液晶屏 控制RA8889软件:绘图 第五讲 单片机驱动彩色液

    2024年01月22日
    浏览(47)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包