Java8的Stream流的学习

最新推荐文章于 2023-06-12 15:16:47 发布
最新推荐文章于 2023-06-12 15:16:47 发布
阅读量517 收藏
点赞数
分类专栏： Java 文章标签： 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qinxun2008081/article/details/131009641
版权
本文介绍了JavaStreamAPI的基本概念和操作，包括如何从集合和数组创建流，以及流的顺序和并行处理。详细讲解了中间操作如filter、map，以及终端操作如reduce、collect等方法，展示了在处理数据时的过滤、映射、聚合和收集等操作。此外，还涵盖了Stream的其他功能，如分组、排序、连接和限制等。
摘要由CSDN通过智能技术生成

一.概念理解

Stream可以由数组或集合创建，对流的操作分为两种：

  1. 中间操作，每次返回一个新的流，可以有多个。
  2. 终端操作，每个流只能进行一次终端操作，终端操作结束后流无法再次使用。终端操作会产生一个新的集合或值。

二、Stream的创建

public class StreamDemo {
    public static void main(String[] args) {
        // 集合
        List<Integer> list = Arrays.asList(1, 2, 3);
        // 集合创建一个顺序流
        Stream<Integer> stream = list.stream();
        // 集合创建一个并行流
        Stream<Integer> parallelStream = list.parallelStream();


        // 数组
        int[] array = {1, 3, 5, 6, 8};
        // 数组创建流方式
        IntStream intStream = Arrays.stream(array);
        
    }
}

stream和parallelStream的简单区分： stream是顺序流，由主线程按顺序对流执行操作，而parallelStream是并行流，内部以多线程并行执行的方式对流进行操作，但前提是流中的数据处理没有顺序要求

三.方法学习

1、遍历/匹配（foreach/find/match）

import java.util.*;

/**
 * @author qinxun
 * @date 2023-06-02
 * @Descripion: 职工测试类
 */
public class EmployeeDemo {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        // foreach
        list.forEach(System.out::println);

        System.out.println("----------");

        //find
        Optional<Integer> firstData = list.stream().findFirst();
        System.out.println(firstData.get());

        System.out.println("----------");

        //match: anyMatch有一个匹配就返回true noneMatch没有任何匹配才返回true allMatch所有匹配才返回true
        System.out.println(list.stream().anyMatch(x -> x > 4));
    }

    /**
     * 初始化职工列表数据
     */
    private static List<Employee> initEmployee() {
        List<Employee> employeeList = new ArrayList<>();
        employeeList.add(new Employee("张三", 8, 3000.0));
        employeeList.add(new Employee("李四", 18, 5000.0));
        employeeList.add(new Employee("王五", 28, 7000.0));
        employeeList.add(new Employee("孙六", 38, 9000.0));
        return employeeList;
    }
}

执行程序返回

1
2
3
4
5
----------
1
----------
true

2、按条件匹配filter 

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

/**
 * @author qinxun
 * @date 2023-06-02
 * @Descripion: 职工测试类
 */
public class EmployeeDemo {
    public static void main(String[] args) {
        List<Employee> employeeList = initEmployee();
        // 筛选年纪大于18岁的职工
        List<Employee> employees = employeeList.stream().filter(s -> s.getAge() > 18).collect(Collectors.toList());
        System.out.println(employees);
    }

    /**
     * 初始化职工列表数据
     */
    private static List<Employee> initEmployee() {
        List<Employee> employeeList = new ArrayList<>();
        employeeList.add(new Employee("张三", 8, 3000.0));
        employeeList.add(new Employee("李四", 18, 5000.0));
        employeeList.add(new Employee("王五", 28, 7000.0));
        employeeList.add(new Employee("孙六", 38, 9000.0));
        return employeeList;
    }
}
[Employee{name='王五', age=28, salary=7000.0}, Employee{name='孙六', age=38, salary=9000.0}]

3、聚合max、min、count

import java.util.*;

/**
 * @author qinxun
 * @date 2023-06-02
 * @Descripion: 职工测试类
 */
public class EmployeeDemo {
    public static void main(String[] args) {
        List<Employee> employeeList = initEmployee();
        // 获取薪水最高的职工
        Optional<Employee> employeeOptional = employeeList.stream().max(Comparator.comparing(Employee::getSalary, Double::compareTo));
        System.out.println(employeeOptional.get());

        // 获取年级最小的职工
        Optional<Employee> employeeOptional1 = employeeList.stream().min(Comparator.comparing(Employee::getAge, Integer::compareTo));
        System.out.println(employeeOptional1.get());

        // 获取年级大于18的职工数量
        long count = employeeList.stream().filter(s -> s.getAge() > 18).count();
        System.out.println(count);
    }

    /**
     * 初始化职工列表数据
     */
    private static List<Employee> initEmployee() {
        List<Employee> employeeList = new ArrayList<>();
        employeeList.add(new Employee("张三", 8, 3000.0));
        employeeList.add(new Employee("李四", 18, 5000.0));
        employeeList.add(new Employee("王五", 28, 7000.0));
        employeeList.add(new Employee("孙六", 38, 9000.0));
        return employeeList;
    }
}

Employee{name='孙六', age=38, salary=9000.0}
Employee{name='张三', age=8, salary=3000.0}
2

4、map与flatMap

/**
 * @author qinxun
 * @date 2023-06-02
 * @Descripion: 职工测试类
 */
public class EmployeeDemo {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("a","b","c");
        // map中把小写字母转换成大写
        List<String> stringList = list.stream().map(String::toUpperCase).collect(Collectors.toList());
        // 输出[A, B, C]
        System.out.println(stringList);
    }
}
/**
 * @author qinxun
 * @date 2023-06-02
 * @Descripion: 职工测试类
 */
public class EmployeeDemo {
    public static void main(String[] args) {
        String[] arr = {"z-h-a-n-g", "s-a-n"};
        List<String> list = Arrays.asList(arr);
        System.out.println(list);
        // 将两个字符数组合并成一个新的字符数组
        List<String> collect = list.stream().flatMap(x -> {
            String[] array = x.split("-");
            return Arrays.stream(array);
        }).collect(Collectors.toList());
        System.out.println(collect);
    }
}
[z-h-a-n-g, s-a-n]
[z, h, a, n, g, s, a, n]

5、规约reduce 

归约，也称缩减，顾名思义，是把一个流缩减成一个值，能实现对集合求和、求乘积和求最值操作。

import java.util.*;

/**
 * @author qinxun
 * @date 2023-06-02
 * @Descripion: 职工测试类
 */
public class EmployeeDemo {
    public static void main(String[] args) {
        List<Employee> list = initEmployee();
        // 求所有工资的和
        Double sum = list.stream().map(Employee::getSalary).reduce(0.0, Double::sum);
        System.out.println(sum);

        // 求职工工资最大值
        Optional<Double> max = list.stream().map(Employee::getSalary).reduce((a, b) -> a > b ? a : b);
        System.out.println(max.get());
    }

    /**
     * 初始化职工列表数据
     */
    private static List<Employee> initEmployee() {
        List<Employee> employeeList = new ArrayList<>();
        employeeList.add(new Employee("张三", 8, 3000.0));
        employeeList.add(new Employee("李四", 18, 5000.0));
        employeeList.add(new Employee("王五", 28, 7000.0));
        employeeList.add(new Employee("孙六", 38, 9000.0));
        return employeeList;
    }
}

24000.0
9000.0

6、收集（toList、toSet、toMap）

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

/**
 * @author qinxun
 * @date 2023-06-02
 * @Descripion: 职工测试类
 */
public class EmployeeDemo {
    public static void main(String[] args) {
        List<Employee> list = initEmployee();
        // 返回名字做为key,工资做为value的map数据
        Map<String, Double> employeeMap = list.stream().collect(Collectors.toMap(Employee::getName, Employee::getSalary));
        System.out.println(employeeMap);

        // 职工名字集合
        List<String> employeeNameList = list.stream().map(Employee::getName).collect(Collectors.toList());
        System.out.println(employeeNameList);

        // 职工年龄集合
        Set<Integer> ageSet = list.stream().map(s -> s.getAge()).collect(Collectors.toSet());
        System.out.println(ageSet);
    }

    /**
     * 初始化职工列表数据
     */
    private static List<Employee> initEmployee() {
        List<Employee> employeeList = new ArrayList<>();
        employeeList.add(new Employee("张三", 8, 3000.0));
        employeeList.add(new Employee("李四", 18, 5000.0));
        employeeList.add(new Employee("王五", 28, 7000.0));
        employeeList.add(new Employee("孙六", 38, 9000.0));
        return employeeList;
    }
}
{李四=5000.0, 张三=3000.0, 王五=7000.0, 孙六=9000.0}
[张三, 李四, 王五, 孙六]
[18, 38, 8, 28]

7、collect

Collectors提供了一系列用于数据统计的静态方法：

  1. 计数：count
  2. 平均值：averagingInt、averagingLong、averagingDouble
  3. 最值：maxBy、minBy
  4. 求和：summingInt、summingLong、summingDouble
  5. 统计以上所有：summarizingInt、summarizingLong、summarizingDouble
import java.util.*;
import java.util.stream.Collectors;

/**
 * @author qinxun
 * @date 2023-06-02
 * @Descripion: 职工测试类
 */
public class EmployeeDemo {
    public static void main(String[] args) {
        List<Employee> employeeList = initEmployee();

        // 统计职工人数
        Long count = employeeList.stream().collect(Collectors.counting());
        System.out.println(count);

        // 获取职工最高工资
        Optional<Double> salaryOptional = employeeList.stream().map(Employee::getSalary).collect(Collectors.maxBy((s1, s2) -> s1.compareTo(s2)));
        System.out.println(salaryOptional);

        // 获取职工平均工资
        Double averageSalary = employeeList.stream().collect(Collectors.averagingDouble(Employee::getSalary));
        System.out.println(averageSalary);

        //一次性统计职工所有工资信息
        DoubleSummaryStatistics summaryStatistics = employeeList.stream().collect(Collectors.summarizingDouble(Employee::getSalary));
        System.out.println(summaryStatistics);
    }

    /**
     * 初始化职工列表数据
     */
    private static List<Employee> initEmployee() {
        List<Employee> employeeList = new ArrayList<>();
        employeeList.add(new Employee("张三", 8, 3000.0));
        employeeList.add(new Employee("李四", 18, 5000.0));
        employeeList.add(new Employee("王五", 28, 7000.0));
        employeeList.add(new Employee("孙六", 38, 9000.0));
        return employeeList;
    }
}
4
Optional[9000.0]
6000.0
DoubleSummaryStatistics{count=4, sum=24000.000000, min=3000.000000, average=6000.000000, max=9000.000000}

8、分组(partitioningBy/groupingBy)

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

/**
 * @author qinxun
 * @date 2023-06-02
 * @Descripion: 职工测试类
 */
public class EmployeeDemo {
    public static void main(String[] args) {
        List<Employee> employeeList = initEmployee();

        // 将员工按薪资是否高于7000分组
        Map<Boolean, List<Employee>> map = employeeList.stream().collect(Collectors.partitioningBy(s -> s.getSalary() > 7000));
        System.out.println(map);

        // 将职工按性别分组
        Map<String, List<Employee>> employeeMap = employeeList.stream().collect(Collectors.groupingBy(Employee::getSex));
        System.out.println(employeeMap);
    }

    /**
     * 初始化职工列表数据
     */
    private static List<Employee> initEmployee() {
        List<Employee> employeeList = new ArrayList<>();
        employeeList.add(new Employee("张三", 8, "男", 3000.0));
        employeeList.add(new Employee("李四", 18, "女", 5000.0));
        employeeList.add(new Employee("王五", 28, "男", 7000.0));
        employeeList.add(new Employee("孙六", 38, "女", 9000.0));
        return employeeList;
    }
}
{false=[Employee{name='张三', age=8, salary=3000.0}, Employee{name='李四', age=18, salary=5000.0}, Employee{name='王五', age=28, salary=7000.0}], true=[Employee{name='孙六', age=38, salary=9000.0}]}
{女=[Employee{name='李四', age=18, salary=5000.0}, Employee{name='孙六', age=38, salary=9000.0}], 男=[Employee{name='张三', age=8, salary=3000.0}, Employee{name='王五', age=28, salary=7000.0}]}

9、接合joining 

joining可以将stream中的元素用特定的连接符（没有的话，则直接连接）连接成一个字符串。

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

/**
 * @author qinxun
 * @date 2023-06-02
 * @Descripion: 职工测试类
 */
public class EmployeeDemo {
    public static void main(String[] args) {
        List<Employee> employeeList = initEmployee();

        // 将职工姓名用逗号拼接返回
        String nameData = employeeList.stream().map(Employee::getName).collect(Collectors.joining(","));
        System.out.println(nameData);
    }

    /**
     * 初始化职工列表数据
     */
    private static List<Employee> initEmployee() {
        List<Employee> employeeList = new ArrayList<>();
        employeeList.add(new Employee("张三", 8, "男", 3000.0));
        employeeList.add(new Employee("李四", 18, "女", 5000.0));
        employeeList.add(new Employee("王五", 28, "男", 7000.0));
        employeeList.add(new Employee("孙六", 38, "女", 9000.0));
        return employeeList;
    }
}
张三,李四,王五,孙六

10、排序sorted

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

/**
 * @author qinxun
 * @date 2023-06-02
 * @Descripion: 职工测试类
 */
public class EmployeeDemo {
    public static void main(String[] args) {
        List<Employee> employeeList = initEmployee();

        // 将职工工资升序排序
        List<Employee> employees = employeeList.stream().sorted(Comparator.comparing(Employee::getSalary)).collect(Collectors.toList());
        System.out.println(employees);

        // 将职工工资降序排序
        List<Employee> list = employeeList.stream().sorted(Comparator.comparing(Employee::getSalary).reversed()).collect(Collectors.toList());
        System.out.println(list);
    }

    /**
     * 初始化职工列表数据
     */
    private static List<Employee> initEmployee() {
        List<Employee> employeeList = new ArrayList<>();
        employeeList.add(new Employee("张三", 8, "男", 3000.0));
        employeeList.add(new Employee("李四", 18, "女", 5000.0));
        employeeList.add(new Employee("王五", 28, "男", 7000.0));
        employeeList.add(new Employee("孙六", 38, "女", 9000.0));
        return employeeList;
    }
}
[Employee{name='张三', age=8, salary=3000.0}, Employee{name='李四', age=18, salary=5000.0}, Employee{name='王五', age=28, salary=7000.0}, Employee{name='孙六', age=38, salary=9000.0}]
[Employee{name='孙六', age=38, salary=9000.0}, Employee{name='王五', age=28, salary=7000.0}, Employee{name='李四', age=18, salary=5000.0}, Employee{name='张三', age=8, salary=3000.0}]

11、提取/组合

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @author qinxun
 * @date 2023-06-02
 * @Descripion: 职工测试类
 */
public class EmployeeDemo {
    public static void main(String[] args) {
        String[] arr1 = {"a", "b", "c", "d"};
        String[] arr2 = {"d", "e", "f", "g"};
        Stream<String> stream1 = Stream.of(arr1);
        Stream<String> stream2 = Stream.of(arr2);

        // 合并流
        List<String> newList = Stream.concat(stream1, stream2).distinct().collect(Collectors.toList());
        System.out.println(newList);

        // 限制从流中获得前1个数据
        System.out.println(Stream.of(arr1).limit(1).collect(Collectors.toList()));

        // 跳过前2个数据
        System.out.println(Stream.of(arr1).skip(2).collect(Collectors.toList()));
    }
}
[a, b, c, d, e, f, g]
[a]
[c, d]

qinxun2008081
关注
专栏目录
java8实战读书笔记：初识Stream、流的基本操作（流计算）
01-07
本文是博主在学习《java8实战》的一些学习笔记。 从本节开始，将进入到java8 Stream(流)的学习中来。 本文中的部分示例基于如下场景：餐厅点菜，Dish为餐厅中可提供的菜品，Dish的定义如下： 1public class Dish { 2    /** 菜品名称 */ 3    private final String name; 4    /** 是否是素食 */ 5    private final boolean vegetarian; 6    /** 含卡路里 */ 7    private final int calories; 8    /** 类型 */ 9  
Java 8 流（Stream）学习
weixin_47724183的博客
07-22 125
流（Stream） Java 8 API添加了一个新的抽象称为流Stream，可以让你以一种声明的方式处理数据。 Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合 运算和表达的高阶抽象。 Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。 这种风格将要处理的元素集合看作一种流， 流在管道中传输， 并且可以在管道的节点上进行处理， 比如筛选， 排序，聚合等。 元素流在管道中经过中间操作（interme
Java8之Stream流的学习
mikelv01的博客
06-17 216
手把手带你体验Stream流 最近在项目上用的挺多 Stream API 的，只是觉得用的很爽！可是不太了解它的原理。今天偶然在收集 gateway 的技术方案的时候看到了 3y 的文章，不错学习下！ 3y 理解的Stream流编程就是：某些场景会经常用到操作(求和/去重/过滤….等等)，已经封装好API给你了，你自己别写了，调我给你提供的API就好了。 1.支持并发 回到我们最原始的代码： public static void main(String[] args) { int[] nums
java8Stream流学习
qs_266的博客
04-25 380
此文为学习https://mp.weixin.qq.com/s/SvnaXF_GMH21IrOnoZepLg大佬文章的笔记
java 8 stream流学习笔记
qq_39324627的博客
08-21 184
public class StreamTest { public static void main(String[] args) { Random random = new Random(); System.out.println("===使用forEach打印5个随机数并排序==="); random.ints().limit(5)....
Java8 Stream学习
01-05
### Java8 Stream学习 #### 一、Stream简介 在Java8中，Stream 是一项重要的新增特性，它提供了一种全新的处理集合数据的方式。不同于传统的集合类（如List、Set等），Stream API支持更加灵活的数据处理方式，使得...
java8 stream 由一个list转化成另一个list案例
08-24
今天，我们学习了如何使用 Java8 Stream 将一个 List 转化成另一个 List，同时还学习了一些其他的应用，例如使用 Stream().forEach() 循环处理 List、使用 Stream().map() 处理 List，并给另外一个 List 赋值、使用 ...
Java8中Stream使用的一个注意事项
08-28
Java 8 中的 Stream 是一个强大的工具，它引入了一种新的数据处理方式，特别是对于集合对象的操作。Stream 不是存储数据的数据结构，而是用于处理数据的 API，它提供了丰富的操作，如过滤、映射、聚合等，使得代码...
Java8新特性之方法引用&Stream流应用实例md，学习代码
最新发布
06-21
以上就是关于Java 8方法引用和Stream流的基本介绍及其应用实例。理解并熟练运用这两个特性，能让你的Java代码变得更加简洁、高效。在实际项目中，如Tomcat服务器的配置、Cookie、Session与Web存储的管理等方面，都...
Java8特性Stream流的使用（学完就会，项目源码，附带个人总结）
09-09
以下将详细介绍Stream流的使用，以及它在Java8中的重要性。 首先，Stream API是一种用于处理集合的新接口，它可以对集合进行各种操作，如过滤、映射、聚合等，而无需显式地遍历集合。这种处理方式称为“函数式编程...
Java 8 流的学习总结
Daz_M的博客
07-04 185
1、首先谈谈什么是流？ 流是从支持数据处理操作的源中生成的元素序列。 拆分理解这句话： 元素序列：流提供了一个接口，可以访问特定元素类型的一组有序值； 源：被处理的数据，从有序集合生成流时会保留原有的顺序；由列表生成的流，其元素顺序和列表一致； 数据处理操作：与数据库操作类似，流操作可以顺序执行，也可以并行执行； 流水线：很多流操作本身会返回一个流，这样多个操作就可以链接起来，形成一条...
Java8的Stream流学习总结
Masterheaven的博客
05-24 163
什么是 Stream？ Stream（流）是一个来自数据源的元素队列并支持聚合操作 元素是特定类型的对象，形成一个队列。 Java中的Stream并不会存储元素，而是按需计算。 数据源 流的来源。 可以是集合，数组，I/O channel， 产生器generator 等。 聚合操作 类似SQL语句一样的操作， 比如filter, map, reduce, find, match, sorted等。 和以前的Collection操作不同， Stream操作还有两个基础的特征： Pipelining: 中
JAVA流的基本操作
m0_53029821的博客
06-12 1999
1.由值创建流//由值创建//流构造器创建2.数组、列表、文件创建//由数组创建流//由列表创建流//由文件创建。
Java 操作数组的流
Aseveng的博客
10-16 869
package io.p6.bytestream; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.IOException; public class byteArrayStreamDemo { public static void main(String[]
【Java学习】Stream流操作集合数组(31)
Prodigal
02-11 5962
Stream流 用来操作数组和集合中的元素,对容器中的元素,进行一系列的流水线式的中间操作,过滤筛选切片,不会对原数据做任何的改变,只是得到一个(持有结果的)新流. 创建Stream串行流,单线程 List&lt;Integer&gt; integers = Arrays.asList(10, 20, 50, 40, 30); Stream&lt;Integer&gt; str...
java流操作
王文萱的博客
01-06 1875
java流创建&基础操作【带有代码示例】
8种方法在java8中创建流对象(Stream)
长河的博客
10-23 1万+
8种方法在java8中创建流对象(Stream) 0. 创建空的Stream empty()方法用来创建一个空的流 Stream<String> stream = Stream.empty(); stream.forEach(System.out::println); 这个方法经常被用在创建一个不含元素的空的流进行返回,避免返回null public Str...
Java8的 Stream 流学习与使用总结
weixin_43927773的博客
09-02 686
1. Stream 流介绍 Stream的原理：将要处理的元素看做一种流，流在管道中传输，并且可以在管道的节点上处理，包括过滤筛选、去重、排序、聚合等。元素流在管道中经过中间操作的处理，最后由最终操作得到前面处理的结果。 Stream 流的使用总是按照一定的步骤进行，可以抽象出下面的使用流程。 数据源 -> 数据处理/转换-> 结果处理 1.1. 数据源 数据源也就是数据的来源，可以通过多种方式获得 Stream 数据源，下面列举几种常见的获取方式。 • Collection.stream();
JDK8 新特性流式数据处理
热门推荐
不能说的秘密的博客
10-28 2万+
在学习JDK8新特性Optional类的时候，提到对于Optional的两个操作映射和过滤设计到JDK提供的流式出来。这篇文章便详细的介绍流式处理
Java8 Stream流操作详解
"JavaStream流是Java8引入的新特性，配合Lambda表达式，为集合操作提供了高效且简洁的方式。Stream不存储数据，而是通过中间操作定义处理逻辑，并在终端操作时执行。它具有延迟执行和不可变性，常用于数据过滤、排序...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

qinxun2008081

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

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

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

打赏作者

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

抵扣说明：

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

余额充值