1、函数式接口的介绍

  • 如果一个接口中，只声明了一个抽象方法，则此接口就称为函数式接口。我们可以在一个接口上使用 @FunctionalInterface 注解， 这样做可以检查它是否是一个函数式接口。 ```java /*
    • 4.Lambda表达式的本质：作为函数式接口的实例 *
      1. 如果一个接口中，只声明了一个抽象方法，则此接口就称为函数式接口。我们可以在一个接口上使用 @FunctionalInterface 注解，
    • 这样做可以检查它是否是一个函数式接口。 /

/**

  • 自定义函数式接口 */ public interface MyInterFace {

    void method();

// void method2();

}

  2. - 在java.util.function包下定义了Java 8 的丰富的函数式接口
  3. - Java从诞生日起就是一直倡导“一切皆对象”，在Java里面面向对象(OOP)编程是一切。但是随着python、scala等语言的兴起和新技术的挑战，Java不得不做出调整以便支持更加广泛的技术要求，也即java不但可以支持OOP还可以支持OOF（面向函数编程）
  4. - 在函数式编程语言当中，函数被当做一等公民对待。在将函数作为一等公民的编程语言中，Lambda表达式的类型是函数。但是在Java8中，有所不同。在Java8中，Lambda表达式是对象，而不是函数，它们必须依附于一类特别的对象类型——函数式接口。
  5. - 简单的说，在Java8中，Lambda表达式就是一个函数式接口的实例。这就是Lambda表达式和函数式接口的关系。也就是说，**只要一个对象是函数式接口的实例，那么该对象就可以用Lambda表达式来表示。**
  6. - **所以以前用匿名实现类表示的现在都可以用Lambda表达式来写。**
  7. <a name="LahPi"></a>
  8. # 2、Java内置的函数式接口介绍及使用举例
  9. | **函数式接口** | **参数类型** | **返回类型** | **用途** |
  10. | --- | --- | --- | --- |
  11. | Consumer 消费型接口 | T | void | 对类型为T的对象应用操作，包含方法：void accept(T t) |
  12. | Supplier 供给型接口 | 无 | T | 返回类型为T的对象，包含方法：T get() |
  13. | Function<T, R>函数型接口 | T | R | 对类型为T的对象应用操作，并返回结果。结果是R类型的对象。包含方法：R apply(T t) |
  14. | Predicate断定型接口 | T | boolean | 确定类型为T的对象是否满足某约束，并返回boolean 值。包含方法：boolean test(T t) |
  15. | BiFunction<T,U,R> | T, U | R | 对类型为T,U参数应用操作，返回R类型的结果。包含方法为：Rapply(T t,U u); |
  16. | UnaryOperator(Function子接口) | T | T | 对类型为T的对象进行一元运算，并返回T类型的结果。包含方法为：Tapply(T t); |
  17. | BinaryOperator(BiFunction子接口) | T,T | T | 对类型为T的对象进行二元运算，并返回T类型的结果。包含方法为：Tapply(T t1,T t2); |
  18. | BiConsumer<T,U> | T,U | void | 对类型为T,U参数应用操作。包含方法为：voidaccept(Tt,Uu) |
  19. | BiPredicate<T,U> | T,U | boolean | 包含方法为：booleantest(Tt,Uu) |
  20. | ToIntFunction | T | int | 计算int值的函数 |
  21. | ToLongFunction | T | long | 计算long值的函数 |
  22. | ToDoubleFunction | T | double | 计算double值的函数 |
  23. | IntFunction | int | R | 参数为int类型的函数 |
  24. | LongFunction | long | R | 参数为long类型的函数 |
  25. | DoubleFunction | double | R | 参数为double类型的函数 |
  27. ```java
  28. import org.junit.Test;
  30. import java.util.ArrayList;
  31. import java.util.Arrays;
  32. import java.util.List;
  33. import java.util.function.Consumer;
  34. import java.util.function.Predicate;
  36. /**
  37.  * java内置的4大核心函数式接口
  38.  *
  39.  * 消费型接口 Consumer<T>     void accept(T t)
  40.  * 供给型接口 Supplier<T>     T get()
  41.  * 函数型接口 Function<T,R>   R apply(T t)
  42.  * 断定型接口 Predicate<T>    boolean test(T t)
  43.  */
  44. public class LambdaTest2 {
  46.     public void happyTime(double money, Consumer<Double> con) {
  47.         con.accept(money);
  48.     }
  50.     @Test
  51.     public void test(){
  52.         happyTime(30, new Consumer<Double>() {
  53.             @Override
  54.             public void accept(Double aDouble) {
  55.                 System.out.println("熬夜太累了，点个外卖，价格为：" + aDouble);
  56.             }
  57.         });
  58.         System.out.println("+++++++++++++++++++++++++");
  60.         //Lambda表达式写法
  61.         happyTime(20,money -> System.out.println("熬夜太累了，吃口麻辣烫，价格为：" + money));
  62.     }
  64.     //根据给定的规则，过滤集合中的字符串。此规则由Predicate的方法决定
  65.     public List<String> filterString(List<String> list, Predicate<String> pre){
  67.         ArrayList<String> filterList = new ArrayList<>();
  68.         for(String s : list){
  69.             if(pre.test(s)){
  70.                 filterList.add(s);
  71.             }
  72.         }
  73.         return filterList;
  75.     }
  77.     @Test
  78.     public void test2(){
  79.         List<String> list = Arrays.asList("长安","上京","江南","渝州","凉州","兖州");
  81.         List<String> filterStrs = filterString(list, new Predicate<String>() {
  82.             @Override
  83.             public boolean test(String s) {
  84.                 return s.contains("州");
  85.             }
  86.         });
  88.         System.out.println(filterStrs);
  90.         List<String> filterStrs1 = filterString(list,s -> s.contains("州"));
  91.         System.out.println(filterStrs1);
  92.     }
  93. }