JAVA8新特性之Stream API

最新推荐文章于 2025-05-10 19:36:35 发布
原创 最新推荐文章于 2025-05-10 19:36:35 发布 · 464 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#stream #java

1 前言
1.1 对Stream流的个人理解：

  1. 它和IO流是不一样的；
  2. 它是对数据源（集合，数组等）进行一系列的中间操作，产生一个新的流或者说我们想要的结果，并且对数据源不产生影响。
  3. 集合讲的是数据，流讲的是计算。
    个人理解

1.2Stream流操作的三个步骤

  1. 创建Stream
  2. 中间操作：对数据源数据进行处理
  3. 终端操作：执行中间操作，并产生结果

注意： 从终端操作可以看出stream流是延迟执行的，只有执行终端操作（想要需要的结果）的时候才执行中间操作

2 下面我们对Stream的三个步骤一一说明

2.1创建Stream

/**
* 创建流
*/
@Test
public void test01(){
    /**
    * 集合流
    *  - Collection.stream() 穿行流
    *  - Collection.parallelStream() 并行流
    */
    List<String> list = new ArrayList<>();
    Stream<String> stream1 = list.stream();

    //数组流
    //Arrays.stream(array)
    String[] strings = new String[10];
    Stream<String> stream2 = Arrays.stream(strings);

    //Stream 静态方法
    //Stream.of(...)
    Stream<Integer> stream3 = Stream.of(1, 2, 3);

    //无限流
    //迭代
    Stream<Integer> stream4 = Stream.iterate(0, (i) -> ++i+i++);
    stream4.forEach(System.out::println);

    //生成
    Stream.generate(() -> Math.random())
        .limit(5)
        .forEach(System.out::println);
}

2.2中间操作

创建一个list集合，这个集合只是下面例子中用，方便区别各API的用途，可不要误会

 List<Employee> emps = Arrays.asList(
            new Employee(101, "Z3", 19, 9999.99),
            new Employee(102, "L4", 20, 7777.77),
            new Employee(103, "W5", 35, 6666.66),
            new Employee(104, "Tom", 44, 1111.11),
            new Employee(105, "Jerry", 60, 4444.44)
            new Employee(105, "Jerry", 60, 4444.44)
    );
  • filter：接收 Lambda ，从流中排除某些元素
 @Test
    public void test2() {
        emps.stream()
                .filter((emp)->emp.getAge()>20)
                .forEach(System.out::println);
    }
    
    //输出
    Employee(id=103, name=W5, age=35, salary=6666.66)
    Employee(id=104, name=Tom, age=44, salary=1111.11)
    Employee(id=105, name=Jerry, age=60, salary=4444.44)
    Employee(id=105, name=Jerry, age=60, salary=4444.44)
  • limit：截断流，使其元素不超过给定数量
  @Test
    public void test2() {
        emps.stream()
                .filter((emp)->emp.getAge()>20)
                .limit(2)
                .forEach(System.out::println);
    }
     //输出
   Employee(id=103, name=W5, age=35, salary=6666.66)
   Employee(id=104, name=Tom, age=44, salary=1111.11)
  • skip(n)：跳过元素，返回一个舍弃了前n个元素的流；若流中元素不足n个，则返回一个空流；与 limit(n) 互补
  @Test
    public void test2() {
        emps.stream()
                .filter((emp)->emp.getAge()>20)
                .limit(2)
                .skip(1)
                .forEach(System.out::println);

    }
    //输出
    Employee(id=104, name=Tom, age=44, salary=1111.11)
  • distinct：筛选，通过流所生成的 hashCode() 与 equals() 取除重复元素

     @Test
    public void test2() {
        emps.stream()
                .filter((emp)->emp.getAge()>20)
                .distinct()
                .forEach(System.out::println);

    }
//输出
Employee(id=103, name=W5, age=35, salary=6666.66)
Employee(id=104, name=Tom, age=44, salary=1111.11)
Employee(id=105, name=Jerry, age=60, salary=4444.44)
  • map：接收 Lambda ，将元素转换为其他形式或提取信息；接受一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素
 @Test
    public void test2() {
        emps.stream()
               .map((emp)->emp.getAge())
                .forEach(System.out::println);
    }
    //输出   19 20 35 44 60 60

  • flatMap（难点）：接收一个函数作为参数，将流中每一个值都换成另一个流，然后把所有流重新连接成一个流，可以看做是两层for循环

    • 个人理解：与map（）可以看做是一层for循环，flatMap（）可以看做是两层for循环

    • 例如下面例子（将两个集合合并为一个集合）

flatMap()操作的一个作用就是将两个集合合并为一个集合，相当于join操作，若没有filter操作，会产生笛卡尔积现象。

//例子中boys和stus分别是boy对象集合和stu对象集合
 List<String> collect = boys.stream().flatMap(b -> stus.stream().
                        //第二层for循环中处理数据
                                filter(s -> b.getName().equals(s.getName())).
                        //将数据放入到一个新的集合中
                                map(Student::getName)
                //结束第二层循环
        ).collect(Collectors.toList());

       //等效于
        List<String> data=new ArrayList<>();
        //双层for循环处理数据
        for (Boy boy : boys) {
            for (Student student : stus) {
                //filter条件
                if(boy.getName().equals(student.getName())){
                    //map子句，将元素放入到新集合中
                    data.add(student.getName());
                }
            }
        }
//参考网址https://www.jianshu.com/p/279967ceb45f
  • sorted()：自然排序
SortList.java

package com.concretepage;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;
public class SortList {
    public static void main(String[] args) {
        List<Student> list = new ArrayList<Student>();
        list.add(new Student(1, "Mahesh", 12));
        list.add(new Student(2, "Suresh", 15));
        list.add(new Student(3, "Nilesh", 10));

        System.out.println("---Natural Sorting by Name---");
        List<Student> slist = list.stream().sorted().collect(Collectors.toList());
        slist.forEach(e -> System.out.println("Id:"+ e.getId()+", Name: "+e.getName()+", Age:"+e.getAge()));

        System.out.println("---Natural Sorting by Name in reverse order---");
        slist = list.stream().sorted(Comparator.reverseOrder()).collect(Collectors.toList());
        slist.forEach(e -> System.out.println("Id:"+ e.getId()+", Name: "+e.getName()+", Age:"+e.getAge()));        

        System.out.println("---Sorting using Comparator by Age---");
        slist = list.stream().sorted(Comparator.comparing(Student::getAge)).collect(Collectors.toList());
        slist.forEach(e -> System.out.println("Id:"+ e.getId()+", Name: "+e.getName()+", Age:"+e.getAge()));

        System.out.println("---Sorting using Comparator by Age with reverse order---");
        slist = list.stream().sorted(Comparator.comparing(Student::getAge).reversed()).collect(Collectors.toList());
        slist.forEach(e -> System.out.println("Id:"+ e.getId()+", Name: "+e.getName()+", Age:"+e.getAge()));
    }
} 

Output *

—Natural Sorting by Name—
Id:1, Name: Mahesh, Age:12
Id:3, Name: Nilesh, Age:10
Id:2, Name: Suresh, Age:15
—Natural Sorting by Name in reverse order—
Id:2, Name: Suresh, Age:15
Id:3, Name: Nilesh, Age:10
Id:1, Name: Mahesh, Age:12
—Sorting using Comparator by Age—
Id:3, Name: Nilesh, Age:10
Id:1, Name: Mahesh, Age:12
Id:2, Name: Suresh, Age:15
—Sorting using Comparator by Age with reverse order—
Id:2, Name: Suresh, Age:15
Id:1, Name: Mahesh, Age:12
Id:3, Name: Nilesh, Age:10
  • sorted(Comparator c)：定制排序
 @Test
    public void test2() {
        emps.stream()
              .sorted((e1,e2)->{
                  if (e1.getAge().equals(e2.getAge())){
                      return e1.getName().compareTo(e2.getName());
                  } else {
                      return e1.getAge().compareTo(e2.getAge());
                  }
              })
                .limit(2)
                .forEach(System.out::println);
    }
//输出
Employee(id=101, name=Z3, age=19, salary=9999.99)
Employee(id=102, name=L4, age=20, salary=7777.77)

2.3 终端操作（中间操作可以几个中间操作API连用，而终端操作不能几个终端操作API连用，只能用一个）

  • forEach()： 遍历输出
 @Test
    public void test2() {
        emps.stream()
               .map((emp)->emp.getAge())
                .forEach(System.out::println);
    }
    //输出   19 20 35 44 60 60
  • allMatch：检查是否匹配所有元素
 @Test
    public void test2() {
        boolean b = emps.stream()
                .allMatch(e -> e.getAge() == 19);
        System.out.println(b);//不可以使用forEach(System.out::println);，因为allMatch(e -> e.getAge() == 19);属于终端操作
        
        //输出flase
    }
  • allMatch：检查是否匹配所有元素
  • anyMatch：检查是否至少匹配一个元素
  • noneMatch：检查是否没有匹配所有元素
  • findFirst：返回第一个元素
  • findAny：返回当前流中的任意元素
  • count：返回流中元素的总个数
  • max：返回流中最大值
  • min：返回流中最小值
  • reduce(T identity, BinaryOperator) / reduce(BinaryOperator) 可以将流中的数据反复结合起来，得到一个值
/**
* Java：
*  - reduce：需提供默认值（初始值）
*/
@Test
public void test01(){
    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
    Integer integer = list.stream()
        .reduce(0, (x, y) -> x + y);
    System.out.println(integer);
}
  • collect：将流转换成其他形式（如利用Collectors转化为list，set，map等好多常用API）
 @Test
    public void test2() {
        //转list集合
        List<String> collect = emps.stream()
                .map(employee -> employee.getName())
                .collect(Collectors.toList());
        System.out.println(collect);
  //输出 [Z3, L4, W5, Tom, Jerry, Jerry]
    }

//转map集合
  @Test
    public void test2() {
      
        Map<Integer, List<Employee>> collect = emps.stream()
                .collect(Collectors.groupingBy(Employee::getId));
        System.out.println(collect);

    }
    //输出（从输出可以看出，应该先去重，再转换）
    {101=[Employee(id=101, name=Z3, age=19, salary=9999.99)],
     102=[Employee(id=102, name=L4, age=20, salary=7777.77)], 
     103=[Employee(id=103, name=W5, age=35, salary=6666.66)], 
     104=[Employee(id=104, name=Tom, age=44, salary=1111.11)], 
     105=[Employee(id=105, name=Jerry, age=60, salary=4444.44), Employee(id=105, name=Jerry, age=60, salary=4444.44)]}


//总结
       @Test
    public void test2() {
        //总结
        DoubleSummaryStatistics dss = emps.stream()
                .collect(Collectors.summarizingDouble(Employee::getSalary));
        System.out.println( dss);
        System.out.println(dss.getMax());
        System.out.println(dss.getMin());
        System.out.println(dss.getSum());
        System.out.println(dss.getCount());
        System.out.println(dss.getAverage());

    }
//输出
DoubleSummaryStatistics{count=6, sum=34444.410000, min=1111.110000, average=5740.735000, max=9999.990000}
9999.99
1111.11
34444.409999999996
6
5740.735

//其他API
@Test
public void test02(){
	//放入Set
    Set<String> set = emps.stream()
        .map(Employee::getName)
        .collect(Collectors.toSet());
    set.forEach(System.out::println);

    //放入LinkedHashSet
    LinkedHashSet<String> linkedHashSet = emps.stream()
        .map(Employee::getName)
        .collect(Collectors.toCollection(LinkedHashSet::new));
    linkedHashSet.forEach(System.out::println);
}

@Test
public void test03(){
    //总数
    Long count = emps.stream()
        .collect(Collectors.counting());
    System.out.println(count);

    //平均值
    Double avg = emps.stream()
        .collect(Collectors.averagingDouble(Employee::getSalary));
    System.out.println(avg);

    //总和
    Double sum = emps.stream()
        .collect(Collectors.summingDouble(Employee::getSalary));
    System.out.println(sum);

    //最大值
    Optional<Employee> max = emps.stream()
        .collect(Collectors.maxBy((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary())));
    System.out.println(max.get());

    //最小值
    Optional<Double> min = emps.stream()
        .map(Employee::getSalary)
        .collect(Collectors.minBy(Double::compare));
    System.out.println(min.get());
}

@Test
public void test04(){
    //分组
    Map<Integer, List<Employee>> map = emps.stream()
        .collect(Collectors.groupingBy(Employee::getId));
    System.out.println(map);

    //多级分组
    Map<Integer, Map<String, List<Employee>>> mapMap = emps.stream()
        .collect(Collectors.groupingBy(Employee::getId, Collectors.groupingBy((e) -> {
            if (e.getAge() > 35) {
                return "开除";
            } else {
                return "继续加班";
            }
        })));
    System.out.println(mapMap);
    
    //分区
    Map<Boolean, List<Employee>> listMap = emps.stream()
        .collect(Collectors.partitioningBy((e) -> e.getSalary() > 4321));
    System.out.println(listMap);
}

@Test
public void test05(){
    //总结
    DoubleSummaryStatistics dss = emps.stream()
        .collect(Collectors.summarizingDouble(Employee::getSalary));
    System.out.println(dss.getMax());
    System.out.println(dss.getMin());
    System.out.println(dss.getSum());
    System.out.println(dss.getCount());
    System.out.println(dss.getAverage());
    
    //连接
    String str = emps.stream()
        .map(Employee::getName)
        .collect(Collectors.joining("-")); //可传入分隔符
    System.out.println(str);
}
  • 完结
java基础重难点（四）-stream流、IO流
qxjswl的博客
02-23 1255
Stream流的使用：首先得有一个数据源，再获取到它的Stream流，通过调用Stream流中的各种方法对数据进行处理，然后进行统计，获得最终结果。IO框架：封装了Java提供的对文件、数据进行操作的代码，对外提供了更简单的方式来对文件进行操作，对数据进行读写等。File是java.io.包下的类，File类的对象，用于代表当前操作系统的文件 (可以是文件、或文件夹)。以内存为基准，把内存中的数据以字节的形式写出到文件中去。以内存为基准，把内存中的数据以字符的形式写出到文件中去。
Java8新特性之Stream API
MOKE_SPACE
07-25 1302
概述 Stream API 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。同时它提供串行和并行两种模式进行汇聚操作，并发模式能够充分利用多核处理器的优势，使用fork/join并行方式来拆分任务和加速处理过程。总得来说，Stream API 就是提供了一种高效且易于使用的处理数据的方式。 注：需要会使用 Lambda 表达...
java8的stream中怎么对一个类里面的某个字段实现去重
米诺有糖吃
11-08 3594
java8的stream中怎么对一个类里面的某个字段实现去重
JAVA8新特性stream的几点用法
weixin_41524626的博客
12-23 356
JAVA 8新特性stream流         Java 8 API添加了一个新的抽象称为流Stream，可以让你以一种声明的方式处理数据。         Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对...
Java 8 常用Stream操作
20000_ZuuuuYao的博客
12-25 393
java8 常用Stream操作获取Stream对象stream对象操作stream匿名对象操作filter 过滤map 映射groupingBy 分组sorted 排序limit 方法用于获取指定数量的流统计&统计结果收集器 获取Stream对象 stream对象操作 public static void main(String[] args) { // 非集合 ...
JDK8特性：Stream流
mundo.wang的个人博客
11-17 1万+
这个stream流和io流是完全不同的概念。io流的工作是硬盘到内存以及内存到硬盘的操作，而stream流是针对集合的一种管道操作。类似于mybatis-plus可以简化sql操作，stream流也可以简化对集合的操作。
Java8 新特性 —— Stream API 详解
m0_74620530的博客
10-31 1745
Stream作为Java 8的一大亮点，它专门针对集合的各种操作提供各种非常便利、简单、高效的API，Stream API主要是通过Lambda表达式完成，极大的提高了程序的效率和可读性，同时Stram API中自带的并行流使得并发处理集合的门槛再次降低，使用Stream API编程无需多写一行多线程的代码就可以非常方便的写出高性能的并发程序。使用Stream API能够使代码更加优雅。
java8新特性之stream的collect实战教程
08-18
Java8新特性之Stream的Collect实战教程 Java8中引入了Stream API，它是一个功能强大且灵活的数据处理工具。Stream API提供了一个高效的方式来处理数据，特别是在处理大量数据时。Stream API的核心是collect方法，它...
精选资源
【Java面试系列】JDK 1.8 新特性之 Stream API.pdf
02-21
- **重要性**：Stream API 是 Java 8 中的重要特性之一，它结合了函数式编程的思想与现代多核处理器的优势，极大地提高了 Java 开发者的生产力。 #### 二、Stream API 的特点详解 1. **数据渠道**：Stream 是一个...
677.675.JAVA基础教程_动态代理与Java8新特性-Stream API的概述(677).rar
11-09
本教程将深入探讨两个关键的Java技术：动态代理和Java 8的新特性——Stream API。这两个主题都是现代Java开发中不可或缺的部分，它们极大地提升了代码的可读性和效率。 首先，让我们来了解一下动态代理。动态代理在...
流式接口和非流式接口的区别
m0_69134284的博客
01-21 3996
流式接口和非流式接口主要区别在于数据传输和处理的方式。流式接口适用于实时数据传输和逐步处理的场景，而非流式接口适用于数据整体传输和处理的场景。
Java 学习之路 之 File类（六十三）
12-12 719
File 类时 java.io 包下代表与平台无关的文件和目录，也就是说，如果希望在程序中操作文件和目录，都可以通过 File 类来完成。值得指出的是，不管是文件还是目录都是使用 File 来操作的，File 能新建、删除、重命名文件和目录，File 不能访问文件内容本身。如果需要访问内容本身，则需要使用输入/输出流。 1，访问文件和目录 2，文件过滤器
HTTP 1.0协议 1.1协议 流水、非流水方式
zijin-jdd的博客
11-14 8735
HTTP 1.0协议 1.1协议 流水、非流水方式
HTTP非流式请求 vs HTTP流式请求
Dontla的博客
02-26 1508
【代码】HTTP非流式请求 vs HTTP流式请求。
非流式HTTP和流式的Websocket区别
ZZU_LGY
08-25 2711
Websocket 是一种在 Web 应用程序中实现全双工、持久性连接的通信协议。它是基于 HTTP 协议构建的，但与传统的 HTTP 请求-响应模型不同。下面详细解释 Websocket 是如何实现的：1.HTTP 握手：当客户端想要与服务器建立 WebSocket 连接时，它首先发送一个普通的 HTTP 请求到服务器。这是一个特殊的 HTTP 请求，称为握手请求（Handshake Request）。该请求的头部包含了一些特定的标识信息，使服务器知道该请求是用于建立 WebSocket 连接的。
流式数据（Streaming Data）和非流式数据（Batch Data）区别、使用场景、优化-来自前端的浅解
最新发布
在全栈和前端徘徊的程序员
05-10 2269
流式数据（Streaming Data）** 和 **非流式数据（Batch Data）
手把手教你用pycharts绘制各种图（常做报表可视化的同学请进）
热门推荐
m0_49501453的博客
06-20 1万+
使用pycharts各种图绘制 安装pycharts使用 pip install pycharts==1.9.0 建议使用jupyter notebook 本图代码参考自官网，仅供学习使用 柱状图1 #数据可视化库,需要使用pip install pyecharts #官网： http://pyecharts.org/#/ import pandas as pd from pyecharts.charts import Bar bar = Bar() #pyechars需要的数据只能是Python中内置
十五、【智能体】消息节点：流式与非流式输出的比较分析
qq_40585384的博客
10-24 1881
想象一个我们使用电脑场景：当我们在copy一个很大的文件，电脑会显示“正在复制”，然后还有一个进度条。在智能体中，消息节点的作用是告知用户当前任务执行到什么阶段了，起一个提示作用。在扣子中，消息的输出支持“”和“”两种：一边进行内容生成，一边进行输出。消息看起来是一个字一个字输出的。：当消息全部接收到，然后一起输出。
Java8新特性详解：Lambda与Stream API
Java 8是Java编程语言的一个重要更新版本，其中引入了两个非常重要的特性：Lambda表达式和Stream API。这两个特性极大地改变了Java程序编写的方式，使得代码更加简洁且易于理解。 **Lambda表达式** Lambda表达式是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值