首页 > 编程语言 >Java8 函数式编程stream流

Java8 函数式编程stream流

时间:2023-07-27 23:23:21浏览次数:43  
标签:Collectors stream departmentList 编程 collect 部门 Department Java8

开篇介绍

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

1.初始环境准备

​ 场景:现在有一个公司,公司部门有一级部门,二级部门甲和二级部门乙(其中二级部门甲和二级部门乙是一级部门的子部门),

一级部门下面有有001号员工小明,二级部门甲下面有002号员工小刚和003号员工小李,二级部门乙有002号员工小刚和004号员工小张,其中员工id是唯一的,员工小刚既是二级部门甲又是二级部门乙的员工。代码展示如下:

public class LambdaUseCase {
    static List<Department> departmentList;
    static {
        // 一级部门,部门人员有001号员工小明
        Department departmentOne = new Department("一级部门", 1,10000L,11000L,
                Arrays.asList(new Person("001","小明",22)));
        // 二级部门甲,部门人员有002号员工小刚和003号员工小李
        Department departmentTwoFirst = new Department("二级部门甲", 2,8000L,13000L,
                Arrays.asList(new Person("002","小刚",23),
                        new Person("003","小李",32)));
        // 二级部门乙,部门人员有002号员工小刚和004号员工小张
        Department departmentTwoSecond = new Department("二级部门已", 2,7500L,15000L,
                Arrays.asList(new Person("002","小刚",23),
                        new Person("004","小张",34)));

        departmentList = Arrays.asList(departmentOne,departmentTwoFirst,departmentTwoSecond);
    }
}

@Data
@AllArgsConstructor
@NoArgsConstructor
class Department {
    // 部门名
    private String departmentName;
    // 部门等级
    private Integer departmenRank;
    // 部门薪资(单位分)
    private Long departSalary;
    // 部门日盈利
    private Long departProfit;
    // 部门人员集合
    private List<Person> persons;
}

@Data
@AllArgsConstructor
@NoArgsConstructor
//重写equal和hashcode方法,用于数据去重
@EqualsAndHashCode
class Person {
    // 人员id
    private String personId;
    // 人员姓名
    private String personName;
    // 人员年龄
    private Integer personAge;
}

2.创建流

单列集合: 集合对象.stream() 创建流

departmentList.stream();

数组:Arrays.stream(数组) 或者使用Stream.of来创建

Integer[] arr = {1,2,3,4,5};
Stream<Integer> stream = Arrays.stream(arr);
Stream<Integer> stream2 = Stream.of(arr);
Stream.of(1,2,3,4);

双列集合:转换成单列集合后再创建

Map<String, Integer> map = new HashMap<>();
map.put("a", 1);
map.put("b", 2);
map.put("c", 3);
Stream<Map.Entry<String, Integer>> stream = map.entrySet().stream();

3.中间操作

3.1 map

如果有一个函数可以将一种类型的值转换成另外一种类型,map 操作就可以使用该函数,将一个流中的值转换成一个新的流

需求:公司今年收益提供,决定把所有部门的平均薪资提升1000。

List<Department> departments = departmentList.stream().map(e -> {
    e.setDepartSalary(e.getDepartSalary() + 1000);
    return e;
}).collect(Collectors.toList());

3.2 filter

对流中的元素进行过滤,筛选出符合过滤条件的数据

需求:需要筛选出部门平均薪资大于等于8000的数据。

List<Department> departments = departmentList.stream()
		.filter(e -> e.getDepartSalary() >= 8000)
		.collect(Collectors.toList());

3.3 flatMap

flatMap 方法可用 Stream 替换值,然后将多个 Stream 连接成一个 Stream

需求:把公司所有的人员收集到一个集合中。

不使用flatMap,你可能会这么做,循环里套循环,看上去不太美观。

Set<Person> personSet = new HashSet<>();
departmentList.stream().forEach(e->{
	e.getPersons().stream().forEach(person->{
		personSet.add(person);
	});
});

使用flatMap写法。

Set<Person> personSet = departmentList.stream()
        .flatMap(e -> e.getPersons().stream())
        .collect(Collectors.toSet());

3.4 distinct

去除流中的重复元素

需求:将公司所有的人员统计出来,这回不使用Set去重,注意:002号员工即在二级部门甲又在二级部门乙

List<Person> personSet = departmentList.stream()
        .flatMap(e -> e.getPersons().stream())
        .distinct()
        .collect(Collectors.toList());

注意:distinct方法是依赖Object的equals方法来判断是否是相同对象的。所以需要注意重写equals方法。

3.5 sorted

对流中的元素进行排序

需求: 按薪资从低到高将部门列出来。

List<Department> departments = departmentList.stream()
        .sorted((o1, o2) -> o1.getDepartSalary().compareTo(o2.getDepartSalary()))
        .collect(Collectors.toList());

注意:如果调用空参的sorted()方法,需要流中的元素是实现了Comparable。

3.6 limit

可以设置流的最大长度,超出的部分将被抛弃

需求:按薪资从低到高将部门列出来,并且找出薪资最低的俩个部门

List<Department> departments = departmentList.stream()
		.sorted(Comparator.comparing(Department::getDepartSalary))
		.limit(2)
		.collect(Collectors.toList());

3.7 skip

跳过流中的前n个元素,返回剩下的元素

需求:按薪资从低到高将部门列出来,并且忽略薪资最低的部门

List<Department> departments = departmentList.stream()
		.sorted(Comparator.comparing(Department::getDepartSalary))
		.skip(1)
		.collect(Collectors.toList());

4.终结操作

4.1 foreach

对流中的元素进行遍历操作

需求:要求输出全部部门的名称

departmentList.stream()
                .forEach(e -> System.out.println(e.getDepartmentName()));

4.2 count

可以用来获取当前流中元素的个数。

需求:统计部门的格式

long count = departmentList.stream()
    .count();

4.3 max和min

Stream 上常用的操作之一是求最大值和最小值

需求:分别找出部门里面薪资最高的部门和最低的部门

Department maxDepartment = departmentList.stream()
		.max(Comparator.comparing(Department::getDepartSalary))
		.get();
Department minDepartment = departmentList.stream()
		.min(Comparator.comparing(Department::getDepartSalary))
		.get();

4.4 collect

将当前的流转换为一个集合

4.4.1 Collectors.toList()

需求:获得一个保存所有部门名字的集合

List<String> departNameList = departmentList.stream()
		.map(Department::getDepartmentName)
		.collect(Collectors.toList());

4.4.2 Collectors.toSet()

需求:获得部门所有人的姓名(重名的忽略)

Set<String> personNameList = departmentList.stream()
		.flatMap(e -> e.getPersons().stream())
		.map(Person::getPersonName)
        .collect(Collectors.toSet());

4.4.3 Collectors.toMap(keyMapper, valueMapper)

需求:获得部门名称当做key,员工当做value的Map

Map<String, List<Person>> collect = departmentList.stream()
		.collect(Collectors.toMap(Department::getDepartmentName, Department::getPersons));

4.4.4 Collectors.joining()

需求:将所有的部门名字连起来,并且前缀是【,后缀是】,分隔符是,

departmentList.stream()
		.map(Department::getDepartmentName)
		.collect(Collectors.joining(",","[","]"));

4.4.5 Collectors.partitioningBy(predicate)

接受一个流,并将其分成两部分,使用 Predicate 对象判断一个元素应该属于哪个部分,并根据布尔值返回一个 Map 到列表。

需求:将一级部门和其他级别的部门分离出来

Map<Boolean, List<Department>> collect = departmentList
    .stream()
    .collect(Collectors.partitioningBy(e -> e.getDepartmenRank() == 1));

4.4.6 Collectors.groupingBy(classifier)

接受一个分类函数,用来对数据分组

需求:将部门按部门的阶级分组

Map<Integer, List<Department>> collect = departmentList
    .stream()
    .collect(Collectors.groupingBy(Department::getDepartmenRank));

4.4.7 组合收集器

各种收集器已经很强大了,但如果将它们组合起来,会变得更强大。

需求:统计各个阶级部门的平均薪资

Map<Integer, Double> collect = departmentList.stream()
.collect(Collectors.groupingBy(Department::getDepartmenRank,Collectors.averagingLong(Department::getDepartSalary)));

这个例子中用到了第二个收集器,用以收集最终结果的一个子集。这些收集器叫作下游收集器。收集器是生成最终结果的一剂配方,下游收集器则是生成部分结果的配方,主收集器中会用到下游收集器。这种组合使用收集器的方式,使得它们在 Stream 类库中的作用更加强大。

4.5 reduce

对流中的数据按照指定的方式计算出结果

需求:计算出部门总的日盈利

Long sum = departmentList.stream()
		.map(Department::getDepartProfit)
		.reduce(0L, (result, element) -> result + element);

4.6 anyMatch

可以用来判断是否有任意符合匹配条件的元素,结果为boolean类型。

需求:判断部门中有没有薪资大于9000的部门

boolean b = departmentList.stream()
                .anyMatch(e -> e.getDepartSalary() > 9000L);

4.7 allMatch

可以用来判断是否都符合匹配条件,结果为boolean类型。如果都符合结果为true,否则结果为false。

需求:判断部门薪资是不是都大于9000

boolean b = departmentList.stream()
                .allMatch(e -> e.getDepartSalary() > 9000L);

4.8 noneMatch

可以判断流中的元素是否都不符合匹配条件。如果都不符合结果为true,否则结果为false

需求:判断是不是所有的部门薪资都大于9000

boolean b = departmentList.stream()
                .noneMatch(e -> e.getDepartSalary() > 9000L);

4.9 findAny

获取流中的任意一个元素。该方法没有办法保证获取的一定是流中的第一个元素。

需求:找到任意一个部门

Department department = departmentList
                .stream()
                .findAny()
                .get();

4.10 findFirst

获取流中的第一个元素。

需求:获得薪资最低的一个部门

Department department = departmentList
                .stream()
                .sorted(Comparator.comparing(Department::getDepartSalary))
                .findFirst()
                .get();

5.高级用法

5.1 对基本类型处理(mapToInt,mapToLong,mapToDouble)

在 Java 中,有一些相伴的类型,比如 int 和 Integer——前者是基本类型,后者是装箱类型。基本类型内建在语言和运行环境中,是基本的程序构建模块;而装箱类型属于普通的 Java 类,只不过是对基本类型的一种封装。由于装箱类型是对象,因此在内存中存在额外开销。比如,整型在内存中占用4 字节,整型对象却要占用 16 字节。这一情况在数组上更加严重,整型数组中的每个元素只占用基本类型的内存,而整型对象数组中,每个元素都是内存中的一个指针,指向 Java堆中的某个对象。在最坏的情况下,同样大小的数组,Integer[] 要比 int[] 多占用 6 倍内存。

将基本类型转换为装箱类型,称为装箱,反之则称为拆箱,两者都需要额外的计算开销。对于需要大量数值运算的算法来说,装箱和拆箱的计算开销,以及装箱类型占用的额外内存,会明显减缓程序的运行速度。

为了减小这些性能开销,Stream 类的某些方法对基本类型和装箱类型做了区分。高阶函数 mapToLong 和其他类似函数即为该方面的一个尝试。在 Java 8 中,仅对整型、长整型和双浮点型做了特殊处理,因为它们在数值计算中用得最多,特殊处理后的系统性能提升效果最明显。

如有可能,应尽可能多地使用对基本类型做过特殊处理的方法,进而改善性能。这些特殊的 Stream 还提供额外的方法,避免重复实现一些通用的方法,让代码更能体现出数值计算的意图。

需求:需要计算出公司部门利润的平均值,最大值,最小值,以及利润总和。

LongSummaryStatistics longSummaryStatistics = departmentList
    .stream()
    .mapToLong(Department::getDepartProfit)
    .summaryStatistics();
System.out.println("利润最大值"+longSummaryStatistics.getMax());
System.out.println("利润最小值"+longSummaryStatistics.getMin());
System.out.println("利润平均值"+longSummaryStatistics.getAverage());
System.out.println("利润总和"+longSummaryStatistics.getSum());

这些统计值在所有特殊处理的 Stream,如 DoubleStream、LongStream 中都可以得出。如无需全部的统计值,也可分别调用 min、max、average 或 sum 方法获得单个的统计值,同样,三种基本类型对应的特殊 Stream 也都包含这些方法。

6. 数据并行化

并 行 化 操 作 流 只 需 改 变 一 个 方 法 调 用。 如 果 已 经 有 一 个 Stream 对 象, 调 用 它 的parallel 方法就能让其拥有并行操作的能力。如果想从一个集合类创建一个流,调用parallelStream 就能立即获得一个拥有并行能力的流。

需求:并行的统计公司的所有的人员。

Set<Person> collect = departmentList.stream()
		.parallel()
		.flatMap(e -> e.getPersons().stream()).collect(Collectors.toSet());
Set<Person> collect1 = departmentList.parallelStream()
		.flatMap(e -> e.getPersons().stream()).collect(Collectors.toSet());

在底层,并行流还是沿用了 fork/join 框架。fork 递归式地分解问题,然后每段并行执行,最终由 join 合并结果,返回最后的值。

标签:Collectors,stream,departmentList,编程,collect,部门,Department,Java8
From: https://www.cnblogs.com/yuyiming/p/17586390.html

相关文章

  • Delphi 的 DBGrid 中的下拉列表和查找字段编程方法
    数据网格是非常流行的数据输入和显示形式,像大家熟悉的Excel、VFP 中的功能强大的BROWS 等,为广大程序员乐于采用。在用 Delphi 开发数据库应用系统时,利用数据网格DBGrid 输入数据时,有些字段只允许某几个固定的字符串,像档案案卷的保管期限,只有“永久”、“长期”和“短期”三种......
  • linux shell编程入门
    摘要介绍shell是什么shell快速开始一、基本概念1.shell是什么Shell是一个命令行解释器,它为用户提供了一个向Linux内核发送请求以便运行程序的界面系统级程序用户可以用Shell来启动、挂起、停止甚至是编写一些程序。2.shell脚本|执行方式脚本格式要求脚本以#!/b......
  • 23年暑假大一第一周编程练习
    23年暑假大一第一周编程练习1.消失的数字:deffind_missing_number(nums):#计算完整数组的和complete_sum=sum(range(1,len(nums)+2))#range包:[1,7)#print(complete_sum)#1+2+3+4+5+6=21#计算数组中所有数的和array_sum=sum(nums)......
  • Android studio DerInputStream.getLength(): lengthTag=109, too big.Failed to
    AndroidStudio:解决DerInputStream.getLength():lengthTag=109,toobig.Failedto的问题简介在使用AndroidStudio开发Android应用程序时,你可能会遇到DerInputStream.getLength():lengthTag=109,toobig.Failedto的错误。该错误通常发生在尝试使用包含较大数据的......
  • Java 连接redis at java.io.FilterOutputStream.flush(FilterOutputStream.java:1
    了解RedisRedis(REmoteDIctionaryServer)是一个开源的、基于内存的数据结构存储系统,它支持多种数据结构,如字符串、哈希、列表、集合、有序集合等。Redis提供了丰富的功能和高性能的数据操作,使其成为一个流行的数据库和缓存解决方案。Redis提供了多种语言的客户端库,使开发人员......
  • text/event-stream协议
    客户端接收text/event-streamhtml<!DOCTYPEhtml><html> <head> <metacharset="UTF-8"> <title>EventStreamDemo</title> <styletype="text/css"> body{ font-family:Arial,sans-serif;......
  • @Accessors注解——Lombok的链式编程
    用注解@Accessors 给实体类加上 chain=true 选项,即@Accessors(chain=true) 支持了Java链式写法; 什么是链式写法,比如:report.getOne().getTwo().getId(); 相关连接:https://susu-math.blog.csdn.net/article/details/122770688?spm=1001.2101.3001.6650.1&utm_me......
  • 网络编程面试
      TCP和UDP的区别TCP是面向连接的,传输前需要建立连接。UDP传输前不需要建立连接TCP仅支持一对一,UDP支持点对点,一对多,多对一TCP是面向字节流,UDP面向数据报TCP是可靠的,UDP是不可靠的TCP首部开销大于UDP,TCP首部开销最少20字节,UDP只需要8字节 TCP有三次握手机制和四次......
  • java8 list转map把key重复的value合并
    无序Map<String,List<GeneralVO>>groupMap=generalVOS.stream().collect(Collectors.groupingBy(GeneralVO::getTaskId));有序Map<String,List<GeneralVO>>groupMap2=generalVOS.stream().collect(Collectors.groupingBy(GeneralVO::getTa......
  • 6、编程基础-控制器编程
    控制器编程下页介绍如何编写控制器代码。尽管最初专注于C,但大多数相关和非语言特定的细节已被翻译成C++、Java、Python和MATLAB。要更深入地了解其他语言中的等效函数/方法,请检查节点和API函数以及C++/Java/Python。HelloWorld例子c语言#include<webots/robot.h>#include......