BiConsumer跟BiFunction的区别详解

电玩女神 2023-02-21 09:06 14阅读 0赞

## Comsumer和BiConsumer方法: ##

首先看一下两个接口:几乎差不多,就是方法参数多一个.BiConsumer可以看做Consumer的增强吧!  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MzY2MDYz_size_16_color_FFFFFF_t_70]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MzY2MDYz_size_16_color_FFFFFF_t_70 1]  
**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);
    
      }

执行结果:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MzY2MDYz_size_16_color_FFFFFF_t_70 2]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MzY2MDYz_size_16_color_FFFFFF_t_70 3]

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

执行结果:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MzY2MDYz_size_16_color_FFFFFF_t_70 4]

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,等…  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MzY2MDYz_size_16_color_FFFFFF_t_70 5]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MzY2MDYz_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200630103649113.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MzY2MDYz,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MzY2MDYz_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200629191959189.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MzY2MDYz,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MzY2MDYz_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200630105334675.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MzY2MDYz,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MzY2MDYz_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200630105319729.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MzY2MDYz,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MzY2MDYz_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200630114308348.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MzY2MDYz,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MzY2MDYz_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20200630122923175.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MzY2MDYz,size_16,color_FFFFFF,t_70