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

已于 2024-05-26 11:02:06 修改
阅读量5.4k 收藏 5
点赞数 6
分类专栏： java 进阶教程 文章标签： java Stream Api java 8 新特性 集合操作
于 2024-05-26 10:56:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38411796/article/details/139211432
版权

深入探讨 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));
    }
}

示例：使用 forEach 遍历 Map

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 在遍历、转换、过滤、分组、去重、并行处理等方面的强大功能。这些新特性不仅提高了代码的简洁性和可读性，还显著提升了开发效率。

微笑听雨。
关注
专栏目录
JAVA 8 Stream API及聚合操作简介
u012476022的博客
04-02 1177
其实这篇文章早就列上计划了，只不过因为时间原因没有成行，正巧泛型的那篇文章基本上也要收尾了，正好接上这篇。 不过本人对于Stream也是一知半解，毕竟小城市野生程序员，没那么多大厂的实战经验，再加上本人的实力有限，所以如果文章中有任何不当之处也欢迎读到文章的同仁们不吝赐教，当然，本人CSDN博客建立的初衷其实只是给自己一个记录梳理知识的平台，方便作为自己工作的一个知识库，嗯，就酱！ 其实如果想要良...
Java中，Map、List集合遍历、去重方式超详细总结
weixin_55746254的博客
07-16 4563
Java面试总结，Java集合常问内容，集合的基本概念，Map集合去重、List集合去重
深入解析Java 8 Stream API：介绍与使用方法
一名资深Java工程师的技术分享
06-11 1024
Java 8的Stream API 是一种强大的数据处理工具，通过提供简洁、高效且易于并行化的操作，简化了数据处理流程。Stream 不是数据结构，而是一种数据计算的抽象，支持多种创建方式，包括从集合、数组或生成无限流。Stream 支持中间操作如 filter和 sorted，以及终端操作如 forEach、collect。并行流通过 parallelStream 或 parallel 方法实现高效的数据处理。
Java 8 集合 Stream
teletian的专栏
11-27 696
Java 8 是一个成功的版本，新增的内容很实用。比如大家熟悉的 lamda 表达式，集合的 Stream，等等。本文讲讲 Stream 的使用。
java8源码-javasource:Java8sourcecodeanalysis.Java源码解析系列，集合、线程、NIO等
06-04
这个名为 "java8source:Java8sourcecodeanalysis" 的项目专注于解析 Java 8 的源码，涵盖了一系列关键概念，如集合框架的改进、并发处理、以及非阻塞I/O（NIO）等。下面我们将深入探讨这些核心知识点。 首先，Java ...
java8 streamList转换使用详解
08-18
Java 8 引入了 Stream API，极大地增强了处理集合数据的能力。在本文中，我们将深入探讨如何使用 Stream API 将 `List, Object>>` 转换为 `Map, Object>`，以及如何统计字符串中字母的个数。 首先，让我们详细解析...
探索Java版本的特性：深入解析与实践
哎 你看的博客
07-24 662
Java作为一种成熟且广泛使用的编程语言，一直在不断地演进和更新。随着每个新版本的发布，Java都会引入一系列新特性，以提高开发效率、增强语言表现力，并优化性能。本文将深入探讨Java最新版本的特性，包括模块系统、新的集合操作、改进的垃圾回收等，并通过代码示例展示这些特性的应用。
Java泛型与Java 8新特性：Stream API的最佳实践
Java泛型是在Java 5中引入的一个重要的语言特性，它允许在编译时提供类型安全检查。使用泛型，可以在类或方法中声明一个或多个类型参数，这使得代码可以在使用时被具体化为特定的类型。泛型的好处包括减少强制类型...
Java8深入学习系列（二）函数式编程
08-29
Java8深入学习系列的第二部分将探讨函数式编程这一概念，它是现代编程范式中的一种重要方式。函数式编程结合了“函数”和“编程”的思想，强调使用纯函数和不可变数据结构来构建程序。在Java8中，引入了Lambda表达式...
spring事务详细讲解-深入浅出
小电玩
09-08 525
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1511
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
自动生成不重复的订单id
ClaireCheney的博客
09-13 154
【代码】自动生成不重复的订单id。
Java集合：Stack详解
yang_brother的博客
09-10 569
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
币安/OK现货合约量化系统APP开发
I592O929783的博客
09-08 603
后端：考虑系统需要处理大量实时数据和高频交易的特点，选择高性能的编程语言和技术框架，如Python的Django或Flask框架，Java的Spring Boot等。用户交互界面：设计直观易用的用户交互界面，包括交易界面、策略配置界面、风险管理界面等，方便用户进行交易操作、策略配置和风险管理。市场数据接入：开发市场数据接入模块，从币安等交易所或数据服务商获取实时的市场数据，包括行情数据、订单簿数据、成交数据等。前端：选择适合开发复杂界面的前端框架，如React、Vue.js等，以提供用户友好的交互界面。
基于SpringBoot的考研资讯平台设计与实现
最新发布
linzhongshu的专栏
09-13 527
对于本次的系统开发来看，它主要是把我以前所学的知识进行了一次综合的应用。经过这次毕业设计的制作它主要是把我以前所学的理论知识应用到社会实践当中。通过这一次的考研资讯平台的设计与实现它能够有效把计算机知识与实际问题相互应用，通过计算机网络技术来解决学生生活当中的实际问题，从而提高我的编程能力。虽然在这次毕业设计当中我遇到了很多的问题和困难，但是通过不断的调试和老师的帮助让我圆满的完成了这次毕业设计。
MyBatis面试
Tony_yitao的博客
09-09 775
MyBatis面试
Linux服务器Java启动脚本
Jack魏
09-08 569
本文章介绍了如何在Linux服务器上执行Java并启动jar包，通常我们会使用nohup直接启动，但是还是需要手动停止然后再次启动，那如何更优雅的在服务器上启动jar包呢，让我们一起探讨一下吧。
springboot数据库连接由localhost改成IP以后访问报错500（2024/9/7
不起眼小菜菜的博客
09-07 363
步骤很详细，直接上教程……
Java8 Stream：状态与并行操作解析
"这篇PDF文档主要探讨了Java 8中的Stream API，特别是关于Stream的状态以及并行操作。文章由字母哥哥在2020年6月发布，回顾了Stream的基本操作，并深入讲解了有状态与无状态的中间操作在Stream中的应用。" 在Java 8...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

微笑听雨。

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值