函数式接口(Functional Interface)就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。 java8 引入 @FunctionalInterface 注解声明该接口是一个函数式接口。

1.Function<T,R> 和BiFunction<T,U,R>

Function<T,R> ：接受一个输入参数，返回一个结果。

BiFunction<T,U,R>：代表了一个接受两个输入参数的方法，并且返回一个结果

Function中源码：

/**
 * 接收一个参数，生成一个结果。
 * @param <T> 函数的输入类型
 * @param <R> 函数的结果类型
 * @since 1.8
 */
@FunctionalInterface
public interface Function<T, R> {

    /**
     * 将该函数应用到给定的参数
     * @param t 函数的参数
     * @return 函数的结果
     */
    R apply(T t);
    
   /**
    * 返回一个组合函数, 首先执行before function的apply方法, 将它的返回作为输入参数再应用当前的function
    */
    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

   /**
    * 返回一个组合函数, 它是先调用当前函数的apply方法, 再将其结果作为输入参数传递给after function调用apply()
    */
    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函数应用：

public class FunctionTest {
    public static void main(String[] args) {

        System.out.println(testFunction(2,i -> i * 2 + 1));
        System.out.println(testBiFunction(2,5,(a,b) -> (a*b) - 1));
    
        //先执行value -> value * 2 >>5*2=10,10-1=9
        System.out.println(testCompose(5, value -> value - 1,value -> value * 2));
        //先执行value -> value - 1 >>5-1=4
        System.out.println(andThen(5, value -> value - 1,value -> value * 2));
    }
    
  
    //Function<Integer,Integer>中第一个Integer表示传进的参数，第二个Integer表示返回的参数类型
    public static int testFunction(int i, Function<Integer,Integer> function) {
        return function.apply(i);
    }
    
    public static int testBiFunction(int a,int b, BiFunction<Integer,Integer,Integer> biFunction) {
        return biFunction.apply(a,b);
    }
    
    public static int testCompose(int a, Function<Integer, Integer> funA, Function<Integer, Integer> funB) {
        return funA.compose(funB).apply(a);
    }
    
    public static int andThen(int a, Function<Integer, Integer> funA, Function<Integer, Integer> funB) {
        return funA.andThen(funB).apply(a);
    }
}

运行结果：

2.Predicate：

功能点：接受一个输入参数，返回一个布尔值结果。

@FunctionalInterface public interface Predicate {

/**
 * 根据给定的参数评估该断言
 * 匹配返回true, 否则false
 */
boolean test(T t);

/**
 * 返回复合Predicate, 当前的Predicate与传入参数的其它Predicate的短路的逻辑与运算
 * 调用and的当前Predicate如果是false或抛出异常, 后者不再计算
 */
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);
}

/**
 * 返回复合Predicate, 当前的Predicate与传入参数的其它Predicate的逻辑或运算
 */
default Predicate<T> or(Predicate<? super T> other) {
    Objects.requireNonNull(other);
    return (t) -> test(t) || other.test(t);
}

/**
 * 两个参数是否相等 {@link Objects#equals(Object, Object)}
 */
static <T> Predicate<T> isEqual(Object targetRef) {
    return (null == targetRef)
            ? Objects::isNull
            : object -> targetRef.equals(object);
}}

Predicate函数应用：

public class PredicateTest {

        public static void main(String[] args) {
            List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
            PredicateTest myTest = new PredicateTest();
            // 输出偶数
            List<Integer> conditionResult1=  myTest.conditionFilter(list, item -> item % 2 == 0);
            System.out.println("输出偶数===="+conditionResult1.toString());
            // 输出>5的偶数
            List<Integer> conditionResult2= myTest.conditionFilter(list, item -> item % 2 == 0 && item > 5);
            System.out.println("输出>5的偶数====" +conditionResult2.toString());
            // 输出>5的偶数
            List<Integer> andFilter= myTest.andFilter(list, item -> item % 2 == 0, item -> item > 5);
            System.out.println("输出>5的偶数===="+andFilter.toString());
            // 输出>5或是偶数
            List<Integer> orFilter= myTest.orFilter(list, item -> item % 2 == 0, item -> item > 5);
            System.out.println("输出输出>5或是偶数===="+orFilter.toString());
        }

        public List<Integer> conditionFilter(List<Integer> list, Predicate<Integer> predicate) {
            List<Integer>result=new ArrayList<Integer>();
            for (Integer integer : list) {
                if (predicate.test(integer)) {
                    result.add(integer);
                }
            }
            return result;
        }
       //逻辑与运算
        public List<Integer> andFilter(List<Integer> list, Predicate<Integer> predicate, Predicate<Integer> other) {
            List<Integer> result=new ArrayList<Integer>();
            for (Integer integer : list) {
                if (predicate.and(other).test(integer)) {
                    result.add(integer);
                }
            }
            return result;
        }

      //逻辑或运算
    public List<Integer> orFilter(List<Integer> list, Predicate<Integer> predicate, Predicate<Integer> other) {
        List<Integer> result=new ArrayList<Integer>();
        for (Integer integer : list) {
            if (predicate.or(other).test(integer)) {
                result.add(integer);
            }
        }
        return result;
    }
}

运行结果：

3.Supplier接口

功能点：无参数，返回一个结果 @FunctionalInterface public interface Supplier {

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

Supplier函数应用：

/**
 * @program: practise-model
 * @description:
 * @author: lbw
 * @create: 2022-03-30 14:49
 **/

public class SupplierTest {

    public static void main(String args[]) {

        Supplier<String> supplier1 = () -> "lbw";   // lambda表达式
        System.out.println(supplier1.get());

        Supplier<Student> supplier = () -> new Student();
        System.out.println(supplier.get().getName());
        // 构造方法引用
        Supplier<Student> supplier23 = Student::new;
        System.out.println(supplier23.get().getAge());


        int[] numbers = {100, 200, 300, 400, 500, -600, -700, -800, -900, -1000};
        int numberMax = arrayMax(
                () -> {
                    int max = numbers[0];
                    for (int number : numbers) {
                        if (max < number) {
                            max = number;
                        }
                    }
                    return max;
                }
        );
        System.out.println("数组中的最大值为：" + numberMax);
    }

    public static Student get(Supplier<Student> supplier) {
        return supplier.get();
    }

    public static Integer arrayMax(Supplier<Integer> integerSupplier) {
        return integerSupplier.get();
    }

    @Data
    @NoArgsConstructor
    public static class Student {

        private String name = "lbw";
        private int age = 30;
    }
}

运行结果：

4.consumer

代表了接受一个输入参数并且无返回的操作

@FunctionalInterface public interface Consumer {

/**
 * 对给定参数执行消费操作。
 *
 * @param 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 ConsumerTest {

    public static void main(String[] args) {
        consumerString(s -> System.out.println(s));

        String[] array = {"张三，男", "李四，女", "王五，男"};
        printInfo(
                s -> System.out.print("姓名：" + s.split("，")[0] + "，"),
                s -> System.out.println("性别：" + s.split("，")[1] + "。"),
                array
        );
    }

    private static void consumerString(Consumer<String> function) {
        function.accept("Hello");
    }

    private static void printInfo(Consumer<String> one, Consumer<String> two, String[] array) {
        for (String info : array) {
            one.andThen(two).accept(info);
        }
    }
}