Java Stream的讲解

最新推荐文章于 2024-08-27 04:38:06 发布
最新推荐文章于 2024-08-27 04:38:06 发布
阅读量332 收藏
点赞数
文章标签： java stream lambda
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45953000/article/details/118274228
版权

Stream的概述

Stream是java 8新增的特性，用来补充集合类。
Stream就是流，流中的数据元素的数量可以是有限个数，也可能是无限个数。

Stream的特性

  • 不存储数据：流失基于数据源的对象，它本身不存储数据元素，而是通过管道蒋淑媛的元素传递操作。
  • 函数式编程：流在每一级的操作中，都会新创建一个副本，例如执行filter不会将数据源中的数据进行删除。
  • 具有顺序不可逆性：每一个级别的操作都是按照编写的顺序进行的，下一个操作会基于上一个操作。

流的创建方法

  1. 使用Collection.stream()直接获取流对象
List<String> list = new ArrayList<>();
Stream<String> stream = list.stream(); //获取一个顺序流
Stream<String> parallelStream = list.parallelStream(); //获取一个并行流
  1. 数组直接转成流对象
Integer[] nums = new Integer[10];
Stream<Integer> stream = Arrays.stream(nums);
  1. 使用Stream中的静态方法：of（），iterate(),generate()
Stream<Integer> stream = Stream.of(1,2,3,4,5,6);
 
Stream<Integer> stream2 = Stream.iterate(0, (x) -> x + 2).limit(6);
stream2.forEach(System.out::println); // 0 2 4 6 8 10
 
Stream<Double> stream3 = Stream.generate(Math::random).limit(2);
stream3.forEach(System.out::println);
  1. 使用 BufferedReader.lines() 方法，将每行内容转成流
BufferedReader reader = new BufferedReader(new FileReader("F:\\test_stream.txt"));
Stream<String> lineStream = reader.lines();
lineStream.forEach(System.out::println);
  1. 使用 Pattern.splitAsStream() 方法，将字符串分隔成流
Pattern pattern = Pattern.compile(",");
Stream<String> stringStream = pattern.splitAsStream("a,b,c,d");
stringStream.forEach(System.out::println);

流的操作（流的操作包括中间操作和终端操作，中间操作通常是一些过滤，求值操作，终端操作为统计，或者转换为某种容器的操作）

流的中间操作

  • filter（表达式）：过滤流中的某些元素，获取流中符合表达式的元素
  Stream<Integer> integerStream=Stream.of(1,2,3,4,5,6);
        List<Integer> integerList=integerStream
                .filter(integer -> integer.intValue()<5)
                .collect(Collectors.toList());
        System.out.println(integerList);

结果为：在这里插入图片描述

-limit（n）：n为数值，获取流中的前n个元素

 Stream<Integer> integerStream=Stream.of(1,2,3,4,5,6);
        List<Integer> integerList=integerStream
                .filter(integer -> integer.intValue()<5)
                .limit(3)
                .collect(Collectors.toList());
        System.out.println(integerList);

在这里插入图片描述

-skip(n)：跳过前n元素，配合limit(n)可实现分页

 Stream<Integer> integerStream=Stream.of(1,2,3,4,5,6);
        List<Integer> integerList=integerStream
                .filter(integer -> integer.intValue()<5)
                .limit(3)
                .skip(2)
                .collect(Collectors.toList());
        System.out.println(integerList);

在这里插入图片描述
原本应该是[1,2,3],调用skip（2）后，跳过前面两个元素

  • distinct：通过流中元素的 hashCode() 和 equals() 去除重复元素
   Stream<Integer> integerStream=Stream.of(1,2,2,4,5,6,6,7,8);
        List<Integer> integerList=integerStream
                .skip(2)
                .distinct()
                .collect(Collectors.toList());
        System.out.println(integerList);

在这里插入图片描述

  • 映射：
  • map：接收一个函数作为参数，该函数会被应用到每一个元素上，并将其根据函数转换成为一个新的元素。
  Stream<Integer> integerStream=Stream.of(1,2,2,4,5,6,6,7,8);
        List<Integer> integerList=integerStream
                .map(integer -> integer+2)
                .collect(Collectors.toList());
        System.out.println(integerList);

每个元素都进行了+2的操作

  • flatMap:接收一个函数作为参数，将流中的每个值都换成另一个流，然后将所有的流连接成为一个流。
  public static List<Integer> getLessThan(Integer integer) {
        return Stream.iterate(0, x -> x + 1).limit(integer).collect(Collectors.toList());
    }

    public static void main(String[] args) {
        Stream<Integer> integerStream = Stream.of(1, 2, 3, 4);
        List<Integer> integerList = integerStream.flatMap(s -> {
            return getLessThan(s).stream();
        })
                .collect(Collectors.toList());
        System.out.println(integerList);
    }

在这里插入图片描述

  • 排序
  • sorted（）：自然排序，流中的元素需实现Comparable接口
  • sorted（Comparator comparator ）:定制排序，自定义Comparator排序器

自然排序：
先实现comparable接口

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User implements Comparable<User> {
    private String name;
    private Integer age;
    private String phone;

    @Override
    public int compareTo(User user) {
        return user.age-this.getAge();
    }
}

    List<User> userList=new ArrayList<>();
        User user=new User("张三",22,"17806533481");
        User user2=new User("李四",27,"18906533481");
        User user3=new User("王老五",28,"15806533481");
        userList.add(user);
        userList.add(user2);
        userList.add(user3);
       List<User> list=userList.stream().sorted().collect(Collectors.toList());
        System.out.println(list);

在这里插入图片描述
自定义排序：不需要实现comparable接口，直接使用比较器

 List<User> userList=new ArrayList<>();
        User user=new User("张三",29,"17806533481");
        User user2=new User("李四",27,"18906533481");
        User user3=new User("王老五",28,"15806533481");
        User user4=new User("赵六",27,"15806533481");
        userList.add(user);
        userList.add(user2);
        userList.add(user3);
        userList.add(user4);
       List<User> list=userList.stream().sorted((o1,o2)->{
           if (o1.getAge()> o2.getAge()){
               return 1;
           }else if (o1.getAge()<o2.getAge()){
               return -1;
           }else {
               return 0;
           }
       }).collect(Collectors.toList());
        System.out.println(list);

结果按照age升序
在这里插入图片描述

  • 消费
    如同于map，能获得流中的每一个元素，但是map接受的是Function表达式，具有返回值，而peek接受的是Consumer表达式，没有返回值，只进行消费，可以是输出，或者是外部处理。
List<User> userList=new ArrayList<>();
        User user=new User("张三",29,"17806533481");
        User user2=new User("李四",27,"18906533481");
        User user3=new User("王老五",28,"15806533481");
        User user4=new User("赵六",27,"15806533481");
        userList.add(user);
        userList.add(user2);
        userList.add(user3);
        userList.add(user4);

       userList.stream().peek(System.out::println)
               .collect(Collectors.toList());

在这里插入图片描述

流的终端操作

allmatch，noneMatch，anyMatch用于对集合中对象的某一个属性值进行判断，
allMatch全部符合该条件返回true，
noneMatch全部不符合该断言返回true
anyMatch 任意一个元素符合该断言返回true

  • allMatch
List<User> userList=new ArrayList<>();
        User user=new User("张三",29,"17806533481");
        User user2=new User("李四",27,"18906533481");
        User user3=new User("王老五",28,"15806533481");
        User user4=new User("赵六",27,"15806533481");
        userList.add(user);
        userList.add(user2);
        userList.add(user3);
        userList.add(user4);

        boolean allMatch= userList.stream().allMatch(user1 -> user1.getAge()<30);
        System.out.println(allMatch);

结果为true；

  • noneMatch
List<User> userList=new ArrayList<>();
        User user=new User("张三",29,"17806533481");
        User user2=new User("李四",27,"18906533481");
        User user3=new User("王老五",28,"15806533481");
        User user4=new User("赵六",27,"15806533481");
        userList.add(user);
        userList.add(user2);
        userList.add(user3);
        userList.add(user4);

        boolean noneMatch= userList.stream().noneMatch((user1 -> user1.getAge()>30));
        System.out.println(noneMatch);

判断user.age()是不是没有任何一个大于30，结果是的

  • anyMatch
 List<User> userList=new ArrayList<>();
        User user=new User("张三",29,"17806533481");
        User user2=new User("李四",27,"18906533481");
        User user3=new User("王老五",31,"15806533481");
        User user4=new User("赵六",27,"15806533481");
        userList.add(user);
        userList.add(user2);
        userList.add(user3);
        userList.add(user4);

        boolean anyMatch= userList.stream().anyMatch((user1 -> user1.getAge()>30));
        System.out.println(anyMatch)

判断是否至少有一个，符合条件。

findFirst：返回流中第一个元素

findAny：返回流中的任意元素

 List<User> userList = new ArrayList<>();
        User user = new User("张三", 29, "17806533481");
        User user2 = new User("李四", 27, "18906533481");
        User user3 = new User("王老五", 31, "15806533481");
        User user4 = new User("赵六", 27, "15806533481");
        userList.add(user);
        userList.add(user2);
        userList.add(user3);
        userList.add(user4);

        User userFirst =userList.stream().findFirst().get();
        System.out.println(userFirst);

在这里插入图片描述

count：返回流中元素的总个数

   List<User> userList = new ArrayList<>();
        User user = new User("张三", 29, "17806533481");
        User user2 = new User("李四", 27, "18906533481");
        User user3 = new User("王老五", 31, "15806533481");
        User user4 = new User("赵六", 27, "15806533481");
        userList.add(user);
        userList.add(user2);
        userList.add(user3);
        userList.add(user4);

        Long aLong =userList.stream().count();
        System.out.println(aLong);

在这里插入图片描述

max：返回流中元素最大值

 List<User> userList = new ArrayList<>();
        User user = new User("张三", 29, "17806533481");
        User user2 = new User("李四", 27, "18906533481");
        User user3 = new User("王老五", 31, "15806533481");
        User user4 = new User("赵六", 27, "15806533481");
        userList.add(user);
        userList.add(user2);
        userList.add(user3);
        userList.add(user4);

        User userMax = userList.stream().max((u1, u2) -> {
            if (u1.getAge() > u2.getAge()) {
                return 1;
            } else if (u1.getAge() < u2.getAge()) {
                return -1;
            } else {
                return 0;
            }
        }).get();
        System.out.println(userMax);

在这里插入图片描述
min：返回流中元素最小值

   List<User> userList = new ArrayList<>();
        User user = new User("张三", 29, "17806533481");
        User user2 = new User("李四", 27, "18906533481");
        User user3 = new User("王老五", 31, "15806533481");
        User user4 = new User("赵六", 20, "15806533481");
        userList.add(user);
        userList.add(user2);
        userList.add(user3);
        userList.add(user4);

        User userMin = userList.stream().min((u1, u2) -> {
            if (u1.getAge() > u2.getAge()) {
                return 1;
            } else if (u1.getAge() < u2.getAge()) {
                return -1;
            } else {
                return 0;
            }
        }).get();
        System.out.println(userMin);

在这里插入图片描述

人笨但爱学习
关注
Java 流（Stream）简介：1、基本的输入流和输出流
YidingHe's Blog
04-20 1万+
本人打算写几篇文章，介绍一下流。本文是针对初学者的，加上本人水平有限，所以不敢说写得很高深。如果你是初学者，而且对流这个东西很头疼，你就应该看看这个。本文发表在：http://blog.csdn.net/YidingHe，转载请保留出处。流是 Java 中最重要的基本概念之一。文件读写、网络收发、进程通信，几乎所有需要输入输出的地方，都要用到流。流是做什么用的呢
Java的Stream流详细讲解
热门推荐
qq_45443475的博客
06-28 1万+
Java的Stream流详细讲解
Java中Stream流详解
最新发布
welcome
08-27 1301
Java中的Stream是Java 8引入的一种新的API，用于处理集合或数组中的数据，提供了一种简洁且高效的方式来进行各种操作，如过滤、排序、映射、汇总等。Stream不存储数据，它更像是一个高级迭代器，通过一系列流水线操作来处理数据。中间操作和终端操作。
Java-Stream详解
yueerba126的博客
06-30 7733
Stream是Java 8新增的接口，Stream可以认为是一个高级版本的 Iterator。
Java中Stream的快速了解
m0_60528766的博客
02-07 257
快速了解Stream，更深一步的使用我会在后续总结 关于Stream: 定义: 遍历集合,对集合中的元素进行过滤 优点: 更关注做了什么,不关心怎么做,使代码更优美 大概介绍: *Java8API添加了一个新的抽象称为流Stream，可以让你以一种声明的方式处理数据。 *Stream使用一种类似用SQL语句从数据库查询数据的直观方式来提供一种对Java集合运算和表达的高阶抽象。 *StreamAPI可...
java基础知识stream讲解和练习.rar
11-01
Java Stream API是Java 8引入的一个新特性，用于处理集合数据。它允许你以声明性方式处理数据，这意味着你可以描述你想要做什么，而不是详细说明怎么做。...本资源是一些基本的Java Stream API的讲解和练习。
Java Stream全面讲解
06-23
Java Stream 是Java编程语言中处理数据流的一种抽象概念，它允许程序员以一种声明性的方式处理数据，特别是集合数据。在Java中，Stream主要用于处理大量数据，它可以与集合、I/O通道等多种数据源交互，提供了丰富的...
归约、分组与分区，深入讲解JavaStream终结操作
A1867350的博客
04-21 1037
对于很多Java工程师而言，想要提升技能，往往是自己摸索成长，不成体系的学习效果低效漫长且无助。整理的这些资料希望对Java开发的朋友们有所参考以及少走弯路，本文的重点是你有没有收获与成长，其余的都不重要，希望读者们能谨记这一点。再分享一波我的Java面试真题+视频学习详解+技能进阶书籍《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！正体系化！**
详解JAVA Stream流
08-18
Java Stream流详解 Java Stream流是Java 8中引入的一种新的数据处理方式，它提供了一种高效、灵活的数据处理方式，能够帮助开发者更方便地处理大量数据。 Stream流不是一种数据结构，它也不是集合元素，而是一种...
Java Stream流的详解
流楚丶格念的博客
07-18 2580
Stream作为Java8的一大亮点，它与java.io包里的InputStream和OutputStream是完全不同的概念。Java8中的Stream是对集合(Collection)对象功能的增强，它专注于对集合对象进行各种非常便利、高效的聚合操作(aggregateoperation)，或者大批量数据操作(bulkdataoperation)。StreamAPI借助于同样新出现的Lambda表达式，而且使用并发模式，极大的提高编程效率和程序可读性。...
Java Stream流的概念
diaoqi5743的博客
02-24 177
关于java中stream的概念，让人困惑了很久，下面是今天从网上摘抄的集锦： 刚开始接触流的概念，很迷惑，搞了很久终于搞懂，时隔许久，又迷惑了，现做一小结，拿来与大家分享。 1. Java的流分为 Inputstream 和 OutputStream； 2. 流(stream)的概念源于UNIX中管道(pipe)的概念。在UNIX中...
【Java 基础篇】Java Stream流详解
繁依Fanyi的博客
06-27 3646
本文详细介绍了Java Stream流的概念、特性和使用方法。通过Stream流，开发人员可以以声明式的方式对数据进行操作，使代码更加简洁、易读。我们还介绍了Stream流的常用操作方法，包括过滤、映射、排序、聚合等，以及并行流操作的使用。通过充分利用Stream流的特性和优势，开发人员可以编写更加优雅、高效的数据处理代码。希望本文对你理解和应用Java Stream流有所帮助！
Java8 Stream 的深度理解
曳凡的博客
11-12 482
前言 在java8中，stream流式处理极大的简化了我们的功能代码，其中用来筛选数据的filter也是我们用的非常多的，本篇文章用来记录stream运用时的思考，会不断更新，但是这篇文章不是讲解stream是如何使用的，如果想要学习stream的同学，可以戳这里 简化stream执行语句 平时大家在写流式数据处理来筛选数据时一般都会这样写 list.stream().filter(a-> {具体筛选条件}).collect(Collectors.toList()); 这样的写法非常好理解，但是会存
java stream的理解和使用
qq_43470725的博客
06-22 644
stream:意思是 流 的意思，那么其操作的对象就应该是小个体组成的流，不能是一个完整的组合体如类（不是集合类），所以其可以操作集合，数组等。 方法： filter：过滤流中的某些元素 limit(n)：获取n个元素 skip(n)：跳过n元素，配合limit(n)可实现分页 distinct：通过流中元素的 hashCode() 和 equals() 去除重复元素 map:遍历每个集合中的元素，对每个能进行自己想要的操作，最后出流。 出流后，不转换，就会返回stream类型； java代
java中简述什么是流_Java Stream简介, 流的基本概念
weixin_39723920的博客
02-13 542
在Javaor .net编程中, 我们经常见到"stream" 这个字眼.我们大概知道这是个流的意思, 如果看完本文的话, 应该会有1个大概的概念.一, Java中什么是Stream(流)1.1 1段输出文件内容到屏幕的代码假如我们有个需求, 利用Java写1个程序, 将1个硬盘上的文件(/home/gateman/tmp/build.xml)内容输出到屏幕上.Java的代码如下:import...
java Stream详解看我这一篇就够了
m0_64332518的博客
04-01 3958
java Stream详解看一篇就够了。
Java8中的优雅擦操作Stream详解
as576228266的博客
02-04 208
java8已经发布相当长一段时间了，我工作中一直维护的几个项目发布在很多环境中，我也不敢保证每个环境的JDK都是1.8版本以上的，也就一直没在工作中使用java8的一些新特性 java8刚发布时我学习了一下，写了一些demo，没有及时的进行归档，现在这些demo基本都已经找不到了。在工作中每每遇到对集合进行一些操作时都很头疼，只能不停的对集合进行for循环，有时还需要对同一个集合循环两次以...
Java中的Stream
isGentleman的博客
07-04 398
Java中的Stream是一种用于处理集合（数组、列表等）和其他数据源的元素序列的抽象。Stream API提供了一种声明性的编程风格，可以方便地对数据进行过滤、映射、聚合等操作。Stream是Java8API添加的一个新的抽象，称为流Stream，以一种声明性方式处理数据集合（侧重对于源数据计算能力的封装，并且支持序列与并行两种操作方式)Stream流是从支持数据处理操作的源生成的元素序列，源可以是数组、文件、集合、函数。流不是集合元素，它不是数据结构并不保存数据，它的主要目的在于计算。
Java8 Stream API讲解
07-11
Java 8 中的 Stream API 提供了许多有用的方法来处理集合数据。常见的 API 包括： - filter()：过滤元素 - map()：将元素映射成另一种元素 - limit()：限制流中元素的数量 - sorted()：按照顺序对元素进行排序 - ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值