java中函数式接口的学习

函数式接口

1.概述
函数式接口在Java中是指：有且仅有一个抽象方法的接口。

函数式接口，即适用于函数式编程场景的接口。而Java中的函数式编程体现就是Lambda，所以函数式接口就是可以适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导。

2.自定义函数式接口

package hanshushi;

public class Demo01 {
    public static void main(String[] args) {
        //匿名内部类写法
        test(new MyFunc() {
            @Override
            public void method() {
                System.out.println("匿名内部类的抽象");
            }
        });

        //Lambda表达式写法
        test(() -> {
            System.out.println("我是表达式的抽象");
        });

        //Lambda表达式简写写法
        test(() -> System.out.println("我是简写的抽象"));
    }

    public static void test(MyFunc f1){
        f1.method();
        f1.mo();
        MyFunc.jing();
    }

}

package hanshushi;

public interface MyFunc {
    public abstract void method();

    public default void mo(){
        System.out.println("我是默认方法");
    }

    public static void jing(){
        System.out.println("我是静态方法");
    }
}

3.常用函数式接口
JDK提供了大量常用的函数式接口以丰富Lambda的典型使用场景，它们主要在 java.util.function 包中被提供。
Consumer接口
java.util.function.Consumer 接口，是消费一个数据，其数据类型由泛型参数决定。
Consumer 接口中包含抽象方法 void accept(T t) : 消费一个指定泛型的数据。

package hanshushi;

import java.util.function.Consumer;

public class Demo02 {
    public static void main(String[] args) {
        //匿名内部类写法
        String s = "hello world";
        test(s, new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });

        //表达式写法
        test(s,(p1) -> {
            System.out.println(s.length());
        });

        //表达式简写
        test(s,(p2) -> System.out.println(s.toUpperCase()));
    }

    private static void test(String str,Consumer<String> con) {
        con.accept(str);
    }
}

4.Predicate接口
有时候我们需要对某种类型的数据进行判断，从而得到一个boolean值结果。这时可以使用java.util.function.Predicate 接口。

Predicate 接口中包含一个抽象方法： boolean test(T t) 。用于条件判断的场景：

package hanshushi;

import java.util.function.Predicate;

public class Demo03 {
    public static void main(String[] args) {
        String s = "hello world";

        //匿名内部类写法
        method(s, new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.length() > 5;
            }
        });

        //表达式方式
        method(s,(String s1) -> {
            return s.length() > 5;
        });

        //表达式简写
        method(s,(s1) -> s.length() > 5);
    }

    private static void method(String str, Predicate<String> p) {
        boolean a = p.test(str);
        System.out.println(a);
    }
}