Java Lambda 表达式常用函数和示例

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 表达式在集合处理方面展现了强大的功能。