Java8之函数式接口

• 简介
  只定义一个抽象方法的接口，以函数式接口为参数的方法就可以使用Lambda表达式(Lambda表达式允许直接以内联的形式为函数式接口的抽象方法提供实现，并把整个表达式作为函数式接口的实例)。函数式接口的抽象方法的签名称为函数描述符。

• 与Lambda之间的关联
  函数式接口中的抽象方法的签名可以描述Lambda表达式的签名，如果没有符合条件的函数式接口的方法签名，那么此Lambda表达式是不成立的。

• java8内置的常用函数式接口

  • Predicate：定义了 boolean test(T t) 抽象方法，需要表示一个涉及类型T的布尔表达式时可以使用

    Predicate<String> predicate = (String s)-> "aaa".equals(s);
    

  • Consumer：定义了 void accept(T t) 抽象方法，需要访问某对象并对其进行某些操作时可以使用

  	public static void consumer(List<Orange> oranges,Consumer<Orange> consumer) {
          oranges.forEach(orange ->{
              consumer.accept(orange);
          } );
      }
  
      public static void main(String[] args) {
          consumer(Lists.newArrayList(new Orange(),new Orange()), (Orange orange) -> orange.setColor("red"));
      }
  

  • Function：定义了 R apply(T t) 抽象方法，它接受一个 泛型T的对象，并返回一个泛型R的对象。如果需要将接收对象转换成其它对象可以使用

  	/**
       * 根据传入的Lambda表达式的要求转入传入的ts
       *
       * @param ts
       * @param function
       * @param <T>
       * @param <R>
       * @return
       */
      public static <T, R> List<R> function(List<T> ts, Function<T, R> function) {
          List<R> list = Lists.newArrayList();
          ts.forEach(s -> {
              list.add(function.apply(s));
          });
          return list;
      }
      public static void main(String[] args) {
          //demo中的Lambda表达式实现的是接收字符串s返回s的长度
          System.out.println(function(Lists.newArrayList("a", "aa", "aaa"), (String s) -> s.length()).toString());
      }
  

  • Supplier：定义了 T get() 抽象方法，不接收参数返回Lambda表达式的值

  	public static <T> T supplier(Supplier<T> supplier){
          return supplier.get();
      }
  	// 输出结果：supplier functionaal
  	System.out.println(supplier(()->"supplier functionaal"));
  

  • BiFunction：定义 R apply(T t, U u) 抽象方法，接收t和u参数，返回R对象，如果需要两个对象中的某些值来组装成另一个对象，可以使用。我把它看成Function的神级版

  	public static <T, U, R> R biFunction(T t,U u,BiFunction<T, U, R> biFunction){
          return biFunction.apply(t, u);
      }
  	// 输出结果：ab
  	System.out.println(biFunction("a", "b", (String t,String s)-> t+s));
  

  • BiPredicate：定义了 boolean test(T t, U u) 抽象方法，接收 t 和 u参数，返回比较的接口，需要两个对象做比较可以使用

  	public static <T, U> boolean biPredicate(T t,U u,BiPredicate<T,U> biPredicate){
          return biPredicate.test(t, u);
      }
      
      System.out.println(biPredicate("a", "b",(String s1,String s2)->s1.equals(s2)));
  

• BiConsumer：定义了 void accept(T t, U u) 抽象方法，我把它看成Consumer的神级版

	public static <T, U> void biConsumer(T t, U u, BiConsumer<T, U> biConsumer) {
        biConsumer.accept(t, u);
    }
    // 输出结果：20.0
	Orange orange1 = new Orange();
	orange1.setWeight(10);
    Orange orange2 = new Orange();
    orange2.setWeight(10);
    biConsumer(orange1, orange2, (Orange orange11, Orange orange22) -> orange11.setWeight(orange11.getWeight()+orange22.getWeight()));
    System.out.println(orange1.getWeight());

更多文章：
CSDN博客
简书博客
公众号：代码小搬运