一、Lambda表达式基础
Lambda表达式是Java 8引入的一个重要特性,它让我们可以将行为像数据一样传递。可以把它理解为一种简洁的、匿名的函数定义方式。
Lambda表达式语法
java">// 基本语法: (参数) -> {表达式}// 1. 无参数
Runnable r = () -> System.out.println("Hello");// 2. 单个参数(可以省略括号)
Consumer<String> consumer = str -> System.out.println(str);// 3. 多个参数
BiFunction<Integer, Integer, Integer> add = (a, b) -> a + b;// 4. 带代码块
Comparator<String> c = (s1, s2) -> {System.out.println("Comparing");return s1.compareTo(s2);
};
Lambda表达式的类型推断
java">// Java编译器可以根据上下文推断Lambda表达式的参数类型
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");// 不需要指定String类型
names.sort((x, y) -> x.compareToIgnoreCase(y));
二、函数式接口
函数式接口是只有一个抽象方法的接口,可以用@FunctionalInterface注解标记。
常用函数式接口
java">// 1. Consumer:接收一个参数,不返回结果
Consumer<String> printer = s -> System.out.println(s);// 2. Function:接收一个参数,返回一个结果
Function<String, Integer> lengthFunc = s -> s.length();// 3. Predicate:接收一个参数,返回布尔值
Predicate<String> isEmpty = s -> s.isEmpty();// 4. Supplier:不接收参数,返回一个结果
Supplier<Double> random = () -> Math.random();
自定义函数式接口
java">@FunctionalInterface
interface MathOperation {int operate(int a, int b);// 可以有默认方法default int operateDouble(int a, int b) {return operate(a, b) * 2;}
}// 使用自定义函数式接口
MathOperation add = (a, b) -> a + b;
MathOperation multiply = (a, b) -> a * b;
三、Stream API详解
Stream API提供了一种声明式的方式来处理数据集合。
Stream操作基础
java">List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");// 创建流
Stream<String> stream = names.stream();// 链式操作
List<String> filteredNames = names.stream().filter(name -> name.length() > 4) // 过滤.map(String::toUpperCase) // 转换.sorted() // 排序.collect(Collectors.toList()); // 收集结果
常用Stream操作
java">List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);// 1. 筛选和切片
List<Integer> evenNumbers = numbers.stream().filter(n -> n % 2 == 0).collect(Collectors.toList());// 2. 映射
List<String> numberStrings = numbers.stream().map(String::valueOf).collect(Collectors.toList());// 3. 归约
int sum = numbers.stream().reduce(0, Integer::sum);// 4. 收集
Map<Boolean, List<Integer>> evenOddMap = numbers.stream().collect(Collectors.groupingBy(n -> n % 2 == 0));
四、并行流和性能优化
并行流使用
java">// 将顺序流转换为并行流
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.parallelStream().mapToInt(Integer::intValue).sum();// 复杂操作的并行处理
List<String> processedData = bigList.parallelStream().filter(item -> item != null).map(item -> processItem(item)).collect(Collectors.toList());
性能优化建议
java">// 1. 避免在并行流中使用有状态操作
// 不好的例子
AtomicInteger counter = new AtomicInteger();
stream.parallel().forEach(item -> counter.incrementAndGet());// 2. 使用适当的数据结构
// 好的例子
ArrayList<Integer> list = new ArrayList<>();
// 不好的例子
LinkedList<Integer> linkedList = new LinkedList<>();
五、Optional类使用
Optional类是用来防止空指针异常的容器对象。
java">// 创建Optional对象
Optional<String> optional = Optional.of("Hello");
Optional<String> empty = Optional.empty();
Optional<String> nullable = Optional.ofNullable(null);// 安全地获取值
String result = optional.orElse("Default");
String result2 = optional.orElseGet(() -> "Computed Default");
String result3 = optional.orElseThrow(() -> new RuntimeException("Value not present"));// 链式操作
Optional<String> name = Optional.ofNullable(user).map(User::getAddress).map(Address::getCity).map(City::getName);
最佳实践建议 💡
- Lambda表达式
- 保持简短和清晰
- 避免在Lambda中使用复杂的逻辑
- 适当使用方法引用
- Stream操作
- 使用合适的终端操作
- 注意流操作的顺序
- 避免过度使用Stream
- 并行流
- 在适当的场景使用并行流
- 注意数据量和计算复杂度
- 考虑线程安全性
常见陷阱提醒 ⚠️
- Lambda陷阱
java">// 错误:在Lambda中修改外部变量
int sum = 0;
list.forEach(i -> sum += i); // 编译错误
- Stream陷阱
java">// 错误:重复使用Stream
Stream<String> stream = list.stream();
stream.forEach(System.out::println);
stream.forEach(System.out::println); // IllegalStateException
- Optional陷阱
java">// 错误:不恰当的Optional使用
Optional<String> optional = Optional.ofNullable(str);
if (optional.isPresent()) { // 不推荐return optional.get();
} else {return "default";
}// 正确方式
return optional.orElse("default");
函数式编程特性大大提升了Java的表达能力和代码简洁性。合理使用这些特性可以写出更加优雅和高效的代码。