Java Stream流

于 2024-07-17 16:29:47 发布
阅读量368 收藏 10
点赞数 11
文章标签： java python windows 算法 开发语言 数据结构 android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62854966/article/details/140490881
版权

文章目录

一、概念

Java 的 Stream流 是 Java 8 引入的一个重要特性，用于对集合数据进行高效、简洁的操作和处理。

Stream流 具有以下一些特点和优势：

  • 声明式编程风格：可以通过一系列的方法调用来描述对数据的操作，而无需关注具体的实现细节。
  • 链式操作：可以将多个操作链接在一起，形成一个处理流水线，提高代码的可读性和简洁性。
  • 并行处理：Stream流 支持并行操作，能够充分利用多核 CPU 的优势，提高数据处理的效率。

使用 Stream流 的步骤如下：

  1. 创建一个集合的 Stream流。
  2. 使用一系列 中间操作 来对元素进行处理和转换。
  3. 最后使用 终结操作 来获取结果。

二、创建流

2.1 单列集合

  • 集合对象.stream()。
import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        // 创建集合
        ArrayList<Integer> list = new ArrayList<>();

        // 创建Stream流
        list.stream();
    }
}

2.2 数组

  • Arrays.stream(数组)，注意数组的类型要用包装类。
import java.util.Arrays;

public class Test {
    public static void main(String[] args) {
        // 创建数组
        Integer[] arr = {1, 2 , 3 , 4 , 5};
        
        // 创建Stream流
        Arrays.stream(arr);
    }
}

2.3 双列集合

  • 获取map对象的键值对对象，在调用stream()。
import java.util.HashMap;
import java.util.Map;
import java.util.stream.Stream;

public class Test {
    public static void main(String[] args) {
        // 创建集合
        HashMap<String, Object> map = new HashMap<>();

        // 创建Stream流
        Stream<Map.Entry<String, Object>> stream = map.entrySet().stream();
    }
}

三、中间操作

3.1 filter

  • 对集合中的元素过滤，符合条件的才会留下来。
import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        // 创建集合
        ArrayList<String> list = new ArrayList<>();

        // 添加元素
        list.add("石昊");
        list.add("张三丰");
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("欧阳天天");

        // 创建Stream流
        list.stream()
                .filter(name -> name.length() == 3) // 筛选集合中元素长度等于3的元素
                .forEach(name -> System.out.println(name)); // 打印集合元素

    }
}

运行结果：

张三丰
张无忌
周芷若

3.2 map

  • 对集合中的元素计算或者转换类型。
import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        // 创建集合
        ArrayList<String> list = new ArrayList<>();

        // 添加元素
        list.add("12");
        list.add("16");
        list.add("25");
        list.add("31");
        list.add("11");
        list.add("18");

        // 创建Stream流
        list.stream()
                .map(age -> Integer.parseInt(age)) // 将元素转换成Integer类型
                .map(age -> age + 2) // 将集合中所有元素 +2
                .forEach(age -> System.out.println(age)); // 打印集合
    }
}

运行结果：

14
18
27
33
13
20

3.3 distinct

  • 对集合元素进行去重。需要注意的是它是通过 Object 父类的 hashCode() 和 equals() 来去重的，所以如果是自定义类，就需要重写 Object 父类的 hashCode() 和 equals() 方法。
import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        // 创建集合
        ArrayList<String> list = new ArrayList<>();

        // 添加元素
        list.add("石昊");
        list.add("张三丰");
        list.add("张三丰");
        list.add("张三丰");
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("欧阳天天");

        // 创建Stream流
        list.stream()
                .distinct() // 对元素去重
                .forEach(name -> System.out.println(name)); // 打印集合元素
    }
}

运行结果：

石昊
张三丰
张无忌
周芷若
赵敏
欧阳天天

3.4 sorted

  • 对集合元素进行排序。
  • 需要注意的是sorted()有两种实现方法，
    • 一种是空参的，默认是升序，如果集合中的元素是自定义类，那么需要在类上添加 Comparable 接口，否则会报错；
    • 一种是有参的，可以使用 Lmabda表达式 来实现 Comparator 接口，然后在流中使用。
import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        // 创建集合
        ArrayList<Integer> list = new ArrayList<>();

        // 添加元素
        list.add(1);
        list.add(5);
        list.add(3);
        list.add(2);
        list.add(9);

        // 创建Stream流
        list.stream()
                .sorted((o1, o2) -> o2 - o1) // 对元素进行降序排列，从大到小
                .forEach(num -> System.out.println(num)); // 打印集合元素
    }
}

运行结果：

9
5
3
2
1

3.5 limit

  • 获取集合的前几个元素。
import java.util.ArrayList;
import java.util.Optional;
import java.util.stream.Stream;

public class Test {
    public static void main(String[] args) {
        // 创建集合
        ArrayList<String> list = new ArrayList<>();

        // 添加元素
        list.add("石昊");
        list.add("张三丰");
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("欧阳天天");

        // 创建Stream流
        list.stream()
                .limit(3) // 获取前三个元素
                .forEach(name -> System.out.println(name)); // 打印集合元素
    }
}

运行结果

石昊
张三丰
张无忌

3.6 skip

  • 跳过集合的前几个元素。
import java.util.ArrayList;
import java.util.Optional;
import java.util.stream.Stream;

public class Test {
    public static void main(String[] args) {
        // 创建集合
        ArrayList<String> list = new ArrayList<>();

        // 添加元素
        list.add("石昊");
        list.add("张三丰");
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("欧阳天天");

        // 创建Stream流
        list.stream()
                .skip(3) // 跳过前三个元素
                .forEach(name -> System.out.println(name)); // 打印集合元素
    }
}

运行结果：

周芷若
照明
欧阳天天

三、终结操作

4.1 forEach

  • 对集合元素进行遍历操作。
import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        // 创建集合
        ArrayList<String> list = new ArrayList<>();

        // 添加元素
        list.add("石昊");
        list.add("张三丰");
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("欧阳天天");

        // 创建Stream流
        list.stream()
                .filter(name -> name.length() == 2) // 筛选出集合中长度等于2的元素
                .forEach(name -> System.out.println(name)); // 打印集合元素
    }
}

运行结果：

石昊
赵敏

4.2 count

  • 统计集合元素的个数。
import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        // 创建集合
        ArrayList<String> list = new ArrayList<>();

        // 添加元素
        list.add("石昊");
        list.add("张三丰");
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("欧阳天天");

        // 创建Stream流
        long count = list.stream()
                .filter(name -> name.length() == 2) // 筛选出集合中长度等于2的元素
                .count(); // 获取集合元素的个数

        System.out.println("个数：" + count);
    }
}

运行结果：

个数：2

4.3 max

  • 返回集合中最大的元素
import java.util.ArrayList;
import java.util.Optional;
import java.util.stream.Stream;

public class Test {
    public static void main(String[] args) {
        // 创建集合
        ArrayList<Integer> list = new ArrayList<>();

        // 添加元素
        list.add(12);
        list.add(24);
        list.add(32);
        list.add(44);
        list.add(56);

        // 创建Stream流
        Optional<Integer> max = list.stream()
                .max(((o1, o2) -> o1 - o2));// 返回集合中最大的数字

        System.out.println("集合最大的元素是：" + max.get());
    }
}

运行结果：

集合最大的元素是：56

4.4 min

  • 返回集合中最小的元素
import java.util.ArrayList;
import java.util.Optional;
import java.util.stream.Stream;

public class Test {
    public static void main(String[] args) {
        // 创建集合
        ArrayList<Integer> list = new ArrayList<>();

        // 添加元素
        list.add(12);
        list.add(24);
        list.add(32);
        list.add(44);
        list.add(56);

        // 创建Stream流
        Optional<Integer> min = list.stream()
                .min(((o1, o2) -> o1 - o2));// 返回集合中最大的数字

        System.out.println("集合最小的元素是：" + min.get());
    }
}

运行结果：

集合最小的元素是：12

4.5 collect

  • 将集合中的元素转成 List、Set 或 Map 集合。

List 集合

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;

public class Test {
    public static void main(String[] args) {
        // 创建集合
        ArrayList<String> list = new ArrayList<>();

        // 添加元素
        list.add("石昊-12");
        list.add("张三丰-121");
        list.add("张无忌-42");
        list.add("周芷若-21");
        list.add("赵敏-22");
        list.add("欧阳天天-33");

        // 创建Stream流
        List<String> collect = list.stream()
                .map(name -> name.split("-")[0]) // 将集合中的姓名分割出来
                .collect(Collectors.toList()); // 将结果转成List集合

        System.out.println("新集合：" + collect);
    }
}

运行结果：

新集合：[石昊, 张三丰, 张无忌, 周芷若, 赵敏, 欧阳天天]

Set 集合

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

public class Test {
    public static void main(String[] args) {
        // 创建集合
        ArrayList<String> list = new ArrayList<>();

        // 添加元素
        list.add("石昊-12");
        list.add("张三丰-121");
        list.add("张无忌-42");
        list.add("周芷若-21");
        list.add("赵敏-22");
        list.add("欧阳天天-33");

        // 创建Stream流
        Set<String> collect = list.stream()
                .map(name -> name.split("-")[0]) // 将集合中的姓名分割出来
                .collect(Collectors.toSet()); // 将结果转成List集合

        System.out.println("新集合：" + collect);
    }
}

运行结果：

新集合：[欧阳天天, 石昊, 张三丰, 周芷若, 赵敏, 张无忌]

map 集合

import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;

public class Test {
    public static void main(String[] args) {
        // 创建集合
        ArrayList<String> list = new ArrayList<>();

        // 添加元素
        list.add("石昊-12");
        list.add("张三丰-121");
        list.add("张无忌-42");
        list.add("周芷若-21");
        list.add("赵敏-22");
        list.add("欧阳天天-33");

        // 创建Stream流
        Map<String, Integer> collect = list.stream()
                // 将集合元素的姓名作为key，年龄作为value，返回一个map集合
                .collect(Collectors.toMap(name -> name.split("-")[0], age -> Integer.parseInt(age.split("-")[1])));

        System.out.println("新集合：" + collect);
    }
}

运行结果：

新集合：{欧阳天天=33, 石昊=12, 张三丰=121, 周芷若=21, 赵敏=22, 张无忌=42}

4.6 anyMatch

  • 判断集合是否满足条件，结果为 boolean 类型
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

public class Test {
    public static void main(String[] args) {
        // 创建集合
        ArrayList<Integer> list = new ArrayList<>();

        // 添加元素
        list.add(35);
        list.add(12);
        list.add(32);
        list.add(12);
        list.add(42);

        // 创建Stream流
        boolean flag = list.stream()
                .anyMatch(num -> num > 35);// 判断集合中是否存在大于35的元素

        System.out.println(flag);
    }
}

运行结果

true

4.6 allMatch

  • 判断集合中的元素是否全部都满足条件，结果为 boolean 类型
import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        // 创建集合
        ArrayList<Integer> list = new ArrayList<>();

        // 添加元素
        list.add(35);
        list.add(12);
        list.add(32);
        list.add(12);
        list.add(42);

        // 创建Stream流
        boolean flag = list.stream()
                .allMatch(num -> num > 35); // 判断集合中是否全部都大于35

        System.out.println(flag);
    }
}

运行结果

false

4.7 findAny

  • 返回集合中随机的元素。

在串行流中，findAny方法很可能返回流中的第一个元素，但这并不是确定的，因为它可以自由选择流中的任何元素。而在并行流中，findAny方法会返回最先处理完的元素，这可能不是第一个元素。

import java.util.ArrayList;
import java.util.Optional;

public class Test {
    public static void main(String[] args) {
        // 创建集合
        ArrayList<Integer> list = new ArrayList<>();

        // 添加元素
        list.add(35);
        list.add(12);
        list.add(32);
        list.add(12);
        list.add(42);

        // 创建Stream流
        Optional<Integer> optionalI = list.stream()
                .findAny(); // 获取集合中任意的元素

        // 如果存在该元素，就输出
        optionalI.ifPresent(num -> System.out.println(num));
    }
}

运行结果

35

4.8 findFirst

  • 返回集合中第一个元素。
import java.util.ArrayList;
import java.util.Optional;

public class Test {
    public static void main(String[] args) {
        // 创建集合
        ArrayList<Integer> list = new ArrayList<>();

        // 添加元素
        list.add(12);
        list.add(32);
        list.add(35);
        list.add(12);
        list.add(42);

        // 创建Stream流
        Optional<Integer> optionalI = list.stream()
                .findFirst(); // 获取集合中第一个元素

        // 如果存在该元素，就输出
        optionalI.ifPresent(num -> System.out.println(num));
    }
}

运行结果

12

五、注意事项

  • 中间操作会返回新的 Stream流 ，推荐使用链式编程去调用方法；
  • 如果对 Stream流 执行了终结操作，那么就无法再对原先的 Stream流 进行操作，只能重新创建一个新的流；
  • 修改 Stream流 中的数据，不会影响到原来的集合或数组。
野生派蒙
关注
  • 11
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
Java Stream流的详解
流楚丶格念的博客
07-18 2499
Stream作为Java8的一大亮点，它与java.io包里的InputStream和OutputStream是完全不同的概念。Java8中的Stream是对集合(Collection)对象功能的增强，它专注于对集合对象进行各种非常便利、高效的聚合操作(aggregateoperation)，或者大批量数据操作(bulkdataoperation)。StreamAPI借助于同样新出现的Lambda表达式，而且使用并发模式，极大的提高编程效率和程序可读性。...
Java Stream流详解
唯有努力，方可自信！
06-10 2万+
Java Stream流是一种非常强大和灵活的数据处理工具，可以帮助开发人员轻松处理和转换数据。Stream流支持丰富多样的操作方法，如filter()、map()、reduce()等，能够简化代码，提高效率和可读性。在多线程场景下，Stream流更是发挥了现代多核处理器的优势，可以获得更好的性能表现。本文从基础入门到进阶特点为读者介绍Java Stream流的相关知识。
Java Stream流（详解）
m0_60489526的博客
08-29 7万+
一、Stream流引入 Lambda表达式，基于Lambda所带来的函数式编程，又引入了一个全新的Stream概念，用于解决集合类库既有的鼻端。（Lambda表达式详解在上篇博客内容） 现有一个需求： 将list集合中姓张的元素过滤到一个新的集合中 然后将过滤出来的姓张的元素中，再过滤出来长度为3的元素，存储到一个新的集合中 1.用常规方法解决需求 /...
Java--Stream流详解
热门推荐
MinggeQingchun的博客
08-30 7万+
Stream是Java 8 API添加的一个新的抽象，称为流Stream，可以一种声明的方式处理数据 stream().filter()一般适用于list集合过滤list中的数据，主要作用就是模拟sql查询，从集合中查询想要的数据，不用像之前一样遍历list再筛选 orElse(null)表示如果一个都没找到返回null（orElse()中可以塞默认值。如果找不到就会返回orElse中设置的默认值） orElseGet(null)表示如果一个都没找到返回null（orElseGet()中可以塞默认值。
Java Stream流之求和
少年一贯快马扬帆，道阻且长不转弯； 要盛大，要绚烂，要哗然； 要用理想的泰坦尼克，去撞现实的冰川； 要当烧赤壁的风，而非借鉴草船； 要为了一片海，就肯翻万山。
04-14 2万+
Java Stream流之求和 流方式实现 基本数据类型 和 包装类型 的一位数组求和 package top.yangbocsu; import java.util.Arrays; /** * @author yangbocsu * @date 2022年4月14日 * @version 1.0 * @description: 流方式实现 基本数据类型 和 包装类型 的一位数组求和 */ public class Test { public static void main(St
探索Java Stream流：概念、应用与代码示例详解
聚焦于深度解析最新的编程语言特性、框架升级、架构设计、开发工具和最佳实践，涵盖Web前端（如Vue3, React, Angular等）、后端开发（如Node.js, Java, Python等）、移动端开发（iOS, Android原生及跨平台开发）
04-30 2万+
Java Stream流为处理集合数据提供了强大的工具集，其声明式、延迟计算和可并行化的特性使得代码更为简洁、高效。通过熟练掌握Stream API的使用，开发者能够编写出易于理解、易于维护且高性能的Java程序。在实际项目中，应根据具体需求灵活运用Stream的各种操作，同时注意衡量并行流的收益与成本，以达到最佳的编程效果。持续实践与探索，将使您在Java编程中充分受益于Stream流的强大功能。
JAVA stream流详细教程
QiuHaoqian的博客
10-25 4万+
目录1、什么是流2、如何生成流3、流的操作类型3.1、中间操作3.2、终端操作4、流的使用4.1 中间操作filter 筛选distinct 去重limit 返回指定流个数skip 跳过流中的元素map 流映射flatMap 流转换allMatch 匹配所有元素anyMatch匹配其中一个noneMatch全部不匹配4.2 终端操作count 统计流中元素个数findFirst 查找第一个findAny 随机查找一个reduce 将流中的元素组合min/max 获取最小最大值sum / summingxxx
java stream流排序_java stream流 排序
weixin_34785304的博客
02-28 1571
// 按状态排序，排序顺序是PipelineState枚举类的顺序List newPipelineList = pipelineList.stream().sorted(Comparator.comparing(Pipeline::getState)).collect(Collectors.toList());Collections.reverse(newPipelineList); //排序翻转...
Java Stream流处理
weixin_56892092的博客
01-08 1666
1.Stream的概念 Stream是一组用来处理数组.集合的API ​ 好处: 1. 代码简洁 意图明确 使用Stream接口让你从此告别for循环 2. 多核友好,函数式编程使得并行程序如此简单 你需要的全部就是调用一下parallel()方法 处理集合非常方便 2.Stream的特点 1. 不是数据结构,没有内部存储 在一套执行操作中,中间的某个操作不会存储数据 2. 不支持索引访问 例如一个int[] i = {1,2,3,4}; 的数组,在操作中不.
一文带你入门Java Stream流，太强了
沉默王二
04-01 2万+
两个星期以前，就有读者强烈要求我写一篇 Java Stream 流的文章，我说市面上不是已经有很多了吗，结果你猜他怎么说：“就想看你写的啊！”你看你看，多么苍白的喜欢啊。那就“勉为其难”写一篇吧，嘻嘻。 单从“Stream”这个单词上来看，它似乎和 java.io 包下的 InputStream 和 OutputStream 有些关系。实际上呢，没毛关系。Java 8 新增的 Stream 是为...
Java Stream 流实现合并操作示例
08-19
Java Stream 流实现合并操作示例 Java Stream 流实现合并操作示例是 Java Stream Api 的一个重要应用场景。在实际开发中，我们经常需要将多个 Stream 流合并成一个流，以便进行后续的数据处理。今天，我们将详细...
JavaStream流
08-22
Java Stream流 详细文档
详解JAVA Stream流
08-18
Java Stream流详解 Java Stream流是Java 8中引入的一种新的数据处理方式，它提供了一种高效、灵活的数据处理方式，能够帮助开发者更方便地处理大量数据。 Stream流不是一种数据结构，它也不是集合元素，而是一种...
java Stream流
12-22
Java Stream流是Java 8及以后版本引入的一个重要特性，它为处理集合提供了新的方式，尤其是在函数式编程中。Stream不同于传统的输入输出流InputStream和OutputStream，它的主要目标是增强Java集合框架，提供一种高效...
Java Stream流知识总结
08-19
"Java Stream流知识总结" Java Stream流是Java 8中引入的一种新的编程模型，用于解决传统集合类库的弊端。 Stream流可以看作是一个集合元素的函数模型，它并不是集合，也不是数据结构，其本身并不存储任何元素或其...
java版的上门家政系统和PHP版的上门家政有什么区别？
baina666的博客
07-12 602
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
Spring Security 授权
最新发布
persistence_PSH的博客
07-14 812
在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。通过 RBAC 获取到用户的具体权限后，再通过 Security 的 用户-权限-资源 来进行权限控制。HttpSecurity 权限配置。
【Go系列】 Sync并发控制
u013379032的博客
07-14 954
在上一篇文章中，我们介绍了goroutine和channel，理论上，通过channel可以实现并发控制，但是其他语言的开发者可能更习惯一些原子操作的库。当然Go语言也会提供这样的库，所以我们今天了解一下sync库。
Java方法练习-双色球彩票系统
T1798218285的博客
07-11 318
红色球号码从1-33中选择；蓝色球号码从1-16中选择。投注号码由6个红色球号码和1个蓝色球号码组成。三等奖 5+1 / 5+0 3000。四等奖4+1 / 4+0 200。六等奖1+1 / 1+0 5。一等奖6+1 1000w。二等奖6+0 500w。五等奖3+1 / 2+1。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

野生派蒙

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

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

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

打赏作者

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

抵扣说明：

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

余额充值