深入理解 Java 8 函数式接口：定义、用法与示例详解

Java 8 引入了函数式编程的概念，使代码更加简洁和可读。函数式接口是 Java 函数式编程的核心，它们是只包含一个抽象方法的接口。这种接口可以用于 Lambda 表达式和方法引用。本文将详细介绍 Java 8 的函数式接口，包括它们的定义、常用接口和使用示例。

1. 函数式接口的定义

函数式接口是只有一个抽象方法的接口，可以使用 @FunctionalInterface 注解进行标注，但这不是必须的。该注解的作用是为了保证该接口符合函数式接口的定义。

@FunctionalInterface
public interface MyFunctionalInterface {void execute();
}

虽然 @FunctionalInterface 注解不是必须的，但推荐使用它，因为它能使代码更具可读性，并在编译时提供额外的检查。

2. 常用的函数式接口

Java 8 提供了许多内置的函数式接口，这些接口都在 java.util.function 包中。以下是一些常用的函数式接口：

💣💥🔥Predicate：接收一个参数，返回一个布尔值。

@FunctionalInterface
public interface Predicate<T> {boolean test(T t);
}

💣💥🔥** Function<T, R>**：接收一个参数，返回一个结果。

@FunctionalInterface
public interface Function<T, R> {R apply(T t);
}

💣💥🔥Supplier：不接收参数，返回一个结果。

@FunctionalInterface
public interface Supplier<T> {T get();
}

💣💥🔥Consumer：接收一个参数，没有返回值。

@FunctionalInterface
public interface Consumer<T> {void accept(T t);
}

💣💥🔥** UnaryOperator**：接收一个参数，返回与该参数类型相同的结果。

@FunctionalInterface
public interface UnaryOperator<T> extends Function<T, T> {
}

💣💥🔥BinaryOperator：接收两个参数，返回与参数类型相同的结果。

@FunctionalInterface
public interface BinaryOperator<T> extends BiFunction<T, T, T> {
}

3. 函数式接口的使用示例

函数式接口通常与 Lambda 表达式和方法引用一起使用。下面是一些使用示例：

💣 Predicate 示例

import java.util.function.Predicate;public class PredicateExample {public static void main(String[] args) {Predicate<String> isLongerThan5 = s -> s.length() > 5;System.out.println(isLongerThan5.test("hello")); // falseSystem.out.println(isLongerThan5.test("hello world")); // true}
}

💣Function 示例

import java.util.function.Function;public class FunctionExample {public static void main(String[] args) {Function<String, Integer> stringLength = s -> s.length();System.out.println(stringLength.apply("hello")); // 5}
}

💣Supplier 示例

import java.util.function.Supplier;public class SupplierExample {public static void main(String[] args) {Supplier<String> stringSupplier = () -> "Hello, World!";System.out.println(stringSupplier.get()); // Hello, World!}
}

💣Consumer 示例

import java.util.function.Consumer;public class ConsumerExample {public static void main(String[] args) {Consumer<String> printConsumer = s -> System.out.println(s);printConsumer.accept("Hello, World!"); // Hello, World!}
}

💣UnaryOperator 示例

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(5)); // 25}
}

💣BinaryOperator 示例

import java.util.function.BinaryOperator;public class BinaryOperatorExample {public static void main(String[] args) {BinaryOperator<Integer> add = (a, b) -> a + b;System.out.println(add.apply(5, 3)); // 8}
}

4. 自定义函数式接口

除了使用 Java 提供的函数式接口外，你还可以定义自己的函数式接口。下面是一个自定义函数式接口的示例：

@FunctionalInterface
public interface MyFunctionalInterface {void execute(String message);
}public class FunctionalInterfaceDemo {public static void main(String[] args) {MyFunctionalInterface myFunc = (message) -> System.out.println(message);myFunc.execute("Hello, Functional Interface!"); // Hello, Functional Interface!}
}

5. 使用方法引用

方法引用是另一种简洁的 Lambda 表达式写法。常见的用法包括引用静态方法、实例方法和构造方法。

💥静态方法引用

import java.util.function.Function;public class MethodReferenceExample {public static void main(String[] args) {Function<String, Integer> stringToInt = Integer::parseInt;System.out.println(stringToInt.apply("123")); // 123}
}

💥实例方法引用

import java.util.function.Predicate;public class InstanceMethodReferenceExample {public static void main(String[] args) {String str = "Hello";Predicate<String> isEqual = str::equals;System.out.println(isEqual.test("Hello")); // trueSystem.out.println(isEqual.test("World")); // false}
}

💥构造方法引用

import java.util.function.Supplier;
import java.util.ArrayList;
import java.util.List;public class ConstructorReferenceExample {public static void main(String[] args) {Supplier<List<String>> listSupplier = ArrayList::new;List<String> list = listSupplier.get();System.out.println(list); // []}
}