函数式编程

参考

 java8 函数式接口详解 函数接口详解 lambda表达式 匿名函数 方法引用使用含义 函数式接口实例 如何定义函数式接口

 JAVA8内置的函数式编程接口应用场景和方式

 Java8新特性学习-函数式编程(Stream/Function/Optional/Consumer)

 JAVA8 Consumer接口

java8中 java.util.function包下，内置所有的接口简介和表达的意思

1 BiConsumer<T,U> 代表了一个接受两个输入参数的操作，并且不返回任何结果

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

3 BinaryOperator<T> 代表了一个作用于于两个同类型操作符的操作，并且返回了操作符同类型的结果

4 BiPredicate<T,U> 代表了一个两个参数的boolean值方法

5 BooleanSupplier 代表了boolean值结果的提供方

6 Consumer<T> 代表了接受一个输入参数并且无返回的操作

7 DoubleBinaryOperator 代表了作用于两个double值操作符的操作，并且返回了一个double值的结果。

8 DoubleConsumer 代表一个接受double值参数的操作，并且不返回结果。

9 DoubleFunction<R> 代表接受一个double值参数的方法，并且返回结果

10 DoublePredicate 代表一个拥有double值参数的boolean值方法

11 DoubleSupplier 代表一个double值结构的提供方

12 DoubleToIntFunction 接受一个double类型输入，返回一个int类型结果。

13 DoubleToLongFunction 接受一个double类型输入，返回一个long类型结果

14 DoubleUnaryOperator 接受一个参数同为类型double,返回值类型也为double 。

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

16 IntBinaryOperator 接受两个参数同为类型int,返回值类型也为int 。

17 IntConsumer 接受一个int类型的输入参数，无返回值 。

18 IntFunction<R> 接受一个int类型输入参数，返回一个结果 。

19 IntPredicate 接受一个int输入参数，返回一个布尔值的结果。

20 IntSupplier 无参数，返回一个int类型结果。

21 IntToDoubleFunction 接受一个int类型输入，返回一个double类型结果 。

22 IntToLongFunction 接受一个int类型输入，返回一个long类型结果。

23 IntUnaryOperator 接受一个参数同为类型int,返回值类型也为int 。

24 LongBinaryOperator 接受两个参数同为类型long,返回值类型也为long。

25 LongConsumer 接受一个long类型的输入参数，无返回值。

26 LongFunction<R> 接受一个long类型输入参数，返回一个结果。

27 LongPredicate R接受一个long输入参数，返回一个布尔值类型结果。

28 LongSupplier 无参数，返回一个结果long类型的值。

29 LongToDoubleFunction 接受一个long类型输入，返回一个double类型结果。

30 LongToIntFunction 接受一个long类型输入，返回一个int类型结果。

31 LongUnaryOperator 接受一个参数同为类型long,返回值类型也为long。

32 ObjDoubleConsumer<T> 接受一个object类型和一个double类型的输入参数，无返回值。

33 ObjIntConsumer<T> 接受一个object类型和一个int类型的输入参数，无返回值。

34 ObjLongConsumer<T> 接受一个object类型和一个long类型的输入参数，无返回值。

35 Predicate<T> 接受一个输入参数，返回一个布尔值结果。

36 Supplier<T> 无参数，返回一个结果。

37 ToDoubleBiFunction<T,U> 接受两个输入参数，返回一个double类型结果

38 ToDoubleFunction<T> 接受一个输入参数，返回一个double类型结果

39 ToIntBiFunction<T,U> 接受两个输入参数，返回一个int类型结果。

40 ToIntFunction<T> 接受一个输入参数，返回一个int类型结果。

41 ToLongBiFunction<T,U> 接受两个输入参数，返回一个long类型结果。

42 ToLongFunction<T> 接受一个输入参数，返回一个long类型结果。

43 UnaryOperator<T> 接受一个参数为类型T,返回值类型也为T。

Funtion接口

        Function<Integer,Integer> function1=x->x*2;
        System.out.println(function1.apply(2));

        Function<String,String> function2=(str)->new String(str);
        System.out.println(function2.apply("111"));

Funtion接口，定义了一个apply的抽象方法，接收一个泛型T对象，并且返回泛型R对象

 R apply(T t);
    
    /**
     * 先做传入的Function类型的参数的apply操作，再做当前这个接口的apply操作
     * V表示这个Function类型的参数的传入参数类型，也就是本接口的T类型
     * @param before
     * @return
     */
    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }
    /**
     * 先做本接口的apply操作，再做传入的Function类型的参数的apply操作
     * @param after
     * @return
     */
    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }
    /**
     * 静态方法表示，这个传入的泛型参数T的本身
     * @return
     */
    static <T> Function<T, T> identity() {
        return t -> t;
    }

Consumer接口

接口，接收一个泛型的参数T，然后调用accept，对这个参数做一系列的操作，没有返回值

@FunctionalInterface
public interface Consumer<T> {
 
    
    void accept(T t);
 
/**传入一个Consumer类型的参数，
     *他的泛型类型，
     *跟本接口是一致的T，先做本接口的accept操作，
     *然后在做传入的Consumer类型的参数的accept操作
    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

        //调用accept的时候，传入一个泛型T的参数Integer，然后定义参数对一系列操作，然后打印这些值；
        Consumer<Integer> consumer1 = x -> {
            int a = x + 2;
            System.out.println(a);
            System.out.println(a + "_");
        };
        consumer1.accept(112);


        Consumer f = System.out::println;
        Consumer f2 = n -> System.out.println(n + "-F2");

        //执行完F后再执行F2的Accept方法
        f.andThen(f2).accept("test");

        //连续执行F的Accept方法
        f.andThen(f).andThen(f).andThen(f).accept("test1");

Supplier接口

接口是一个提供者的意思，只有一个get的抽象类，没有默认的方法以及静态的方法，传入一个泛型T的，get方法，返回一个泛型T

public class Supplier_Test {
    public static void main(String[] args) {
        Supplier<String> supplier=String::new;
        supplier.get();


        //这个接口，只是为我们提供了一个创建好的对象，这也符号接口的语义的定义，提供者，提供一个对象，
        //直接理解成一个创建对象的工厂
        Supplier<Emp> empSupplierEmp=Emp::new;
        Emp emp=empSupplierEmp.get();
        emp.setName("dd");
        System.out.println(emp.getName());
    }


    public static class Emp {
        private String name;
        public Emp() {
        }

        public Emp(String name) {
            super();
            this.name = name;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

    }
}