2024年大数据最新Stream之JDK8-最全使用汇总V1(1)，三级缓存框架问题你都了解了吗

于 2024-05-09 21:42:05 发布
阅读量347 收藏 6
点赞数 3
分类专栏： 程序员 文章标签： 大数据 面试 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84166811/article/details/138633102
版权

img
img

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

```
+ 【案例】筛选工资大于8000的人，并返回新的集合


	- 新集合依赖collect(收集)
	
	 
	```
	public class StreamTest {
	 public static void main(String[] args) {
	  List<Person> personList = new ArrayList<Person>();
	  personList.add(new Person("douglas", 8900, 23, "male", "beijing"));
	  personList.add(new Person("zw", 9500, 25, "male", "kelamy"));
	  personList.add(new Person("zy", 7900, 26, "female", "kelamy"));
		//打开流，先过滤工资大于8000的，对象转map取出对应人名字，最后收集为新的List集合
	  List<String> fiterList = personList.stream().filter(x -> x.getSalary() > 8000).map(Person::getName)
	    .collect(Collectors.toList());
	  System.out.print("高于8000的员工姓名：" + fiterList);
	 }
	}
	
	```
3.4.聚合

  • 方便我们对集合、数组的数据进行统计。

    • max、min、count
    • 【案例1】获取String集合中最长的元素
    public class StreamTest {
 public static void main(String[] args) {
  List<String> list = Arrays.asList("adnm", "pot", "xbangd", "weoujgsd");
	//打开流，对每个值得长度进行比较返回最大的一个值
  Optional<String> max = list.stream().max(Comparator.comparing(String::length));
  System.out.println("最长的字符串：" + max.get());
 }
}
    • 【案例2】获取Integer集合中的最大值
    public class StreamTest {
 public static void main(String[] args) {
  List<Integer> list = Arrays.asList(7, 6, 9, 4, 11, 6);

  // 第一种方式：自然排序
  Optional<Integer> max = list.stream().max(Integer::compareTo);
  // 第二种方式：自定义排序
  Optional<Integer> max2 = list.stream().max(new Comparator<Integer>() {
   @Override
   public int compare(Integer o1, Integer o2) {
    return o1.compareTo(o2);
   }
  });
  System.out.println("自然排序的最大值：" + max.get());
  System.out.println("自定义排序的最大值：" + max2.get());
 }
}
    • 【案例3】获取员工工资最高的人
    public class StreamTest {
 public static void main(String[] args) {
  List<Person> personList = new ArrayList<Person>();
  personList.add(new Person("douglas", 8900, 23, "male", "beijing"));
  personList.add(new Person("wf", 9500, 25, "male", "wuhan"));
  personList.add(new Person("zy", 7900, 26, "female", "kelamy"));
 //打开流，比价每个人得薪资值，返回最高得
  Optional<Person> max = personList.stream().max(Comparator.comparingInt(Person::getSalary));
  System.out.println("员工工资最大值：" + max.get().getSalary());
 }
}
    • 【案例4】计算Integer集合中大于6的元素的个数
    public class StreamTest {
 public static void main(String[] args) {
  List<Integer> list = Arrays.asList(7, 6, 4, 8, 2, 11, 9);
	//打开流，条件过滤大于6的元素，最后统计个数返回
  long count = list.stream().filter(x -> x > 6).count();
  System.out.println("list中大于6的元素个数：" + count);
 }
}
3.5.映射
  • 【概念】可以将一个流的元素按照一定的映射规则映射到另一个流中。
  • 【map】：接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
  • 【flatMap】：接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。
  • 【案例1】英文字符串数组的元素全部改为大写，整数数组每个元素+3：
public class StreamTest {
 public static void main(String[] args) {
  String[] strArr = { "abcd", "bcdd", "defde", "fTr" };
  List<String> strList = Arrays.stream(strArr).map(String::toUpperCase).collect(Collectors.toList());
  List<Integer> intList = Arrays.asList(1, 3, 5, 7, 9, 11);
  List<Integer> intListNew = intList.stream().map(x -> x + 3).collect(Collectors.toList());
  System.out.println("每个元素大写：" + strList);
  System.out.println("每个元素+3：" + intListNew);
 }
}
//结果如下：
//每个元素大写：[ABCD, BCDD, DEFDE, FTR]
//每个元素+3：[4, 6, 8, 10, 12, 14]
  • 【案例2】将两个字符数组合并成一个新的字符数组:
public class StreamTest {
 public static void main(String[] args) {
  List<String> list = Arrays.asList("m,k,l,a", "1,3,5,7");
  List<String> listNew = list.stream().flatMap(s -> {
   // 将每个元素转换成一个stream
   String[] split = s.split(",");
   Stream<String> s2 = Arrays.stream(split);
   return s2;
  }).collect(Collectors.toList());
  System.out.println("处理前的集合：" + list);
  System.out.println("处理后的集合：" + listNew);
 }
}
//结果如下：
//处理前的集合：[m-k-l-a, 1-3-5]
//处理后的集合：[m, k, l, a, 1, 3, 5]
3.6.归约
  • 【概念】归约reduce，也称缩减，顾名思义，是把一个流缩减成一个值，能实现对集合求和、求乘积和求最值操作。
  • 【案例】求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 = list.stream().reduce((x, y) -> x + y);
  // 求和方式2
  Optional<Integer> sum2 = list.stream().reduce(Integer::sum);
  // 求和方式3
  Integer sum3 = list.stream().reduce(0, Integer::sum);
  // 求乘积
  Optional<Integer> product = list.stream().reduce((x, y) -> x \* y);
  // 求最大值方式1
  Optional<Integer> max = list.stream().reduce((x, y) -> x > y ? x : y);
  // 求最大值写法2
  Integer max2 = list.stream().reduce(1, Integer::max);
  System.out.println("list求和：" + sum.get() + "," + sum2.get() + "," + sum3);
  System.out.println("list求积：" + product.get());
  System.out.println("list求和：" + max.get() + "," + max2);
 }
}
//结果：
//list求和：29,29,29
//list求积：2112
//list求和：11,11
3.7.收集
  • 【概念】collect收集，就是把一个流收集起来，最终可以是收集成一个值也可以收集成一个新的集合。
    • collect主要依赖java.util.stream.Collectors类内置的静态方法。
    • 因为流不存储数据，那么在流中的数据完成处理后，需要将流中的数据重新归集到新的集合中。
    • 常用的toList、toSet、toMap、toCollection、toConcurrentMap等等这些用法。
  • 【案例】
public class StreamTest {
 public static void main(String[] args) {
  List<Integer> list = Arrays.asList(1, 6, 3, 4, 6, 7, 9, 6, 20);
  //收集为list集合，只收集偶数
  List<Integer> listNew = list.stream().filter(x -> x % 2 == 0).collect(Collectors.toList());
  //收集为set集合，过滤重复值
  Set<Integer> set = list.stream().filter(x -> x % 2 == 0).collect(Collectors.toSet());
  //收集为map集合
  List<Person> personList = new ArrayList<Person>();
  personList.add(new Person("douglas", 8900, 23, "male", "beijing"));
  personList.add(new Person("wf", 7000, 25, "male", "shanghai"));
  personList.add(new Person("hw", 7800, 21, "female", "kelamay"));
  personList.add(new Person("zy", 8200, 24, "female", "kelamay"));
  
  Map<?, Person> map = personList.stream().filter(p -> p.getSalary() > 8000)
    .collect(Collectors.toMap(Person::getName, p -> p));
  System.out.println("toList:" + listNew);
  System.out.println("toSet:" + set);
  System.out.println("toMap:" + map);
 }
}
//结果：
//toList：[6, 4, 6, 6, 20]
//toSet：[4, 20, 6]
//toMap：{Tom=mutest.Person@5fd0d5ae, Anni=mutest.Person@2d98a335}
3.8.统计
  • 【Collectors提供的数据统计静态方法】
    • 计数：count
    • 平均值：averagingInt、averagingLong、averagingDouble
    • 最值：maxBy、minBy
    • 求和：summingInt、summingLong、summingDouble
    • 统计以上所有：summarizingInt、summarizingLong、summarizingDouble
  • 【案例】
public class StreamTest {
 public static void main(String[] args) {
  List<Person> personList = new ArrayList<Person>();
  personList.add(new Person("douglas", 8900, 23, "male", "beijing"));
  personList.add(new Person("sam", 7000, 25, "male", "kelamy"));
  personList.add(new Person("tom", 7800, 21, "female", "kelamy"));

  // 求总数
  Long count = personList.stream().collect(Collectors.counting());
  // 求平均工资
  Double average = personList.stream().collect(Collectors.averagingDouble(Person::getSalary));
  // 求最高工资
  Optional<Integer> max = personList.stream().map(Person::getSalary).collect(Collectors.maxBy(Integer::compare));
  // 求工资之和
  Integer sum = personList.stream().collect(Collectors.summingInt(Person::getSalary));
  // 一次性统计所有信息
  DoubleSummaryStatistics collect = personList.stream().collect(Collectors.summarizingDouble(Person::getSalary));

  System.out.println("员工总数：" + count);
  System.out.println("员工平均工资：" + average);
  System.out.println("员工工资总和：" + sum);
  System.out.println("员工工资所有统计：" + collect);
 }
}
3.9.分组
  • 【Collectors提供的分组方式】
    • partitioningBy：判断且分组
    • groupingBy：只分组
  • 【案例】
public class StreamTest {
 public static void main(String[] args) {
  List<Person> personList = new ArrayList<Person>();
  personList.add(new Person("douglas", 8900, "male", "beijing"));
  personList.add(new Person("hw", 7000, "male", "wuhan"));
  personList.add(new Person("yw", 7800, "female", "shanghai"));
  personList.add(new Person("gal", 8200, "female", "kelamay"));
  personList.add(new Person("zw", 9500, "male", "kelamay"));
  personList.add(new Person("zss", 7900, "female", "kelamay"));

       // 将员工按薪资是否高于8000分组
        Map<Boolean, List<Person>> part = personList.stream().collect(Collectors.partitioningBy(x -> x.getSalary() > 8000));
        // 将员工按性别分组
        Map<String, List<Person>> group = personList.stream().collect(Collectors.groupingBy(Person::getSex));
        // 将员工先按性别分组，再按地区分组
        Map<String, Map<String, List<Person>>> group2 = personList.stream().collect(Collectors.groupingBy(Person::getSex, Collectors.groupingBy(Person::getArea)));
        System.out.println("员工按薪资是否大于8000分组情况：" + part);
        System.out.println("员工按性别分组情况：" + group);
        System.out.println("员工按性别、地区：" + group2);
 }
}
3.10.接合
  • 【joining】可以将stream中的元素用特定的连接符（没有的话，则直接连接）连接成一个字符串。
  • 【案例】
public class StreamTest {
 public static void main(String[] args) {
  List<Person> personList = new ArrayList<Person>();
  personList.add(new Person("douglas", 8900, 23, "male", "beijing"));
  personList.add(new Person("zw", 7000, 25, "male", "shanghai"));
  personList.add(new Person("zy", 7800, 21, "female", "wuhan"));
//以逗号分割链接为一个字符串
  String names = personList.stream().map(p -> p.getName()).collect(Collectors.joining(","));
  System.out.println("所有员工的姓名：" + names);
  List<String> list = Arrays.asList("A", "B", "C");
//以-连接为一个字符串
  String string = list.stream().collect(Collectors.joining("-"));
  System.out.println("拼接后的字符串：" + string);
 }
}
3.11.排序
  • 【sorted】排序由两种操作：
    • sorted()：自然排序，流中元素需实现Comparable接口
    • sorted(Comparator com)：Comparator排序器自定义排序

img
img

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

+ sorted(Comparator com)：Comparator排序器自定义排序

[外链图片转存中…(img-EfOrvREr-1715262094573)]
[外链图片转存中…(img-QfwafC2n-1715262094573)]

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

2401_84166811
关注
  • 3
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JDK8 Stream 效率如何？，线程同步面试题
m0_64867688的博客
12-20 431
不少问题都可以被表达为无限流（infinite stream）： 用户不停地读取流直到满意的结果出现为止（比如说，枚举 完美数 这个操作可以被表达为在所有整数上进行过滤）； 集合是有限的，但流可以表达为无线流； 代码简练： 对于一些collection的迭代处理操作，使用 stream 编写可以十分简洁，如果使用传统的 collection 迭代操作，代码可能十分啰嗦，可读性也会比较糟糕； stream 和 iterator 迭代的效率比较 好了，上面 stream 的优点吹了那么多，stream 函数
大数据常用安装包-jdk8-py39-node16-spark351
最新发布
05-08
大数据常用安装包-jdk8-py39-node16-spark351
Stream之JDK8-最全使用汇总V1
2401_84185471的博客
04-30 443
方便我们对集合、数组的数据进行统计。
java8 stream 最大值_JDK8-Stream流常用方法
weixin_39654322的博客
02-25 4859
Stream流的使用流操作是Java8提供一个重要新特性，它允许开发人员以声明性方式处理集合，其核心类库主要改进了对集合类的 API和新增Stream操作。Stream类中每一个方法都对应集合上的一种操作。将真正的函数式编程引入到Java中，能 让代码更加简洁，极大地简化了集合的处理操作，提高了开发的效率和生产力。同时stream不是一种数据结构，它只是某种数据源的一个视图，数据源可以是一个数组，...
JDK8新特性Stream流
w13966597931的博客
07-24 269
JDK8新特性Stream流，基础使用以及项目实践
java中级高级面试题及答案，Java8 Stream 数据流，推荐学习
2401_84002630的博客
04-04 546
给大家送一个小福利附高清脑图，高清知识点讲解教程，以及一些面试真题及答案解析。送给需要的提升技术、准备面试跳槽、自身职业规划迷茫的朋友们。一个人可以走的很快，但一群人才能走的更远。如果你从事以下工作或对以下感兴趣，欢迎戳这里加入程序员的圈子，让我们一起学习成长！
jdk-8u241-windows-X86-32位-官网最新版
01-29
JDK8 32位最新版，Java SE Development Kit 8 ，jdk-8u241-windows-X86-32位-官网最新版。
最新版windows jdk-8u341-windows-x64.zip
08-11
最新版windows jdk-8u341-windows-x64.zip最新版windows jdk-8u341-windows-x64.zip
最新版windows jdk-8u401-windows-x64.zip
02-28
最新版windows jdk-8u401-windows-x64.zip最新版windows jdk-8u401-windows-x64.zip最新版windows jdk-8u401-windows-x64.zip最新版windows jdk-8u401-windows-x64.zip
最新版linux jdk-8u333-linux-x64.tar.gz
05-06
最新版linux jdk-8u333-linux-x64.tar.gz最新版linux jdk-8u333-linux-x64.tar.gz最新版linux jdk-8u333-linux-x64.tar.gz
JDK8新特性(Stream流)
chuyouyinghe的专栏
06-27 1314
一、Stream流的概念Stream 是Java8中处理集合的关键抽象概念，它可以对集合进行非常复杂的查找、过滤、筛选等操作，在新版的JPA【连接数据库】中，也已经加入了Stream。二、为什么要使用Stream流?每当我们需要对集合中的元素进行操作的时候，总是需要进行循环、循环、再循环。这是理所当然的么？不是。循环 是做事情的方式，而不是目的。每个需求都要循环一次，还要搞一个新集合来装数据，如果希望再次遍历，只能再使 用另一个循环从头开始。
Java8 面试题
dreamZhanglx的博客
04-24 384
Stream流是Java 8引入的一种数据流处理方式，可以用来对集合或数组进行函数式的处理。Stream流的操作可以分为两类：中间操作和终止操作。Lambda表达式由"->"符号分为两部分，左边是参数列表，右边是方法体。一个接口中只有一个抽象方法的接口称为函数式接口，通常使用@FunctionalInterface注解进行标识。是一种用于更好地处理空值的容器，可以避免在代码中使用大量的null检查，提高代码可读性和可维护性。如何使用Stream流对一个列表进行分组和统计？什么是Stream流？
JDK8 Stream 详细使用
Al_assad的博客
09-03 1万+
JDK8 管道 Stream 详细使用介绍   Stream 的获取 ① 通过集合Collection获取 List&lt;Integer&gt; list = new ArrayList&lt;Integer&gt;(Arrays.asList(1,2,3,4,5)); Stream&lt;Integer&gt; stream = list.stream(); ② 通过数组获取 ...
JDK8新特性(三)：集合之 Stream 流式操作
热门推荐
扛麻袋的少年的博客
01-07 1万+
1.Stream流由来 首先我们应该知道：Stream流的出现，主要是用在集合的操作上。在我们日常的工作中，经常需要对集合中的元素进行相关操作。诸如：增加、删除、获取元素、遍历。 最典型的就是集合遍历了。接下来我们先举个例子来看看 JDK8 Stream流式操作出现之前，我们对集合操作的过程，从中来了解一下JDK8 之前集合操作数据的弊端。 Demo...
JDK8之Stream流
bluede2015的博客
04-01 917
Stream流式思想类似于工厂车间的“生产流水线”，Stream流不是一种数据结构，不保存数据，而是对数据进行加工 处理。
Jdk8 之 Stream流详细用法(一)
木字楠的博客
11-14 3713
本篇文章参考云深i不知处的文章 原文链接：https://blog.csdn.net/mu_wind/article/details/109516995 一、概述   Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简而言之，Stream API 提供了一种高效且易于使用的处理数据的方
JDK8新特性进阶篇Stream
2301_76614448的博客
06-14 115
中间的操作: filter map sorted distinct() skip limit()终止操作: forEach count() reduce() collect(Collectors.toList()) findFirst​ max min。
【jdk8】Stream流学习
JZJ_LYH的博客
08-09 224
Stream流是Java 8中引入的一个新的抽象层，用于处理集合数据（数组、集合等）的操作。它提供了一种声明性的方式来处理数据，使得代码更简洁、可读性更强，并且支持并行处理大量数据。
JDK8 "2024-02-1" 转 LocalDateTime
04-10
要将字符串 "2024-02-1" 转换为 LocalDateTime 对象，您可以使用 Java 8 中的 DateTimeFormatter 类和 LocalDateTime 类来实现。以下是一个示例代码： ```java import java.time.LocalDateTime; import java.time....

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值