Java 8 Stream操作示例

以下是 Java 8 之后常见的 Stream 操作示例,包含中文注释,便于理解各个操作的用途:

一. 常用操作

操作 说明
filter 过滤符合条件的元素
map 对元素进行转换
reduce 聚合操作,如求和、求乘积等
sorted 排序
distinct 去重
limit 截取前 N 个元素
skip 跳过前 N 个元素
anyMatch 是否存在至少一个满足条件
allMatch 是否所有都满足条件
noneMatch 是否全部都不满足条件
collect 收集结果,可以是 list、map 等
groupingBy 分组

1. filter 过滤出偶数

复制代码
    // filter 过滤出偶数
    @Test
    public void testFilter() {
        List<Integer> list = Arrays.asList(1, 2, 3, 4);
        List<Integer> even = list.stream()
                .filter(n -> n % 2 == 0) // 过滤出偶数
                .collect(Collectors.toList());
        log.info("even: {}", even);
    }

2. map 将每个元素乘2

复制代码
    // map 将每个元素乘2
    @Test
    public void testMap() {
        List<Integer> list = Arrays.asList(1, 2, 3);
        List<Integer> mapped = list.stream()
                .map(n -> n * 2) // 每个元素乘2
                .collect(Collectors.toList());
        log.info("mapped: {}", mapped);
    }

3. reduce 求和

复制代码
    // reduce 求和
    @Test
    public void testReduce() {
        List<Integer> list = Arrays.asList(1, 2, 3);
        int sum = list.stream()
                .reduce(0, Integer::sum); // 从0开始累加
        log.info("sum: {}", sum);
    }

4. sorted 升序排序

复制代码
    // sorted 升序排序
    @Test
    public void testSorted() {
        List<Integer> list = Arrays.asList(3, 1, 2);
        List<Integer> sorted = list.stream()
                .sorted() // 默认升序
                .collect(Collectors.toList());
        log.info("sorted: {}", sorted);
    }

5. sorted + reverseOrder 倒序排序

复制代码
    // sorted + reverseOrder 倒序排序
    @Test
    public void testReverseSorted() {
        List<Integer> list = Arrays.asList(1, 3, 2);
        List<Integer> reversed = list.stream()
                .sorted(Comparator.reverseOrder()) // 倒序排序
                .collect(Collectors.toList());
        log.info("reversed: {}", reversed);
    }

6. distinct 去重

复制代码
    // distinct 去重
    @Test
    public void testDistinct() {
        List<Integer> list = Arrays.asList(1, 2, 2, 3);
        List<Integer> distinct = list.stream()
                .distinct() // 去除重复
                .collect(Collectors.toList());
        log.info("distinct: {}", distinct);
    }

7. limit 取前N个

复制代码
    // limit 取前N个
    @Test
    public void testLimit() {
        List<Integer> list = Arrays.asList(1, 2, 3, 4);
        List<Integer> limited = list.stream()
                .limit(2) // 取前两个元素
                .collect(Collectors.toList());
        log.info("limited: {}", limited);
    }

8. skip 跳过前N个

复制代码
    // skip 跳过前N个
    @Test
    public void testSkip() {
        List<Integer> list = Arrays.asList(1, 2, 3, 4);
        List<Integer> skipped = list.stream()
                .skip(2) // 跳过前两个
                .collect(Collectors.toList());
        log.info("skipped: {}", skipped);
    }

9. anyMatch 判断是否存在符合条件的元素

复制代码
    // anyMatch 判断是否存在符合条件的元素
    @Test
    public void testAnyMatch() {
        List<Integer> list = Arrays.asList(1, 3, 5);
        boolean hasEven = list.stream()
                .anyMatch(n -> n % 2 == 0); // 是否有偶数
        log.info("hasEven: {}", hasEven);
    }

10. allMatch 判断是否所有元素都符合条件

复制代码
    // allMatch 判断是否所有元素都符合条件
    @Test
    public void testAllMatch() {
        List<Integer> list = Arrays.asList(2, 4, 6);
        boolean allEven = list.stream()
                .allMatch(n -> n % 2 == 0); // 是否都是偶数
        log.info("allEven: {}", allEven);
    }

11. noneMatch 判断是否没有元素符合条件

复制代码
    // noneMatch 判断是否没有元素符合条件
    @Test
    public void testNoneMatch() {
        List<Integer> list = Arrays.asList(1, 2, 3);
        boolean noneNegative = list.stream()
                .noneMatch(n -> n < 0); // 没有负数
        log.info("noneNegative: {}", noneNegative);
    }

12. collect + joining 拼接字符串

复制代码
    // collect + joining 拼接字符串
    @Test
    public void testJoining() {
        List<String> names = Arrays.asList("张三", "李四", "王五");
        String result = names.stream()
                .collect(Collectors.joining(", ")); // 使用逗号拼接
        log.info("result: {}", result);
    }

13. collect + groupingBy 分组

复制代码
    // collect + groupingBy 分组
    @Test
    public void testGroupingBy() {
        List<String> words = Arrays.asList("apple", "banana", "apricot", "blueberry");
        Map<Character, List<String>> grouped = words.stream()
                .collect(Collectors.groupingBy(word -> word.charAt(0))); // 按首字母分组
        log.info("grouped: {}", grouped);

    }

一线网资源-全网一站式平台

相关推荐
果果软件9 小时前
2026 后台管理系统选型:若依、JeecgBoot、芋道、NocoBase 和 GewuMind Boot 怎么选?
java·人工智能·后端·ai·开源
码云社区12 小时前
Java家政服务系统源码:人员技能、服务范围与多商家业务落地
java·开发语言·家政服务·家政小程序·家政系统
摇滚侠13 小时前
《On Java 中文版 基础卷》阅读笔记 接口 18
java·笔记·python
CoderYanger13 小时前
Java EE 进阶:9.MyBatis 操作数据库(进阶)(第八弹):MyBatis Generator
java·数据库·spring boot·spring·java-ee·tomcat·mybatis
jaysee-sjc16 小时前
【黑马点评】Day02:优惠券秒杀与分布式锁
java·分布式·nginx·spring·node.js·tomcat·maven
秋天的怀念_David17 小时前
算法一千零一夜 · 第三十五夜 · 恢复风暴
java·程序人生·算法
考虑考虑17 小时前
JDK27中的加密对象的 PEM 编码
java·后端·java ee
行者-全栈开发17 小时前
SpringBoot + GraalVM 原生编译实战:启动时间从8秒到0.5秒的极致优化
java·spring boot·后端
CoderYanger17 小时前
Java EE 进阶:10. MyBatis-Plus使用(第一弹)
java·spring boot·后端·sql·spring·java-ee·mybatis
大胖爱学习_MJ20 小时前
超越向量检索:用 Spring Boot + Neo4j 手搓 GraphRAG 知识图谱记忆
java·后端·python