java 8新特性——函数式接口

函数式接口

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

函数式接口可以被隐式转换为 lambda 表达式。

常用的函数式接口

Supplier

Supplier，它的中文意思为供应商、提供者。具体的方法也是相当的简单，不接受任何参数，返回一个结果

/**
*源码
**/
@FunctionalInterface
public interface Supplier<T> {

    /**
     * Gets a result.
     *
     * @return a result
     */
    T get();
}

测试：

/**
 * @author： zhouzhou
 * @date：2021/10/27 15:01
 */
public class Test {
    public static void main(String[] args) {
        User result= testSupplier(()-> new User("王也", 1));
        String result2 = testSupplier(() -> "测试Supplier接口");
        
        System.out.println(result.toString());
        System.out.println(result2);
    }
    /**
     * description: 供给型接口，无输入有输出
     *
     * @param supplier
     * @return java.lang.String
     */
    private static <T> T testSupplier(Supplier<T> supplier){
        return supplier.get();
    }
}

运行结果：

User(name=王也, age=1)
测试Supplier接口

我们也可使用使用Suppler创建对象。

        Supplier<User> supplier = User::new;
        User user = supplier.get();

Consumer

接口则正好与Supplier接口相反，它不是生产一个数据，而是消费一个数据， 其数据类型由泛型决定。

public class Test {
    public static void main(String[] args) {
       /**
         * testConsumer()方法中第二个参数传递的是消费性接口Consumer<T>的实例
         * 分析x -> System.out.println("传入的数字为:" + x)
         *    x：为传递的参数
         *    System.out.println("传入的数字为:" + x)相当于抽象方法accept()的方法体	
         */
        testConsumer(2 ,i -> System.out.println("传入的数字为："+i));
    }

    /**
     * description: 消费性接口有输入，但是没有返回值
     *
     * @param t
     * @param consumer
     * @return void
     */
    private static <T> void testConsumer(T t, Consumer<T> consumer) {
        // accept()方法为消费性接口Consumer<Integer>的唯一抽象方法
        consumer.accept(t);
    }
}

-----------------------------
console：
    传入的数字为：2

Predicate

Predicate的使用（构造断言式）含有一个抽象方法test()，有输入，输出为Boolean。含有4个由default修饰的具体实现方法and()、or()、negate()、isEquals()

• and()对应java的连接符 &&；

• or()对应java的连接符 || ；

• negate()对应java的连接符 ! ；

• isEquals对应java的连接符 == ；

public class Test {
    public static void main(String[] args) {
        //判断1==2？
        Boolean result = testPredicate(1, i -> i.equals(2));
        System.out.println(result);
    }
    /**
     * description:断言型接口，有输入，输出为Boolean
     *
     * @param t
     * @param predicate
     * @return java.lang.Boolean
     */
    private static <T> Boolean testPredicate(T t, Predicate<T> predicate) {
        // test()方法为断言型接口Predicate<T>的唯一抽象方法
        return predicate.test(t);
    }
}


-----------------------------------
    console:
	false

Function

Function<T, R>接口有两个参数，一个是输入，一个输出，先这么理解。T输入 R输出。

• R apply(T t) ：输入参数T，经过该函数处理得到R。也就是将参数应用于这个函数。

public class Test {
    public static void main(String[] args) {
        String str = testFunction("hello", hello -> hello + "World");
        System.out.println(str);
    }
    private static <T,R> R testFunction(T t, Function<T, R> function) {
        // apply()方法为函数型接口Function<T, R>的唯一抽象方法
        return function.apply(t);
    }

}

---------------------
    console:
	helloWorld

ps：我朋友给我的代码包含的这个函数式接口，我就想了解一下，看了半天的代码和源码，稍微整理一下，也没多少东西，可能因为我在实际项目中还没有遇到吧。后续遇到在去更新吧