Java8 函数式接口

函数式接口（Functional Interface）就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。

提到函数式接口肯定少不了 Lambda 表达式，函数式接口可以隐式的转换为 Lambda 表达式。

我们可以选择向各种各样的方法和构造函数传递 Lambda 表达式，包括在 Java 8 之前创建的一些方法和构造函数。因为 Lambda 表达式在 Java 中表示为函数接口。

Thread t1 = new Thread(new Runnable() {
    @Override
    publicvoid run() {
        System.out.println("t1");
    }
});
t1.start();

Thread t2 = new Thread(() -> System.out.println("函数式接口"));
t2.start();

                @FunctionalInterface

                public
                interface
                 Runnable {

    
                public
                abstract
                void
                 run();
    
}
            

                @Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)

                public @interface FunctionalInterface {
    
}

JDK 1.8 之前已有的函数式接口:

• java.lang.Runnable
• java.util.concurrent.Callable
• java.security.PrivilegedAction
• java.util.Comparator
• java.io.FileFilter
• java.nio.file.PathMatcher
• java.lang.reflect.InvocationHandler
• java.beans.PropertyChangeListener
• java.awt.event.ActionListener
• javax.swing.event.ChangeListener

JDK 1.8 新增加的函数接口：

• java.util.function

我们主要了解一下 Java 8 专门新增的函数式接口：function

函数式接口规范：

任何满足单一抽象方法法则的接口，都会被自动视为函数接口。这包括 Runnable 和 Callable 等传统接口，以及自己构建的自定义接口。

java.util.function 包中最常用的接口包括有四个：Consumer<T>、Supplier<T>、Function<T> 和 Predicate<T>。

                public
                class
                 ConsumerDemo {

    
                /**
                
     * 使用Consumer接口消费字符串
     *
     * 
                @param
                 str      - 传递一个字符串
     * 
                @param
                 consumer - 传递Consumer接口,泛型使用String
     
                */
                public
                static
                void method1(String str, Consumer<String> consumer) {
        consumer.accept(str);
    }

    /**
     * 将两个Consumer接口组合到一起,再对数据进行消费
     *
     * @param str   - 传递一个字符串
     * @param cons1 - 连接con2参数
     * @param cons2 - 传递Consumer接口,泛型使用String
     */publicstaticvoid method2(String str, Consumer<String> cons1, Consumer<String> cons2) {
        cons1.andThen(cons2).accept(str);
    }

    publicstaticvoid main(String[] args) {

        // 调用method方法,传递字符串,方法的另一个参数是Consumer接口,
        // Consumer是一个函数式接口,所以可以传递Lambda表达式
        method1("consumer", (String str) -> {
                    System.out.println(str.toUpperCase()); // 消费方式:把字符串转换为大写输出                }
        );
        // 优化Lambda
        method1("consumer", str -> System.out.println(str.toUpperCase()));

        System.out.println("==============================");

        // 调用method方法,传递一个字符串,两个Lambda表达式
        method2("jjjjjjjjj_CCCCCCCC", (str) -> {
            System.out.println(str.toUpperCase()); // 消费方式:把字符串转换为大写输出
        }, (str) -> {
            System.out.println(str.toLowerCase()); // 消费方式:把字符串转换为小写输出        });
        // 优化Lambda
        method2("EEEEEEEEEEEEE_ccccccccccccccc", str -> System.out.println(str.toUpperCase()), str -> System.out.println(str.toLowerCase()));
    }
}

                public
                class
                 SupplierDemo {

    
                /**
                
     * 取一个泛型参数指定类型的对象数据
     *
     * 
                @param
                 supplier - Supplier<String>接口
     * 
                @return
                 - 泛型执行String,get方法就会返回一个String
     
                */
                public
                static String getString(Supplier<String> supplier) {
        return supplier.get();
    }

    /**
     * 求数组元素最大值
     *
     * @param supplier - Supplier<Integer>接口
     * @return - 获取int类型数组中元素的最大值
     */publicstatic Integer getMax(Supplier<Integer> supplier) {
        return supplier.get();
    }

    publicstaticvoid main(String[] args) {

        // 调用getString方法,方法的参数Supplier是一个函数式接口,可以传递Lambda表达式        System.out.println(
                getString(() -> {
                    return "啊哈";
                })
        );
        // 优化Lambda表达式        System.out.println(
                getString(() -> "呵呵")
        );

        System.out.println("====================================");

        int[] arr = {188, 210, 52, 263, 66, 312, 75, 29, 125, 55};
        // 调用getMax方法,方法的参数Supplier是一个函数式接口,所以可以传递Lambda表达式int maxValue = getMax(
                () -> {
                    int max = arr[0]; // 定义一个变量,把数组中的第一个元素赋值给该变量,记录数组中元素的最大值for (int i : arr) { // 遍历数组,获取数组中的其他元素if (i > max) { // 使用其他的元素和最大值比较
                            max = i; // 如果i大于max,则替换max作为最大值                        }
                    }
                    return max; // 返回最大值                }
        );
        System.out.println("数组中元素的最大值是:" + maxValue);
    }
}

                public
                class
                 FunctionDemo {

    
                /**
                
     * 把字符串类型的整数,转换为Integer类型的整数返回
     *
     * 
                @param
                 str      - 字符串类型的整数
     * 
                @param
                 function - Function接口,泛型使用<String,Integer>
     
                */
                public
                static
                void change1(String str, Function<String, Integer> function) {
        //Integer in = function.apply(str);int in = function.apply(str);//自动拆箱 Integer->int        System.out.println(in);
    }

    /**
     * 将字符串类型的整数转换为Integer类型进行运算后(x<<1)，再把结果转换为字符串进行输出
     *
     * @param str       - 字符串类型的整数
     * @param function1 - 将字符串整数转换为Integer类型
     * @param function2 - 将Integer类型转换为字符串整数
     */publicstaticvoid change2(String str, Function<String, Integer> function1, Function<Integer, String> function2) {
        String result = function1.andThen(function2).apply(str);
        System.out.println(result);
    }

    publicstaticvoid main(String[] args) {

        // 调用change方法,传递字符串类型的整数,和Lambda表达式
        change1("1234", (str) -> {
            return Integer.parseInt(str);
        });

        // 优化Lambda
        change1("4321", str -> Integer.parseInt(str));

        System.out.println("==============================");

        change2("8", (str) -> {
            return Integer.parseInt(str) << 1; // 把字符串转换为整数后左移一位
        }, (i) -> {
            return String.valueOf(i); // 把整数转换为字符串        });

        // 优化Lambda
        change2("16", s -> Integer.parseInt(s) << 1, i -> String.valueOf(i));
    }
}

有时候我们需要对某种类型的数据进行判断，从而得到一个 boolean 值结果。这时可以使用java.util.function.Predicate<T> 接口。接口中包含一个抽象方法： boolean test(T t)

2. Stream 流中 filter(Predicate断定型接口)

如果哪一天，你觉得它的接口已经无法满足你的需求时，那么，你就能自定义接口了，hhh，Java 8 很友好，知道你想要，满足你的个性化定制。

我们只需要做两件事：

1. 使用 @FunctionalInterface 注释该接口，这是 Java 8 对自定义函数接口的约定。
2. 确保该接口只有一个抽象方法。

仔细观察 java.util.function 的接口，也一样，都做了两件事，自定义就是那么简单。

使用 @FunctionalInterface 注释可以确保，如果在未来更改该接口时意外违反抽象方法数量规则，您会获得错误消息。

实列就不写了，因为不是很难理解，我们参考参考 Function<T,R> 

                @FunctionalInterface

                public
                interface Function<T, R> {

    /**
     * Applies this function to the given argument.
     *
     * @param t the function argument
     * @return the function result
     */
    R apply(T t);
}