JDK1.8新特性--函数式接口

学如逆水行舟，不进则退

定义：什么是函数式接口？

，什么是函数式接口？--函数式接口(Functional Interface)就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口，它可以被隐式转换为 lambda 表达式。函数式接口的常见的实现方式：lambda表达式和函数式接口。JDK1.8之前就已经存在函数式接口，那常见的函数式接口有哪些呢？像我们熟知的创建线程使用的Ruanable接口。

package java.lang;

/**
 * @FunctionalInterface该注解是JDK1.8中新增的注解，它的作用在于编译时检查该接口
 * 是不是函数式接口，否则编译不通过。需要注意的是，即使不使用该注解，只要满足函数式接
 * 口的定义，它仍然是个函数式接口。
 * @author  Arthur van Hoff
 * @see     java.lang.Thread
 * @see     java.util.concurrent.Callable
 * @since   JDK1.0
 */
@FunctionalInterface
public interface Runnable {
    /**
     * When an object implementing interface <code>Runnable</code> is used
     * to create a thread, starting the thread causes the object's
     * <code>run</code> method to be called in that separately executing
     * thread.
     * <p>
     * The general contract of the method <code>run</code> is that it may
     * take any action whatsoever.
     *
     * @see     java.lang.Thread#run()
     */
    public abstract void run();
}

此外还有我们熟知的几个函数式接口：

java.lang.reflect.InvocationHandler;
java.util.Comparator;
java.util.concurrent.Callable;

JDK1.8的java.util.function包下提供了很多函数式接口，先主要学习常用的四大函数式接口：Consumer消费型接口、Supplier供给型接口、Function函数型接口、Predicate断言型接口。

一、Consumer消费型接口

package java.util.function;
import java.util.Objects;

@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); };
    }
}

消费型接口，类似于熟知的消费者角色，只负责消费，它的accept方法是个有参数，无返回值的方法。举个简单示例，结合lambda表达式，可以完成手机号做脱敏处理。

public static void main(String[] args) {
        encryptMemPhone("155588888121",s->{
            String newStr = s.replaceAll("(\\d{3})\\d*(\\d{3})", "$1****$2");
            System.out.println(newStr);
        });
    }

    public static void encryptMemPhone(String memPhone, Consumer<String> consumer){
        consumer.accept(memPhone);
    }

二、Supplier供给型接口

package java.util.function;

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

供给型接口，类似于熟知的生产者角色，只负责生产，它的get方法是个无参数，有返回值的方法。

public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        Random random = new Random();
        getNewList(list,10,() -> random.nextInt(100));
        list.forEach(s-> System.out.println(s));
    }

    public static List<Integer> getNewList(List<Integer> list, int length,Supplier<Integer> supplier){
        for (int i=0;i<length;i++){
          list.add(supplier.get());
        }
        return list;
    }

三、Function函数型接口

package java.util.function;
import java.util.Objects;

@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;
    }
}

一个函数型接口，用来根据一个类型的数据得到另外一个类型的数据

   public static void main(String[] args) {
        String str="123";
        Integer integer = applyMethod(str, s -> Integer.parseInt(s));
        System.out.println(integer);

    }

    public static Integer applyMethod(String str, Function<String, Integer> function) {
        return function.apply(str);
    }

四、Predicate断言型接口

package java.util.function;

import java.util.Objects;

@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);
    }
}

断言型接口经常用来判断，返回一个布尔类型的数据。

    public static void main(String[] args) {
        String str="我爱中国";
        Boolean aBoolean = testMethod(str, s -> s.equals("我爱中国"));
        System.out.println(aBoolean);

    }

    public static Boolean testMethod(String str, Predicate predicate){
        return predicate.test(str);
    }

本文参考：

https://blog.csdn.net/weixin_43767015/article/details/108252916

https://blog.csdn.net/xcbeyond/article/details/106308973