Java 函数式接口（Functional Interface）

定义与基本概念

函数式接口是Java 8引入的一个重要特性，它是指仅包含一个抽象方法的接口（可以包含多个默认方法或静态方法）。这类接口的主要目的是支持Lambda表达式的使用，为函数式编程提供基础。

具体来说：

1. 一个标准的函数式接口只能有一个抽象方法，但可以包含：

   • 任意数量的默认方法（default methods）
   • 任意数量的静态方法
   • 从Object类继承的方法（如toString、equals等）

2. 常见的函数式接口示例：

   • java.util.function包中的Predicate、Function、Consumer、Supplier等
   • Runnable接口（只有一个run()方法）
   • Comparator接口（只有一个compare()抽象方法）

3. 使用场景：

   • 作为Lambda表达式的目标类型
   • 作为方法引用的目标类型
   • 在流式操作(Stream API)中作为参数传递

注解@FunctionalInterface用于明确标识一个接口是函数式接口，它会在编译时检查接口是否符合函数式接口的条件（即只能有一个抽象方法）。虽然不是强制要求，但推荐使用该注解来表明设计意图。

使用该注解的好处包括：

• 提高代码可读性，明确表明该接口是用于函数式编程
• 编译器会进行严格检查，确保接口确实只有一个抽象方法
• 防止其他开发人员意外添加新的抽象方法破坏函数式接口的特性

例如：

@FunctionalInterface
public interface MyFunctionalInterface {
    void execute();
    
    default void defaultMethod() {
        System.out.println("默认方法");
    }
    
    static void staticMethod() {
        System.out.println("静态方法");
    }
}

核心函数式接口

Java 8在java.util.function包中内置了四大核心函数式接口：

1. Consumer<T>（消费者接口）

• 抽象方法：void accept(T t)
• 表示接收一个参数但不返回结果的操作
• 典型应用：集合遍历

List<String> list = Arrays.asList("a", "b", "c");
list.forEach(str -> System.out.println(str));  // 使用Consumer

2. Supplier<T>（供应者接口）

• 抽象方法：T get()
• 表示不接收参数但返回结果的操作
• 典型应用：延迟计算

Supplier<Double> randomSupplier = () -> Math.random();
System.out.println(randomSupplier.get());

3. Function<T,R>（函数接口）

• 抽象方法：R apply(T t)
• 表示接收一个参数并返回结果的操作
• 典型应用：数据转换

Function<String, Integer> strToLength = str -> str.length();
System.out.println(strToLength.apply("Hello"));  // 输出5

4. Predicate<T>（断言接口）

• 抽象方法：boolean test(T t)
• 表示接收一个参数并返回布尔值的操作
• 典型应用：数据过滤

Predicate<Integer> isEven = num -> num % 2 == 0;
System.out.println(isEven.test(4));  // 输出true

其他常见函数式接口

除了上述四大核心接口外，Java还提供了许多其他的函数式接口：

• BiFunction<T,U,R>：接收两个参数，返回一个结果
• UnaryOperator<T>：继承自Function，接收和返回相同类型
• BinaryOperator<T>：继承自BiFunction，接收两个相同类型参数并返回相同类型结果
• BiConsumer<T,U>：接收两个参数，不返回结果
• BiPredicate<T,U>：接收两个参数，返回布尔值

方法引用

方法引用是函数式接口的一种简化写法，有以下四种形式：

1. 静态方法引用：ClassName::staticMethod

   Function<String, Integer> parseInt = Integer::parseInt;
   

2. 实例方法引用：instance::method

   String str = "Hello";
   Supplier<Integer> lengthSupplier = str::length;
   

3. 任意对象的实例方法引用：ClassName::instanceMethod

   Function<String, String> upperCase = String::toUpperCase;
   

4. 构造方法引用：ClassName::new

   Supplier<List<String>> listSupplier = ArrayList::new;
   

实际应用场景

1. 集合操作：Stream API中大量使用函数式接口

   List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
   int sum = numbers.stream()
                   .filter(n -> n % 2 == 0)  // Predicate
                   .mapToInt(n -> n * 2)     // Function
                   .sum();
   

2. 事件处理：GUI编程中的事件监听器

   button.addActionListener(event -> System.out.println("Button clicked"));
   

3. 线程创建：简化线程创建代码

   new Thread(() -> System.out.println("Running in a thread")).start();
   

4. 策略模式：通过Lambda表达式实现不同策略

   public void process(List<String> list, Predicate<String> predicate) {
       list.stream().filter(predicate).forEach(System.out::println);
   }
   

函数式接口的详细说明与注意事项

核心特性

1. 抽象方法限制：

   • 严格规定只能包含一个抽象方法（Single Abstract Method，简称SAM）
   • 示例：Runnable接口只包含void run()一个抽象方法
   • 违反示例：若接口包含void method1()和int method2()两个抽象方法，则不符合函数式接口定义

2. 默认方法与静态方法：

   • 可以包含任意数量的默认方法（default方法）
   • 可以包含任意数量的静态方法
   • 示例：Comparator接口包含多个默认方法如reversed()、thenComparing()等

3. Object类方法例外：

   • 从java.lang.Object继承的抽象方法不计入抽象方法数量
   • 示例：接口可以同时声明void execute()和boolean equals(Object obj)，仍视为函数式接口
   • 理由：equals等方法是所有对象都具备的，不会增加额外的抽象方法

注解使用

@FunctionalInterface注解的用途：

• 显式标记接口为函数式接口
• 触发编译时检查，确保接口符合函数式接口规范
• 提高代码可读性，明确设计意图
• 示例：

@FunctionalInterface
interface StringProcessor {
    String process(String input);
    // 编译错误：若添加第二个抽象方法
    // String validate(String input); 
}

Lambda表达式关联

• Lambda表达式必须与函数式接口配合使用
• 目标类型推断依赖于函数式接口
• 示例：

Function<String, Integer> stringToInt = s -> Integer.parseInt(s);
// Function是函数式接口，只包含一个抽象方法R apply(T t)

应用优势

1. 集合处理：

   • 简化集合操作，如过滤、映射、归约
   • 示例：

   List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
   names.stream()
        .filter(name -> name.length() > 3)  // Predicate函数式接口
        .forEach(System.out::println);     // Consumer函数式接口
   

2. 并行编程：

   • 便于使用并行流(parallelStream)进行数据处理
   • 示例：

   List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
   int sum = numbers.parallelStream()
                   .reduce(0, (a, b) -> a + b);  // BinaryOperator函数式接口
   

3. 回调机制：

   • 简化事件处理器、线程任务等回调场景
   • 示例：

   new Thread(() -> System.out.println("Running in thread")).start();
   // Runnable函数式接口
   

4. 策略模式：

   • 轻松实现不同的算法策略
   • 示例：

   Comparator<String> lengthComparator = (s1, s2) -> s1.length() - s2.length();
   

常见函数式接口

Java 8在java.util.function包中提供的核心函数式接口：

• Function<T,R>：接受T类型参数，返回R类型结果
• Predicate<T>：接受T类型参数，返回boolean
• Consumer<T>：接受T类型参数，无返回值
• Supplier<T>：无参数，返回T类型结果
• UnaryOperator<T>：接受T类型参数，返回T类型结果
• BinaryOperator<T>：接受两个T类型参数，返回T类型结果