AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

深入探讨 Java 8 集合操作：全面解析 Stream API 的强大功能

2024-06-14 90
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
公共DNS（含HTTPDNS解析），每月1000万次HTTP解析
全局流量管理 GTM，标准版 1个月
云解析 DNS，旗舰版 1个月
简介： 深入探讨 Java 8 集合操作：全面解析 Stream API 的强大功能

深入探讨 Java 8 集合操作：全面解析 Stream API 的强大功能

Java 8 引入的 Stream API 使得集合操作更加简洁和高效。本文通过详细示例，展示如何利用 Stream API 进行各种集合操作，包括遍历、转换、过滤、排序、分组、去重等。

1. 遍历集合

示例：使用 forEach 遍历列表

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

public class ForEachExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Peter", "Anna", "Mike", "Xenia");

        // 使用 forEach 遍历列表
        names.forEach(name -> System.out.println(name));
    }
}

import java.util.HashMap;
import java.util.Map;

public class ForEachMapExample {
    public static void main(String[] args) {
        Map<String, Integer> ages = new HashMap<>();
        ages.put("Peter", 30);
        ages.put("Anna", 25);
        ages.put("Mike", 35);

        // 使用 forEach 遍历 Map
        ages.forEach((name, age) -> System.out.println(name + ": " + age));
    }
}

2. List 转 Map

示例：将 List 转换为 Map

import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;

class Person {
    private String name;
    private int age;

    // 构造方法和 getter 方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

public class ListToMapExample {
    public static void main(String[] args) {
        List<Person> people = Arrays.asList(new Person("Peter", 30), new Person("Anna", 25), new Person("Peter", 28));

        // 将 List 转换为 Map
        Map<String, Integer> personMap = people.stream()
                .collect(Collectors.toMap(Person::getName, Person::getAge, (existing, replacement) -> existing));

        personMap.forEach((name, age) -> System.out.println(name + ": " + age));

        // 有序写法
        Map<String, Person> personOrderlyMap = people
                .stream()
                .collect(Collectors.toMap(Person::getName,
                        a -> a, (oldValue, newValue) -> newValue, LinkedHashMap::new));

        // value为对象时，也可以这样写，注意ID相同时，会抛异常
        Map<String, Person> personMapOther = people
                .stream()
                .collect(Collectors.toMap(Person::getName, person -> person));

        // 还可以这样写 输出跟输入一样的Lambda表达式对象，等价于person -> person
        Map<String, Person> personAscMap = people
                .stream()
                .collect(Collectors.toMap(Person::getName, Function.identity()));

        // map按key排序 默认正序，反序为： Map.Entry.comparingByKey().reversed()
        Map<String, Person> personDescMap = personAscMap
                .entrySet()
                .stream()
                .sorted(Map.Entry.comparingByKey())
                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (oldValue, newValue) -> oldValue, LinkedHashMap::new));
    }
}

3. 过滤和映射

示例：过滤列表

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class FilterExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Peter", "Anna", "Mike", "Xenia");

        // 过滤名字以 "P" 开头的元素
        List<String> filteredNames = names.stream()
                                          .filter(name -> name.startsWith("P"))
                                          .collect(Collectors.toList());

        System.out.println(filteredNames); // 输出：[Peter]
    }
}

示例：映射列表

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class MapExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Peter", "Anna", "Mike", "Xenia");

        // 将名字转换为大写
        List<String> upperCaseNames = names.stream()
                                           .map(String::toUpperCase)
                                           .collect(Collectors.toList());

        System.out.println(upperCaseNames); // 输出：[PETER, ANNA, MIKE, XENIA]
    }
}

4. 聚合操作

示例：求和

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

public class SumExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

        // 使用 Stream API 计算总和
        int sum = numbers.stream()
                         .mapToInt(Integer::intValue)
                         .sum();

        System.out.println("Sum: " + sum); // 输出：Sum: 15
    }
}

示例：求平均值

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

public class AverageExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

        // 使用 Stream API 计算平均值
        OptionalDouble average = numbers.stream()
                                        .mapToInt(Integer::intValue)
                                        .average();

        System.out.println("Average: " + (average.isPresent() ? average.getAsDouble() : "N/A"));
    }
}

5. 分组和分区

示例：按条件分组

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class GroupingByExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Peter", "Anna", "Mike", "Xenia");

        // 按名字的长度分组
        Map<Integer, List<String>> groupedByLength = names.stream()
                                                          .collect(Collectors.groupingBy(String::length));

        groupedByLength.forEach((length, nameList) -> System.out.println(length + ": " + nameList));
    }
}

示例：按条件分区

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class PartitioningByExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);

        // 按是否为偶数分区
        Map<Boolean, List<Integer>> partitionedByEven = numbers.stream()
                                                               .collect(Collectors.partitioningBy(n -> n % 2 == 0));

        partitionedByEven.forEach((isEven, numList) -> System.out.println(isEven + ": " + numList));
    }
}

6. 并行流

示例：使用并行流提高性能

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

public class ParallelStreamExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        // 使用并行流计算总和
        int sum = numbers.parallelStream()
                         .mapToInt(Integer::intValue)
                         .sum();

        System.out.println("Sum: " + sum); // 输出：Sum: 55
    }
}

7. 去重操作

示例：去除列表中的重复元素

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class DistinctExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Peter", "Anna", "Mike", "Anna", "Xenia", "Peter");

        // 使用 distinct 去重
        List<String> uniqueNames = names.stream()
                                        .distinct()
                                        .collect(Collectors.toList());

        System.out.println(uniqueNames); // 输出：[Peter, Anna, Mike, Xenia]
        
        // 对象，根据ID去重
    List<User> duplicateRemoval = zxrMaps.stream().collect(
    Collectors.collectingAndThen(
      Collectors.toCollection(() -> 
      new TreeSet<>(Comparator.comparing(User::getId))), ArrayList::new)
    );
    }
}

8. 收集结果

示例：将列表转换为 Set

import java.util.Arrays;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

public class ToSetExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Peter", "Anna", "Mike", "Xenia");

        // 将列表转换为 Set
        Set<String> nameSet = names.stream()
                                   .collect(Collectors.toSet());

        System.out.println(nameSet);
    }
}

示例：连接字符串

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class JoiningExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Peter", "Anna", "Mike", "Xenia");

        // 连接字符串，使用逗号分隔
        String joinedNames = names.stream()
                                  .collect(Collectors.joining(", "));

        System.out.println(joinedNames); // 输出：Peter, Anna, Mike, Xenia
    }
}

9. 映射和扁平化

示例：扁平化嵌套列表

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class FlatMapExample {
    public static void main(String[] args) {
        List<List<String>> nestedList = Arrays.asList(
            Arrays.asList("Peter", "Anna"),
            Arrays.asList("Mike", "Xenia")
        );

        // 扁平化嵌套列表
        List<String> flatList = nestedList.stream()
                                          .flatMap(List::stream)
                                          .collect(Collectors.toList());

        System.out.println(flatList); // 输出：[Peter, Anna, Mike, Xenia]
    }
}

10. 生成流

示例：生成数值范围

import java.util.stream.IntStream;

public class IntStreamRangeExample {
    public static void main(String[] args) {
        // 生成 1 到 10 的数值范围
        IntStream.rangeClosed(1, 10)
                 .forEach(System.out::println);
    }
}

11. 归约操作

示例：使用 reduce 求和

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

public class ReduceSumExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

        // 使用 reduce 求和
        int sum = numbers.stream()
                         .reduce(0, Integer::sum);

        System.out.println("Sum: " + sum); // 输出：Sum: 15
    }
}

示例：使用 reduce 求乘积

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

public class ReduceProductExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

        // 使用 reduce 求乘积
        int product = numbers.stream()
                             .reduce(1, (a, b) -> a * b);

        System.out.println("Product: " + product); // 输出：Product: 120
    }
}

12. 排序和查找

示例：排序列表

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class SortExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Peter", "Anna", "Mike", "Xenia");

        // 排序列表
        List<String> sortedNames = names.stream()
                                        .sorted()
                                        .collect(Collectors.toList());

        System.out.println(sortedNames); // 输出：[Anna, Mike, Peter, Xenia]
    }
}

示例：查找第一个匹配元素

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

public class FindFirstExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Peter", "Anna", "Mike", "Xenia");

        // 查找第一个以 "P" 开头的元素
        Optional<String> firstMatchingName = names.stream()
                                                  .filter(name -> name.startsWith("P"))
                                                  .findFirst();

        System.out.println("First matching name: " + firstMatchingName.orElse("No match"));
    }
}

13. 自定义收集器

示例：自定义收集器

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collector;
import java.util.stream.Collectors;

public class CustomCollectorExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Peter", "Anna", "Mike", "Xenia");

        // 自定义收集器
        String result = names.stream()
                             .collect(Collector.of(
                                 StringBuilder::new,
                                 (sb, name) -> sb.append(name).append("|"),
                                 StringBuilder::append,
                                 StringBuilder::toString
                             ));

        System.out.println(result); // 输出：Peter|Anna|Mike|Xenia|
    }
}

14. List 并集、差集、交集

// list1
List<String> list1 = Arrays.asList("a", "b", "c");

// list2
List<String> list2 = Arrays.asList("b", "c", "d");

// 交集 ("b", "c")
List<String> intersection = list1.stream().filter(item -> list2.contains(item)).collect(toList());

// 差集 (list1 - list2)
List<String> reduce1 = list1.stream().filter(item -> !list2.contains(item)).collect(toList());

// 差集 (list2 - list1)
List<String> reduce2 = list2.stream().filter(item -> !list1.contains(item)).collect(toList());

// 并集 (list1 + list2)
List<String> listAll = new ArrayList();
listAll.addAll(list1);
listAll.addAll(list2);
listAll.parallelStream().forEach(System.out :: println);

// 并集去重
List<String> listAllDistinct = listAll.stream().distinct().collect(toList());

总结

Java 8 的 Stream API 通过提供流畅、声明式的编程方式，使集合操作更加灵活和高效。本文通过详尽的示例展示了 Stream API 在遍历、转换、过滤、分组、去重、并行处理等方面的强大功能。这些新特性不仅提高了代码的简洁性和可读性，还显著提升了开发效率。

文章标签：
云解析DNS
API
Java
关键词：
云解析DNS api
解析API
云解析DNS功能
API功能
Java解析
Jack_hrx
目录
相关文章
软件求生
|
4天前
|
存储 安全 Java
Java 集合框架中的老炮与新秀：HashTable 和 HashMap 谁更胜一筹？
嗨，大家好，我是技术伙伴小米。今天通过讲故事的方式，详细介绍 Java 中 HashMap 和 HashTable 的区别。从版本、线程安全、null 值支持、性能及迭代器行为等方面对比，帮助你轻松应对面试中的经典问题。HashMap 更高效灵活，适合单线程或需手动处理线程安全的场景；HashTable 较古老，线程安全但性能不佳。现代项目推荐使用 ConcurrentHashMap。关注我的公众号“软件求生”，获取更多技术干货！
软件求生
23 3
TENGZO
|
18天前
|
数据可视化 数据挖掘 BI
团队管理者必读：高效看板类协同软件的功能解析
在现代职场中，团队协作的效率直接影响项目成败。看板类协同软件通过可视化界面，帮助团队清晰规划任务、追踪进度，提高协作效率。本文介绍看板类软件的优势，并推荐五款优质工具：板栗看板、Trello、Monday.com、ClickUp 和 Asana，助力团队实现高效管理。
TENGZO
44 2
蚝油菜花
|
3天前
|
人工智能 自然语言处理 Java
FastExcel：开源的 JAVA 解析 Excel 工具，集成 AI 通过自然语言处理 Excel 文件，完全兼容 EasyExcel
FastExcel 是一款基于 Java 的高性能 Excel 处理工具，专注于优化大规模数据处理，提供简洁易用的 API 和流式操作能力，支持从 EasyExcel 无缝迁移。
蚝油菜花
46 9
FastExcel：开源的 JAVA 解析 Excel 工具，集成 AI 通过自然语言处理 Excel 文件，完全兼容 EasyExcel
运营研究坊
|
10天前
|
存储 缓存 Java
Java 并发编程——volatile 关键字解析
本文介绍了Java线程中的`volatile`关键字及其与`synchronized`锁的区别。`volatile`保证了变量的可见性和一定的有序性，但不能保证原子性。它通过内存屏障实现，避免指令重排序，确保线程间数据一致。相比`synchronized`，`volatile`性能更优，适用于简单状态标记和某些特定场景，如单例模式中的双重检查锁定。文中还解释了Java内存模型的基本概念，包括主内存、工作内存及并发编程中的原子性、可见性和有序性。
运营研究坊
49 5
Java 并发编程——volatile 关键字解析
蓝染-惣右介
|
10天前
|
设计模式 XML Java
【23种设计模式·全精解析 | 自定义Spring框架篇】Spring核心源码分析+自定义Spring的IOC功能，依赖注入功能
本文详细介绍了Spring框架的核心功能，并通过手写自定义Spring框架的方式，深入理解了Spring的IOC(控制反转)和DI（依赖注入）功能，并且学会实际运用设计模式到真实开发中。
蓝染-惣右介
40 1
【23种设计模式·全精解析 | 自定义Spring框架篇】Spring核心源码分析+自定义Spring的IOC功能，依赖注入功能
TDengine
|
3天前
|
存储 数据库 对象存储
新版本发布：查询更快，兼容更强，TDengine 3.3.4.3 功能解析
经过 TDengine 研发团队的精心打磨，TDengine 3.3.4.3 版本正式发布。作为时序数据库领域的领先产品，TDengine 一直致力于为用户提供高效、稳定、易用的解决方案。本次版本更新延续了一贯的高标准，为用户带来了多项实用的新特性，并对系统性能进行了深度优化。
TDengine
14 3
游客x4wok3c7ts5b2
|
3天前
|
供应链 数据可视化 数据挖掘
企业服务品牌深度解析：销售易、用友、白码功能与特色对比
在企业服务领域，销售易、用友、白码等品牌凭借独特的产品和解决方案占据重要地位。销售易专注于CRM，提供客户管理、销售自动化、市场营销等功能，提升销售效率与客户满意度。用友作为领先的企业服务提供商，涵盖ERP、财务管理、人力资源管理等，助力企业资源优化配置。白码则以低代码开发平台为核心，支持快速构建业务应用，具备高度可定制化和易于维护的特点。三者各具特色，共同推动企业数字化转型。
游客x4wok3c7ts5b2
11 3
李游Leo
|
3天前
|
人工智能 数据可视化 API
自学记录鸿蒙API 13:Calendar Kit日历功能从学习到实践
本文介绍了使用HarmonyOS的Calendar Kit开发日程管理应用的过程。通过API 13版本，不仅实现了创建、查询、更新和删除日程等基础功能，还深入探索了权限请求、日历配置、事件添加及查询筛选等功能。实战项目中，开发了一个智能日程管理工具，具备可视化管理、模糊查询和智能提醒等特性。最终，作者总结了模块化开发的优势，并展望了未来加入语音助手和AI推荐功能的计划。
李游Leo
111 1
三三是该溜子
|
8天前
|
Java 数据库连接 Spring
反射-----浅解析（Java）
在java中，我们可以通过反射机制，知道任何一个类的成员变量（成员属性）和成员方法，也可以堆任何一个对象，调用这个对象的任何属性和方法，更进一步我们还可以修改部分信息和。
三三是该溜子
18 3
DK九月
|
14天前
|
小程序 安全 搜索推荐
陪玩小程序的搭建解析与功能需求
陪玩小程序是为玩家提供专业陪玩服务的应用，嵌入社交或游戏平台，具备智能匹配、实时聊天、预约服务等功能，支持便捷高效的游戏体验。源码交付时需提供详细文档、技术支持及定制开发服务，确保客户能顺利维护和升级。选择陪玩小程序时应关注功能需求、用户体验、安全性和成本效益，以确保最佳使用效果。
DK九月
37 0

热门文章

最新文章

  • 1
    OpenAI 12天发布会全解析 | AI大咖说
  • 2
    【C语言】深入浅出：C语言链表的全面解析
  • 3
    深入解析PID控制算法：从理论到实践的完整指南
  • 4
    微服务架构解析：跨越传统架构的技术革命
  • 5
    鸿蒙HarmonyOS应用开发 |鸿蒙技术分享HarmonyOS Next 深度解析：分布式能力与跨设备协作实战
  • 6
    阿里云服务器租用、注册域名、备案及域名解析完整流程参考（图文教程）
  • 7
    深入解析 vsftpd 2.3.4 的笑脸漏洞及其检测方法
  • 8
    鸿蒙HarmonyOS应用开发 | HarmonyOS Next-从应用开发到上架全流程解析
  • 9
    《docker高级篇（大厂进阶）：2.DockerFile解析》包括：是什么、DockerFile构建过程解析、DockerFile常用保留字指令、案例、小总结
  • 10
    深入解析图神经网络：Graph Transformer的算法基础与工程实践
  • 1
    Java Stream API详解与使用
    101
  • 2
    Kubernetes学习-集群搭建篇(三) Node配置完善和API概述
    89
  • 3
    HTML5 Canvas 提供丰富的绘图API，支持绘制图形、文本、渐变和图像，助力游戏开发
    81
  • 4
    Java 8新特性之Lambda表达式与Stream API的深度解析
    107
  • 5
    Linux系统编程之文件编程常用API回顾和文件编程一般步骤
    87
  • 6
    阿里云微服务引擎及 API 网关 2024 年 4 月产品动态
    396
  • 7
    阿里云微服务引擎 MSE 及 API 网关 2024 年 04 月产品动态
    279
  • 8
    智能体-Agent能力升级！新增Assistant API & Tools API服务接口
    573
  • 9
    使用Performance API进行性能监控
    121
  • 10
    RESTful API的最佳实践
    68

    • 相关课程

    更多
  • Java开发工具
  • Java 虚拟机原理
  • Java Web项目实战 - 图书商城
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计

    • 相关电子书

    更多
  • 神龙云服务器产品及技术深度解析
  • 弹性创造价值：基于ECS的最佳性价比实践解析
  • 又快又稳：阿里云下一代虚拟交换机解析

    • 相关实验场景

    更多
  • 基于Assistant Api的旅游助手
  • 快速体验智能体API应用
  • 对象和接口-2：常见用法
  • 通过云拨测对指定服务器进行Ping/DNS监测
  • 阿里云平台上进行Java程序的编译与运行
  • 使用Java面向对象编写网络通信程序应用

    • 推荐镜像

    更多
  • DNS
  • NTP
  • wireshark
    • 下一篇
    阿里云无影云电脑免费试用，最长可试用3个月