Java 中的 lambda 表达式是 Java 8 引入的一项重要特性，它简化了函数式编程的实现方式。Lambda 表达式通常与 java.util.function 包中的函数式接口结合使用，这些接口为常见的操作提供了标准化的函数定义。

---

常用函数式接口及示例

1. Function<T, R>

表示接受一个输入参数并返回结果的函数。

示例：将字符串转换为大写

import java.util.function.Function;

public class FunctionExample {
    public static void main(String[] args) {
        Function<String, String> toUpperCase = s -> s.toUpperCase();
        System.out.println(toUpperCase.apply("hello")); // 输出: HELLO
    }
}

示例：计算字符串长度

Function<String, Integer> stringLength = s -> s.length();
System.out.println(stringLength.apply("lambda")); // 输出: 6

---

2. Predicate<T>

表示一个布尔值函数，用于判断某个条件是否成立。

示例：检查数字是否为偶数

import java.util.function.Predicate;

public class PredicateExample {
    public static void main(String[] args) {
        Predicate<Integer> isEven = n -> n % 2 == 0;
        System.out.println(isEven.test(4)); // 输出: true
        System.out.println(isEven.test(5)); // 输出: false
    }
}

示例：检查字符串是否为空

Predicate<String> isEmpty = s -> s.isEmpty();
System.out.println(isEmpty.test("")); // 输出: true
System.out.println(isEmpty.test("abc")); // 输出: false

---

3. Consumer<T>

表示接受一个输入参数且不返回结果的操作。

示例：打印字符串

import java.util.function.Consumer;

public class ConsumerExample {
    public static void main(String[] args) {
        Consumer<String> printMessage = message -> System.out.println(message);
        printMessage.accept("Hello, Lambda!"); // 输出: Hello, Lambda!
    }
}

示例：遍历集合并打印元素

import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;

public class ListConsumer {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
        names.forEach(name -> System.out.println(name));
    }
}

---

4. Supplier<T>

表示无参数但返回结果的提供者。

示例：生成随机数

import java.util.function.Supplier;
import java.util.Random;

public class SupplierExample {
    public static void main(String[] args) {
        Supplier<Integer> randomNum = () -> new Random().nextInt(100);
        System.out.println(randomNum.get()); // 输出: 0 到 99 的随机整数
    }
}

示例：返回默认字符串

Supplier<String> defaultGreeting = () -> "Hello, World!";
System.out.println(defaultGreeting.get()); // 输出: Hello, World!

---

5. BiFunction<T, U, R>

表示接受两个输入参数并返回结果的函数。

示例：求两个数的和

import java.util.function.BiFunction;

public class BiFunctionExample {
    public static void main(String[] args) {
        BiFunction<Integer, Integer, Integer> add = (a, b) -> a + b;
        System.out.println(add.apply(3, 5)); // 输出: 8
    }
}

示例：连接两个字符串

BiFunction<String, String, String> concatenate = (s1, s2) -> s1 + s2;
System.out.println(concatenate.apply("Java", "Lambda")); // 输出: JavaLambda

---

6. UnaryOperator<T>

是 Function<T, T> 的子接口，表示接受一个参数并返回相同类型的结果。

示例：对整数进行平方运算

import java.util.function.UnaryOperator;

public class UnaryOperatorExample {
    public static void main(String[] args) {
        UnaryOperator<Integer> square = x -> x * x;
        System.out.println(square.apply(4)); // 输出: 16
    }
}

---

7. BinaryOperator<T>

是 BiFunction<T, T, T> 的子接口，表示接受两个相同类型的参数并返回相同类型的结果。

示例：找出两个数的最大值

import java.util.function.BinaryOperator;

public class BinaryOperatorExample {
    public static void main(String[] args) {
        BinaryOperator<Integer> max = (a, b) -> a > b ? a : b;
        System.out.println(max.apply(10, 20)); // 输出: 20
    }
}

---

高级应用示例

使用 Lambda 表达式处理集合

过滤列表

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

public class FilterExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
        List<Integer> evenNumbers = numbers.stream()
                                           .filter(n -> n % 2 == 0)
                                           .collect(Collectors.toList());
        System.out.println(evenNumbers); // 输出: [2, 4, 6]
    }
}

映射列表

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

public class MapExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("alice", "bob", "charlie");
        List<String> upperCaseNames = names.stream()
                                          .map(name -> name.toUpperCase())
                                          .collect(Collectors.toList());
        System.out.println(upperCaseNames); // 输出: [ALICE, BOB, CHARLIE]
    }
}

归约操作

import java.util.Arrays;
import java.util.List;

public class ReduceExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        int sum = numbers.stream()
                         .reduce(0, (a, b) -> a + b);
        System.out.println(sum); // 输出: 15
    }
}

---

总结

Java 的 lambda 表达式极大地简化了函数式编程的实现，使得代码更加简洁、易读。通过 java.util.function 提供的各种函数式接口（如 Function, Predicate, Consumer, Supplier, BiFunction, UnaryOperator, BinaryOperator），开发者可以轻松地编写出高效且富有表现力的代码。此外，结合 Java Stream API，lambda 表达式在集合处理方面展现了强大的功能。