函数式接口

函数式接口

jdk1.8 之前的函数式接口

• java.lang.Runnable

new Thread(()->System.out.println("开启一个线程！")).start();

• java.util.concurrent.Callable

ExecutorService threadPool = Executors.newSingleThreadExecutor();
Future<String> future = threadPool.submit(()->"创建了一个线程");

• java.security.PrivilegedAction

AccessController.doPrivileged((PrivilegedAction<Object>) ()->null);

• java.util.Comparator

Collections.sort(list, (Comparator<Integer>) (o1, o2) -> o1.compareTo(o2));

• java.io.FileFilter

File file = new File(rootPath);
File[] files = file.listFiles(var1->true);

• java.awt.event.ActionListener

JButton button1 = new JButton("按钮");
button1.addActionListener(e->System.out.println("你点击了按钮！"));

类似的接口还有如下：

• java.nio.file.PathMatcher
• java.lang.reflect.InvocationHandler
• java.beans.PropertyChangeListener
• javax.swing.event.ChangeListener

使用方式类似，不在此赘述。

jdk1.8 新增的函数式接口

jdk1.8 内置的函数式接口放在包 java.util.function 下，默认在jdk安装路径下的 src.zip 中。

这些接口，主要分4大类：

• Consumer(类似于消费者需要传入参数无返回值)
• Supplier(类似于生产者不需要传入参数，但有返回值)
• Function(有输入也有返回)
• Predicate(判断函数，有输入也有返回，返回true or false)

他们特点如下：

Consumer 接口

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

Consumer 的作用仅仅是传入一个参数，并对其进行操作，它在本质上和无返回值的单参方法是一样的：

public class Test {
    private void test(double money, Consumer<Double> con){
        con.accept(money);
    }

    @org.junit.Test
    public void test1(){
        double money = 10000;
        test(money,m->System.out.println("这次消费了" + m + "元!"));
        System.out.println(money);
    }
}

其结果如下：

由此可见，Consumer 的作用仅仅只是对传入的参数进行操作，并不是真正的“消费掉了”，因为函数式编程推崇的是不可变对象，Lambda表达式不允许修改“值”。

但Consumer的真正意义并不是简单的实现一个无返回值的单参数方法（或者说行为），而是由它的default方法所带来的嵌套调用（连锁调用），这种调用是无限次的。

public class Test {
    private void test(double money, Consumer<Double> con){
        con.accept(money);
    }

    @org.junit.Test
    public void test1(){
        double money = 10000;
        Consumer consumer = m->System.out.println("这次消费了"+m+"元");
        Consumer consumer1 = s->System.out.println("这次消费了"+s+"元");
        test(money,consumer.andThen(consumer1.andThen(consumer)));
        System.out.println(money);
    }
}

执行结果如下：

这里将函数式编程的一大理念——对行为的抽象，展示的淋漓尽致。

Supplier 接口

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

Supplier 的真正作用，也仅仅是为产生对象而生，

@Test
    public  void test2(){
        System.out.println(((Supplier)()->(int)(Math.random()*100)).get());
    }

上述的测试用例仅仅是产生了一个100以内的整型随机数，但这毫无意义，完全可以简化成：

System.out.println((int)(Math.random()*100));

但这是两种编程思想的问题，Supplier提供的是一种行为，将行为规范化，为的是如果其他地方需要产生一个对象（比如100以内的整型，这当然可以直接传入对象，但如果是一个复杂对象，这个对象的创建过程特别复杂），Supplier可以为其提供一种产生该对象的规范行为并直接可作为参数传入。

Function 接口

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

Function ，顾名思义，接受一个参数，经过处理后，再返回一个结果，其中 andThen() 方法接受一个行为，并将父方法处理过的结果作为参数再处理，而 compose（） 方法正好相反，它是先自己处理然后将结果作为参数传给父方法执行，虽然处理的都是数据，但传入的却是行为。

@Test
    public  void test3(){
        Function function = str->str+"suffix";
        Function function1 = str->str+"prefix";
        System.out.println(function.apply("111"));
        System.out.println(function.andThen(function1).apply("111"));
        System.out.println(function.compose(function1).apply("111"));
    }

结果如下：

Predicate 接口

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

简单来说，Predicate 也是一种行为的描述，对参入的对象作某些判断，并返回一个boolean值，这些判断逻辑即这个行为的具体实现过程，则完全由使用者定义，其中还提供一些简单的组合判断，与、或、非以及 isEqual 。

@Test
    public void test4(){
        Predicate predicate = obj -> obj.equals("");
        Predicate predicate1 = obj -> Objects.isNull(obj);
        System.out.println(predicate.test(""));
        System.out.println(predicate.and(predicate1).test(""));
        System.out.println(predicate.or(predicate1).test(""));
        System.out.println(predicate.negate().test(""));
        System.out.println(predicate.and(predicate1).test(""));
    }

其中，and、or 的执行顺序与java && 、|| 的执行顺序一致。

其他接口

形如BiYYY类型接口

BiConsumer、BiFunction、BiPrediate 是 Consumer、Function、Predicate 的扩展，可以传入多个参数，没有 BiSupplier 是因为 Supplier 没有入参。

形如XXXYYY类型接口

如果用 XXX 来表示 int、long、double、boolean ，用 YYY 来表示 Consumer、Function、Predicate、Supplier ，那么JDK8就内置了此四种基本数据类型的消费，构建，操作，断言以及他们因此而产生的一系列其他接口，在此不再赘述。

UnaryOperator与BinaryOperator

• UnaryOperator：代表了一个作用于一个类型的操作，并且返回了同类型的结果
• BinaryOperator：代表了一个作用于于两个同类型的操作，并且返回了同类型的结果
• XXXUnaryOperator：代表了一个作用于一个XXX数据类型的操作，并且返回了同类型数据的结果
• XXXBinaryOperator：代表了一个作用于两个XXX数据类型的操作，并且返回了同类型数据的结果

ToXXXFunction与ToXXXBiFunction类型接口

• ToXXXFunction：接受一个输入参数，返回一个XXX类型结果
• ToDoubleBiFunction：接受两个输入参数，返回一个XXX类型结果

ObjXXXConsumer类型接口

对一个对象和一个基本数据类型的消费行为