Java常用新特性之Stream API

最新推荐文章于 2024-08-22 21:27:15 发布
最新推荐文章于 2024-08-22 21:27:15 发布
阅读量637 收藏 8
点赞数 29
分类专栏： Java 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52828297/article/details/137190854
版权
本文介绍了JavaStreamAPI的概念，包括其与集合框架的关系，创建Stream的方式，以及Stream的中间操作（如筛选、映射、排序）、终止操作（如匹配、计数、归约和收集）和并行流的特点。文章强调了Stream的简洁性、延迟执行和性能提升，同时提到了可能遇到的限制和调试挑战。
摘要由CSDN通过智能技术生成

一， 认识Stream

1. Stream API vs 集合框架
  • Stream API 之于 集合 就类似于SQL 之于 数据表。
  • 集合：存储数据，基于内存的。
  • Stream API :处理数据，基于CPU的
3. 使用说明

①Stream 自己不会存储元素。
②Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。
③Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。即一旦执行终止操作，就执行中间操作链，并产生结果。
④ Stream一旦执行了终止操作，就不能再调用其它中间操作或终止操作了。

4. Stream 执行流程

步骤1：创建 Stream 的对象
步骤2：执行一系列的中间操作
步骤3：执行一个终止操作
如图：在这里插入图片描述

开始之前我们先建立两个类以便后续使用

首先建立一个 Employee 类
/**
 * @author liuchaoxu
 * @date 2024年03月31日 9:02
 */
public class Employee {

	private int id;
	private String name;
	private int age;
	private double salary;

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public double getSalary() {
		return salary;
	}

	public void setSalary(double salary) {
		this.salary = salary;
	}

	public Employee() {
		System.out.println("Employee().....");
	}

	public Employee(int id) {
		this.id = id;
	}

	public Employee(int id, String name) {
		this.id = id;
		this.name = name;
	}

	public Employee(int id, String name, int age, double salary) {

		this.id = id;
		this.name = name;
		this.age = age;
		this.salary = salary;
	}

	@Override
	public String toString() {
		return "Employee{" + "id=" + id + ", name='" + name + '\'' + ", age=" + age + ", salary=" + salary + '}';
	}

	@Override
	public boolean equals(Object o) {
		if (this == o)
			return true;
		if (o == null || getClass() != o.getClass())
			return false;

		Employee employee = (Employee) o;

		if (id != employee.id)
			return false;
		if (age != employee.age)
			return false;
		if (Double.compare(employee.salary, salary) != 0)
			return false;
		return name != null ? name.equals(employee.name) : employee.name == null;
	}

	@Override
	public int hashCode() {
		int result;
		long temp;
		result = id;
		result = 31 * result + (name != null ? name.hashCode() : 0);
		result = 31 * result + age;
		temp = Double.doubleToLongBits(salary);
		result = 31 * result + (int) (temp ^ (temp >>> 32));
		return result;
	}
}
然后提供一个生成数据的 EmployeeData 类
public class EmployeeData {
	
	public static List<Employee> getEmployees(){
		List<Employee> list = new ArrayList<>();
		
		list.add(new Employee(1001, "马化腾", 34, 6000.38));
		list.add(new Employee(1002, "马云", 2, 19876.12));
		list.add(new Employee(1003, "刘强东", 33, 3000.82));
		list.add(new Employee(1004, "雷军", 26, 7657.37));
		list.add(new Employee(1005, "李彦宏", 65, 5555.32));
		list.add(new Employee(1006, "比尔盖茨", 42, 9500.43));
		list.add(new Employee(1007, "任正非", 26, 4333.32));
		list.add(new Employee(1008, "扎克伯格", 35, 2500.32));
		
		return list;
	}
	
}

二，创建Stream的三种方式

方式一：通过集合
    @Test
    public void test1(){

//        default Stream<E> stream() : 返回一个顺序流
        List<Employee> list = EmployeeData.getEmployees();
        Stream<Employee> stream = list.stream();

//        default Stream<E> parallelStream() : 返回一个并行流
        Stream<Employee> stream1 = list.parallelStream();

    }
方式二：通过数组
    @Test
    public void test2(){
        //调用Arrays类的static <T> Stream<T> stream(T[] array): 返回一个流
        int[] arr = new int[]{2,3,4,5,6,7,4,32};
        IntStream stream = Arrays.stream(arr);

        Integer[] arr1 = new Integer[]{234,2,2,45,32,32,34};
        Stream<Integer> stream1 = Arrays.stream(arr1);

    }
方式三：通过Stream的of()
    @Test
    public void test3(){
        Stream<Integer> stream = Stream.of(23, 3, 432, 53, 23);

        Employee emp1 = new Employee(1001, "马化腾", 34, 6000.38);
        Employee emp2 = new Employee(1003, "刘强东", 33, 3000.82);
        Stream<Employee> stream1 = Stream.of(emp1, emp2);
    }

三，Stream的中间操作

负责对Stream进行处理操作，并返回一个新的Stream对象，中间操作可以进行叠加。
在这里插入图片描述

测试Stream的中间操作
/**
 * @author liuchaoxu
 * @date 2024年03月31日 9:30
 */
public class StreamAPITest1 {

    //1-筛选与切片
    @Test
    public void test1() {
        List<Employee> list = EmployeeData.getEmployees();
//        filter(Predicate p)——接收 Lambda ， 从流中排除某些元素。
        //练习：查询员工表中薪资大于7000的员工信息
        Stream<Employee> stream = list.stream();
//        stream.filter(emp -> emp.getSalary() > 7000).forEach(emp -> System.out.println(emp));
        stream.filter(emp -> emp.getSalary() > 7000).forEach(System.out::println);
        //或
//        stream.filter(new Predicate<Employee>() {
//            @Override
//            public boolean test(Employee employee) {
//                return employee.getSalary() > 7000;
//            }
//        }).forEach(new Consumer<Employee>() {
//            @Override
//            public void accept(Employee employee) {
//                System.out.println(employee);
//            }
//        });

        System.out.println();
//        limit(n)——截断流，使其元素不超过给定数量。
        list.stream().limit(5).forEach(System.out::println);

        System.out.println();
//        skip(n) —— 跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补
        list.stream().skip(5).forEach(System.out::println);

        System.out.println();
//        distinct()——筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素
        list.add(new Employee(1009,"张一鸣",40,8000));
        list.add(new Employee(1009,"张一鸣",40,8000));
        list.add(new Employee(1009,"张一鸣",40,8000));
        list.add(new Employee(1009,"张一鸣",40,8000));

        list.stream().distinct().forEach(System.out::println);

    }

    //2-映射
    @Test
    public void test2() {
        //map(Function f)——接收一个函数作为参数，将元素转换成其他形式或提取信息，该函数会被应用到每个元素上，并将其映射成一个新的元素。
        //练习：转换为大写
        List<String> list = Arrays.asList("aa", "bb", "cc", "dd");
//        list.stream().map(str -> str.toUpperCase()).forEach(System.out::println);
        list.stream().map(String :: toUpperCase).forEach(System.out::println);

        //练习：获取员工姓名长度大于3的员工。
        List<Employee> list1 = EmployeeData.getEmployees();
        Stream<Employee> stream = list1.stream();
        stream.filter(emp -> emp.getName().length() > 3).forEach(System.out::println);

        //练习：获取员工姓名长度大于3的员工的姓名。
        Stream<Employee> stream1 = list1.stream();
//        stream1.filter(emp -> emp.getName().length() > 3).map(emp -> emp.getName()).forEach(System.out::println);
//        stream1.filter(emp -> emp.getName().length() > 3).map(Employee::getName).forEach(System.out::println);
        stream1.map(emp -> emp.getName()).filter(name -> name.length() > 3).forEach(System.out::println);

    }

    //3-排序
    @Test
    public void test3() {
        //sorted()——自然排序
        Integer[] arr = new Integer[]{345,3,64,3,46,7,3,34,65,68};
        String[] arr1 = new String[]{"GG","DD","MM","SS","JJ"};

        Stream<Integer> stream = Arrays.stream(arr);
        stream.sorted().forEach(System.out::println);

        Stream<String> stream1 = Arrays.stream(arr1);
        System.out.println();
        stream1.sorted().forEach(System.out::println);

        System.out.println();

        //sorted(Comparator com)——定制排序
        Arrays.stream(arr1).sorted((s1,s2) -> -s1.compareTo(s2)).forEach(System.out::println);


    }
}

四，Stream的终止操作

顾名思义，通过终止操作之后，Stream流将会结束，最后可能会执行某些逻辑处理，或者是按照要求返回某些执行后的结果数据。
在这里插入图片描述

测试Stream的终止操作
/**
 * @author liuchaoxu
 * @date 2024年03月31日 9:48
 */
public class StreamAPITest2 {

    //1-匹配与查找
    @Test
    public void test1(){
        List<Employee> list = EmployeeData.getEmployees();
//        allMatch(Predicate p)——检查是否匹配所有元素。
//          练习：是否所有的员工的年龄都大于18
        Stream<Employee> stream = list.stream();
        System.out.println(stream.allMatch(emp -> emp.getAge() > 18));


//        anyMatch(Predicate p)——检查是否至少匹配一个元素。
//         练习：是否存在员工的工资大于 10000
        Stream<Employee> stream1 = list.stream();
        System.out.println(stream1.anyMatch(emp -> emp.getSalary() > 10000));

//        findFirst——返回第一个元素
        Optional<Employee> optional = list.stream().findFirst();
        //Optional类可以避免空指针，这是jdk8的新特性后续文章中我会讲到
        System.out.println(optional.get());
    }

    @Test
    public void test2(){
        List<Employee> list = EmployeeData.getEmployees();
        // count——返回流中元素的总个数
        Stream<Employee> stream = list.stream();
        System.out.println(stream.filter(emp -> emp.getSalary() > 8000).count());

//        max(Comparator c)——返回流中最大值
//        练习：返回最高的工资
//        Optional<Double> optional1 = list.stream().max((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary())).map(emp -> emp.getSalary());
//        Optional<Double> optional1 = list.stream().max((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary())).map(Employee::getSalary);
        Optional<Double> optional1 = list.stream().map(Employee::getSalary).max((salary1, salary2) -> Double.compare(salary1, salary2));
        System.out.println(optional1.get());


//        min(Comparator c)——返回流中最小值
//        练习：返回最低工资的员工
        Optional<Employee> optional = list.stream().min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
        System.out.println(optional.get());


//        forEach(Consumer c)——内部迭代
        list.stream().forEach(System.out::println);

    }

    /*
    * 集合中新增了遍历的方法
    * */
    @Test
    public void test0(){
        List<Employee> list = EmployeeData.getEmployees();
//        list.forEach(System.out::println);
        list.forEach( emp -> {
            System.out.println(emp);
            //...
        });
    }

    //2-归约
    @Test
    public void test3(){
//        reduce(T identity, BinaryOperator)——可以将流中元素反复结合起来，得到一个值。返回 T
//        练习1：计算1-10的自然数的和
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        System.out.println(list.stream().reduce(0, (x1, x2) -> x1 + x2));


//        reduce(BinaryOperator) ——可以将流中元素反复结合起来，得到一个值。返回 Optional<T>
//        练习2：计算公司所有员工工资的总和
        List<Employee> employees = EmployeeData.getEmployees();
//        Optional<Double> sumSalary = employees.stream().map(emp -> emp.getSalary()).reduce((salary1, salary2) -> Double.sum(salary1, salary2));
        Optional<Double> sumSalary = employees.stream().map(Employee::getSalary).reduce(Double :: sum);
        System.out.println(sumSalary.get());


    }

    //3-收集
    @Test
    public void test4(){
//        collect(Collector c)——将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法
//        练习1：查找工资大于6000的员工，结果返回为一个List或Set
        List<Employee> list = EmployeeData.getEmployees();
        List<Employee> filterList = list.stream().filter(emp -> emp.getSalary() > 6000).collect(Collectors.toList());
        filterList.forEach(System.out::println);

        System.out.println();
//        练习2：按照员工的年龄进行排序，返回到一个新的List中
        List<Employee> sortList = list.stream().sorted((emp1, emp2) -> Integer.compare(emp1.getAge(), emp2.getAge())).collect(Collectors.toList());
        sortList.forEach(System.out::println);

    }
}

五，并行Stream说明

运行机制：

在这里插入图片描述
使用并行流，可以有效利用计算机的多CPU硬件，提升逻辑的执行速度。并行流通过将一整个stream划分为多个片段，然后对各个分片流并行执行处理逻辑，最后将各个分片流的执行结果汇总为一个整体流。

并行流存在什么限制？

在并行流终止执行的函数逻辑，必须要保证线程安全。并行流类似于多线程在并行处理，所以与多线程场景相关的一些问题同样会存在，比如死锁等问题。

六，Stream 的优势和缺点

优势：

  • 代码简洁、声明式的编码风格，更容易体现出代码的逻辑
  • 逻辑解耦，一个stream中间处理逻辑，无需关注上游与下游的内容，只需要按约定实现自身逻辑即可，
    并行流场景效率会比迭代器逐个循环更高
  • 避免一些中间不必要的操作消耗，得益于函数式接口，延迟执行的特性，中间操作不管有多少步骤都不会立即执行，只有遇到终止操作的时候才会开始执行

缺点

  • 不方便debug并非无法debug
  • Stream API的使用需要一段时间来熟悉，相对传统写法变化较大，一但适应绝对爱不释手
    debug提示：
    在这里插入图片描述

至此关于Stream的基本内容以及使用方法已经讲述完了，希望对你有所帮助！

Liu-Chao Xu
关注
专栏目录
Java8新特性-Stream对集合进行操作的常用API
BADAO_LIUMANG_QIZHI的博客
07-30 1610
Java8扩展了集合类，可以通过Collection.stream()或者Collection.parallelStream()来创建一个Stream。利用Stream，在对集合比如list进行处理时就不用再进行繁琐的循环遍历操作了。比如遍历一个对象list并输出每个的年龄属性注博客关注公众号霸道的程序猿获取编程相关电子书、教程推送与免费下载。...
JAVA8新特性之StreamAPI（三）
Fjtd_2019的博客
03-09 580
继之前了解了StreamAPI的创建以及中间操作后，今天主要说一下StreamAPI的最后一步，也就是终止操作。 终止操作主要有查找与匹配，以及归约与收集，这些操作很像我们平时的sql操作，也比较好理解。 首先看看查找与匹配，有这样几种操作： allMatch-检查是否匹配所有元素 anyMatch-检查是否至少匹配一个元素 noneMatch-检查是否没有匹配所有元素 findFirst-返回第...
Java Stream(流)API的概述
weixin_52629592的博客
12-28 328
一.Stream API的说明 Stream是Java 8 中处理集合的关键抽象概念,它可以指定你希望对集合进行的操作,可以执行非常复杂的查找,过滤和映射等操作 使用Stream API对集合数据进行操作,就类似于使用SQl执行的数据库查询,也可以使用Stream API来并行执行操作,简言之.Stream API提供了一种高效且易于使用的处理数据的方式 二.为什么要使用Stream API? 实际的开发过程中,项目中的多数数据源都来自于MySql,Oracle等,但现在数据源可以
【JAVA】Stream API 详解
最新发布
weixin_37559642的博客
08-22 754
Stream API 详解
Java8新特性：StreamAPI（超详解）
weixin_52533007的博客
03-31 9212
用于操作数据源（集合、数组等）所生成的元素序列。“集合讲的是数据，Stream讲的是计算！Stream关注的是对数据的运算，与CPU打交道，集合关注的是数据的存储，与内存打交道。Stream 自己不会存储元素。Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。
Java进阶-Java Stream API详解与使用
踏雨歌青春，诗酒趁年华
04-28 9674
本文全面介绍了 Java Stream API 的概念、功能以及如何在 Java 中有效地使用它进行集合和数据流的处理。通过详细解释和示例，文章展示了 Java Stream API 在简化代码、提高效率以及支持函数式编程方面的优势。文中还比较了 Java Stream API 与其他集合处理库的异同，强调了其在现代 Java 开发中的重要性和实用性。
java Stream类的 超全API及实战总结
qq_25720801的博客
07-20 1407
【代码】java Stream类的 超全API及实战总结。
【Java系列】深入解析Stream API
热门推荐
颜淡慕潇
06-23 2万+
Stream API是Java 8中最重要的新特性之一，它提供了一种简单、灵活和可读的方式来处理集合和数组中的元素，使得代码更加简洁、高效和易于维护。
Java8新特性-Stream API 常用完整版
胡啊呦的博客
06-18 1万+
流（Stream） 1. 流的概念 2. 流的操作步骤 2.1. 创建Stream 2.1.1 通过Collection 系列集合提供的串行流：stream()、并行流： paralleStream() 2.1.2 通过Arrays中的静态方法stream(T[] array) 获取数组流 2.1.3 通过Stream类中的静态方法 of() 2.1.4 使用Stream类的静态方法 iter...
java8新特性_day04_(Stream,过滤器,常用API)
06-23
该文件中包括java8学习的第四天内容，前面三天内容在以博客形式发布
Java8新特性Stream流api实用的一些封装
m0_56471151的博客
03-24 1310
对Java Stream API进行一些简单的封装功能介绍List分组根据字段简单分组简单分组测试选择返回字段分组选择返回字段分组测试合并结果集分组合并结果集分组测试分组后对结果集进行处理测试分组后统计每组的数量测试对List的操作List的排序1. 单字段排序多字段排序排序测试从List中查找最大/最小值的元素测试合并List中某个属性值, 计算 总数/平均数测试List统计数据测试List转换为Map如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居
Java中的Stream API详解
m0_73467713的博客
08-17 1384
Stream API是一种处理集合的高级抽象。它能够提供一种声明性的方法来处理数据集合（例如ListSet和Map），并且支持函数式编程的风格。Stream的主要目的是让你以声明性风格处理数据集，而不是以传统的命令式风格。Stream API在Java中提供了一种强大且灵活的方式来处理数据集合。通过使用Stream API，可以编写更加简洁和可维护的代码，并利用流的并行处理能力提升性能。然而，在使用Stream API时，也需要关注性能和资源的使用，确保代码的高效和稳定。
Java中的Stream API简述
唯有努力，方可自信！
05-23 1万+
Java中的Stream API 你真正了解过吗？
Java- Stream API
Adam586007的博客
04-16 1287
目录 Stream Api 特点 一、Stream 实例化 三种方式 二 、中间操作 1.筛选与切片 是的 筛选与切片 筛选与切片 映射 排序 三、终止操作 匹配与查找 归约 收集 四、Optional Stream Api 特点 * 使用 Stream API 对集合数据进行操作，就类似于使用SQL执行的数据库查询。 * 也可以使用Strem API 来并行执行操作。 * Stream API 提供一种高效且易于使...
java 新特性之 Stream API
MeiLiCongLin的博客
10-23 468
toList List 把流中元素收集到List List emps= list.stream().collect(Collectors.toList());filter(Predicate p) 接收 Lambda ， 从流中排除某些元素 distinct() 筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素 limit(long maxSize) 截断流，使其元素不超过给定数量 skip(long n) 跳过元素，返回一个扔掉了前 n 个元素的流。
java中stream的常用API
weixin_57279728的博客
08-21 601
reduce(BinaryOperator)：使用指定的二元操作（BinaryOperator），对流中的元素进行归约操作，返回一个Optional。flatMap(Function)：对流中的每个元素，通过给定的转换函数（Function）进行转换，并将结果流扁平化为一个流。map(Function)：对流中的每个元素，通过给定的转换函数（Function）进行转换，返回转换后的元素流。filter(Predicate)：通过给定的条件（Predicate），过滤流中的元素，返回满足条件的元素流。
Java 8 之Stream API
Symon的博客
10-25 1697
流到底是什么？简单定义：“从支持数据处理操作的源生成的元素序列”，下面剖析这个定义。元素序列：像集合一样，流也提供了一个接口，可以访问特定元素类型的一组有序值。集合讲的是数据，流讲的是计算。源：流使用一个提供数据的源，如集合、数组或输入/输出资源。数据处理操作：流的数据处理功能之处类似于数据库的操作，以及函数式编程语言中的常用操作，如filter、map、reduce、find、match、sort等。流的操作可以顺序执行，也可以并行执行。流水线。
java8：创建Stream及常用API和Optional类
yubin1285570923的博客
08-14 1079
一、四种创建Stream方式 1. Collection 提供了两个方法 stream() 与 parallelStream() List<String> list = new ArrayList<>(); Stream<String> stream = list.stream();//获取一个顺序流 Stream<String&...
爆！Java高级特性之Stream API详解
zhaodash97的博客
07-05 800
Stream就像一个高级的迭代器,允许我们以声明式方式处理数据集合。它可以让我们用一种类似SQL查询的方式来操作Java对象。Stream API结合了函数式编程的概念,大大简化了集合操作。简单来说,Stream就是数据流。我们可以imagin它就像一条传送带,在上面放上要处理的元素,然后让它流过一系列的操作。Stream API无疑是Java 8中最重要的特性之一。它为我们提供了一种新的数据处理方式,让我们的代码更加简洁、易读、高效。但就像所有的技术一样,它也不是银弹。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Liu-Chao Xu

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

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

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

打赏作者

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

抵扣说明：

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

余额充值