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

Java Lambda表达式的最佳实践

2022-05-265.5k 阅读

Java Lambda 表达式基础

什么是 Lambda 表达式

Lambda 表达式是 Java 8 引入的一项重要特性，它允许我们以更简洁、更紧凑的方式表示可传递给方法或存储在变量中的代码块。从本质上来说，Lambda 表达式是一种匿名函数，它没有名称，但有参数列表、函数主体、返回类型，可能还会有一个可以抛出的异常列表。

传统上，在 Java 中，如果要传递一段代码给某个方法，通常需要创建一个实现特定接口的类的实例，该接口只有一个抽象方法（即函数式接口）。例如，要对一个整数列表进行排序，我们可能会这样写：

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

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

        Collections.sort(numbers, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;
            }
        });

        System.out.println(numbers);
    }
}

在这个例子中，我们创建了一个实现 Comparator 接口的匿名内部类。Comparator 是一个函数式接口，它只有一个抽象方法 compare。使用 Lambda 表达式，上述代码可以简化为：

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

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

        Collections.sort(numbers, (o1, o2) -> o1 - o2);

        System.out.println(numbers);
    }
}

Lambda 表达式的语法

Lambda 表达式的基本语法如下：

(parameters) -> expression

或

(parameters) -> { statements; }

  • 参数列表：类似于方法的参数列表，可以为空、有一个参数或多个参数。如果只有一个参数，括号可以省略；如果有多个参数，参数之间用逗号分隔。
  • 箭头符号：-> 是 Lambda 表达式的分隔符，将参数列表和函数主体分开。
  • 表达式或语句块：如果是一个简单的表达式，直接写在箭头后面，表达式的值会作为 Lambda 表达式的返回值；如果是多个语句，需要用花括号 {} 括起来，并且如果有返回值，需要使用 return 语句。

例如：

// 无参数
Runnable runnable = () -> System.out.println("Hello, Lambda!");

// 一个参数
Consumer<String> consumer = s -> System.out.println(s.toUpperCase());

// 两个参数
BinaryOperator<Integer> operator = (a, b) -> a + b;

函数式接口

Lambda 表达式只能用于上下文期待函数式接口的地方。函数式接口是指只包含一个抽象方法的接口。Java 8 在 java.util.function 包中提供了大量常用的函数式接口，例如：

  • Consumer<T>：接受一个输入参数，不返回结果。其抽象方法为 void accept(T t)。
  • Supplier<T>：不接受参数，返回一个结果。其抽象方法为 T get()。
  • Function<T, R>：接受一个输入参数，返回一个结果。其抽象方法为 R apply(T t)。
  • Predicate<T>：接受一个输入参数，返回一个布尔值。其抽象方法为 boolean test(T t)。

例如，使用 Predicate 接口过滤一个整数列表中的偶数：

import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;

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

        Predicate<Integer> isEven = num -> num % 2 == 0;

        List<Integer> evenNumbers = new ArrayList<>();
        for (Integer num : numbers) {
            if (isEven.test(num)) {
                evenNumbers.add(num);
            }
        }

        System.out.println(evenNumbers);
    }
}

使用 Lambda 表达式进行集合操作

集合框架的增强

Java 8 对集合框架进行了重大改进，引入了 Stream API，它与 Lambda 表达式紧密结合，提供了一种更高效、更简洁的方式来处理集合数据。Stream 代表了一系列支持顺序和并行聚合操作的元素。

例如，要计算一个整数列表中所有偶数的和：

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

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

        int sum = numbers.stream()
               .filter(num -> num % 2 == 0)
               .mapToInt(Integer::intValue)
               .sum();

        System.out.println(sum);
    }
}

在这个例子中，我们首先通过 stream() 方法将列表转换为流。然后使用 filter 方法过滤出偶数，mapToInt 方法将 Integer 对象转换为 int 类型，最后使用 sum 方法计算总和。

常用的 Stream 操作

  1. 中间操作：中间操作会返回一个新的流，并且在流上调用中间操作不会立即执行，而是会进行延迟计算，直到终端操作被调用。常见的中间操作包括：

    • filter：根据给定的 Predicate 过滤流中的元素。
    • map：根据给定的 Function 将流中的每个元素映射到一个新的元素。
    • flatMap：与 map 类似，但 flatMap 会将结果展平。例如，如果 map 操作返回一个包含多个子流的流，flatMap 会将这些子流合并为一个流。
    • distinct：去除流中的重复元素。
    • sorted：对流中的元素进行排序。

  2. 终端操作：终端操作会触发流的计算，并返回一个结果或副作用。常见的终端操作包括：

    • forEach：对流中的每个元素执行给定的 Consumer。
    • collect：将流中的元素收集到一个集合或其他数据结构中，例如使用 Collectors 类提供的方法。
    • reduce：通过给定的 BinaryOperator 对流中的元素进行累积操作，返回一个 Optional 对象（如果流为空，Optional 可能为空）。
    • count：返回流中元素的数量。
    • anyMatch、allMatch、noneMatch：根据给定的 Predicate 检查流中的元素是否满足某些条件。

例如，统计一个字符串列表中长度大于 3 的字符串数量：

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

public class CountLongStrings {
    public static void main(String[] args) {
        List<String> words = new ArrayList<>();
        words.add("apple");
        words.add("banana");
        words.add("cat");
        words.add("dog");

        long count = words.stream()
               .filter(word -> word.length() > 3)
               .count();

        System.out.println(count);
    }
}

并行流

Java 8 的 Stream API 支持并行处理，通过并行流可以充分利用多核处理器的优势，提高大数据集的处理效率。要将一个流转换为并行流，只需调用 parallelStream() 方法。

例如，计算 1 到 1000000 中所有偶数的和：

import java.util.stream.IntStream;

public class ParallelSumOfEvenNumbers {
    public static void main(String[] args) {
        long sum = IntStream.rangeClosed(1, 1000000)
               .parallel()
               .filter(num -> num % 2 == 0)
               .sum();

        System.out.println(sum);
    }
}

在这个例子中，通过 parallel() 方法将 IntStream 转换为并行流，从而加速计算过程。不过，需要注意的是，并行流并非在所有情况下都能提高性能，特别是对于小数据集或计算逻辑复杂的情况，并行流的开销可能会抵消其带来的性能提升。

Lambda 表达式与方法引用

方法引用简介

方法引用是一种更简洁的 Lambda 表达式表示形式，当 Lambda 表达式只调用一个已有的方法时，可以使用方法引用。方法引用通过 :: 操作符来表示。

有以下几种类型的方法引用：

  1. 静态方法引用：ClassName::staticMethodName
  2. 实例方法引用：instanceReference::instanceMethodName
  3. 特定类型的实例方法引用：ClassName::instanceMethodName
  4. 构造函数引用：ClassName::new

静态方法引用示例

假设我们有一个工具类 MathUtils，其中有一个静态方法 square 用于计算一个数的平方：

public class MathUtils {
    public static int square(int num) {
        return num * num;
    }
}

我们可以使用方法引用将这个方法作为 Function 传递给流的 map 操作：

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

public class StaticMethodReferenceExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4);

        List<Integer> squaredNumbers = numbers.stream()
               .map(MathUtils::square)
               .collect(Collectors.toList());

        System.out.println(squaredNumbers);
    }
}

实例方法引用示例

假设有一个 Person 类，其中有一个实例方法 getName 用于获取人的名字：

public class Person {
    private String name;

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

我们可以使用实例方法引用将 getName 方法作为 Function 传递给流的 map 操作：

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

public class InstanceMethodReferenceExample {
    public static void main(String[] args) {
        List<Person> people = new ArrayList<>();
        people.add(new Person("Alice"));
        people.add(new Person("Bob"));

        List<String> names = people.stream()
               .map(Person::getName)
               .collect(Collectors.toList());

        System.out.println(names);
    }
}

特定类型的实例方法引用示例

特定类型的实例方法引用是指引用特定类型的实例方法，而不是某个具体实例的方法。例如，对于字符串操作，我们可以使用 String 类的 length 方法：

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

public class SpecificTypeInstanceMethodReferenceExample {
    public static void main(String[] args) {
        List<String> words = Arrays.asList("apple", "banana", "cherry");

        List<Integer> lengths = words.stream()
               .map(String::length)
               .collect(Collectors.toList());

        System.out.println(lengths);
    }
}

构造函数引用示例

假设我们有一个 Point 类，有两个构造函数，一个无参构造函数和一个带两个参数的构造函数：

public class Point {
    private int x;
    private int y;

    public Point() {
    }

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return x;
    }

    public int getY() {
        return y;
    }
}

我们可以使用构造函数引用创建 Point 对象：

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

public class ConstructorReferenceExample {
    public static void main(String[] args) {
        Supplier<Point> pointSupplier = Point::new;
        List<Point> points = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            points.add(pointSupplier.get());
        }

        List<Point> pointsWithArgs = IntStream.range(0, 5)
               .mapToObj(i -> new Point(i, i * 2))
               .collect(Collectors.toList());
    }
}

Lambda 表达式的高级应用

处理复杂业务逻辑

在实际开发中，Lambda 表达式可以极大地简化复杂业务逻辑的实现。例如，假设我们有一个订单系统，订单包含商品列表、客户信息等。我们需要根据不同的条件筛选订单，比如筛选出特定客户的订单，或者订单金额大于某个值的订单。

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

class Product {
    private String name;
    private double price;

    public Product(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public double getPrice() {
        return price;
    }
}

class Order {
    private List<Product> products;
    private String customer;

    public Order(List<Product> products, String customer) {
        this.products = products;
        this.customer = customer;
    }

    public double getTotalPrice() {
        return products.stream()
               .mapToDouble(Product::getPrice)
               .sum();
    }

    public String getCustomer() {
        return customer;
    }
}

public class OrderProcessing {
    public static void main(String[] args) {
        List<Product> productList1 = new ArrayList<>();
        productList1.add(new Product("Laptop", 1000.0));
        productList1.add(new Product("Mouse", 50.0));

        List<Product> productList2 = new ArrayList<>();
        productList2.add(new Product("Monitor", 200.0));

        Order order1 = new Order(productList1, "Alice");
        Order order2 = new Order(productList2, "Bob");

        List<Order> orders = new ArrayList<>();
        orders.add(order1);
        orders.add(order2);

        // 筛选出客户为 Alice 的订单
        List<Order> aliceOrders = orders.stream()
               .filter(order -> "Alice".equals(order.getCustomer()))
               .collect(Collectors.toList());

        // 筛选出订单金额大于 500 的订单
        List<Order> highValueOrders = orders.stream()
               .filter(order -> order.getTotalPrice() > 500)
               .collect(Collectors.toList());
    }
}

结合自定义函数式接口

除了使用 Java 8 提供的标准函数式接口，我们还可以定义自己的函数式接口，并在 Lambda 表达式中使用。例如，假设我们需要定义一个用于处理特定业务逻辑的接口 BusinessLogicHandler：

@FunctionalInterface
interface BusinessLogicHandler<T, R> {
    R handle(T input);
}

然后我们可以在代码中使用这个接口和 Lambda 表达式：

public class CustomFunctionalInterfaceExample {
    public static void main(String[] args) {
        BusinessLogicHandler<Integer, String> handler = num -> "The number is " + num;

        String result = handler.handle(10);
        System.out.println(result);
    }
}

Lambda 表达式与并发编程

在并发编程中，Lambda 表达式也能发挥重要作用。例如，使用 CompletableFuture 进行异步计算时，可以使用 Lambda 表达式来定义异步任务和处理结果。

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class CompletableFutureExample {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            // 模拟一个耗时操作
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return 42;
        });

        CompletableFuture<String> resultFuture = future.thenApplyAsync(num -> "The result is " + num);

        System.out.println(resultFuture.get());
    }
}

在这个例子中，supplyAsync 方法接受一个 Lambda 表达式作为异步任务，thenApplyAsync 方法接受另一个 Lambda 表达式来处理异步任务的结果。

Lambda 表达式的性能与优化

Lambda 表达式的性能分析

虽然 Lambda 表达式在代码简洁性和可读性方面带来了很大的优势，但在性能方面也需要进行分析。在大多数情况下，Lambda 表达式的性能与传统的匿名内部类实现相当。然而，在一些极端情况下，可能会存在性能差异。

例如，对于非常小的数据集，使用 Lambda 表达式的开销可能会相对较大，因为它涉及到方法调用和对象创建等操作。而对于大数据集，特别是在使用并行流时，Lambda 表达式结合 Stream API 可以显著提高性能。

为了准确分析性能，可以使用性能测试工具，如 JMH（Java Microbenchmark Harness）。以下是一个简单的 JMH 示例，用于比较使用 Lambda 表达式和传统方式过滤整数列表中的偶数的性能：

import org.openjdk.jmh.annotations.*;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.RunnerException;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;

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

@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@State(Scope.Thread)
public class LambdaPerformanceTest {
    private List<Integer> numbers;

    @Setup
    public void setup() {
        numbers = new ArrayList<>();
        for (int i = 0; i < 10000; i++) {
            numbers.add(i);
        }
    }

    @Benchmark
    public List<Integer> traditionalFilter() {
        List<Integer> result = new ArrayList<>();
        for (Integer num : numbers) {
            if (num % 2 == 0) {
                result.add(num);
            }
        }
        return result;
    }

    @Benchmark
    public List<Integer> lambdaFilter() {
        return numbers.stream()
               .filter(num -> num % 2 == 0)
               .collect(Collectors.toList());
    }

    public static void main(String[] args) throws RunnerException {
        Options options = new OptionsBuilder()
               .include(LambdaPerformanceTest.class.getSimpleName())
               .warmupIterations(5)
               .measurementIterations(5)
               .forks(1)
               .build();

        new Runner(options).run();
    }
}

通过运行这个 JMH 测试，可以得到两种方式的平均执行时间，从而准确评估性能差异。

性能优化建议

  1. 合理使用并行流：对于大数据集的处理，并行流可以充分利用多核处理器的优势，但对于小数据集或计算逻辑复杂的情况，并行流的开销可能会抵消其性能提升。在使用并行流之前，最好通过性能测试来确定是否真正能提高性能。
  2. 避免不必要的装箱和拆箱：在使用 Stream API 时，尽量使用原始类型的流，如 IntStream、LongStream、DoubleStream 等，避免自动装箱和拆箱操作带来的性能损耗。
  3. 减少中间操作的次数：虽然 Stream API 的中间操作很方便，但过多的中间操作会增加计算的复杂度和开销。尽量将多个中间操作合并为一个，或者提前对数据进行预处理，减少流操作的次数。
  4. 优化 Lambda 表达式的逻辑：确保 Lambda 表达式中的逻辑简洁高效，避免在 Lambda 表达式中进行复杂的、耗时的操作。如果确实需要复杂操作，可以考虑将其封装到一个方法中，在 Lambda 表达式中调用该方法，这样可以提高代码的可读性和可维护性，同时也有助于优化性能。

通过以上性能分析和优化建议，可以在充分发挥 Lambda 表达式优势的同时，确保应用程序的高性能运行。在实际开发中，需要根据具体的业务场景和数据规模，灵活选择合适的方式来使用 Lambda 表达式，以达到最佳的开发效率和性能表现。