JDK8StreamApi

最新推荐文章于 2023-03-31 08:00:00 发布
最新推荐文章于 2023-03-31 08:00:00 发布
阅读量255 收藏
点赞数
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45597391/article/details/124923545
版权

文章目录

方法函数

方法名字说明
foreach循环
findfindFirst():返回第一个元素，findAny():返回任意一个元素
matchanyMatch() :满足一个为true; allMatch():全部满足为true
filter按照过滤
max最大
min最小
count计算个数
map接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素
flatMap接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
reduce把一个流缩减成一个值，能实现对集合求和、求乘积和求最值操作
collect1.计数： count :2:平均值： averagingInt、 averagingLong、 averagingDouble;3.最值： maxBy、 minBy;4.求和： summingInt、 summingLong、 summingDouble;5.统计以上所有： summarizingInt、 summarizingLong、 summarizingDouble
partitioningBy/groupingBy分组·
joining将stream中的元素用特定的连接符（没有的话，则直接连接）连接成一个字符串。
sorted排序
提取/组合流也可以进行合并、去重、限制、跳过等操作。
差集

使用

前提

1.new Person

@Data
public class Person {
    private String name;
    private int age;
    private int salary;//工资

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

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

2.创建person集合


List<Person> personList = new ArrayList<>();
personList.add(new Person("张三", 20, 5000));
personList.add(new Person("李四", 30, 6000));
personList.add(new Person("王五", 40, 7000));
personList.add(new Person("赵六", 50, 8000));
personList.add(new Person("田七", 60, 9000));

foreach

 personList.forEach(System.out::println);

find

// 获取满足（Stream）任意一个值 如：满足员工年大于40 
Optional<Person> findAny= personList.stream().filter(p -> p.getAge() > 40).findAny(); 
System.out.println(findAny.get());//结果：[Person{name='赵六', age=50, salary=8000}]
// 满足（Stream）第一个值 如：满足员工年大于40 
Optional<Person> findFirst= personList.stream().filter(p -> p.getAge() > 40).findFirst();
System.out.println(findFirst.get());//结果：[Person{name='赵六', age=50, salary=8000}]

match


 //判断 员工集合是否全部都大于40岁
boolean allMatch = personList.stream().allMatch(person -> person.getAge() > 40);
System.out.println("allMatch = " + allMatch);//结果：false
// 判断 员工集合是否有一个大于40岁
boolean anyMatch = personList.stream().anyMatch(person -> person.getAge() > 40);
System.out.println("anyMatch = " + anyMatch);//结果：true

filter

//查找年龄大于40的人 并且保存成新集合
List<Person> personList40 = personList.stream().filter(p -> p.getAge() > 40).collect(Collectors.toList());
System.out.println("personList40 = " + personList40);//结果：[Person{name='赵六', age=50, salary=8000}, Person{name='田七', age=60, salary=9000}]

max


//查询工资最大的人
Comparator<? super Person> comparator = Comparator.comparing(Person::getSalary);//按照工资排序
Optional<Person> person = personList.stream().max(comparator);
System.out.println("person = " + person.get());//结果：Person{name='田七', age=60, salary=9000}

min

  //查询年龄最小的人
Comparator<Person> anInt = Comparator.comparingInt(Person::getAge);//按照年龄排序
Optional<Person> person = personList.stream().min(anInt);
System.out.println("person = " + person.get());//结果：Person{name='张三', age=20, salary=5000}

count

//计算年龄大于40的人数量
long count = personList.stream().filter(p -> p.getAge() > 40).count();
System.out.println("count = " + count);//结果：2

map

  // 对所有员工进行涨薪500元
 List<Person> list = personList.stream().map(person -> {
        person.setSalary(String.valueOf(Integer.parseInt(person.getSalary()) + 500));
        return person;
    }).collect(Collectors.toList());
    System.out.println("list = " + list);//结果：[Person{name='张三', age=20, salary=5500}, Person{name='李四', age=30, salary=6500}, Person{name='王五', age=40, salary=7500}, Person{name='赵六', age=50, salary=8500}, Person{name='田七', age=60, salary=9500}]

reduce

  //reduce :求和，求最值，求乘积
//1.求员工工资总和
 Optional<Integer> reduce = personList.stream().map(person -> Integer.parseInt(person.getSalary())).reduce(Integer::sum);
 System.out.println("reduce = " + reduce.get());//结果：35000
 //2.求员工工资最大值
 Optional<Integer> reduce1 = personList.stream().map(person -> Integer.parseInt(person.getSalary())).reduce(Integer::max);
 System.out.println("reduce1 = " + reduce1.get());//结果：9000
 //3.求员工年龄最小值
 Optional<Integer> reduce2 = personList.stream().map(Person::getAge).reduce(Integer::min);
 System.out.println("reduce2 = " + reduce2.get());//结果：20
 //4.求员工工资乘积
 Optional<Integer> reduce3 = personList.stream().map(Person::getAge).reduce((a, b) -> a * b);
 System.out.println("reduce3 = " + reduce3);// 结果：72000000

collect

//1.统计员工人数
long count = personList.stream().count();
System.out.println("count = " + count); //结果：5
Long collect = personList.stream().collect(Collectors.counting());
System.out.println("collect = " + collect); //结果：5
//2.求平均年龄
Double aDouble = personList.stream().collect(Collectors.averagingInt(Person::getAge));
System.out.println("aDouble = " + aDouble);//结果：40.0
Double aDouble1 = personList.stream().collect(Collectors.averagingInt(p -> p.getAge()));
System.out.println("aDouble1 = " + aDouble1);//结果：40.0
//3.求最高年龄
Optional<Integer> maxBy = personList.stream().map(Person::getAge).collect(Collectors.maxBy(Integer::compare));
System.out.println("maxBy = " + maxBy.get());//结果：60
//4.求最低年龄
Optional<Integer> minBy = personList.stream().map(Person::getAge).collect(Collectors.minBy(Integer::compare));
System.out.println("minBy = " + minBy.get());//结果：20
//5.求年龄总和
Integer summingInt = personList.stream().collect(Collectors.summingInt(Person::getAge));
System.out.println("summingInt = " + summingInt);//结果：200
//6统计以上员年龄信息
IntSummaryStatistics summarizingInt = personList.stream().collect(Collectors.summarizingInt(Person::getAge));
System.out.println("summarizingInt = " + summarizingInt);//结果：IntSummaryStatistics{count=5, sum=200, min=20, average=40.0, max=60}

partitioningBy(groupingBy)

// 将员工按年龄高于40分为两部分
Map<Boolean, List<Person>> booleanListMap = personList.stream().collect(Collectors.partitioningBy(person -> person.getAge() > 40));
System.out.println("booleanListMap = " + booleanListMap);//{false=[Person{name='张三', age=20, salary=5000}, Person{name='李四', age=30, salary=6000}, Person{name='王五', age=40, salary=7000}], true=[Person{name='赵六', age=50, salary=8000}, Person{name='田七', age=60, salary=9000}]}
Map<Boolean, List<Person>> booleanListMap1 = personList.stream().collect(Collectors.groupingBy(person -> person.getAge() > 40));
System.out.println("booleanListMap1 = " + booleanListMap1);//{false=[Person{name='张三', age=20, salary=5000}, Person{name='李四', age=30, salary=6000}, Person{name='王五', age=40, salary=7000}], true=[Person{name='赵六', age=50, salary=8000}, Person{name='田七', age=60, salary=9000}]}

joining

//将员工的名字拼接起来
String collect = personList.stream().map(Person::getName).collect(Collectors.joining(","));
System.out.println("collect = " + collect);//结果：张三,李四,王五,赵六,田七

sorted

//将员工按照年龄排序
List<Person> collect = personList.stream().sorted(Comparator.comparing(Person::getAge)).collect(Collectors.toList());
System.out.println("collect = " + collect);//结果：[Person{name='张三', age=20, salary=5000}, Person{name='李四', age=30, salary=6000}, Person{name='王五', age=40, salary=7000}, Person{name='赵六', age=50, salary=8000}, Person{name='田七', age=60, salary=9000}]

提取/组合

String[] arr1 = { "a", "b", "c", "d" };
String[] arr2 = { "d", "e", "f", "g" };
Stream<String> stream1 = Stream.of(arr1);
Stream<String> stream2 = Stream.of(arr2);
// concat:合并两个流 distinct：去重
List<String> newList = Stream.concat(stream1, stream2).distinct().collect(Collectors.toList());
// limit：限制从流中获得前n个数据
List<Integer> collect = Stream.iterate(1, x -> x + 2).limit(10).collect(Collectors.toList());
// skip：跳过前n个数据
List<Integer> collect2 = Stream.iterate(1, x -> x + 2).skip(1).limit(5).collect(Collectors.toList());

System.out.println("流合并：" + newList);//[a, b, c, d, e, f, g]
System.out.println("limit：" + collect);//[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
System.out.println("skip：" + collect2);//[3, 5, 7, 9, 11]

差集

//计算两个list中的差集
List<String> reduce1 = allList.stream().filter(item -> !wList.contains(item)).collect(Collectors.toList());
浮々若年·华
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JDK8新特性 Stream Api（22.6.28）
weixin_67680815的博客
06-28 183
JDK8新特性之一，Stream流的学习
JDK1.8-Stream中常用的API（流操作）
weixin_37967166的博客
04-09 9582
1 Stream Stream是一组用来处理数组，集合的API。 1.1 特性 不是数据结构，没有内部存储。 不支持索引访问。 延迟计算 支持并行 很容易生成数据或集合 支持过滤，查找，转换，汇总，聚合等操作。 1.2 运行机制 Stream分为源source，中间操作，终止操作。 流的源可以是一个数组，集合，生成器方法，I/O通道等等。 一个流可以有零个或多个中间操作，每一个中间操作都会返回...
Java8新特性：StreamAPI（超详解）
weixin_52533007的博客
03-31 7993
用于操作数据源（集合、数组等）所生成的元素序列。“集合讲的是数据，Stream讲的是计算！Stream关注的是对数据的运算，与CPU打交道，集合关注的是数据的存储，与内存打交道。Stream 自己不会存储元素。Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。
JDK8新特性05-Stream API
程序员飞扬的博客
06-04 359
Java8重点掌握Stream API，太优雅了
Java8新特性之Stream API（含具体案例）
Javaの甘乃迪的博客
10-13 494
Java8新特性--Stream API
jdk8中文API文档
05-22
以上只是JDK 8中部分重要更新，实际的API文档中还包含大量其他细节，如集合框架的改进、反射API的增强以及各种工具类的更新。这些变化极大地丰富了Java的生态系统，提高了开发效率，使得JDK 8成为Java开发者不可或缺...
JDK8 API 中文 文档.CHM
06-07
3. **Stream API**：JDK8新增了Stream API，用于处理集合数据，支持串行和并行操作。Stream API提供了丰富的操作，如`filter`、`map`、`reduce`、`collect`等，使得数据处理更高效且代码更简洁。 4. **Optional类**...
JDK8 中文API文档
05-05
Stream API是JDK8新增的一组用于处理集合数据的新接口，它提供了一种声明式处理数据的方式。Stream API支持序列流和并行流，可以方便地进行过滤、映射、聚合等操作。例如： ```java List<String> names = Arrays....
jdk8 api中文版
04-15
**Java JDK 8 API 中文版** Java JDK 8 是Java开发的重要工具包，它包含了运行和构建Java应用程序所需的库和开发工具。JDK 8是Oracle公司发布的一个里程碑版本，引入了许多创新特性，极大地提升了开发效率和代码...
jdk8帮助文档（jdk8_API）
07-09
此外，JDK 8还引入了Stream API，它提供了一种声明式的处理数据的方式，特别适合于集合操作。Stream API允许通过链式调用来执行过滤、映射、归约等操作。例如，`List<String> names = list.stream().filter(name -> ...
JDK8特性(Lambda表达式+StreamAPI简单示例代码)
04-02
JDK8特性(Lambda表达式+StreamAPI的简单使用示例代码)
JDK8新特性——Stream API
vlucky_long的博客
10-08 440
Java8中有两大最为重要的改变。第一个是 Lambda 表达式；另外一个则是 Stream API。Stream API ( java.util.stream) 把真正的函数式编程风格引入到Java中。这是目前为止对Java类库最好的补充，因为Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。 Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。 使用Stream API 对集合
Java8 Stream API 详细使用指南
chongmu2584的博客
08-29 309
福利 现在关注微信公众号：码农小胖哥， 发送关键字【抽奖】进行抽奖，可有机会获取实体编程书籍。活动只剩下2天了抓紧参与！【本次抽奖截止到本周末】 1. 概述 Java 8 引入的一个重要的特性无疑是 Stream API。Stream 翻译过来是“流”，突然想到的是大数据处理有个流式计算的概念...
JDK8新特性之Stream API（三）
勤奋的派大星的博客
09-18 266
JDK8新特性之Stream API（三） JAVA8中有两个最为重要的改变第一个是Lambda表达式，这个在JDK8新特性之Lambda表达式（一），JDK8新特性之方法引用（二）这两篇文章中介绍过，另一个则是Stream API。 Stream API 介绍 Stream API(java.util.stream)是Java8中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射等操作，简而言之，Stream API提供了一种高效且易于使用的处理数据的方式。 St
Stream API 优化代码
l_learning的博客
04-21 301
使用Java8中新特性Lambda表达式和流申明式处理数据集合，让代码更简洁 使用一个简单的员工类来学习使用方法 public class Employee { /** * 姓名 */ private String name; /** * 年龄 */ private int age; /** * 薪资 */ private double salary; /** * 部
JDK8系列之Stream API入门教程和示例
Nicky's blog
07-19 2130
JDK8系列之Stream API入门教程和示例，在前面的章节的学习中，我们学习了jdk8的新特性，lambada表达式、方法引用、函数式接口等等，接着本博客继续JDK8的一个比较重要的特性，JDK8 Stream API
Java8中的Stream API详解:Stream的背景及使用
热门推荐
Rico's Blogs
03-15 7万+
摘要： 　　 　　Stream是Java8的一大亮点，是对容器对象功能的增强，它专注于对容器对象进行各种非常便利、高效的 聚合操作（aggregate operation）或者大批量数据操作。Stream API借助于同样新出现的Lambda表达式，极大的提高编程效率和程序可读性。同时，它提供串行和并行两种模式进行汇聚操作，并发模式能够充分利用多核处理器的优势，使用fork/join并行方式来...
jdk8的新特性总结（二）：StreamAPI
caishi13202的博客
09-12 5360
这篇文章我们一起来学习java8最重要的新特性之一，强大的StreamAPI，在本文中的代码示例中我们会大量使用lambda表达式，如果对lambda表达式还不太熟悉，可以看一下上一篇文章。 java8中Java8中有两大最为重要的改变。第一个是 Lambda 表达式；另外一个则是 Stream API(java.util.stream.*)。Stream 是 Java8 中处理集合的关键抽象概...
JDK8 Stream API使用心得
life is wonderful
05-19 786
自己最近封装的年化收益相关工具类package com.huajin.tradeserver.service.util; import java.math.BigDecimal; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; import jav...
jdk17 Stream API例子
最新发布
06-08
以下是 JDK 17 Stream API 的一个例子： 假设有一个 List<Integer> 类型的列表，我们要筛选出其中大于 5 的元素，并将它们加倍后求和。可以使用 Stream API 来实现： ```java List<Integer> list = List.of(1, 2, ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值