java提供的4种函数式接口

针对“java提供的4种函数式接口”，我将给出一个详尽的讲解。

首先，我们需要了解所谓函数式接口的定义。函数式接口是一种只有一个抽象方法的接口，它可以被用作Lambda表达式的类型。在Lambda表达式中，它就像是一个抽象方法的占位符，我们可以根据需要来实现它。Java为我们定义了大量的函数式接口，其中四个比较重要的是Function、Predicate、Supplier和Consumer。

下面让我们分别来看看这四种接口：

1. Function接口

Function接口表示接受一个参数并返回一个结果的函数。它包含了一个apply方法，该方法接受一个T类型的参数，返回一个R类型的结果。其中，T和R可以是任意类型，不需要相同。

以下是Function接口的定义：

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

下面是一个使用Function接口的示例，我们定义了一个函数式接口Power，它接受两个参数i和j，分别表示底数和指数，返回一个Double类型的结果。Power的实现中使用了Function接口，计算了i的j次方。

@FunctionalInterface
interface Power {
    Double apply(Double i, Integer j);

    default void print(Double i, Integer j) {
        System.out.println(i + "的" + j + "次方：" + apply(i, j));
    }
}

public class FunctionInterfaceExample {
    public static void main(String[] args) {
        // 计算2的3次方，结果为8.0
        Power power = (i, j) -> Math.pow(i, j);
        power.print(2.0, 3);

        // 计算3的4次方，结果为81.0
        power = (i, j) -> Math.pow(i, j);
        power.print(3.0, 4);
    }
}

2. Predicate接口

Predicate接口表示的是一个谓词（一个布尔值函数）。它包含了一个test方法，该方法接受一个T类型的参数，返回一个boolean类型的结果。

以下是Predicate接口的定义：

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

下面是一个使用Predicate接口的示例，我们定义了一个函数式接口Human，它包含了三个属性：姓名name、年龄age和性别gender。我们需要对这些humans进行筛选，筛选出他们年龄在18岁以上的非女性。这里使用了Predicate接口实现谓词。

@FunctionalInterface
interface Human {
    String getName();
    int getAge();
    String getGender();
}

public class PredicateInterfaceExample {
    public static void main(String[] args) {
        // 创建Humans列表
        List<Human> humans = Arrays.asList(
                new Human() {
                    @Override
                    public String getName() {
                        return "Alice";
                    }

                    @Override
                    public int getAge() {
                        return 25;
                    }

                    @Override
                    public String getGender() {
                        return "Female";
                    }
                },
                new Human() {
                    @Override
                    public String getName() {
                        return "Bob";
                    }

                    @Override
                    public int getAge() {
                        return 15;
                    }

                    @Override
                    public String getGender() {
                        return "Male";
                    }
                }
        );

        // 筛选出年龄大于等于18岁的男性
        Predicate<Human> maleAdult = human -> human.getAge() >= 18 && "Male".equals(human.getGender());
        List<Human> maleAdultList = humans.stream().filter(maleAdult).collect(Collectors.toList());
        System.out.println("Male Adults:" + maleAdultList);

        // 筛选出年龄大于等于18岁的女性
        Predicate<Human> femaleAdult = human -> human.getAge() >= 18 && "Female".equals(human.getGender());
        List<Human> femaleAdultList = humans.stream().filter(femaleAdult).collect(Collectors.toList());
        System.out.println("Female Adults:" + femaleAdultList);
    }
}

3. Supplier接口

Supplier接口表示一个供应商（一个生产者函数），它不包含任何参数，返回一个T类型的值。使用函数式接口时，我们可以直接将该接口定义的方法作为函数使用。

以下是Supplier接口的定义：

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

下面是一个使用Supplier接口的示例，我们定义了一个函数式接口Hello，它不接受任何参数，返回一个字符串类型的结果。Hello的实现中使用了Supplier接口，返回了一个固定的字符串。

@FunctionalInterface
interface Hello {
    String sayHello();
}

public class SupplierInterfaceExample {
    public static void main(String[] args) {
        // 返回一个固定的字符串
        Hello hello = () -> "Hello World";
        System.out.println(hello.sayHello());
    }
}

4. Consumer接口

Consumer接口表示一个消费者（一个消费函数），它接受一个T类型的参数并且没有返回值。该接口定义了一个void类型的accept方法，用来接受一个参数。在函数式编程中，常常使用Consumer来操作某个对象或者在一些动作结束后产生一些副作用。

以下是Consumer接口的定义：

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

下面是一个使用Consumer接口的示例，我们定义了一个函数式接口Print，它接受一个Double类型的参数，输出它的平方值。Print的实现使用了Consumer接口，执行操作后不返回任何值。

@FunctionalInterface
interface Print {
    void printSquare(Double d);
}

public class ConsumerInterfaceExample {
    public static void main(String[] args) {
        // 打印输入参数的平方值
        Print print = d -> {
            System.out.println(d*d);
        };
        print.printSquare(2.0);

        // 打印输入参数的平方值
        print = d -> {
            System.out.println(d*d);
        };
        print.printSquare(3.0);
    }
}

综上所述，这是java提供的四种常用的函数式接口的介绍，分别为Function、Predicate、Supplier和Consumer。我们可以使用Lambda表达式来实现这些接口，进行更加灵活和简单的编程。