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

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

2024-06-14 14
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 深入探讨 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
关键词：
Java解析
Java集合
Java API
java云解析DNS
云解析DNS java
Jack_hrx
目录
相关文章
三分钟热度的鱼
|
2天前
|
SQL 关系型数据库 API
实时计算 Flink版产品使用问题之如何使用stream api
实时计算Flink版作为一种强大的流处理和批处理统一的计算框架，广泛应用于各种需要实时数据处理和分析的场景。实时计算Flink版通常结合SQL接口、DataStream API、以及与上下游数据源和存储系统的丰富连接器，提供了一套全面的解决方案，以应对各种实时计算需求。其低延迟、高吞吐、容错性强的特点，使其成为众多企业和组织实时数据处理首选的技术平台。以下是实时计算Flink版的一些典型使用合集。
三分钟热度的鱼
21 5
Jack_hrx
|
4天前
|
安全 Java API
深入解析 Java 8 新特性：LocalDate 的强大功能与实用技巧
深入解析 Java 8 新特性：LocalDate 的强大功能与实用技巧
Jack_hrx
13 1
hsfxuebao
|
6天前
|
存储 Java API
Java8实战-使用Stream
Java8实战-使用Stream
hsfxuebao
7 0
Java8实战-使用Stream
hsfxuebao
|
6天前
|
存储 分布式计算 Java
Java8实战-引入流（Stream）
Java8实战-引入流（Stream）
hsfxuebao
8 0
数据分析螺丝钉
|
8天前
|
数据可视化 数据挖掘 数据处理
【源码解析】深入Pandas的心脏DataFrame 含十大功能、源码实现与编程知识点
【源码解析】深入Pandas的心脏DataFrame 含十大功能、源码实现与编程知识点
数据分析螺丝钉
21 3
sky_qiyi
|
11天前
|
Java
Java——Stream流（2/2）：Stream流的中间方法、终结方法（方法、案例演示）
Java——Stream流（2/2）：Stream流的中间方法、终结方法（方法、案例演示）
sky_qiyi
11 0
sky_qiyi
|
11天前
|
存储 Java API
Java——Stream流（1/2）：Stream流入门、Stream流的创建（认识Stream、体验Stream流、Stream流的使用步骤、获取Stream流的方法）
Java——Stream流（1/2）：Stream流入门、Stream流的创建（认识Stream、体验Stream流、Stream流的使用步骤、获取Stream流的方法）
sky_qiyi
11 0
技术交流18179014480
|
4天前
|
安全 数据挖掘 API
【实时数据】商品详情API接口系列开发
商品详情API接口系列对于电商平台至关重要，它们为开发者提供了实时、准确的商品信息，使得在线销售和展示商品变得更加高效和精准。以下是几个主要的电商平台及其商品详情API接口的介绍：
技术交流18179014480
37 4
chszs
|
Java API
Java 8 Stream API详解
版权声明：本文为博主chszs的原创文章，未经博主允许不得转载。 https://blog.csdn.net/chszs/article/details/47038607 Java ...
chszs
988 0
WBKJ_Noah18870292986
|
13天前
|
监控 供应链 搜索推荐
数据驱动电商：深度利用淘宝API接口掌握商品详情
本文探讨了如何利用淘宝API接口获取商品详情数据以助力电商决策。通过API，商家能获取商品标题、价格、库存等信息，从而进行市场分析、库存优化、定价策略制定及个性化推荐。步骤包括注册获取API权限、理解文档、构建数据收集流程、处理分析数据以及应用结果。示例代码展示了如何用Python调用API获取商品详情。善用API和数据驱动策略可在电商市场中取得优势。请注意遵循淘宝的API使用规范。
WBKJ_Noah18870292986
31 2

热门文章

最新文章

  • 1
    TensorFlow中的那些高级API
  • 2
    Android 3.1 r1 中文API文档 (120) —— SearchView
  • 3
    Windows AWE API 内存分配和普通内存分配的不同点
  • 4
    HTML5使用 JavaScript File API 实现文件上传
  • 5
    .Net Core 使用 Swagger 提供API文档
  • 6
    Error while waiting for device: The emulator process for AVD Pixel_2_XL_API_28 was killed.
  • 7
    Android 2.2 r1 API 中文文档系列（11） —— RadioButton
  • 8
    l5如何通过路由走api版本回退查找设置
  • 9
    通过 File API 使用 JavaScript 读取文件
  • 10
    微信支付开发(3) JS API支付
  • 1
    【软件设计师备考 专题 】面向对象程序设计语言：C++、Java、Visual Basic和Visual C++
    62
  • 2
    【软件设计师备考 专题 】C、C++、Java、Visual Basic、Visual C++等语言的基础知识和应用（三）
    38
  • 3
    【软件设计师备考 专题 】C、C++、Java、Visual Basic、Visual C++等语言的基础知识和应用（二）
    39
  • 4
    【软件设计师备考 专题 】C、C++、Java、Visual Basic、Visual C++等语言的基础知识和应用（一）
    39
  • 5
    java equals和==
    16
  • 6
    静态构造方法解析，Java新手必看技能
    18
  • 7
    构造方法执行过程：揭秘Java代码背后的秘密
    14
  • 8
    使用HtmlUnit库的Java下载器：下载TikTok视频
    53
  • 9
    java智慧城管源码 AI视频智能分析 可直接上项目
    292
  • 10
    Mybatis+mysql动态分页查询数据案例——工具类(MybatisUtil.java)
    39

    • 相关课程

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

    • 相关电子书

    更多
  • CUDA MATH API
  • API PLAYBOOK
  • 传统企业的“+互联网”-API服务在京东方的实践

    • 相关实验场景

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

    • 推荐镜像

    更多
  • DNS
  • NTP
  • kali-security
    • 下一篇
    2024年阿里云免费云服务器及学生云服务器申请教程参考