Java8 函数式接口

函数式接口

有且只有一个抽象方法的接口称为函数式接口，但是可以有多个static方法和default方法。函数式接口适用于函数式编程，Lambda就是Java函数式编程的体现，可以使用Lambda表达式创建一个函数式接口的对象

Java 8中为函数式接口引入了一个新的注解：@FunctionalInterface 。该注解可用于一个接口的定义上，一旦使用该注解来定义接口，编译器将会强制检查该接口是否确实有且仅有一个抽象方法，否则将会报错。但是这个注解不是必须的，只要符合函数式接口的定义，那么这个接口就是函数式接口

接口中的静态方法和默认方法

静态方法：Java 8中为接口新增了一项功能，定义一个或者多个静态方法。用法和普通的static方法一样

public interface OptionInterface {
    /**
     * 静态方法
     */
    static void method() {
        //do something
    }
}

注意：实现接口的类或者子接口不会继承接口中的静态方法 

 默认方法：Java 8在接口中新增 default方法，是为了在现有的类库中中新增功能而不影响它们的实现类。如果定义了默认实现的话，那么实现类直接调用就可以了，并不需要实现这个方法

public interface OptionInterface {
    /**
     * 默认方法
     */
    default void method() {
        //do something
    }
}

注意：如果接口中的默认方法不能满足某个实现类需要，那么实现类可以覆盖默认方法。不用加default关键字 

---

 Java中四大函数式接口

  Consumer<T>：消费型接口

java.util.function.Consumer<T>接口定义了一个名叫 accept 的抽象方法，它接受泛型T，没有返回值。如果需要访问类型 T 的对象，并对其执行某些操作，可以使用这个接口，通常称为消费性接口

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

默认方法

• andThen(Consumer<? super T> after)，先消费然后再消费，先执行调用andThen接口的accept方法，然后在执行andThen方法参数after中的accept方法

使用实例

Consumer<Integer> consumer1 = num -> System.out.print("乘以10："+ (num * 10));
Consumer<Integer> consumer2 = num ->System.out.println(",除以2："+ (num / 2));

int num = 10;
consumer1.andThen(consumer2).accept(num);//输出 乘以10：100,除以2：50

 Supplier<T>：供给型接口 

java.util.function.Supplier<T>接口定义了一个 get 的抽象方法，它没有参数，返回一个泛型 T 的对象，这类似于一个工厂方法，通常称为功能性接口。这类接口适合提供数据的场景

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

 使用实例

//产生一个session工厂对象
Supplier<SessionFactory> s = () -> new SessionFactory();
s.get().info();

 Function<T,R>：函数型接口

java.util.function.Function<T, R> 接口定义了一个叫作 apply 的方法，它接受一个泛型 T 的对象，并返回一个泛型 R 的对象。如果需要定义一个 Lambda，将输入的信息映射到输出，可以使用这个接口，通常称为功能性接口

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

 默认方法

• compose(Function<? super V, ? extends T> before)，先执行compose方法参数before中的apply方法，然后将执行结果传递给调用compose函数中的apply方法在执行

• andThen(Function<? super R, ? extends V> after)，先执行调用andThen函数的apply方法，然后在将执行结果传递给andThen方法after参数中的apply方法在执行

静态方法

• identity()，返回一个始终返回其输入参数的函数

Function<String,Integer> function1 = str -> str.length();
Function<Integer,Integer> function2 = s -> s * 2;
Function<Integer,String> function3 = str -> Integer.toString(str);

System.out.println(function1.apply(" 123 "));// 5
System.out.println(function1.andThen(function2).apply(" 123 "));// 10
System.out.println(function1.compose(function3).apply(123));// 3

Function<Integer, Integer> identity = Function.identity();
System.out.println(identity.apply(123));//123

 Predicate<T> ： 断言型接口

java.util.function.Predicate<T> 接口定义了一个名叫 test 的抽象方法，它接受泛型 T 对象，并返回一个 boolean。在需要表示一个涉及类型 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);
    }
}

 默认方法

• and(Predicate<? super T> other)，相当于逻辑运算符中的 &&，当两个Predicate函数的返回结果都为true时才返回true

• or(Predicate<? super T> other) ,相当于逻辑运算符中的 ||，当两个Predicate函数的返回结果有一个为true则返回true，否则返回false

• negate()，这个方法的意思就是取反

静态方法

• isEqual(Object targetRef)，对当前操作进行"="操作,即取等操作,可以理解为 A == B

 使用实例

Predicate<String> predicate1 = str -> str.length() > 0;
Predicate<String> predicate2 = str -> str.contains("wen");

System.out.println(predicate1.test("wen"));//true
System.out.println(predicate1.and(predicate2).test("ywen"));//true
System.out.println(predicate1.or(predicate2).test("ywc"));//true
System.out.println(predicate2.negate().test("ywenc"));//false