，从而确定相机相对于D点的位姿。 基本概念 旋转矩阵（R）：描述相机的姿态，×维度，用于表示D世界坐标系到相机坐标系的旋转关系 平移 ...
吃技厦步一、函数式接口的定义
函数式接口 （Functional Interface） 是Java 8引入的核心概念，它是指有且仅有一个抽象方法的接口（可包含默认方法和静态方法）。这种接口可以用Lambda表达式或方法引用来实现，是函数式编程在Java中的基础。
// 标准定义
@FunctionalInterface // 编译期检查，可选但推荐
public interface MyFunction {
String apply(int x); // 唯一的抽象方法
// 允许默认方法
default void print(String msg) {
System.out.println(msg);
}
// 允许静态方法
static void log(String msg) {
System.out.println("[LOG] " + msg);
}
}
二、渐进式学习——代码示例
2.1 阶段1：从匿名类到Lambda演化
public class EvolutionDemo {
public static void main(String[] args) {
List names = Arrays.asList("Alice", "Bob", "Charlie");
// 【传统方式】匿名内部类
names.forEach(new Consumer() {
@Override
public void accept(String name) {
System.out.println(name);
}
});
// 【方式1】Lambda完整语法
names.forEach((String name) -> {
System.out.println(name);
});
// 【方式2】Lambda简化（参数类型推导）
names.forEach((name) -> System.out.println(name));
// 【方式3】Lambda最简（单参数可省括号）
names.forEach(name -> System.out.println(name));
// 【方式4】方法引用（终极简化）
names.forEach(System.out::println);
}
}
2.2 阶段2：Java内置的四大核心函数式接口精讲
1. Consumer - 消费型接口
@FunctionalInterface
public interface Consumer {
void accept(T t);
}
作用：接收一个参数，不返回结果
示例：
// 打印字符串
Consumer printer = s -> System.out.println(s);
printer.accept("Hello, Consumer!");
// 消费列表元素
List names = Arrays.asList("Alice", "Bob", "Charlie");
names.forEach(name -> System.out.println("Hello, " + name));
2. Supplier- 供给型接口
@FunctionalInterface
public interface Supplier {
T get();
}
作用：不接收参数，返回一个结果
示例：
// 生成随机数
Supplier randomSupplier = () -> Math.random();
System.out.println("Random: " + randomSupplier.get());
// 延迟初始化
Supplier lazyString = () -> {
System.out.println("Initializing...");
return "Lazy Value";
};
System.out.println("Before get");
System.out.println(lazyString.get());
3. Function - 函数型接口
@FunctionalInterface
public interface Function {
R apply(T t);
}
作用：接收一个参数，返回一个结果
示例：
// 字符串转整数
Function stringToInt = s -> Integer.parseInt(s);
int result = stringToInt.apply("123");
System.out.println("Result: " + result);
// 函数组合
Function doubleIt = x -> x * 2;
Function addOne = x -> x + 1;
Function composed = doubleIt.andThen(addOne);
System.out.println("Composed: " + composed.apply(5)); // 输出: 11
4. Predicate - 断言型接口
@FunctionalInterface
public interface Predicate {
boolean test(T t);
}
作用：接收一个参数，返回布尔值
示例：
// 判断字符串是否为空
Predicate isEmpty = s -> s == null || s.isEmpty();
System.out.println("Is empty: " + isEmpty.test("")); // true
// 过滤列表
List numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
List evenNumbers = numbers.stream()
.filter(n -> n % 2 == 0)
.collect(Collectors.toList());
System.out.println("Even numbers: " + evenNumbers); // [2, 4, 6]
2.3 阶段3：自定义函数式接口实践
// 定义业务相关的函数式接口
@FunctionalInterface
interface OrderValidator {
boolean validate(Order order);
// 默认方法：组合验证
default OrderValidator and(OrderValidator other) {
return order -> this.validate(order) && other.validate(order);
}
}
// 使用自定义接口
public class CustomFunctionalInterface {
public static void main(String[] args) {
List orders = createOrders();
// 定义验证规则
OrderValidator isActive = Order::isActive;
OrderValidator isHighValue = o -> o.getAmount() > 1000;
// 组合验证（利用默认方法）
OrderValidator combined = isActive.and(isHighValue);
// 应用验证
orders.stream()
.filter(combined::validate) // 方法引用
.forEach(o -> System.out.println("Valid: " + o));
}
}
2.4 阶段4：方法引用与构造函数引用
public class ReferenceDemo {
public static void main(String[] args) {
List names = Arrays.asList("Tom", "Jerry");
// 1. 静态方法引用：类名::静态方法
names.stream()
.map(String::toUpperCase) // 等价于 s -> s.toUpperCase()
.forEach(System.out::println);
// 2. 实例方法引用：对象::实例方法
String prefix = "Name: ";
names.forEach(s -> System.out.println(prefix + s));
// 3. 构造函数引用：类名::new
Supplier> listSupplier = ArrayList::new;
List newList = listSupplier.get();
// 4. 数组构造函数引用：类型[]::new
IntFunction arrayCreator = String[]::new;
String[] array = arrayCreator.apply(5); // 创建长度为5的数组
}
}
2.5 阶段5：Stream API中的函数式接口应用
public class StreamFunctionalDemo {
public static void main(String[] args) {
List employees = Arrays.asList(
new Employee("Alice", 8000, "Tech"),
new Employee("Bob", 12000, "Tech"),
new Employee("Charlie", 7000, "HR")
);
// 综合案例：分组、过滤、转换
Map> result = employees.stream()
.filter(e -> e.getSalary() > 7500) // Predicate
.map(Employee::getName) // Function
.collect(Collectors.groupingBy(
name -> name.substring(0, 1) // Function
));
System.out.println(result); // {A=[Alice], B=[Bob]}
}
}
2.6 综合实战案例
// 构建一个函数式风格的订单处理系统
public class OrderProcessor {
// 核心：用函数式接口定义可组合的业务规则
private final Function taxCalculator;
private final Predicate validationRule;
private final Consumer auditLogger;
// 构造函数注入行为
public OrderProcessor(Function taxCalculator,
Predicate validationRule,
Consumer auditLogger) {
this.taxCalculator = taxCalculator;
this.validationRule = validationRule;
this.auditLogger = auditLogger;
}
public void process(List orders) {
orders.stream()
.filter(validationRule) // 验证
.peek(auditLogger) // 记录日志
.map(order -> { // 计算税后价格
double tax = taxCalculator.apply(order);
order.setFinalPrice(order.getAmount() + tax);
return order;
})
.forEach(order -> System.out.println("处理完成: " + order));
}
public static void main(String[] args) {
// 配置不同的业务规则
OrderProcessor domesticProcessor = new OrderProcessor(
order -> order.getAmount() * 0.1, // 10%税
Order::isActive, // 仅处理激活订单
o -> System.out.println("审计: " + o.getId())
);
domesticProcessor.process(createOrders());
}
}
三、总结
在四大核心函数式函数式接口的基础上，还有BiFunction - 双参数转换、UnaryOperator - 一元操作、BinaryOperator - 二元操作。简单来说，UnaryOperator和BinaryOperator并非新的概念，而是两大核心函数式接口的“特化”或“简化版”。它们与四大核心函数接口的关系是包含与被包含的关系，而非并列关系。
接口类型 方法签名 用途 示例
Consumer void accept(T t) 消费数据 forEach
Supplier T get() 提供数据 延迟初始化
Function R apply(T t) 数据转换 map
Predicate boolean test(T t) 条件判断 filter
BiFunction R apply(T t, U u) 双参数转换 合并操作
UnaryOperator T apply(T t) 一元操作 字符串处理
BinaryOperator T apply(T t1, T t2) 二元操作 数学运算
Function和 BiFunction? 是基础且通用的转换接口，适用于各种复杂的类型转换场景。
UnaryOperator和 BinaryOperator? 是前两者的特殊形式，专门用于输入输出类型一致的特定场景，使代码意图更明确。
如果有需要，也可以使用@FunctionalInterface注解来定制契合某个业务的函数式接口。