Java8新特性_Stream_归约与收集

最新推荐文章于 2024-01-06 18:32:11 发布
原创 最新推荐文章于 2024-01-06 18:32:11 发布 · 420 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #开发语言 #后端

本文通过实例展示了如何使用Java 8 Stream API对员工数据进行高效操作，包括工资汇总、分组统计、过滤等，提升代码简洁性和性能。 

package com.zs.boot.controller;

public class Employee implements Comparable<Employee>{

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

	public Employee() {
	}

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

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

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

	public Employee(String name, int age, Status status) {
		this.name = name;
		this.age = age;
		this.status = status;
	}

	public Employee(String name, int age, double salary, Status status) {
		this.name = name;
		this.age = age;
		this.salary = salary;
		this.status = status;
	}

	public Employee(int id, String name, int age, double salary, Status status) {
		this.id = id;
		this.name = name;
		this.age = age;
		this.salary = salary;
		this.status = status;
	}

	public Employee(String name, int age, double salary) {
		this.name = name;
		this.age = age;
		this.salary = salary;
	}

	public Status getStatus() {
		return status;
	}

	public void setStatus(Status status) {
		this.status = status;
	}

	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 String show() {
		return "测试方法引用！";
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + id;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		long temp;
		temp = Double.doubleToLongBits(salary);
		result = prime * result + (int) (temp ^ (temp >>> 32));
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Employee other = (Employee) obj;
		if (age != other.age)
			return false;
		if (id != other.id)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		if (Double.doubleToLongBits(salary) != Double.doubleToLongBits(other.salary))
			return false;
		return true;
	}

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

	@Override
	public int compareTo(Employee o) {
		if(String.valueOf(this.getAge()).equals(o.getAge())){
			return this.getName().compareTo(o.getName());
		}else{
			return String.valueOf(this.getAge()).compareTo(String.valueOf(o.getAge()));
		}
	}

	public enum Status {
		FREE, BUSY, VOCATION;
	}



}

package com.zs.boot.controller;

import org.junit.Test;

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

public class TestStream4API {

    List<Employee> employees = Arrays.asList(
            new Employee("刘德华",48,8000, Employee.Status.FREE),
            new Employee("刘德华1",18,8000, Employee.Status.FREE),
            new Employee("张学友",28,8500, Employee.Status.BUSY),
            new Employee("张学友1",38,8500, Employee.Status.BUSY),
            new Employee("黎明",45,6500, Employee.Status.VOCATION),
            new Employee("郭富城",51,5500, Employee.Status.FREE));

    //归约
    @Test
    public void test3() {
        List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
        Integer sum = list.stream().reduce(0,(x,y ) -> x + y);
        System.out.println(sum);//55

        //计算所有工资的总和，上面起始值是0，不可能为空，所以用Integer sum，下面用Optional
        //有可能为空的值，封装到Optional中去
        Optional<Double> op = employees.stream().map(Employee::getSalary)
                .reduce(Double::sum);
        System.out.println(op.get());//28500.0

    }


    //收集
    @Test
    public void test4() {
        //收集所有的名字
        /*刘德华
        张学友
        黎明
        郭富城*/
        List<String> list = employees.stream().map(Employee::getName)
                .collect(Collectors.toList());
        list.forEach(System.out::println);

        //如果有重复数据，要进行去重，可以用set
        Set<String> list2 = employees.stream().map(Employee::getName)
                .collect(Collectors.toSet());
        list2.forEach(System.out::println);

        HashSet<String> hs = employees.stream().map(Employee::getName)
                .collect(Collectors.toCollection(HashSet::new));
        hs.forEach(System.out::println);
    }

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

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

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

        //最大值
        Optional<Employee> employee = employees.stream().collect(Collectors.maxBy((e1,e2) -> Double.compare(e1.getSalary(),e2.getSalary())));
        System.out.println(employee.get());//Employee [id=0, name=张学友, age=28, salary=8500.0, status=BUSY]

        //最小值，只想看工资
        //方法1，按工资从小到大排序，取第一个
        Optional<Double> db = employees.stream().map(Employee::getSalary).sorted((e1,e2) -> Double.compare(e1,e2)).findFirst();
        System.out.println(db.get());//5500.0
        //方法2
        //Optional<Double> db2 = employees.stream().map(Employee::getSalary).collect(Collectors.minBy(Double::compare));
        //同等写法
        Optional<Double> db2 = employees.stream().map(Employee::getSalary).collect(Collectors.minBy((x1,x2) -> Double.compare(x1,x2)));
        System.out.println(db2.get());//5500.0
    }

    //分组
    @Test
    public void test6() {
        //返回map
       Map<Employee.Status,List<Employee>>  map = employees.stream().collect(Collectors.groupingBy(Employee::getStatus));
        for (Map.Entry<Employee.Status, List<Employee>> statusListEntry : map.entrySet()) {
            Employee.Status key = statusListEntry.getKey();
            List<Employee> employees = statusListEntry.getValue();
            System.out.println(key+"-----"+employees);
        }
        /*FREE-----[Employee [id=0, name=刘德华, age=48, salary=8000.0, status=FREE], Employee [id=0, name=郭富城, age=51, salary=5500.0, status=FREE]]
        BUSY-----[Employee [id=0, name=张学友, age=28, salary=8500.0, status=BUSY]]
        VOCATION-----[Employee [id=0, name=黎明, age=45, salary=6500.0, status=VOCATION]]*/
    }

     //================说明：测试多级分组以及后面的，增加了测试数据，多了刘德华1、张学友1。。。=====================
    //多级分组
    @Test
    public void test7() {
        //返回map
        Map<Employee.Status, Map<String, List<Employee>>> map = employees.stream()
                .collect(Collectors.groupingBy(Employee::getStatus,Collectors.groupingBy(e -> {
                    if(e.getAge() <= 35){
                        return "青年";
                    }else if(e.getAge() <= 50){
                        return "中年";
                    }else{
                        return "老年";
                    }
        })));
        for (Map.Entry<Employee.Status, Map<String, List<Employee>>> statusMapEntry : map.entrySet()) {
               Employee.Status key = statusMapEntry.getKey();
               Map<String, List<Employee>> strMap = statusMapEntry.getValue();
               System.out.println(key+"---------"+strMap);
        }
        /*VOCATION---------{中年=[Employee [id=0, name=黎明, age=45, salary=6500.0, status=VOCATION]]}
        FREE---------{青年=[Employee [id=0, name=刘德华1, age=18, salary=8000.0, status=FREE]], 老年=[Employee [id=0, name=郭富城, age=51, salary=5500.0, status=FREE]], 中年=[Employee [id=0, name=刘德华, age=48, salary=8000.0, status=FREE]]}
        BUSY---------{青年=[Employee [id=0, name=张学友, age=28, salary=8500.0, status=BUSY]], 中年=[Employee [id=0, name=张学友1, age=38, salary=8500.0, status=BUSY]]}*/
    }


    //分区，根据true或false进行分区
    @Test
    public void test8() {
        Map<Boolean,List<Employee>> employeesMap = employees.stream().collect(Collectors.partitioningBy(e ->e.getSalary() >6000));
        for(Map.Entry<Boolean,List<Employee>> MapEntry :employeesMap.entrySet()){
            Boolean b = MapEntry.getKey();
            List<Employee> employeeList = MapEntry.getValue();
            System.out.println(b+"---------"+employeeList);
            /*
            false---------[Employee [id=0, name=郭富城, age=51, salary=5500.0, status=FREE]]
            true---------[Employee [id=0, name=刘德华, age=48, salary=8000.0, status=FREE], Employee [id=0, name=刘德华1, age=18, salary=8000.0, status=FREE], Employee [id=0, name=张学友, age=28, salary=8500.0, status=BUSY], Employee [id=0, name=张学友1, age=38, salary=8500.0, status=BUSY], Employee [id=0, name=黎明, age=45, salary=6500.0, status=VOCATION]]
            */
        }
    }


    @Test
    public void test9() {
        DoubleSummaryStatistics dss = employees.stream().collect(Collectors.summarizingDouble(Employee::getSalary));
        System.out.println(dss.getSum());
        System.out.println(dss.getAverage());
        System.out.println(dss.getMax());
        System.out.println(dss.getMin());
        System.out.println(dss.getCount());
        /*45000.0
        7500.0
        8500.0
        5500.0
        6*/
    }

    @Test
    public void test10(){
        String str = employees.stream().map(Employee::getName).collect(Collectors.joining());
        System.out.println(str);//刘德华刘德华1张学友张学友1黎明郭富城

        String str1 = employees.stream().map(Employee::getName).collect(Collectors.joining(","));
        System.out.println(str1);//刘德华,刘德华1,张学友,张学友1,黎明,郭富城

        String str2 = employees.stream().map(Employee::getName).collect(Collectors.joining(",","===","======"));
        System.out.println(str2);//===刘德华,刘德华1,张学友,张学友1,黎明,郭富城======
    }


    // 定义人名数组
    final String[] names = {"Zebe", "Hebe", "Mary", "July", "David"};
    Stream<String> stream1 = Stream.of(names);
    Stream<String> stream2 = Stream.of(names);
    Stream<String> stream3 = Stream.of(names);
    // 拼接成 [x, y, z] 形式
    String result1 = stream1.collect(Collectors.joining(", ", "[", "]"));
    // 拼接成 x | y | z 形式
    String result2 = stream2.collect(Collectors.joining(" | ", "", ""));
    // 拼接成 x -> y -> z] 形式
    String result3 = stream3.collect(Collectors.joining(" -> ", "", ""));
    System.out.println(result1);
    System.out.println(result2);
    System.out.println(result3);
    
    程序输出结果如下：
    [Zebe, Hebe, Mary, July, David]
    Zebe | Hebe | Mary | July | David
    Zebe -> Hebe -> Mary -> July -> David

    在JAVA8出现之前，我们通常使用循环的方式来拼接字符串，这样做不仅代码冗长丑陋，而且需要仔细阅读代码才知道代码的功能，例如下面的代码：
    final String[] names = {"Zebe", "Hebe", "Mary", "July", "David"};
    StringBuilder builder = new StringBuilder();
    for (int i = 0; i < names.length; i++) {
        if (builder.length() > 1) {
            builder.append(",");
        }
    builder.append(names[i]);
    }
    System.out.println(builder.toString());



}

Java 入门指南：Java 8 新特性 —— Stream 流
热带鱼的技术博客
09-21 2293
Java Stream 是 Java 8 引入的一个新的API，它提供了一种函数式编程的方式来处理集合数据。Stream 可以看作是一系列支持高效的、函数式操作的元素序列。 通过使用Stream，可以对集合进行 过滤、映射、排序、查找 等操作，而不需要显示地使用循环或者迭代器。Stream API 使用一种类似于 SQL 查询的方式来操作数据，这样可以使代码更加简洁、可读性更强。
Java8 新特性 —— Stream API 详解
最新发布
m0_74620530的博客
10-31 1787
Stream作为Java 8的一大亮点，它专门针对集合的各种操作提供各种非常便利、简单、高效的API，Stream API主要是通过Lambda表达式完成，极大的提高了程序的效率和可读性，同时Stram API中自带的并行流使得并发处理集合的门槛再次降低，使用Stream API编程无需多写一行多线程的代码就可以非常方便的写出高性能的并发程序。使用Stream API能够使代码更加优雅。
6.java8流的使用 stream的归约与收集
sunweihao2019的博客
11-08 351
1.关键代码 代码类Stream12SpecificationsAndCollect import com.netease.streamlearningbyjava.bean.Employee2; import org.junit.Test; import java.util.Arrays; import java.util.DoubleSummaryStatistics; import java.util.HashSet; import java.util.List; import java.uti
java8新特性之 Stream Api 之 规约 和收集（四）
TonyWu的博客
07-05 1206
/** *********************************规约********************************/ /** * 规约 * * reduce(T identity ,BinaryOperator) / reduce - 可以将流中元素冉福结合起来,得到一个值 */ @Test public void test11() { List&...
java8新特性--高级集合类和收集器
a18792721831的博客
04-16 646
java8新特性--高级集合类和收集器1.方法引用2.元素顺序3.收集器得到集合4.收集器得到值5.数据分块6.数据分组7.字符串8.组合收集器9.StringJoiner10.Map的迭代 1.方法引用 什么是方法引用： 对于一个对象，我们调用其方法，通常是 对象引用.方法。 比如： package domain; import java.io.Serializable; public cl...
Java8新特性
十二间记，知不足而奋斗，望远山而前行。千里不辞行路远，时光早晚到天涯。
02-20 3392
Java8新特性介绍
2021-04-10 仿牛客网第六章
weixin_43711788的博客
04-10 688
一、Elasticsearch入门 仿牛客网 内容部分引用至 https://blog.youkuaiyun.com/weixin_44406146 目录一、Elasticsearch入门Elasticsearch配置安装中文分词插件安装Postman模拟网页访问使用命令行操作Elasticsearch使用Postman/RESTer访问ES二、Spring整合Elasticsearch导包配置写数据层测试一波三、开发社区搜索功能ElasticsearchService处理DiscussPostController
683.681.JAVA基础教程_动态代理与Java8新特性-Stream的终止操作：归约(683).rar
11-09
在Java编程语言中，动态代理和Java 8的新特性，特别是Stream API的使用，是现代开发中的重要概念。本教程将深入探讨这两个主题，并重点讲解Stream API中的终止操作——归约（Reduction）。 首先，让我们了解动态...
java8新特性-Stream(流)
蒾酒的博客
01-06 2792
流（Stream）是 Java 8 引入的一种处理集合数据的抽象概念，它提供了一种更简洁、更灵活的方式来操作和处理集合数据。流可以看作是一系列元素的管道，可以对这些元素进行筛选、转换、排序、归约等操作，实现各种数据处理需求。与传统的循环迭代方式相比，流的代码更易读、更易于并行化处理，并且能够充分发挥多核处理器的优势。通过使用流，可以提高代码的可读性和可维护性，同时也能够更高效地处理大规模数据集合。
Java8新特性之Stream API
qq_44787933的博客
07-26 638
Java8新特性之Stream API
实用的 Java 8 Stream集合的筛选、归约、分组、聚合
神盾局码农
04-30 1万+
网上看到大神的写文章,总结很好,遂就借鉴一下,以便以后使用, 原文连接:今日头条 先贴上几个案例，水平高超的同学可以挑战一下： 1. 从员工集合中筛选出salary大于8000的员工，并放置到新的集合里。 2. 统计员工的最高薪资、平均薪资、薪资之和。 3. 将员工按薪资从高到低排序，同样薪资者年龄小者在前。 4. 将员工按性别分类，将员工按性别和地区分类，将员工按薪资是否高于8000分为两部分。 用传统的迭代处理也不是很难，但代码就显得冗余了，跟Stream相比高下立判。Java 8
java对字符串归一化_字符串归一化
weixin_29848477的博客
02-19 3197
5import java.util.Scanner;public class Main{public static void main(String[] args){Scanner sc=new Scanner(System.in);char[] chars=sc.nextLine().toCharArray();//经验，一般是用hashmap来统计出现次数的，//但本题是对字符统计次数，可以专...
Java8种Stream流相关操作——集合的筛选、归约、分组、聚合
西瓜的博客
03-08 6252
一、概述 在Java8中，使用Stream配合同版本出现的Lambda，给我们操作集合（Collection）提供了极大的便利。 Stream将要处理的元素集合看作一种流，在流的过程中，借助Stream API对流中的元素进行操作，比如：筛选、排序、聚合等。 二、Stream流的创建 Stream流可以通过集合、数组来创建。 通过集合来进行创建 List<String> list = Arrays.asList("a", "b", "c"); Stream<String> str
Java8 Stream详解~归约(reduce)
小强快跑~~
02-25 2653
归约，也称缩减，顾名思义，是把一个流缩减成一个值，能实现对集合求和、求乘积和求最值操作。 「案例一：求Integer集合的元素之和、乘积和最大值。」 public class StreamTest { public static void main(String[] args) { List<Integer> list = Arrays.asList(1, 3, 2, 8, 11, 4); // 求和方式1 Optional<Integer> sum =
JAVA8 Stream查找、匹配、归约
热门推荐
狮子头儿的博客
09-02 1万+
List&lt;Student&gt; students = Arrays.asList( new Student(1,"zhangsan","class1",18,60), new Student(2,"lisi","class1",20,59), new Student(3,"wangwu","class2
jdk8 的新特性list中stream流进行分组并合并字段
weixin_43447266的博客
07-07 6204
jdk8 的新特性list中stream流进行分组并合并字段
Java8中Stream的归约与收集
weixin_33957648的博客
05-07 245
Java8中Stream的归约与收集 归约 reduce(T identity, BinaryOperator) / reduce(BinaryOperator) --可以将流中元素反复结合起来，得到一个值 public class Employee { private String name; private Integer age; private Double sa...
java8新特性(四) Collector（收集器）
戏流年的博客
04-15 1万+
导航 引例 Collector 什么是Collector Collector工作原理 特征值 自定义Collector Collectors详解 求值 均值：averaging 元素个数：counting 最值：maxBy、minBy 和：summing、summarizing 分组 groupingBy groupingByConcurrent partition...
JDK8中Stream 中Collectors 规约处理
.
01-15 721
JDK8中Stream 中Collectors 规约处理 Collectors常用方法详解 List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","","11","22","33", "jkl"); 一般输出指定集合类型 strings.stream().collect(Collectors.toList()); strings.stream().collect(Coll
Java JDK8新特性：Stream API与Lambda表达式示例
资源摘要信息:"Java Development Kit 8 (JDK 8) 引入了多个新特性，极大地简化了Java编程模型，并且增强了Java语言的表达力。在这些新特性中，Stream API 和 Lambda 表达式是两个特别重要的功能，它们改变了集合操作...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

ZHOU_VIP

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

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

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

打赏作者

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

抵扣说明：

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

余额充值