Consumer接口和Function的最大不同在于Consumer接受参数类型并无返回结果;
Function接口/BiFunction接口是接受参数并生产一个结果;
执行方法R apply(T)
传入一个T参数 并返回我们的R参数;
举例:

	static   Function<Object, String>mFunctionA=x->{
		System.err.println(x+"");
		return   x+"";
	};
	public static void main(String[] args) {
	//	mConsumerA.andThen(mConsumerB).accept(10);;
	  mFunctionA.apply("1");
	}

compose方法:

  default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

先执行参数再调用自身的方法 并返回一个Function方法:

举例:

    static   Function<Object, String>mFunctionA=x->{
		System.err.println(x+"");
		return   x+"";
	};
	static   Function<String,Integer>mFunctionB=x->{
		  return  Integer.valueOf(x);
	};
	public static void main(String[] args) {
	      mFunctionA.compose(mFunctionB).apply("1");
	}

个人觉得 compse方法就是将两个方法的类型经行转化

class a extends boy
class c extends girl
我们输出结果是(a,R)
B(Boy, c)
A(gril,R)
A.compse(b);
调用过程就是
(a,R)->(girl,R).apply(Boy,c)
整理下: B的R 是A的T的子类/自身
B的T 是 输出的结果T的父类/自身

3.andThen 调用顺序和compse的是相反的:

 default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }

先调用自身的 再调传入参数的apply
自身依然是<T,R> after 的 T 是自身R 的父类/自身被向上转型
自身的T 将是结果的T after的 R 也就是? extend是 V 将会被向上转型

4.identity 一致性 消费类型和生产类型一致

 static <T> Function<T, T> identity() {
        return t -> t;
    }

二.BiFunction
输入参数变为二种类型 得到一种结果 是Function的扩展版