1. Toy模板网首页
  2. > Toy博客

Java8的Stream流的学习

7月前 作者：qinxun2008081 分类：Toy博客 阅读(30) 违法举报

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

一.概念理解

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中的元素用特定的连接符（没有的话，则直接连接）连接成一个字符串。文章来源地址https://www.toymoban.com/news/detail-471117.html

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]

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

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

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • Java——Stream流的peek方法

    Java Stream中的peek()方法也是用于查看每个元素，但不改变流的操作的方法。它接收一个Consumer类型的参数，该参数用于针对每个元素执行副作用操作。该方法返回一个与原始流相同的新流，因此可以进行链式操作。 使用peek()方法可以方便地在流处理过程中调试或记录某些数据

    2024年01月20日
    浏览(37)

  • Java中stream流的常见用法

    这篇文章主要是记录stream流的用法，因为stream流比较常用，并且一些操作较复杂，记录在此，以后参考。 1、filter用法 主要是用来过滤集合中的元素，较常用。 2、peek用法 主要是用来修改元素的状态，比如其中对象的字段等 3、map用法 主要是用来替换集合中的元素 4、flatma

    2024年02月12日
    浏览(49)

  • Java，SpringBoot中对Stream流的运用

    详细参考：java 1.8 stream 应用-22种案例_java1.8 流案例-CSDN博客 1. 遍历  2. 汇总

    2024年02月22日
    浏览(36)
  • Java8中Stream详细用法大全

    Java8中Stream详细用法大全

    Java 8 是一个非常成功的版本，这个版本新增的Stream，配合同版本出现的Lambda ，给我们操作集合（Collection）提供了极大的便利。Stream流是JDK8新增的成员，允许以声明性方式处理数据集合，可以把Stream流看作是遍历数据集合的一个高级迭代器。Stream 是 Java8 中处理集合的关键抽

    2023年04月08日
    浏览(68)

  • Java8 函数式编程stream流

    Java 8 中新增的特性旨在帮助程序员写出更好的代码，其中对核心类库的改进是很关键的一部分，也是本章的主要内容。对核心类库的改进主要包括集合类的 API 和新引入的流（Stream），流使程序员得以站在更高的抽象层次上对集合进行操作。下面将介绍stream流的用法。 ​场景

    2024年02月15日
    浏览(25)

  • Java8 Stream流处理树形结构数据

    参考资料 Java8新特性-使用Stream流递归实现遍历树形结构 ID为2，6，11的Menu 是 ID为1的Menu子节点 ID为3，4，5的Menu 是 ID为2的Menu子节点 💥 注意 是下面这种写法的一种更简单的写法

    2024年02月01日
    浏览(42)

  • Java8 Stream 之groupingBy 分组讲解

    本文主要讲解：Java 8 Stream之Collectors.groupingBy()分组示例 Collectors.groupingBy() 分组之常见用法 功能代码: /**      * 使用java8 stream groupingBy操作,按城市分组list      */     public void groupingByCity() {         MapString, ListEmployee map = employees.stream().collect(Collectors.groupingBy(Employee::getCi

    2024年02月13日
    浏览(35)
  • java8 Stream流常用方法（持续更新中...）

    java8 Stream流常用方法（持续更新中...）

    操作对象 模拟数据 操作 打印结果 打印结果 注意：异常自己捕捉，就比如这里String转Intger就可能出现NumberFormatException异常 打印结果 打印结果 断点查看 打印结果 断点查看 持续更新中…

    2024年04月28日
    浏览(46)

  • Java8 Stream流常见操作--持续更新中

    Java8 Stream流是一种处理数据集合的方式，它可以对集合进行一系列的操作，包括过滤、映射、排序等，从而实现对集合中元素的处理和转换。Stream流是一种惰性求值的方式，只有在需要返回结果时才会执行实际操作，这种方式可以提高程序的性能。 延迟执行：Stream流中的操作

    2024年02月11日
    浏览(48)
  • Java8的stream之groupingBy()分组排序

    Java8的stream之groupingBy()分组排序

    groupingBy()是Stream API中最强大的收集器Collector之一，提供与SQL的GROUP BY子句类似的功能。 需要指定一个属性才能使用，通过该属性执行分组。我们通过提供功能接口的实现来实现这一点 - 通常通过传递lambda表达式。 TreeMap默认按照key升序排序,collectPlan.descendingMap()可以进行降序排

    2024年02月12日
    浏览(31)

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

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

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

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

二维码1

领取红包

二维码2

领红包