超好用的特性:Stream 流

这篇具有很好参考价值的文章主要介绍了超好用的特性:Stream 流。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

一、介绍

JDK 8引入了Stream API,它是Java中处理集合数据的一种新方式。Stream流提供了一种更简洁、更灵活的方式来对集合进行操作和处理。

Stream流可以看作是一种高级的迭代器,它可以对集合中的元素进行过滤、映射、排序、聚合等操作,而不需要显式地使用循环。这样可以使代码更加简洁、易读,并且可以充分利用多核处理器的优势。

Stream流的特点包括:

  1. 延迟计算:Stream流中的操作是惰性执行的,只有在终止操作时才会触发计算。这种延迟计算的特性可以提高性能,因为只计算需要的结果。

  2. 内部迭代:Stream流使用内部迭代器来遍历集合,这意味着不需要显式地编写循环来遍历集合。这样可以提高代码的简洁性和可读性。

  3. 支持并行操作:Stream流可以很方便地进行并行操作,即将任务分成多个子任务并行执行,然后将结果合并。这可以提高处理大量数据的效率。

使用Stream流可以大大简化集合数据的处理,使代码更加简洁、易读,并且可以充分发挥多核处理器的优势。

二、相关操作

  1. 创建Stream流:

    • 从集合创建:可以通过集合的stream()方法或parallelStream()方法来创建一个Stream流。
    • 从数组创建:可以使用Arrays类的stream()方法来创建一个Stream流。
    • 使用Stream.of()方法:可以直接传入多个元素来创建一个Stream流。
    • 使用Stream.generate()或Stream.iterate()方法:可以生成一个无限流。
  2. Stream流的中间操作:

    • filter():过滤掉不满足条件的元素。
    • map():对元素进行映射转换。
    • flatMap():将多个流合并成一个流。
    • distinct():去除重复的元素。
    • sorted():对元素进行排序。
    • limit():限制元素的数量。
    • skip():跳过指定数量的元素。
  3. Stream流的终端操作:文章来源地址https://www.toymoban.com/news/detail-492970.html

    • forEach():对每个元素执行指定操作。
    • collect():将元素收集到一个集合中。
    • reduce():将元素进行归约操作,得到一个最终结果。
    • count():计算元素的数量。
    • min()和max():找到最小值和最大值。
    • anyMatch()、allMatch()和noneMatch():检查是否存在满足条件的元素。

三、实例

  1. 过滤(filter):筛选出集合中满足指定条件的元素。
List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David", "Eve");

List<String> filteredNames = names.stream()
                                 .filter(name -> name.length() > 4)
                                 .collect(Collectors.toList());

System.out.println(filteredNames); // 输出:[Alice, Charlie]
  1. 映射(map):将集合中的元素进行转换。
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

List<Integer> squaredNumbers = numbers.stream()
                                       .map(number -> number * number)
                                       .collect(Collectors.toList());

System.out.println(squaredNumbers); // 输出:[1, 4, 9, 16, 25]
  1. 排序(sorted):对集合中的元素进行排序。
List<Integer> numbers = Arrays.asList(5, 2, 8, 1, 9);

List<Integer> sortedNumbers = numbers.stream()
                                     .sorted()
                                     .collect(Collectors.toList());

System.out.println(sortedNumbers); // 输出:[1, 2, 5, 8, 9]
  1. 去重(distinct):去除集合中的重复元素。
List<Integer> numbers = Arrays.asList(1, 2, 3, 2, 4, 3, 5);

List<Integer> distinctNumbers = numbers.stream()
                                       .distinct()
                                       .collect(Collectors.toList());

System.out.println(distinctNumbers); // 输出:[1, 2, 3, 4, 5]
  1. 限制(limit)和跳过(skip):限制集合中元素的数量或跳过指定数量的元素。
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

List<Integer> limitedNumbers = numbers.stream()
                                      .limit(3)
                                      .collect(Collectors.toList());

System.out.println(limitedNumbers); // 输出:[1, 2, 3]

List<Integer> skippedNumbers = numbers.stream()
                                      .skip(2)
                                      .collect(Collectors.toList());

System.out.println(skippedNumbers); // 输出:[3, 4, 5]
  1. 匹配(match):检查集合中是否存在满足指定条件的元素。
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

boolean anyMatch = numbers.stream()
                          .anyMatch(number -> number > 3);

System.out.println(anyMatch); // 输出:true

boolean allMatch = numbers.stream()
                          .allMatch(number -> number > 0);

System.out.println(allMatch); // 输出:true

boolean noneMatch = numbers.stream()
                           .noneMatch(number -> number < 0);

System.out.println(noneMatch); // 输出:true
  1. 归约(reduce):将集合中的元素进行合并操作,得到一个最终结果。
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

int sum = numbers.stream()
                 .reduce(0, (a, b) -> a + b);

System.out.println(sum); // 输出:15

int max = numbers.stream()
                 .reduce(Integer.MIN_VALUE, (a, b) -> a > b ? a : b);

System.out.println(max); // 输出:5
  1. 遍历(forEach):对集合中的每个元素执行指定操作。
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

names.stream()
     .forEach(name -> System.out.println("Hello, " + name));

// 输出:
// Hello, Alice
// Hello, Bob
// Hello, Charlie
  1. 统计(summarizing):获取集合中元素的统计信息,如总数、平均值、最大值、最小值等。
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

IntSummaryStatistics stats = numbers.stream()
                                    .mapToInt(Integer::intValue)
                                    .summaryStatistics();

System.out.println("Count: " + stats.getCount());
System.out.println("Sum: " + stats.getSum());
System.out.println("Average: " + stats.getAverage());
System.out.println("Max: " + stats.getMax());
System.out.println("Min: " + stats.getMin());

// 输出:
// Count: 5
// Sum: 15
// Average: 3.0
// Max: 5
// Min: 1
  1. 分组(groupingBy):根据指定条件对集合中的元素进行分组。
List<Person> people = Arrays.asList(
    new Person("Alice", 25),
    new Person("Bob", 30),
    new Person("Charlie", 25),
    new Person("David", 35),
    new Person("Eve", 30)
);

Map<Integer, List<Person>> ageGroups = people.stream()
                                             .collect(Collectors.groupingBy(Person::getAge));

System.out.println(ageGroups);

// 输出:
// {25=[Person{name='Alice', age=25}, Person{name='Charlie', age=25}], 
//  30=[Person{name='Bob', age=30}, Person{name='Eve', age=30}], 
//  35=[Person{name='David', age=35}]}
  1. 并行处理(parallelStream):使用并行流来并行处理集合中的元素。
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

int sum = numbers.parallelStream()
                 .reduce(0, (a, b) -> a + b);

System.out.println(sum); // 输出:15
  1. flatMap操作:将多个流合并成一个流。
List<List<Integer>> numberLists = Arrays.asList(
    Arrays.asList(1, 2, 3),
    Arrays.asList(4, 5, 6),
    Arrays.asList(7, 8, 9)
);

List<Integer> flattenedList = numberLists.stream()
                                         .flatMap(List::stream)
                                         .collect(Collectors.toList());

System.out.println(flattenedList);

// 输出:[1, 2, 3, 4, 5, 6, 7, 8, 9]
  1. 查找(findFirst和findAny):查找集合中满足指定条件的元素。
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

Optional<Integer> firstEvenNumber = numbers.stream()
                                           .filter(number -> number % 2 == 0)
                                           .findFirst();

System.out.println(firstEvenNumber); // 输出:Optional[2]

Optional<Integer> anyEvenNumber = numbers.stream()
                                         .filter(number -> number % 2 == 0)
                                         .findAny();

System.out.println(anyEvenNumber); // 输出:Optional[2](可能不同于findFirst的结果)
  1. 去除空值(filterNotNull):过滤掉集合中的空值。
List<String> names = Arrays.asList("Alice", null, "Bob", null, "Charlie");

List<String> nonNullNames = names.stream()
                                 .filter(Objects::nonNull)
                                 .collect(Collectors.toList());

System.out.println(nonNullNames); // 输出:[Alice, Bob, Charlie]
  1. 使用自定义操作(customOperation):根据自己的需求编写自定义的操作。
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

List<String> uppercaseNames = names.stream()
                                   .map(String::toUpperCase)
                                   .collect(Collectors.toList());

System.out.println(uppercaseNames); // 输出:[ALICE, BOB, CHARLIE]

到了这里,关于超好用的特性:Stream 流的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

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

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

相关文章

  • Java新特性:Stream流式编程

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

    2024年02月15日
    浏览(44)
  • Redis 高级特性 Redis Stream使用

    Redis Stream 是 Redis 5.0 版本新增加的数据结构。 Stream从字面上看是流类型,但其实从功能上看,应该是Redis对消息队列(MQ,Message Queue)的完善实现。下文称Stream为队列 Stream 出现原因 : Stream的出现是为了给Redis提供完善的消息队列功能 基于Reids的消息队列实现有很多种,例如

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

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

    2024年02月03日
    浏览(51)
  • 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)
  • 盘点C# 9.0中好用的特性

    将类和类里面Main函数省略,只留下核心的逻辑代码就是顶级语句! 1.顶级语句1 1.顶级语句2 init通过允许调用方在构造操作过程中改变成员,访问器使不可变对象更具灵活性。 这意味着对象的不可变属性可以参与对象初始值设定项,因此不再需要类型中的所有构造函数样板。

    2023年04月22日
    浏览(38)
  • JDK8新特性(一)集合之 Stream 流式操作

           首先我们应该知道:Stream流的出现,主要是用在集合的操作上。在我们日常的工作中,经常需要对集合中的元素进行相关操作。诸如:增加、删除、获取元素、遍历。         最典型的就是集合遍历了。接下来我们先举个例子来看看 JDK8 Stream流式操作出现之前,

    2024年01月23日
    浏览(37)
  • JAVA8新特性(Stream API,LocalDate,LocalDateTime)

    一. Stream API 1.1 基础 代码参数准备: 场景一:知道一个ListUser对象,如何获取ListUser的所有用户id? 场景二:知道一个ListUser对象,如何获取ListUser中年龄大于50的用户? 场景三:知道一个ListUser对象,如何按照年龄从小到小排序,从大到小排序? 场景四:知道一个ListUser对象

    2024年02月16日
    浏览(44)
  • Java 8 新特性 Stream 的使用场景(不定期更新)

    方便在写代码的过程中直接使用,好记性不如好文章,直接 CV 改了直接用。提高 办(摸)公(鱼)效(时)率(间), 不然就直接问 GPT 也不是说不行。 anyMatch :只要有一个就会返回 true 。 allMatch :所有元素都满足就返回 true。 后续将不定期更新 Stream 的骚操作使用,如果

    2024年02月05日
    浏览(42)
  • Java8特性,Stream流的使用,收集成为map集合

    Java 8引入了Stream API,这是Java集合操作的一个重大改进。Stream API提供了一种高效且易于使用的处理数据的方式。 Stream是数据渠道,用于操作数据源(集合、数组等)所生成的元素序列。注意:Stream自己不会存储元素,它不会改变源对象,反而它的操作会返回一个全新的Strea

    2024年04月22日
    浏览(83)
  • 带你走进Java8新特性Stream流的小世界

    目录 一. 什么是流(Stream) 1.1 流的定义 1.2 流的特点 1.3 操作流 1.4 创建流 二. 流的中间操作 2.1 流的筛选与切片 2.1.1 filter 2.1.2 limit 2.1.3 skip 2.1.4 distinct 2.2 流的映射 2.2.1 map 2.2.2 flatMap 2.3 流的排序 2.3.1 sort 三. 流的终止操作 3.1 流的查找与匹配 3.1.1 allMatch 3.1.2 anyMatch 3.1.3 none

    2024年01月24日
    浏览(62)

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

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

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

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

二维码1

领取红包

二维码2

领红包