首页 > 编程语言 >Java常用新特性之Stream API

Java常用新特性之Stream API

时间：2024-03-31 10:00:16浏览次数：26  
标签：Java Stream stream list System API println out

一， 认识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的基本内容以及使用方法已经讲述完了，希望对你有所帮助！

标签：Java,Stream,stream,list,System,API,println,out
From： https://blog.csdn.net/weixin_52828297/article/details/137190854

相关文章

  • java毕业设计上门医疗服务小程序（Springboot+mysql+jdk1.8+maven3.39）
    本系统（程序+源码）带文档lw万字以上 文末可领取本课题的JAVA源码参考系统程序文件列表系统的选题背景和意义选题背景：随着社会的发展和人口老龄化的加剧，人们对医疗服务的需求日益增长，特别是对于便捷、高效的上门医疗服务。传统的医疗服务模式要求患者亲自前往医院或诊所就......
  • java毕业设计汽车租赁系统（Springboot+mysql+jdk1.8+maven3.39）
    本系统（程序+源码）带文档lw万字以上 文末可领取本课题的JAVA源码参考系统程序文件列表系统的选题背景和意义选题背景：随着共享经济的兴起和汽车产业的发展，汽车租赁作为一种新兴的出行方式逐渐受到人们的欢迎。传统的汽车租赁业务多依赖于线下门店操作，顾客需要到店选车、签......
  • java毕业设计天勤人力资源管理（Springboot+mysql+jdk1.8+maven3.39）
    本系统（程序+源码）带文档lw万字以上 文末可领取本课题的JAVA源码参考系统程序文件列表系统的选题背景和意义一、选题背景：在当今竞争激烈的商业环境中，人力资源管理(HRM)对于组织的成功至关重要。有效的HRM不仅能够提高员工的工作效率和满意度，而且可以促进企业的整体发展战......
  • java毕业设计数字家谱管理系统（Springboot+mysql+jdk1.8+maven3.39）
    本系统（程序+源码）带文档lw万字以上 文末可领取本课题的JAVA源码参考系统程序文件列表系统的选题背景和意义一、选题背景：在快速变化的社会中，人们越来越意识到家族历史和文化传承的重要性。家谱作为记录家族血脉和历史的重要文献，承载着丰富的文化价值和历史信息。然而，传统......
  • 《手把手教你》系列技巧篇（六十二）-java+ selenium自动化测试-RemoteWebDriver让你的代
    1.简介当本机上没有浏览器，需要远程调用浏览器进行自动化测试时，需要用到RemoteWebDirver。宏哥申请服务器还没有下来，也懒得自己在本地安装虚拟机，等的时间太长了于是就网上找了一个可以免费试用2天的服务器（网址：DedicatedServerHostingService|BareMetal|Varidata），注册一......
  • 《手把手教你》系列技巧篇（六十一）-java+ selenium自动化测试 - 截图三剑客 -下篇（详细教
    1.简介按照计划宏哥今天将介绍java+selenium自动化测试截图操作实现的第三种截图方法，也就是截图的第三剑客-截取某个元素（或者目标区域）的图片。在测试的过程中，有时候不需要截取整个屏幕，只需要截取某个元素（或者目标区域）的图片，今天宏哥就来讲解和分享这些内容。2. 截取某个......
  • Java学习计划和之后的规划
    Java是一种广泛使用的编程语言，以其“一次编写，到处运行”的能力而闻名。对初学者来说，学习Java可以是一个既充满挑战又充满回报的旅程。以下是一份详细的学习计划，可帮助初学者入门并在Java编程世界中稳步前进。##第一阶段：基础入门（1-3个月）###目标-理解Java的基础概念和语法......
  • Java的心脏：深入解析Java虚拟机、进程与线程的精妙互动
    一、定义进程（Process）和线程（Thread）是操作系统中非常基础且重要的概念，它们对于理解程序的执行、资源分配和并发编程至关重要。我将从操作系统（OS）和Java编程语言的角度来详细解释这两个概念。从操作系统的角度进程：定义：进程是操作系统进行资源分配和调度的基本单位。它是一......
  • ssm656基于JAVA的校园失物招领平台的设计与实现
    ......
  • Linux服务器准备java运行环境
    安装JAVA下检查是否安装了JAVAjava-version提示"java:commandnotfound"则表示没有安装，如果安装了会显示JAVA版本信息CentOS安装JAVAsudoyuminstalljava-11-openjdk-devel 安装完成再执行一下:java-version 说明安装成功，没问题设置环境变量设置JAVA_HO......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99