Java Lambda和Stream开发中20个高频错误案例分析与避坑指南

// 错误案例1：多个参数省略括号
List<String> list = Arrays.asList("Java", "Lambda");
// 报错：多个参数必须加括号，不能省略
list.stream().sorted(s1, s2 -> s1.compareTo(s2));

// 错误案例2：代码块多行省略大括号和return
List<Integer> numList = Arrays.asList(1, 2, 3);
// 报错：代码块有多个语句，必须加大括号和return
numList.stream().map(num -> {
    num *= 2;
    return num;
}); // 正确写法，若省略大括号和return则报错

// 错误案例3：单个参数加了类型，却省略括号
// 报错：参数加了类型，就不能省略括号
list.stream().forEach(String s -> System.out.println(s));

// 正确写法
list.stream().sorted((s1, s2) -> s1.compareTo(s2)); // 多个参数加括号
numList.stream().map(num -> num * 2); // 单行代码省略大括号和return
list.stream().forEach((String s) -> System.out.println(s)); // 加类型则加括号

// 错误案例
public static void main(String[] args) {
    int count = 0;
    List<Integer> numList = Arrays.asList(1, 2, 3, 4);
    // 报错：count被修改，不是有效final变量
    numList.stream().forEach(num -> {
        if (num % 2 == 0) {
            count++; // 修改外部变量
        }
    });
    System.out.println(count);
}

// 正确解法1：使用AtomicInteger
AtomicInteger count = new AtomicInteger(0);
numList.stream().forEach(num -> {
    if (num % 2 == 0) {
        count.incrementAndGet();
    }
});
System.out.println(count.get());
// 正确解法2：用Stream的count()方法（更简洁）
long count = numList.stream().filter(num -> num % 2 == 0).count();
System.out.println(count);

// 错误案例：Function接口要求返回String，却返回int
Function<Integer, String> func = num -> num * 2; // 报错：返回值是int，不是String
// 错误案例：Predicate接口要求返回boolean，却返回String
Predicate<String> predicate = str -> str.length(); // 报错：返回值是int，不是boolean

// 正确写法
Function<Integer, String> func = num -> String.valueOf(num * 2); // 返回String
Predicate<String> predicate = str -> str.length() > 0; // 返回boolean

// 错误案例1：需要消费数据（无返回值），却用了Supplier接口（无参数、有返回值）
Supplier<String> supplier = str -> System.out.println(str); // 报错：Supplier无参数，且需返回值
// 错误案例2：需要判断数据（返回boolean），却用了Function接口（返回任意类型）
Function<String, Boolean> func = str -> str.isEmpty(); // 语法正确，但不符合场景，冗余

// 正确写法
Consumer<String> consumer = str -> System.out.println(str); // 消费数据，无返回值
Predicate<String> predicate = str -> str.isEmpty(); // 判断数据，返回boolean

// 错误案例：自定义接口，误加两个抽象方法，无@FunctionalInterface注解，编译不报错
interface MyFunction {
    void method1();
    void method2(); // 误加第二个抽象方法
}
// 报错：MyFunction有两个抽象方法，不是函数式接口，无法用Lambda实现
MyFunction myFunction = () -> System.out.println("test");

// 正确写法
@FunctionalInterface
interface MyFunction {
    void method1(); // 唯一抽象方法
    // 可添加默认方法、静态方法
    default void method2() {
        System.out.println("默认方法");
    }
    static void method3() {
        System.out.println("静态方法");
    }
}
MyFunction myFunction = () -> System.out.println("test"); // 正常使用

// 错误案例
List<Integer> numList = Arrays.asList(1, 2, 3, 4);
Stream<Integer> stream = numList.stream();
// 第一次执行终止操作（forEach），流关闭
stream.forEach(System.out::println);
// 第二次使用流，执行count()，报错
long count = stream.count(); // 报错：IllegalStateException: stream has already been operated upon or closed

// 正确写法1：每次使用都重新获取流
List<Integer> numList = Arrays.asList(1, 2, 3, 4);
numList.stream().forEach(System.out::println);
long count = numList.stream().count(); // 重新获取流，正常执行
// 正确写法2：转换为集合，再复用
List<Integer> list = numList.stream().filter(num -> num % 2 == 0).collect(Collectors.toList());
long count = list.stream().count(); // 从集合重新获取流

// 错误案例：只有中间操作，无终止操作，代码不执行
List<Integer> numList = Arrays.asList(1, 2, 3, 4);
numList.stream().filter(num -> num % 2 == 0).map(num -> num * 2); // 无任何效果

// 正确写法：添加终止操作（forEach/collect/count等）
numList.stream()
       .filter(num -> num % 2 == 0)
       .map(num -> num * 2)
       .forEach(System.out::println); // 终止操作，触发执行

// 错误案例：认为Stream流的map操作会修改原集合
List<Integer> numList = new ArrayList<>(Arrays.asList(1, 2, 3, 4));
numList.stream().map(num -> num * 2); // 无终止操作，不执行；即使有终止操作，也不修改原集合
System.out.println(numList); // 输出：[1,2,3,4]，原集合未变化

// 正确写法：收集流处理后的结果到新集合
List<Integer> newList = numList.stream()
                               .map(num -> num * 2)
                               .collect(Collectors.toList());
System.out.println(newList); // 输出：[2,4,6,8]，原集合仍为[1,2,3,4]

// 错误案例：集合包含null元素，未处理，触发空指针
List<User> userList = Arrays.asList(new User("张三", 25), null, new User("李四", 30));
userList.stream().map(User::getName).forEach(System.out::println); // 报错：NullPointerException

// 正确解法1：filter过滤null元素（推荐，简洁）
userList.stream()
        .filter(Objects::nonNull) // 过滤null用户
        .map(User::getName)
        .forEach(System.out::println);
// 正确解法2：结合Optional处理null值（适合需要保留null相关逻辑的场景）
userList.stream()
        .map(user -> Optional.ofNullable(user).map(User::getName).orElse("未知姓名"))
        .forEach(System.out::println);

// 错误案例1：将实例方法当作静态方法引用
// 报错：toUpperCase()是String的实例方法，不能用“类名::方法名”当作静态方法引用
List<String> list = Arrays.asList("java", "lambda");
list.stream().map(String::toUpperCase); // 看似正确？不，这里是类的实例方法引用，实际能运行？
// 补充：上面代码能运行，因为符合类的实例方法引用规则；下面才是错误案例
// 错误案例2：将静态方法当作类的实例方法引用，参数不匹配
// 报错：valueOf()是静态方法，Lambda参数需作为方法参数，而非调用者
List<Integer> numList = Arrays.asList(1, 2, 3);
numList.stream().map(String::valueOf); // 正确（静态方法引用），下面是错误写法
// 错误写法：试图当作类的实例方法引用，参数不匹配
numList.stream().sorted(String::valueOf); // 报错：sorted需要Comparator，参数不匹配

// 错误案例1：方法参数不匹配
List<Integer> numList = Arrays.asList(1, 2, 3);
// 报错：System.out.println()接收1个参数，而Supplier接口无参数
Supplier<Void> supplier = System.out::println;
// 错误案例2：方法返回值不匹配
List<Integer> numList = Arrays.asList(1, 2, 3);
// 报错：String.valueOf()返回String，而Consumer接口无返回值
numList.stream().forEach(String::valueOf);

// 正确写法1：匹配Supplier接口（无参数，有返回值）
Supplier<String> supplier = () -> "test"; // 改用Lambda，或选择无参数、有返回值的方法引用
// 正确写法2：匹配Consumer接口（有参数，无返回值）
numList.stream().forEach(System.out::println); // println有参数、无返回值，匹配Consumer

// 错误案例：User类有参构造器（String name, int age），函数式接口参数不匹配
class User {
    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
// 报错：Supplier接口无参数，无法匹配User的有参构造器
Supplier<User> userSupplier = User::new;
// 错误案例2：参数数量不匹配
Function<String, User> userFunc = User::new; // 报错：Function接收1个参数，User构造器需要2个参数

// 正确写法1：使用BiFunction接口（接收2个参数，返回User），匹配有参构造器
BiFunction<String, Integer, User> userFunc = User::new;
User user = userFunc.apply("张三", 25);
// 正确写法2：添加无参构造器，匹配Supplier接口
class User {
    public User() {} // 无参构造器
    public User(String name, int age) { this.name = name; this.age = age; }
}
Supplier<User> userSupplier = User::new; // 匹配无参构造器

// 错误案例：引用的对象为null
PrintStream out = null;
List<String> list = Arrays.asList("Java", "Lambda");
list.stream().forEach(out::println); // 报错：NullPointerException（out为null）

// 正确写法
PrintStream out = System.out; // 确保对象不为null
if (out != null) {
    list.stream().forEach(out::println);
}

// 错误案例
List<Integer> numList = new ArrayList<>();
for (int i = 1; i <= 10000; i++) {
    numList.add(i);
}
List<Integer> resultList = new ArrayList<>(); // 非线程安全集合
// 并行流向非线程安全集合添加元素，数据错乱
numList.parallelStream()
       .filter(num -> num % 2 == 0)
       .forEach(num -> resultList.add(num));
System.out.println("预期数量：5000，实际数量：" + resultList.size()); // 实际数量小于5000

// 正确解法1：collect方法收集（推荐）
List<Integer> resultList = numList.parallelStream()
                                   .filter(num -> num % 2 == 0)
                                   .collect(Collectors.toList());
// 正确解法2：使用CopyOnWriteArrayList
List<Integer> resultList = new CopyOnWriteArrayList<>();
numList.parallelStream()
       .filter(num -> num % 2 == 0)
       .forEach(resultList::add);

// 错误案例
List<Integer> numList = new ArrayList<>();
for (int i = 1; i <= 10000; i++) {
    numList.add(i);
}
int sum = 0; // 非线程安全变量
// 并行流并发修改sum，结果错误
numList.parallelStream()
       .filter(num -> num % 2 == 0)
       .forEach(num -> sum += num);
System.out.println("预期结果：25005000，实际结果：" + sum); // 实际结果小于预期

// 正确解法1：用Stream的sum()方法（推荐，最简洁）
long sum = numList.parallelStream()
                   .filter(num -> num % 2 == 0)
                   .mapToLong(Integer::longValue)
                   .sum();
// 正确解法2：用AtomicLong线程安全累加器
AtomicLong sum = new AtomicLong(0);
numList.parallelStream()
       .filter(num -> num % 2 == 0)
       .forEach(num -> sum.addAndGet(num));

// 错误案例：小数据量（10条）使用并行流，效率低下
List<Integer> numList = Arrays.asList(1, 2, 3, ..., 10); // 10条数据
// 并行流处理，线程切换、分片合并开销大于处理本身
long start = System.currentTimeMillis();
numList.parallelStream().forEach(System.out::println);
long end = System.currentTimeMillis();
System.out.println("并行流处理时间：" + (end - start) + "ms");
// 串行流处理，效率更高
start = System.currentTimeMillis();
numList.stream().forEach(System.out::println);
end = System.currentTimeMillis();
System.out.println("串行流处理时间：" + (end - start) + "ms");

// 错误案例：需要固定顺序，却用并行流
List<String> list = Arrays.asList("1", "2", "3", "4", "5");
System.out.println("并行流处理顺序（不固定）：");
list.parallelStream().forEach(System.out::print); // 输出可能是：31254、21435等

// 正确写法1：需要固定顺序，用串行流
list.stream().forEach(System.out::print); // 输出：12345（固定顺序）
// 正确写法2：并行流固定顺序（效率降低）
list.parallelStream().forEachOrdered(System.out::print); // 输出：12345（固定顺序）