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

本文涉及的产品
全局流量管理 GTM,标准版 1个月
公共DNS(含HTTPDNS解析),每月1000万次HTTP解析
云解析 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 在遍历、转换、过滤、分组、去重、并行处理等方面的强大功能。这些新特性不仅提高了代码的简洁性和可读性,还显著提升了开发效率。

目录
相关文章
|
11天前
|
传感器 监控 Java
Java代码结构解析:类、方法、主函数(1分钟解剖室)
### Java代码结构简介 掌握Java代码结构如同拥有程序世界的建筑蓝图,类、方法和主函数构成“黄金三角”。类是独立的容器,承载成员变量和方法;方法实现特定功能,参数控制输入环境;主函数是程序入口。常见错误包括类名与文件名不匹配、忘记static修饰符和花括号未闭合。通过实战案例学习电商系统、游戏角色控制和物联网设备监控,理解类的作用、方法类型和主函数任务,避免典型错误,逐步提升编程能力。 **脑图速记法**:类如太空站,方法即舱段;main是发射台,static不能换;文件名对仗,括号要成双;参数是坐标,void不返航。
34 5
|
26天前
|
机器学习/深度学习 人工智能 自然语言处理
企业级API集成方案:基于阿里云函数计算调用DeepSeek全解析
DeepSeek R1 是一款先进的大规模深度学习模型,专为自然语言处理等复杂任务设计。它具备高效的架构、强大的泛化能力和优化的参数管理,适用于文本生成、智能问答、代码生成和数据分析等领域。阿里云平台提供了高性能计算资源、合规与数据安全、低延迟覆盖和成本效益等优势,支持用户便捷部署和调用 DeepSeek R1 模型,确保快速响应和稳定服务。通过阿里云百炼模型服务,用户可以轻松体验满血版 DeepSeek R1,并享受免费试用和灵活的API调用方式。
160 12
|
23天前
|
Java API 数据处理
深潜数据海洋:Java文件读写全面解析与实战指南
通过本文的详细解析与实战示例,您可以系统地掌握Java中各种文件读写操作,从基本的读写到高效的NIO操作,再到文件复制、移动和删除。希望这些内容能够帮助您在实际项目中处理文件数据,提高开发效率和代码质量。
28 4
|
1月前
|
数据采集 监控 搜索推荐
深度解析淘宝商品详情API接口:解锁电商数据新维度,驱动业务增长
淘宝商品详情API接口,是淘宝开放平台为第三方开发者提供的一套用于获取淘宝、天猫等电商平台商品详细信息的应用程序接口。该接口涵盖了商品的基本信息(如标题、价格、图片)、属性参数、库存状况、销量评价、物流信息等,是电商企业实现商品管理、市场分析、营销策略制定等功能的得力助手。
|
8天前
|
存储 缓存 监控
如何高效爬取天猫商品数据?官方API与非官方接口全解析
本文介绍两种天猫商品数据爬取方案:官方API和非官方接口。官方API合法合规,适合企业长期使用,需申请企业资质;非官方接口适合快速验证需求,但需应对反爬机制。详细内容涵盖开发步骤、Python实现示例、反爬策略、数据解析与存储、注意事项及扩展应用场景。推荐工具链包括Playwright、aiohttp、lxml等。如需进一步帮助,请联系作者。
|
9天前
|
JSON API 数据格式
淘宝商品评论API接口系列的应用与数据解析
在电商平台中,用户评论是了解商品质量、服务水平和用户满意度的重要数据来源。淘宝作为中国最大的电商平台,提供了商品评论API接口,帮助开发者获取和分析用户评价数据。本文将介绍淘宝商品评论API接口系列的作用、使用方法,并通过示例展示如何调用API并解析返回的JSON数据。
|
1月前
|
XML JSON Java
Java中Log级别和解析
日志级别定义了日志信息的重要程度,从低到高依次为:TRACE(详细调试)、DEBUG(开发调试)、INFO(一般信息)、WARN(潜在问题)、ERROR(错误信息)和FATAL(严重错误)。开发人员可根据需要设置不同的日志级别,以控制日志输出量,避免影响性能或干扰问题排查。日志框架如Log4j 2由Logger、Appender和Layout组成,通过配置文件指定日志级别、输出目标和格式。
|
10天前
|
存储 自然语言处理 监控
深度解析淘宝商品评论API接口:技术实现与应用实践
淘宝商品评论API接口是电商数据驱动的核心工具,帮助开发者高效获取用户评价、画像及市场趋势。其核心功能包括多维度信息采集、筛选排序、动态更新、OAuth 2.0认证和兼容多种请求方式。通过该接口,开发者可进行商品优化、竞品分析、舆情监控等。本文详细解析其技术原理、实战应用及挑战应对策略,助力开启数据驱动的电商运营新篇章。
|
1月前
|
XML API 开发者
使用 API 接口获取京东商品详情全解析
京东作为头部电商平台,其商品数据极具价值。开发者可通过API接口获取商品详情、订单数据等信息,满足各种业务需求。使用前需注册账号并创建应用获取App Key和App Secret。调用流程包括认证授权、构建请求、发送请求及处理响应。注意事项包括遵守平台规则、控制调用频率和确保数据时效性。通过这些步骤,可为电商数据分析提供有力支持。
|
2月前
|
数据挖掘 API 数据安全/隐私保护
深度解析:获取亚马逊畅销榜API接口及实战应用
Lazada 淘宝详情 API 是连接 Lazada 和淘宝商品数据的桥梁,帮助电商从业者获取淘宝商品的详细信息(如标题、描述、价格等),并应用于 Lazada 平台。它在市场调研、产品选品、价格策略和数据分析等方面为商家提供支持,助力优化运营策略。通过 Python 示例代码展示了 API 的实际应用,并强调了数据准确性、API 使用限制及数据安全的重要性。
64 10

热门文章

最新文章

推荐镜像

更多