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

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"，因为流被执行了
}

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);
}

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);
    // 输出可能显示为简单任务创建了不必要的线程
}

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));
}

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);
}

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);
}

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'");
    }
}

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);
}

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);
}