Java8新特性学习之函数式接口

Java8函数式接口

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

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

有四大类型函数式接口：

供给型接口

@FunctionalInterface
public interface Supplier<T> {

    T get();
}

消费型接口

@FunctionalInterface
public interface Consumer<T> {

    void accept(T t);
    
    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

函数型接口

@FunctionalInterface
public interface Function<T, R> {

    R apply(T t);

    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

  
    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }

   
    static <T> Function<T, T> identity() {
        return t -> t;
    }
}

段言型接口

@FunctionalInterface
public interface Predicate<T> {

    boolean test(T t);
    
    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }
    
    default Predicate<T> negate() {
        return (t) -> !test(t);
    }

    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }

    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }
}

1、供给型接口Supplier

java.util.function.Supplier 接口仅包含一个无参的方法: T get() ，用来获取一个泛型参数指定类型的对象数据。

调用handleString()方法，传入一个supplier类型的函数式接口，实际是将两个字符串msg1和msg2拼接，通过Supplier的get()方法，返回结果。

// 输出
public class HelloSupplier {

    public static void main(String[] args) {
        String msg1="I LOVE";
        String msg2=" CHINA";
        String res = handleString(() -> {
            return msg1 + msg2;
        });
        System.out.println(res);
    }

    private static String handleString(Supplier<String> supplier){
        return supplier.get();
    }

}

输出如下：

2、消费型接口Consumer

Consumer 接口中包含抽象方法 void accept(T t) ，意为消费一个指定泛型的数据。

调用consumeSome()方法，传入的str，实际经过consumer.accept()方法，作为方法的参数传入，通过lambda表达式作为println()的参数输出。

// 
public class HelloConsumer {

    public static void main(String[] args) {
        consumeSome(s->{
            System.out.println(s);
        },"Hello Java");
    }

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

输出如下：

3、函数型接口Function

Function 接口中最主要的抽象方法为: R apply(T t) ，根据类型T的参数获取类型R的结果。
调用calculator()方法，实际上是将4396作为参数，通过函数式接口的apply()方法，传给lambda表达式的形参e，传入e，返回的是parseInt(e)后的值。

// 
public class HelloFunction {

    public static void main(String[] args) {
        Integer calculator = calculator(e -> Integer.parseInt(e));
        System.out.println(calculator+4);
    }

    private static Integer calculator(Function<String,Integer> function) {
       return function.apply("4396");
    }
}

输出如下：

4、断言型接口Predicate

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

调用isShort()方法，实际是test()方法的参数“American and Japanese fucking ***”，通过lambda表达式传给e，判断后得到一个Boolean类型的值。

// 代码
public class HelloPredicate {

    public static void main(String[] args) {
        isShort(e->e.length()<40);
    }

    private static void isShort(Predicate<String> predicate){
        boolean res = predicate.test("American and Japanese fucking ***");
        System.out.println("狗日的短吗："+res);
    }
}

输出如下：

新手学习，个人认知尚浅，不足之处望指正。

谁不喜欢天天的爱情呢？努力追求！！！😃😃😃