MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

使用Java Lambda表达式简化集合操作

2022-04-075.4k 阅读

Java Lambda 表达式基础

Java 8 引入的 Lambda 表达式是一种简洁的、可传递给方法或存储在变量中的匿名函数。它提供了一种更紧凑的方式来表示可传递给方法或存储在变量中的代码块。Lambda 表达式的基本语法形式为：(parameters) -> expression 或 (parameters) -> { statements; }。

例如，一个简单的 Lambda 表达式，接受两个整数并返回它们的和：

BinaryOperator<Integer> add = (a, b) -> a + b;
int result = add.apply(3, 5);
System.out.println(result);

在上述代码中，(a, b) -> a + b 就是一个 Lambda 表达式。它接受两个参数 a 和 b，并返回它们相加的结果。BinaryOperator<Integer> 是一个函数式接口，它定义了一个 apply 方法，接受两个相同类型的参数并返回相同类型的结果。

函数式接口

函数式接口是 Java Lambda 表达式的基础。函数式接口是指只包含一个抽象方法的接口。Java 8 提供了许多内置的函数式接口，如 Consumer、Supplier、Function 和 Predicate 等。

  1. Consumer：Consumer 接口代表一个接受单个输入参数但不返回结果的操作。例如：
Consumer<String> printMessage = message -> System.out.println(message);
printMessage.accept("Hello, Lambda!");

这里 message -> System.out.println(message) 是一个 Consumer 类型的 Lambda 表达式，它接受一个字符串参数并将其打印到控制台。

  1. Supplier：Supplier 接口代表一个生产者，它不接受参数但返回一个结果。例如：
Supplier<Double> randomNumber = () -> Math.random();
double number = randomNumber.get();
System.out.println(number);

() -> Math.random() 是一个 Supplier 类型的 Lambda 表达式，它每次调用 get 方法时返回一个随机数。

  1. Function：Function 接口接受一个参数并返回一个结果。例如：
Function<Integer, String> convertToString = num -> Integer.toString(num);
String str = convertToString.apply(123);
System.out.println(str);

num -> Integer.toString(num) 是一个 Function 类型的 Lambda 表达式，它将一个整数转换为字符串。

  1. Predicate：Predicate 接口接受一个参数并返回一个布尔值。例如：
Predicate<Integer> isEven = num -> num % 2 == 0;
boolean result1 = isEven.test(4);
boolean result2 = isEven.test(5);
System.out.println(result1); 
System.out.println(result2);

num -> num % 2 == 0 是一个 Predicate 类型的 Lambda 表达式，它判断一个整数是否为偶数。

使用 Lambda 表达式简化集合操作

在 Java 8 之前，对集合进行操作往往需要编写冗长的迭代代码。例如，遍历一个整数列表并打印出所有偶数：

import java.util.ArrayList;
import java.util.List;

public class OldStyleCollectionOperation {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(4);
        numbers.add(5);

        for (Integer number : numbers) {
            if (number % 2 == 0) {
                System.out.println(number);
            }
        }
    }
}

上述代码使用传统的 for - each 循环来遍历列表，检查每个元素是否为偶数并打印。

使用 Lambda 表达式和 Stream API 进行过滤操作

Java 8 引入的 Stream API 结合 Lambda 表达式可以极大地简化这种操作。Stream API 提供了一种函数式的方式来处理集合数据。例如，同样是打印列表中的偶数：

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

public class LambdaCollectionOperation {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(4);
        numbers.add(5);

        numbers.stream()
              .filter(num -> num % 2 == 0)
              .forEach(System.out::println);
    }
}

在这段代码中，numbers.stream() 将列表转换为流。filter(num -> num % 2 == 0) 使用 Predicate 类型的 Lambda 表达式过滤出偶数。forEach(System.out::println) 使用 Consumer 类型的 Lambda 表达式将每个过滤后的元素打印到控制台。这里 System.out::println 是方法引用，它是一种更简洁的 Lambda 表达式写法，等价于 element -> System.out.println(element)。

映射操作

Stream API 中的 map 方法可以将流中的每个元素按照指定的规则进行转换。例如，将一个字符串列表中的每个字符串转换为大写：

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

public class MapOperation {
    public static void main(String[] args) {
        List<String> words = new ArrayList<>();
        words.add("hello");
        words.add("world");

        List<String> upperCaseWords = words.stream()
                                          .map(String::toUpperCase)
                                          .collect(Collectors.toList());
        System.out.println(upperCaseWords); 
    }
}

在上述代码中，map(String::toUpperCase) 使用方法引用，等价于 word -> word.toUpperCase()，将流中的每个字符串转换为大写。collect(Collectors.toList()) 将流转换回列表。

归约操作

归约操作可以将流中的元素组合成一个值。例如，计算一个整数列表中所有元素的和：

import java.util.ArrayList;
import java.util.List;
import java.util.Optional;

public class ReductionOperation {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);

        Optional<Integer> sum = numbers.stream()
                                      .reduce((a, b) -> a + b);
        sum.ifPresent(System.out::println); 
    }
}

这里 reduce((a, b) -> a + b) 使用 BinaryOperator 类型的 Lambda 表达式将流中的元素进行累加。Optional 类型用于处理可能为空的结果，ifPresent 方法在结果存在时执行相应的操作。

聚合操作

聚合操作可以对流中的元素进行统计，如计算最大值、最小值、平均值等。例如，计算一个整数列表的平均值：

import java.util.ArrayList;
import java.util.List;
import java.util.OptionalDouble;

public class AggregationOperation {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);

        OptionalDouble average = numbers.stream()
                                       .mapToInt(Integer::intValue)
                                       .average();
        average.ifPresent(System.out::println); 
    }
}

mapToInt(Integer::intValue) 将 Stream<Integer> 转换为 IntStream，因为 average 方法在 IntStream 中可用。average 方法返回一个 OptionalDouble，包含平均值，如果流为空则为空。

并行流与性能优化

Java 的 Stream API 支持并行流，通过并行处理可以提高大数据集的处理效率。将一个普通流转换为并行流非常简单，只需调用 parallel 方法。例如，计算一个大整数列表的总和：

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ThreadLocalRandom;
import java.util.stream.Collectors;

public class ParallelStreamExample {
    public static void main(String[] args) {
        List<Integer> largeList = ThreadLocalRandom.current().ints(1, 1000000)
                                                 .limit(1000000)
                                                 .boxed()
                                                 .collect(Collectors.toList());

        long startTime = System.currentTimeMillis();
        long sumSequential = largeList.stream()
                                      .mapToLong(Integer::longValue)
                                      .sum();
        long endTime = System.currentTimeMillis();
        System.out.println("Sequential sum: " + sumSequential + " in " + (endTime - startTime) + " ms");

        startTime = System.currentTimeMillis();
        long sumParallel = largeList.parallelStream()
                                    .mapToLong(Integer::longValue)
                                    .sum();
        endTime = System.currentTimeMillis();
        System.out.println("Parallel sum: " + sumParallel + " in " + (endTime - startTime) + " ms");
    }
}

在上述代码中，首先生成一个包含一百万个随机整数的列表。然后分别使用顺序流和并行流计算列表的总和，并记录计算时间。通常情况下，对于大数据集，并行流的计算速度会明显快于顺序流。

然而，并行流并非在所有情况下都能提高性能。在一些情况下，并行流的任务划分和线程调度开销可能会超过并行处理带来的优势。例如，当数据集非常小或者操作本身非常简单时，顺序流可能更高效。此外，并行流操作需要注意数据的线程安全性，因为并行处理可能会同时访问和修改共享数据。

深入理解 Lambda 表达式在集合操作中的原理

当我们使用 Lambda 表达式结合 Stream API 进行集合操作时，其背后涉及到一些重要的原理。Stream API 采用了一种延迟求值的策略。这意味着像 filter、map 等中间操作并不会立即执行，而是会被记录下来形成一个操作链。只有当终端操作（如 forEach、collect 等）被调用时，整个操作链才会被执行，这种机制被称为惰性求值。

例如，考虑以下代码：

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

public class LazyEvaluationExample {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);

        List<Integer> result = numbers.stream()
                                      .filter(num -> {
                                            System.out.println("Filtering " + num);
                                            return num % 2 == 0;
                                        })
                                      .map(num -> {
                                            System.out.println("Mapping " + num);
                                            return num * 2;
                                        })
                                      .collect(Collectors.toList());
        System.out.println(result); 
    }
}

在这段代码中，filter 和 map 是中间操作，collect 是终端操作。如果运行这段代码，你会发现只有在调用 collect 时，filter 和 map 中的打印语句才会执行，并且是按照数据在流中的顺序依次经过 filter 和 map 操作。这就是惰性求值的体现，它避免了不必要的计算，提高了效率。

另外，在并行流的情况下，数据会被分成多个部分，每个部分由不同的线程进行处理。Stream API 会自动管理线程的创建、任务的分配和结果的合并。例如，在并行流的 reduce 操作中，每个线程会对自己处理的数据部分进行局部的归约，最后再将所有局部结果合并得到最终结果。这种并行处理的方式充分利用了多核处理器的优势，提高了大数据集的处理速度。

复杂集合操作中的 Lambda 表达式应用

在实际开发中，我们经常会遇到更复杂的集合操作。例如，假设有一个包含学生对象的列表，每个学生对象包含姓名、年龄和成绩等信息。我们可能需要根据不同的条件对学生列表进行筛选、排序和分组等操作。

首先，定义学生类：

public class Student {
    private String name;
    private int age;
    private double grade;

    public Student(String name, int age, double grade) {
        this.name = name;
        this.age = age;
        this.grade = grade;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public double getGrade() {
        return grade;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", grade=" + grade +
                '}';
    }
}

复杂筛选操作

假设我们要筛选出年龄大于 18 岁且成绩大于 80 分的学生：

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

public class ComplexFiltering {
    public static void main(String[] args) {
        List<Student> students = new ArrayList<>();
        students.add(new Student("Alice", 20, 85));
        students.add(new Student("Bob", 17, 78));
        students.add(new Student("Charlie", 19, 82));

        List<Student> filteredStudents = students.stream()
                                               .filter(student -> student.getAge() > 18 && student.getGrade() > 80)
                                               .collect(Collectors.toList());
        System.out.println(filteredStudents); 
    }
}

在上述代码中，filter(student -> student.getAge() > 18 && student.getGrade() > 80) 使用一个复杂的 Predicate Lambda 表达式来筛选符合条件的学生。

多字段排序

如果要根据学生的年龄升序，年龄相同的情况下根据成绩降序排序：

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

public class MultiFieldSorting {
    public static void main(String[] args) {
        List<Student> students = new ArrayList<>();
        students.add(new Student("Alice", 20, 85));
        students.add(new Student("Bob", 20, 88));
        students.add(new Student("Charlie", 19, 82));

        List<Student> sortedStudents = students.stream()
                                               .sorted(Comparator.comparingInt(Student::getAge)
                                                                 .thenComparingDouble(Student::getGrade).reversed())
                                               .collect(Collectors.toList());
        System.out.println(sortedStudents); 
    }
}

这里 sorted(Comparator.comparingInt(Student::getAge).thenComparingDouble(Student::getGrade).reversed()) 使用 Comparator 结合 Lambda 表达式实现了多字段排序。comparingInt(Student::getAge) 首先根据年龄排序，thenComparingDouble(Student::getGrade).reversed() 在年龄相同的情况下根据成绩降序排序。

分组操作

假设要根据学生的年龄对学生进行分组：

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class GroupingOperation {
    public static void main(String[] args) {
        List<Student> students = new ArrayList<>();
        students.add(new Student("Alice", 20, 85));
        students.add(new Student("Bob", 17, 78));
        students.add(new Student("Charlie", 20, 82));

        Map<Integer, List<Student>> groupedStudents = students.stream()
                                                             .collect(Collectors.groupingBy(Student::getAge));
        System.out.println(groupedStudents); 
    }
}

Collectors.groupingBy(Student::getAge) 使用 Lambda 表达式根据学生的年龄进行分组，返回一个 Map，其中键是年龄，值是对应年龄的学生列表。

常见问题与注意事项

  1. 空指针问题：在使用 Lambda 表达式进行集合操作时，要注意空指针问题。例如，在 map 操作中，如果流中的元素可能为 null，调用 map 方法可能会抛出 NullPointerException。可以通过 filter 操作先过滤掉 null 元素，或者使用 Optional 类来处理可能为空的值。

  2. 性能问题：如前文所述，并行流并非在所有情况下都能提高性能。在决定是否使用并行流时，需要考虑数据集的大小、操作的复杂度以及系统的硬件资源等因素。此外，频繁地在顺序流和并行流之间切换也可能会带来性能开销。

  3. 线程安全问题：当使用并行流时，要确保操作的数据和中间结果是线程安全的。如果在并行操作中修改共享数据，可能会导致数据竞争和不一致的结果。可以使用线程安全的数据结构，如 ConcurrentHashMap，或者采用不可变数据的方式来避免线程安全问题。

  4. 调试问题：由于 Lambda 表达式的简洁性和惰性求值的特性，调试基于 Lambda 表达式的集合操作可能会比较困难。可以通过在 Lambda 表达式中添加打印语句或者使用调试工具来帮助定位问题。例如，在 filter 或 map 操作中添加打印语句，观察数据在流中的处理过程。

  5. 函数式编程思维转变：使用 Lambda 表达式和 Stream API 需要一定的函数式编程思维转变。传统的命令式编程注重如何实现操作步骤，而函数式编程更关注对数据的转换和处理结果。开发人员需要习惯将操作看作是对数据的一系列变换，而不是对数据的直接修改。

通过深入理解和掌握 Java Lambda 表达式在集合操作中的应用，可以大大提高代码的简洁性、可读性和性能，使我们在处理集合数据时更加高效和灵活。在实际开发中，结合具体的业务需求，合理运用 Lambda 表达式和 Stream API 的各种功能，能够编写出更优雅、更强大的 Java 代码。同时，注意避免常见问题和遵循最佳实践，确保代码的正确性和稳定性。