Java 8四大函数式接口的定义及使用示例详解

@FunctionalInterface
public interface MyFunctionalInterface {
    void doSomething(); // 只有一个抽象方法
}

void accept(T t);

import java.util.function.Consumer;

public class ConsumerExample {
    public static void main(String[] args) {
        // 使用 Lambda 表达式实现 Consumer
        Consumer<String> printConsumer = (s) -> System.out.println(s);
        printConsumer.accept("Hello, Consumer!");

        // 使用方法引用实现 Consumer
        Consumer<String> printConsumerRef = System.out::println;
        printConsumerRef.accept("Hello, Method Reference!");
    }
}

Consumer<String> first = (s) -> System.out.println("First: " + s);
Consumer<String> second = (s) -> System.out.println("Second: " + s);
first.andThen(second).accept("Hello");

T get();

import java.util.function.Supplier;

public class SupplierExample {
    public static void main(String[] args) {
        // 使用 Lambda 表达式实现 Supplier
        Supplier<String> stringSupplier = () -> "Hello, Supplier!";
        System.out.println(stringSupplier.get());

        // 使用方法引用实现 Supplier
        Supplier<Double> randomSupplier = Math::random;
        System.out.println(randomSupplier.get());
    }
}

R apply(T t);

import java.util.function.Function;

public class FunctionExample {
    public static void main(String[] args) {
        // 使用 Lambda 表达式实现 Function
        Function<String, Integer> lengthFunction = (s) -> s.length();
        System.out.println(lengthFunction.apply("Hello, Function!"));

        // 使用方法引用实现 Function
        Function<String, String> upperCaseFunction = String::toUpperCase;
        System.out.println(upperCaseFunction.apply("hello"));
    }
}

Function<String, Integer> lengthFunction = String::length;
Function<Integer, String> toStringFunction = Object::toString;
Function<String, String> composedFunction = lengthFunction.andThen(toStringFunction);
System.out.println(composedFunction.apply("Hello")); // 输出 "5"

boolean test(T t);

import java.util.function.Predicate;

public class PredicateExample {
    public static void main(String[] args) {
        // 使用 Lambda 表达式实现 Predicate
        Predicate<String> lengthPredicate = (s) -> s.length() > 5;
        System.out.println(lengthPredicate.test("Hello")); // false
        System.out.println(lengthPredicate.test("Hello, Predicate!")); // true

        // 使用方法引用实现 Predicate
        Predicate<String> isEmptyPredicate = String::isEmpty;
        System.out.println(isEmptyPredicate.test("")); // true
    }
}

Predicate<String> lengthPredicate = (s) -> s.length() > 5;
Predicate<String> containsPredicate = (s) -> s.contains("Hello");
Predicate<String> combinedPredicate = lengthPredicate.and(containsPredicate);
System.out.println(combinedPredicate.test("Hello, World!")); // true