BiConsumer跟BiFunction的区别详解

Comsumer和BiConsumer方法:

首先看一下两个接口:几乎差不多,就是方法参数多一个.BiConsumer可以看做Consumer的增强吧!


Consumer的作用就是定义一个函数,然后对其进行消费处理,(accept方法);
而andThen方法相当于是组合两个方法,返回一个新的方法,是先对给定的参数进行定义的操作然后在执行after操作;
BiConsumer就是Consumer的加强版,处理两个参数,默认方法andThen也是一样的:写个测试:

@Test
  public void test41() throws Exception {
    Consumer<Integer> action1 = (x) -> {
      System.out.println("对传进来的进行加1操作: " + (x + 1));
    };
    Consumer<Integer> action2 = (x) -> {
      System.out.println("对传进来的进行减1操作: " + (x - 1));
    };
    Consumer<Integer> anction3 = action1.andThen(action2);

    //先执行加法在执行减法
    System.out.println("执行anction1");
    action1.accept(3);
    System.out.println("执行anction2");
    action2.accept(3);
    System.out.println("执行anction3");
    anction3.accept(3);

  }

  @Test
  public void test42() throws Exception {
    BiConsumer<Integer, Integer> action1 = (x, y) -> {
      System.out.println("对传进来的进行相加操作: " + (x + y));
    };
    BiConsumer<Integer, Integer> action2 = (x, y) -> {
      System.out.println("对传进来的进行相减操作: " + (x - y));
    };
    BiConsumer<Integer, Integer> anction3 = action1.andThen(action2);

    //先执行加法在执行减法
    System.out.println("执行anction1");
    action1.accept(1, 1);
    System.out.println("执行anction2");
    action2.accept(1, 1);
    System.out.println("执行anction3");
    anction3.accept(1, 1);

  }

执行结果:

Function和BiFunction的区别

先看源码,其实感觉跟Consumer都差不多:

@FunctionalInterface
public interface Function<T, R> {

    /**
     * Applies this function to the given argument.
     *
     * @param t the function argument
     * @return the function result
     */
    R apply(T t);

    /**
     * Returns a composed function that first applies the {@code before}
     * function to its input, and then applies this function to the result.
     * If evaluation of either function throws an exception, it is relayed to
     * the caller of the composed function.
     *
     * @param <V> the type of input to the {@code before} function, and to the
     *           composed function
     * @param before the function to apply before this function is applied
     * @return a composed function that first applies the {@code before}
     * function and then applies this function
     * @throws NullPointerException if before is null
     *
     * @see #andThen(Function)
     */
    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

    /**
     * Returns a composed function that first applies this function to
     * its input, and then applies the {@code after} function to the result.
     * If evaluation of either function throws an exception, it is relayed to
     * the caller of the composed function.
     *
     * @param <V> the type of output of the {@code after} function, and of the
     *           composed function
     * @param after the function to apply after this function is applied
     * @return a composed function that first applies this function and then
     * applies the {@code after} function
     * @throws NullPointerException if after is null
     *
     * @see #compose(Function)
     */
    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }

    /**
     * Returns a function that always returns its input argument.
     *
     * @param <T> the type of the input and output objects to the function
     * @return a function that always returns its input argument
     */
    static <T> Function<T, T> identity() {
        return t -> t;
    }
}

BiFunction的源码:

@FunctionalInterface
public interface BiFunction<T, U, R> {

    /**
     * Applies this function to the given arguments.
     *
     * @param t the first function argument
     * @param u the second function argument
     * @return the function result
     */
    R apply(T t, U u);

    /**
     * Returns a composed function that first applies this function to
     * its input, and then applies the {@code after} function to the result.
     * If evaluation of either function throws an exception, it is relayed to
     * the caller of the composed function.
     *
     * @param <V> the type of output of the {@code after} function, and of the
     *           composed function
     * @param after the function to apply after this function is applied
     * @return a composed function that first applies this function and then
     * applies the {@code after} function
     * @throws NullPointerException if after is null
     */
    default <V> BiFunction<T, U, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t, U u) -> after.apply(apply(t, u));
    }
}

先说function,function主要就apply方法,接收参数为T返回R类型的;
compose,和andThen都是差不多的,都是组合成一个新的函数,然后按照不同顺序执行…
identity是一个静态方法,注释也写的很明了了,返回接收的参数的函数,就是接收啥返回对应的函数;

 @Test
  public void test51() throws Exception {

    Function<Integer, Integer> action1 = (x) -> {
      System.out.println("对传进来的进行加1操作: " + (x + 1));
      return x + 1;
    };
    Function<Integer, Integer> action2 = (x) -> {
      System.out.println("对传进来的进行-1操作: " + (x - 1));
      return (x - 1);
    };
    Function<Integer, Integer> action3 = action1.andThen(action2);
    Function<Integer, Integer> compose = action1.compose(action2);

    //先执行加法在执行减法
    System.out.println("执行anction1");
    action1.apply(1);
    System.out.println("执行anction2");
    action2.apply(1);
    System.out.println("执行andThen返回的函数");
    action3.apply(1);
    System.out.println("执行compose返回的函数");
    compose.apply(1);

//Function.identity()返回一个输出跟输入一样的Lambda表达式对象，等价于形如t -> t形式的Lambda表达式
    Stream<String> stream = Stream.of("I", "love", "you", "too");
    //这三个相同的作用...就是返回的是原来的字符串.
//    Map<String, Integer> map = stream.collect(Collectors.toMap(Function.identity(), String::length));
    Map<String, Integer> map = stream.collect(Collectors.toMap(String::toString, String::length));
//    Map<String, Integer> map = stream.collect(Collectors.toMap(str->str, String::length));
    System.out.println(map);
    
  }

执行结果:

BiFunction跟BiConsumer差不多,都是对原来的进行增强,多加了个参数,都是差不多的…注意BiFunction的andThen方法是传入的Function,

  @Test
  public void test52() throws Exception {
    BiFunction<Integer, Integer, Integer> action = (x, y) -> {
      System.out.println(x + y);
      return x + y;
    };
    Function<Integer, Integer> action2 = (x) -> {
      System.out.println("Function..." + x);
      return x;
    };
    BiFunction<Integer, Integer, Integer> integerIntegerBiConsumer = action.andThen(action2);

    integerIntegerBiConsumer.apply(1, 1);

  }

fuction包下

有很多扩展的接口,比如DoubleConsumer,请求参数固定是dubbo,等…