Java多线程之JUC

位置：java.util.function包下

接口中只能有一个抽象方法的接口，称函数式接口

java内置核心四大函数式接口：
| 函数式接口 | 参数类型 | 返回类型 | 用途 |
| --------------------- | -------- | -------- | ------------------------------------------------------------ |
| Consumer 消费型 | T | void | 对类型为T的对象应用操作，包含方法：void accept(T t) |
| Supplier 供给型 | 无 | T | 返回类型为T的对象，包含方法：T get(); |
| Function 函数型 | T | R | 对类型为T的对象应用操作，并返回结果；
结果是R类型的对象，包含方法：R apply(T t) |
| Predicate 断定型 | T | boolean | 确定类型为T的对象是否满足某约束，并返回boolean值，包含方法：boolean test(T t) |

• 消费型Consumer

  • 对类型为T的对象应用操作

  

      /**
       * 消费型
       */
      public static void testConsumer() {
          /*Consumer consumer = new Consumer() {
              @Override
              public void accept(String s) {
                  System.out.println("输入的值是：" + s);
              }
          };*/
          Consumer consumer = (s) -> {
              System.out.println("输入的值是：" + s);
          };
          consumer.accept("abc");
      }
  

• 供给型Supplier

  • 返回类型为T的对象

  

      /**
       * 供给型
       */
      public static void testSupplier() {
          /*Supplier supplier = new Supplier() {
              @Override
              public String get() {
                  return "供给型接口";
              }
          };*/
          Supplier supplier = () -> {
              return "供给型接口lambda";
          };
  
          System.out.println(supplier.get());
      }
  

函数型Function

• 对类型为T的对象应用操作，并返回结果，结果是R类型的对象

    /**
     * 函数型
     */
    public static void testFunction() {
        /*Function function = new Function() {
            @Override
            public String apply(String s) {
                s += "123";
                return s;
            }
        };*/
        Function function = (s) -> {
            s += "123lambda";
            return s;
        };
        System.out.println(function.apply("abc"));
    }

断定型Predicate

• 确定类型为T的对象是否满足某约束，并返回boolean值

    /**
     * 断定型
     */
    public static void testPredicate() {
        /*Predicate predicate = new Predicate() {
            @Override
            public boolean test(String s) {
                return "1024".equals(s);
            }
        };*/
        Predicate predicate = (s) -> {
            return "1024".equals(s);
        };
        System.out.println(predicate.test("1024"));
    }