脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → Java Streams常见错误

Java使用Streams时的7个常见错误与解决方案

 更新时间：2025年04月27日 08:14:45   作者：写bug写bug  
这篇文章主要为大家详细介绍了Java使用Streams时的7个常见错误与解决方案,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下

在使用 Java Streams 时，以下是一些常见的错误：

1.不使用终止操作

错误：忘记调用终止操作（如collect()、forEach()或reduce()），这会导致流没有执行。

public static void main(String[] args) {
    List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");

    // 创建流但没有调用终止操作
    names.stream()
    .filter(name -> name.startsWith("A")); // 这里没有调用终止操作

    // 由于流没有执行，什么都不会打印
    System.out.println("Stream operations have not been executed.");
}

解决方案：始终以终止操作结束，以触发流的处理。

public static void main(String[] args) {
    List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");

    // 创建流并调用终止操作
    names.stream()
    .filter(name -> name.startsWith("A")) // 中间操作
    .forEach(System.out::println); // 终止操作

    // 这将打印 "Alice"，因为流被执行了
}

2.修改源数据

错误：在处理流时修改源数据结构（如List）可能导致未知的结果。

public static void main(String[] args) {
    List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
    // 尝试在流处理时修改源列表
    names.stream()
    .filter(name -> {
        if (name.startsWith("B")) {
            names.remove(name); // 修改源列表
        }
        return true;
    })
    .forEach(System.out::println);
    // 由于并发修改，输出可能不符合预期
    System.out.println("Remaining names: " + names);
}

解决方案：不要在流操作期间修改源数据，而是使用流创建新的集合。

public static void main(String[] args) {
    List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
    // 基于过滤结果创建一个新列表
    List<String> filteredNames = names.stream()
    .filter(name -> name.startsWith("B")) // 过滤出以 'B' 开头的名字
    .collect(Collectors.toList());
    // 显示过滤后的列表
    System.out.println("Filtered names: " + filteredNames);
    System.out.println("Original names remain unchanged: " + names);
}

3.忽略并行流的开销

错误：认为并行流总是能提高性能，而不考虑上下文，例如小数据集或轻量级操作。

public static void main(String[] args) {
    List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5); // 小数据集
    // 在小数据集上使用并行流
    numbers.parallelStream()
    .map(n -> {
        // 模拟轻量级操作
        System.out.println(Thread.currentThread().getName() + " processing: " + n);
        return n * n;
    })
    .forEach(System.out::println);
    // 输出可能显示为简单任务创建了不必要的线程
}

解决方案：谨慎使用并行流，尤其是对于大数据集的 CPU 密集型任务。

public static void main(String[] args) {
    List<Integer> numbers = IntStream.rangeClosed(1, 1_000_000) // 大数据集
    .boxed()
    .collect(Collectors.toList());
    // 在大数据集上使用并行流进行 CPU 密集型操作
    List<Integer> squareNumbers = numbers.parallelStream()
    .map(n -> {
        // 模拟 CPU 密集型操作
        return n * n;
    })
    .collect(Collectors.toList());
    // 打印前 10 个结果
    System.out.println("First 10 squared numbers: " + squareNumbers.subList(0, 10));
}

4.过度使用中间操作

错误：链式调用过多的中间操作（如filter()和map()）可能会引入性能开销。

public static void main(String[] args) {
    List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David", "Eve");

    // 过度使用中间操作
    List<String> result = names.stream()
    .filter(name -> name.startsWith("A")) // 第一个中间操作
    .filter(name -> name.length() > 3) // 第二个中间操作
    .map(String::toUpperCase) // 第三个中间操作
    .map(name -> name + " is a name") // 第四个中间操作
    .toList(); // 终端操作

    // 输出结果
    System.out.println(result);
}

解决方案：尽量减少流管道中的中间操作，并在可能的情况下使用流融合。

public static void main(String[] args) {
    List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David", "Eve");

    // 优化流管道
    List<String> result = names.stream()
    .filter(name -> name.startsWith("A") && name.length() > 3) // 将过滤器合并为一个
    .map(name -> name.toUpperCase() + " is a name") // 合并 map 操作
    .toList(); // 终端操作

    // 输出结果
    System.out.println(result);
}

5.不处理 Optional 值

错误：在使用findFirst()或reduce()等操作时，没有正确处理Optional结果。

public static void main(String[] args) {
    List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
    // 尝试查找以 "Z" 开头的名字（不存在）
    String firstNameStartingWithZ = names.stream()
    .filter(name -> name.startsWith("Z")) 
    .findFirst() // 返回一个 Optional
    .get(); // 如果 Optional 为空，这将抛出 NoSuchElementException
    // 输出结果
    System.out.println(firstNameStartingWithZ);
}

解决方案：在访问Optional的值之前，始终检查它是否存在，以避免NoSuchElementException。

public static void main(String[] args) {
    List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
    // 正确处理 Optional
    Optional<String> firstNameStartingWithZ = names.stream()
    .filter(name -> name.startsWith("Z")) 
    .findFirst(); // 返回一个 Optional
    // 检查 Optional 是否存在
    if (firstNameStartingWithZ.isPresent()) {
        System.out.println(firstNameStartingWithZ.get());
    } else {
        System.out.println("No name starts with 'Z'");
    }
}

6.忽略线程安全

错误：在并行流中使用共享的可变状态可能导致竞态条件和不一致的结果。

public static void main(String[] args) {
    List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
    List<Integer> results = new ArrayList<>(); // 共享的可变状态
    // 在并行流中使用共享的可变状态
    numbers.parallelStream().forEach(number -> {
        results.add(number * 2); // 这可能导致竞态条件
    });
    // 输出结果
    System.out.println("Results: " + results);
}

解决方案：避免共享可变状态；使用线程安全的集合或局部变量。

public static void main(String[] args) {
    List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
    List<Integer> results = new CopyOnWriteArrayList<>(); // 线程安全的集合
    // 在并行流中使用线程安全的集合
    numbers.parallelStream().forEach(number -> {
        results.add(number * 2); // 避免竞态条件
    });
    // 输出结果
    System.out.println("Results: " + results);
}

7.混淆中间操作和终止操作

错误：不清楚中间操作（返回新流）和终止操作（产生结果）之间的区别。

public static void main(String[] args) {
    List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
    // 错误：尝试将中间操作用作终止操作
    // 这将无法编译，因为 'filter' 返回一个 Stream，而不是一个 List
    names.stream().filter(name -> name.startsWith("A")).forEach(System.out::println); // 这里正确使用了终止操作
}

解决方案：熟悉每种操作类型的特性，以避免代码中的逻辑错误。

public static void main(String[] args) {
    List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
    // 正确使用中间操作和终止操作
    List<String> filteredNames = names.stream()
        .filter(name -> name.startsWith("A")) // 中间操作
        .collect(Collectors.toList()); // 终止操作

    // 输出过滤后的名字
    System.out.println("Filtered Names: " + filteredNames);
}

通过掌握这些技巧并实施这些解决方案，你可以更好地使用 Java Streams，并编写更简洁、更高效的代码。

到此这篇关于Java使用Streams时的7个常见错误与解决方案的文章就介绍到这了,更多相关Java Streams常见错误内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

相关文章

  • SSH框架网上商城项目第24战之Struts2中处理多个Model请求的方法

    SSH框架网上商城项目第24战之Struts2中处理多个Model请求的方法

    这篇文章主要为大家详细介绍了SSH框架网上商城项目第24战之Struts2中处理多个Model请求的方法，感兴趣的小伙伴们可以参考一下
    2016-06-06
  • Springboot整合阿里巴巴SMS的实现示例

    Springboot整合阿里巴巴SMS的实现示例

    本文主要介绍了Springboot整合阿里巴巴SMS的实现示例，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
    2023-12-12
  • 学习JVM之java内存区域与异常

    学习JVM之java内存区域与异常

    关于JVM内存区域的知识对于初学者来说其实是很重要的，了解Java内存分配的原理，这对于以后JAVA的学习会有更深刻的理解。下面来看看详细介绍。
    2016-07-07
  • Java实战之实现OA办公管理系统

    Java实战之实现OA办公管理系统

    这篇文章主要介绍了如何通过Java实现OA办公管理系统，文章采用到了JSP、JQuery、Ajax等技术，文中的示例代码讲解详细，感兴趣的小伙伴可以了解一下
    2022-02-02
  • SSH框架网上商城项目第25战之使用java email给用户发送邮件

    SSH框架网上商城项目第25战之使用java email给用户发送邮件

    这篇文章主要为大家详细介绍了SSH框架网上商城项目第25战之使用java email给用户发送邮件，感兴趣的小伙伴们可以参考一下
    2016-06-06
  • MyBatis-plus批量插入的通用方法使用

    MyBatis-plus批量插入的通用方法使用

    mybatis-plus的IService接口默认提供saveBatch批量插入，也是唯一一个默认批量插入，在数据量不是很大的情况下可以直接使用，本文带你详细了解MyBatis-plus 批量插入的通用方法及使用方法，需要的朋友可以参考一下
    2023-04-04
  • Java中struts2和spring MVC的区别_动力节点Java学院整理

    Java中struts2和spring MVC的区别_动力节点Java学院整理

    这篇文章主要介绍了Java中struts2和spring MVC的区别，非常不错，具有参考借鉴价值，需要的朋友参考下吧
    2017-09-09
  • 如何自定义hibernate validation注解示例代码

    如何自定义hibernate validation注解示例代码

    Hibernate Validator 是 Bean Validation 的参考实现 . Hibernate Validator 提供了 JSR 303 规范中所有内置 constraint 的实现，下面这篇文章主要给大家介绍了关于如何自定义hibernate validation注解的相关资料，需要的朋友可以参考下
    2018-04-04
  • Java 事务注解@Transactional回滚(try catch、嵌套)问题

    Java 事务注解@Transactional回滚(try catch、嵌套)问题

    这篇文章主要介绍了Java @Transactional回滚(try catch、嵌套)问题,Spring 事务注解 @Transactional 本来可以保证原子性，如果事务内有报错的话，整个事务可以保证回滚，但是加上try catch或者事务嵌套，可能会导致事务回滚失败
    2022-08-08
  • RPC框架之Thrift的入门教程

    RPC框架之Thrift的入门教程

    Thrift是一个跨语言的服务部署框架,主要用于各个服务之间的RPC通信,支持跨语言,下面小编就来和大家讲讲Thrift框架的具体使用,希望对大家有所帮助
    2023-10-10

最新评论