JUC入门（六）

news2025/5/23 15:45:16

12、四大函数式接口

Consumer<T>（消费者接口）

源码

功能

接收一个参数T，不返回任何结果。主要用于消费操作，例如打印日志、更新状态等。

使用场景

  • 遍历集合并执行操作。

  • 对象的字段赋值。

代码示例

import java.util.Arrays;
import java.util.List;

public class ConsumerExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

        // 使用Consumer接口打印每个名字
        names.forEach(name -> System.out.println(name));
    }
}

Supplier<T>（供给者接口）

源码

功能

不接收任何参数，返回一个T类型的值。主要用于生成数据。

使用场景

  • 生成默认值或随机值。

  • 提供数据源。

代码示例

import java.util.Random;

public class SupplierExample {
    public static void main(String[] args) {
        // 使用Supplier接口生成随机整数
        Supplier<Integer> randomSupplier = () -> new Random().nextInt(100);

        // 获取随机整数
        System.out.println("Random Integer: " + randomSupplier.get());
    }
}

Function<T, R>（函数接口）

源码

功能

接收一个T类型的参数，返回一个R类型的值。主要用于数据转换。

使用场景

  • 数据类型转换。

  • 数据处理和映射。

代码示例

package com.yw.FI;

import java.util.function.Function;

public class FunctionExample {
    public static void main(String[] args) {
       Function<String,String> function = (low) ->{return low.toUpperCase();};
        System.out.println(function.apply("abcdefg"));
    }
}

Predicate<T>（断言接口）

源码

功能

接收一个T类型的参数，返回一个布尔值。主要用于条件判断。

使用场景

  • 过滤数据。

  • 条件判断。

代码示例

package com.yw.FI;

import java.util.function.Predicate;

public class PredicateExample {
    public static void main(String[] args) {
        Predicate<Integer> predicate = i -> i % 2 ==0;
        System.out.println(predicate.test(2));
    }
}

13、stream流式计算

基本操作分类

Stream API的操作主要分为两大类：中间操作和终端操作。中间操作是惰性执行的，它们返回一个新的Stream对象，可以继续进行链式操作；终端操作会触发整个Stream的实际计算，并返回一个结果

中间操作
  • filter(Predicate<? super T> predicate)：根据条件过滤流中的元素。底层使用了Predicate函数式接口，该接口定义了一个test(T t)方法，用于判断一个元素是否满足特定条件。
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> evenNumbers = numbers.stream()
                                    .filter(n -> n % 2 == 0) // 使用Predicate
                                    .collect(Collectors.toList());
  • map(Function<? super T, ? extends R> mapper)：将流中的每个元素映射成另一种形式。底层使用了Function函数式接口，该接口定义了一个apply(T t)方法，用于将一个类型转换为另一个类型。
List<String> words = Arrays.asList("apple", "banana", "cherry");
List<String> upperWords = words.stream()
                               .map(String::toUpperCase) // 使用Function
                               .collect(Collectors.toList());
  • sorted() 或 sorted(Comparator<? super T> comparator)：对流中的元素进行排序。sorted()方法默认使用自然排序，而sorted(Comparator)则允许自定义排序规则。底层使用了Comparator函数式接口，该接口定义了compare(T o1, T o2)方法。
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
List<String> sortedNames = names.stream()
                                .sorted() // 自然排序
                                .collect(Collectors.toList());
  • distinct()：去除流中的重复元素。该操作不直接使用函数式接口，但依赖于元素的equals()和hashCode()方法。
List<Integer> numbers = Arrays.asList(1, 2, 2, 3, 4, 4, 5);
List<Integer> uniqueNumbers = numbers.stream()
                                     .distinct()
                                     .collect(Collectors.toList());
  • limit(long maxSize)：限制流中元素的数量。
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
List<Integer> limitedNumbers = numbers.stream()
                                      .limit(5)
                                      .collect(Collectors.toList());
  • skip(long n)：跳过流中的前n个元素。
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
List<Integer> skippedNumbers = numbers.stream()
                                      .skip(3)
                                      .collect(Collectors.toList());

终端操作
  • forEach(Consumer<? super T> action)：遍历流中的每个元素，并对其执行操作。底层使用了Consumer函数式接口，该接口定义了一个accept(T t)方法。
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
names.stream()
     .forEach(System.out::println); // 使用Consumer
  • reduce(BinaryOperator<T> accumulator)：将流中的元素组合起来，得到一个值。底层使用了BinaryOperator函数式接口，该接口是BiFunction的特化版本，定义了apply(T t1, T t2)方法。
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> sum = numbers.stream()
                               .reduce((a, b) -> a + b); // 使用BinaryOperator
sum.ifPresent(System.out::println);
  • collect(Collectors.toList())、collect(Collectors.toSet())等：将流中的元素收集到新的集合中。Collectors类提供了多种收集器，用于将流中的元素收集到不同的集合类型中。
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
String joinedNames = names.stream()
                          .collect(Collectors.joining(", ")); // 收集为字符串
System.out.println(joinedNames);

这里的clooect以后我经常使用，其中的收集器种类很多，列举常用收集器

  1. Collectors.toList()

  • Collectors.toList()
  • 示例：
List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
List<String> filteredNames = names.stream()
                                  .filter(name -> name.startsWith("A"))
                                  .collect(Collectors.toList());
System.out.println(filteredNames); // 输出: [Alice]

     2. Collectors.toSet()

  • 作用：将流中的元素收集到一个新的 Set 中，去除重复元素。
  • 示例：
List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "Alice");
Set<String> uniqueNames = names.stream()
                               .collect(Collectors.toSet());
System.out.println(uniqueNames); // 输出: [Alice, Bob, Charlie]

   3. Collectors.toCollection(Supplier<C> collectionFactory)

  • 作用：将流中的元素收集到指定的集合类型中。
  • 示例：
List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "Alice");
HashSet<String> uniqueNames = names.stream()
                                   .collect(Collectors.toCollection(HashSet::new));
System.out.println(uniqueNames); // 输出: [Alice, Bob, Charlie]

  4. Collectors.joining(CharSequence delimiter)

  • 作用：将流中的字符串元素连接成一个单一的字符串，使用指定的分隔符。
  • 示例：
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
String joinedNames = names.stream()
                          .collect(Collectors.joining(", "));
System.out.println(joinedNames); // 输出: Alice, Bob, Charlie

 5. Collectors.groupingBy(Function<? super T, ? extends K> classifier)

  • 作用：将流中的元素按某个属性或条件分组，返回一个 Map。
  • 示例：
List<Person> people = Arrays.asList(
    new Person("Alice", 25),
    new Person("Bob", 30),
    new Person("Charlie", 25)
);
Map<Integer, List<Person>> peopleByAge = people.stream()
                                               .collect(Collectors.groupingBy(Person::getAge));
System.out.println(peopleByAge); // 输出: {25=[Alice, Charlie], 30=[Bob]}

6. Collectors.toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper)

  • 作用：将流中的元素收集到一个 Map 中，指定键和值的映射方式。
  • 示例：
List<Person> people = Arrays.asList(
    new Person("Alice", 25),
    new Person("Bob", 30),
    new Person("Charlie", 25)
);
Map<String, Integer> nameToAge = people.stream()
                                        .collect(Collectors.toMap(Person::getName, Person::getAge));
System.out.println(nameToAge); // 输出: {Alice=25, Bob=30, Charlie=25}

7. Collectors.summingInt(ToIntFunction<? super T> mapper)

  • 作用：对流中的元素进行求和操作，返回一个 int 值。
  • 示例：
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.stream()
                 .collect(Collectors.summingInt(Integer::intValue));
System.out.println(sum); // 输出: 15

8. Collectors.averagingInt(ToIntFunction<? super T> mapper)

  • 作用：对流中的元素进行平均值计算，返回一个 double 值。
  • 示例：
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
double average = numbers.stream()
                        .collect(Collectors.averagingInt(Integer::intValue));
System.out.println(average); // 输出: 3.0

9. Collectors.maxBy(Comparator<? super T> comparator)

  • 作用：找到流中的最大元素，返回一个 Optional<T>。
  • 示例：
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> max = numbers.stream()
                               .collect(Collectors.maxBy(Integer::compare));
System.out.println(max.get()); // 输出: 5

10. Collectors.minBy(Comparator<? super T> comparator)

  • 作用：找到流中的最小元素，返回一个 Optional<T>。
  • 示例：
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> min = numbers.stream()
                               .collect(Collectors.minBy(Integer::compare));
System.out.println(min.get()); // 输出: 1

11. Collectors.counting()

  • 作用：计算流中的元素数量，返回一个 long 值。
  • 示例：
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
long count = numbers.stream()
                    .collect(Collectors.counting());
System.out.println(count); // 输出: 5

12. Collectors.reducing(BinaryOperator<T> operator)

  • 作用：对流中的元素进行归并操作，返回一个归并后的结果。
  • 示例：
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.stream()
                 .collect(Collectors.reducing(0, Integer::intValue, Integer::sum));
System.out.println(sum); // 输出: 15

13. Collectors.partitioningBy(Predicate<? super T> predicate)

  • 作用：将流中的元素按某个条件分为两部分，返回一个 Map<Boolean, List<T>>。
  • 示例：
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Map<Boolean, List<Integer>> partitioned = numbers.stream()
                                                 .collect(Collectors.partitioningBy(n -> n % 2 == 0));
System.out.println(partitioned); // 输出: {false=[1, 3, 5], true=[2, 4]}

  • anyMatch(Predicate<? super T> predicate)、allMatch(Predicate<? super T> predicate)、noneMatch(Predicate<? super T> predicate)：检查流中的元素是否满足某个条件。这些操作底层使用了Predicate函数式接口。
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
boolean hasEven = numbers.stream()
                         .anyMatch(n -> n % 2 == 0); // 使用Predicate
System.out.println(hasEven);
  • findFirst()、findAny()：查找流中的元素。
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
Optional<String> first = names.stream()
                              .findFirst();
first.ifPresent(System.out::println);
  • max(Comparator<? super T> comparator)、min(Comparator<? super T> comparator)：找到流中的最大或最小元素。底层使用了Comparator函数式接口。
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> max = numbers.stream()
                               .max(Integer::compare); // 使用Comparator
max.ifPresent(System.out::println);
  • count()：计算流中的元素数量。
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
long count = numbers.stream()
                    .count();
System.out.println(count);

希望以上Java Stream能够带给大家帮助

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2383986.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

window xampp apache使用腾讯云ssl证书配置https

window xampp apache使用腾讯云ssl证书配置https

下载腾讯云ssl证书&#xff1a; 编辑Apache根目录下 conf/httpd.conf 文件&#xff1a; #LoadModule ssl_module modules/mod_ssl.so和#Include conf/extra/httpd-ssl.conf&#xff0c;去掉前面的#号注释。 编辑Apache根目录下 conf/httpd-ssl.conf 文件&#xff1a; <Vi…
阅读更多...
逆向音乐APP：Python爬虫获取音乐榜单 (1)

逆向音乐APP：Python爬虫获取音乐榜单 (1)

1. 引言 在数字音乐时代&#xff0c;许多平台如音乐有榜单&#xff0c;限制非付费用户访问高音质或独家内容。然而&#xff0c;从技术研究的角度来看&#xff0c;我们可以通过逆向工程和Python爬虫技术解音乐的API接口&#xff0c;获取付费音乐的播放链接。 2. 技术准备 在当…
阅读更多...
支持向量存储：PostgresSQL及pgvector扩展详细安装步骤！老工程接入RAG功能必备！

支持向量存储：PostgresSQL及pgvector扩展详细安装步骤！老工程接入RAG功能必备！

之前文章和大家分享过&#xff0c;将会出一篇专栏&#xff08;从电脑装ubuntu系统&#xff0c;到安装ubuntu的常用基础软件&#xff1a;jdk、python、node、nginx、maven、supervisor、minio、docker、git、mysql、redis、postgresql、mq、ollama等&#xff09;&#xff0c;目前…
阅读更多...
idea常用配置 properties中文输出乱码

idea常用配置 properties中文输出乱码

propertis配置中文乱码 源码和编译后的都是中文 程序输入效果 idea配置3处 程序输出效果 自定义注释模板 IDEA 中有以下两种配置模板。 File and Code Templates Live Templates File and Code Templates File and Code Templates 用来配置文件和代码模板&#xff0c;即…
阅读更多...
day1 大模型学习 Qwen系列学习

day1 大模型学习 Qwen系列学习

Qwen 模型学习笔记：RM、SFT 与 RLHF 技术解析 一、Qwen 模型概述 Qwen 是阿里巴巴开源的大型语言模型系列，旨在实现通用人工智能（AGI）。其架构包括基础语言模型（如 Qwen-7B、Qwen-14B、Qwen-72B）和经过后训练的对话模型（如 Qwen-Chat）。后训练主要通过 SFT 和 RLHF 技…
阅读更多...
Unity3D仿星露谷物语开发47之砍树时落叶特效

Unity3D仿星露谷物语开发47之砍树时落叶特效

1、目标 当橡树被砍伐时的落叶粒子效果。 2、创建粒子物体 Hierarchy -> PersistentScene下创建新物体命名为DeciduousLeavesFalling。 添加Particle System组件。 基础配置如下&#xff1a;&#xff08;暂时勾选Looping实时可以看生成效果&#xff0c;后面反选即可&am…
阅读更多...
第十节第六部分：常见API：DateTimeFormatter、Period、Duration

第十节第六部分：常见API：DateTimeFormatter、Period、Duration

DateTimeFormatter类常用方法 Period类常用方法 Duration类常用方法 总结 代码&#xff1a; 代码一&#xff1a;DateTimeFormatter类常用方法 package com.itheima.jdk8_time;import java.time.LocalDateTime; import java.time.format.DateTimeFormatter;public class DateT…
阅读更多...
如何在VSCode中更换默认浏览器：完整指南

如何在VSCode中更换默认浏览器：完整指南

引言 作为前端开发者&#xff0c;我们经常需要在VSCode中快速预览HTML文件。默认情况下&#xff0c;VSCode会使用系统默认浏览器打开文件&#xff0c;但有时我们可能需要切换到其他浏览器进行测试。本文将详细介绍如何在VSCode中更换默认浏览器。 方法一&#xff1a;使用VSCo…
阅读更多...
【机器人】复现 3D-Mem 具身探索和推理 | 3D场景记忆 CVPR 2025

【机器人】复现 3D-Mem 具身探索和推理 | 3D场景记忆 CVPR 2025

3D-Mem 是用于具体探索和推理的3D场景记忆&#xff0c;来自CVPR 2025. 本文分享3D-Mem复现和模型推理的过程&#xff5e; 下面是一个推理和选择识别的结果&#xff1a; 看一下机器人探索的效果&#xff1a; 下面是真实环境下&#xff0c;官方跑的demo&#xff0c;3D-Mem无需训…
阅读更多...
鸿蒙进阶——CMakelist、GN语法简介及三方库通用移植指南

鸿蒙进阶——CMakelist、GN语法简介及三方库通用移植指南

文章大纲 引言一、GN常用的内置变量二、GN常用的内置函数三、CMake 重要语法1、生成动态库2、生成静态库3、生成OBJECT 库4、重要的函数和模块4.1、add_definitions4.2、execute_process4.3、add_dependencies4.4、install4.5、FetchContent 四、GN 重要语法1、编译Target2、预…
阅读更多...
CSS-5.1 Transition 过渡

CSS-5.1 Transition 过渡

本系列可作为前端学习系列的笔记&#xff0c;代码的运行环境是在HBuilder中&#xff0c;小编会将代码复制下来&#xff0c;大家复制下来就可以练习了&#xff0c;方便大家学习。 HTML系列文章 已经收录在前端专栏&#xff0c;有需要的宝宝们可以点击前端专栏查看&#xff01; 点…
阅读更多...
从虚拟仿真到行业实训再到具身智能--华清远见嵌入式物联网人工智能全链路教学方案

从虚拟仿真到行业实训再到具身智能--华清远见嵌入式物联网人工智能全链路教学方案

2025年5月23-25日&#xff0c;第63届中国高等教育博览会&#xff08;高博会&#xff09;将在长春中铁东北亚国际博览中心举办。作为国内高等教育领域规模大、影响力广的综合性展会&#xff0c;高博会始终聚焦教育科技前沿&#xff0c;吸引全国高校管理者、一线教师、教育科技企…
阅读更多...
告别手动绘图！2分钟用 AI 生成波士顿矩阵

告别手动绘图！2分钟用 AI 生成波士顿矩阵

波士顿矩阵作为经典工具&#xff0c;始终是企业定位产品组合、制定竞争策略的核心方法论。然而&#xff0c;传统手动绘制矩阵的方式&#xff0c;往往面临数据处理繁琐、图表调整耗时、团队协作低效等痛点。 随着AI技术的发展&#xff0c;这一现状正在被彻底改变。boardmix博思白…
阅读更多...
GraphPad Prism工作表的管理

GraphPad Prism工作表的管理

《2025新书现货 GraphPad Prism图表可视化与统计数据分析&#xff08;视频教学版&#xff09;雍杨 康巧昆 清华大学出版社教材书籍 9787302686460 GraphPadPrism图表可视化 无规格》【摘要 书评 试读】- 京东图书 GraphPad Prism统计数据分析_夏天又到了的博客-CSDN博客 工作…
阅读更多...
UE 材质几个输出向量节点

UE 材质几个输出向量节点

PixelNormalWS
阅读更多...
告别静态UI！Guineration用AI打造用户专属动态界面

告别静态UI！Guineration用AI打造用户专属动态界面

摘 要 作为智能原生操作系统 DingOS 的核心技术之一&#xff0c;Guineration 生成式 UI 体系深刻践行了 DingOS“服务定义软件”的核心理念。DingOS 以“一切皆服务、服务按需而取、按用付费”为设计宗旨&#xff0c;致力于通过智能原生能力与粒子服务架构&#xff0c;实现资源…
阅读更多...
第六届电子通讯与人工智能国际学术会议（ICECAI 2025）

第六届电子通讯与人工智能国际学术会议（ICECAI 2025）

在数字化浪潮中&#xff0c;电子通讯与人工智能的融合正悄然重塑世界的运行逻辑。技术基础的共生关系是这场变革的核心——电子通讯如同“信息高速公路”&#xff0c;通过5G等高速传输技术&#xff0c;将海量数据实时输送至AI系统&#xff0c;使其能够像人类神经系统般快速响应…
阅读更多...
解决vscode在任务栏显示白色图标

解决vscode在任务栏显示白色图标

长久不用&#xff0c;不知道怎么着就显示成白色图标&#xff0c;虽然不影响使用&#xff0c;但是看起来不爽 问了豆包&#xff0c;给了个解决方法&#xff1a; 1、打开隐藏文件&#xff0c; 由于图标缓存文件是隐藏文件&#xff0c;首先点击资源管理器中的 “查看” 菜单&am…
阅读更多...
架构思维：构建高并发扣减服务_分布式无主架构

架构思维：构建高并发扣减服务_分布式无主架构

文章目录 Pre无主架构的任务简单实现分布式无主架构 设计和实现扣减中的返还什么是扣减的返还返还实现原则原则一&#xff1a;扣减完成才能返还原则二&#xff1a;一次扣减可以多次返还原则三&#xff1a;返还的总数量要小于等于原始扣减的数量原则四&#xff1a;返还要保证幂等…
阅读更多...
uni-app学习笔记九-vue3 v-for指令

uni-app学习笔记九-vue3 v-for指令

v-for 指令基于一个数组来渲染一个列表。v-for 指令的值需要使用 item in items 形式的特殊语法&#xff0c;其中 items 是源数据的数组&#xff0c;而 item 是迭代项的别名&#xff1a; <template><view v-for"(item,index) in 10" :key"index"…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023