一、JDK1.8常用函数式接口

  • Supplier接口 - 用来获取一个泛型参数指定类型的对 象数据

    1. Supplier接口
    2. @FunctionalInterface
    3. public interface Supplier<T> {
    4.   T get();
    5. }

  • Consumer接口 - 正好与Supplier接口相反，它不是生产一个数据，而是消费一个数据， 其数据类型由泛型决定。

    1. @FunctionalInterface
    2. public interface Consumer<T> {
    4.   void accept(T t);
    6.   default Consumer<T> andThen(Consumer<? super T> after) {
    7.       Objects.requireNonNull(after);
    8.       return (T t) -> { accept(t); after.accept(t); };
    9.   }
    10. }

  • Predicate接口 - 对某种类型的数据进行判断，从而得到一个boolean值结果。 ```java @FunctionalInterface public interface Predicate {

    boolean test(T t);

  1. default Predicate<T> and(Predicate<? super T> other) {
  2.     Objects.requireNonNull(other);
  3.     return (t) -> test(t) && other.test(t);
  4. }
  7. default Predicate<T> negate() {
  8.     return (t) -> !test(t);
  9. }
  12. default Predicate<T> or(Predicate<? super T> other) {
  13.     Objects.requireNonNull(other);
  14.     return (t) -> test(t) || other.test(t);
  15. }
  18. static <T> Predicate<T> isEqual(Object targetRef) {
  19.     return (null == targetRef)
  20.             ? Objects::isNull
  21.             : object -> targetRef.equals(object);
  22. }

}

  2. - **Function接口 - 来根据一个类型的数据得到另一个类型的数据，前者称为前置条件， 后者称为后置条件。**
  3. ```java
  4. @FunctionalInterface
  5. public interface Function<T, R> {
  7.     R apply(T t);
  10.     default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
  11.         Objects.requireNonNull(before);
  12.         return (V v) -> apply(before.apply(v));
  13.     }
  16.     default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
  17.         Objects.requireNonNull(after);
  18.         return (T t) -> after.apply(apply(t));
  19.     }
  22.     static <T> Function<T, T> identity() {
  23.         return t -> t;
  24.     }
  25. }

二、函数式接口应用

  • Supplier get方法应用 ```java public static String getString(Supplier supplier){ return supplier.get(); } public static void main(String[] args) { String str = getString(() -> {
    1.   return "hello";
    }); System.out.println(str); }

— 结果 hello

  2. - **Consumer accept接口**
  3. - **Consumer andThen方法相当于调用两次accept**
  4. ```java
  5.  public static void accept(String str, Consumer<String> consumer){
  6.      consumer.accept(str);
  7.  }
  9. public static void main(String[] args) {
  10.     accept("hello world", (str) -> {
  11.         String[] strArr =str.split(" ");
  12.         System.out.println(strArr[0]);
  13.     });
  14. }
  15. --- 输出结果  hello
  17. public static void acceptAndThen(String str, Consumer<String> consumer1, Consumer<String> consumer2){
  18.      consumer1.andThen(consumer2).accept(str);
  19. }
  20.     public static void main(String[] args) {
  21.         acceptAndThen("hello world",
  22.                 (String str1) -> {
  23.                     String a = str1 + " a";
  24.                     System.out.println(a);
  25.                 },
  26.                 (String str2) -> {
  27.                     String b = str2 + " b";
  28.                     System.out.println(b);
  29.                 });
  30.     }
  32. -- 输出结果
  33. hello world a
  34. hello world b
  • Predicate test方法
  • Predicate and方法，两个test的逻辑与 &&
  • Predicate or方法，两个test的或 ||
  • Predicate negate方法，对test方法进行去反 ```java public class Demo15PredicateTest {
    private static void method(Predicate predicate) { 
    1.   boolean veryLong = predicate.test("HelloWorld");         
    2.   System.out.println("字符串很长吗：" + veryLong);
    }
    public static void main(String[] args) { 
    1.   method(s ‐> s.length() > 5);
    } }

private static void method(Predicate one, Predicate two) { boolean isValid = one.and(two).test(“Helloworld”);
System.out.println(“字符串符合要求吗：” + isValid);
}
public static void main(String[] args) {
method(s ‐> s.contains(“H”), s ‐> s.contains(“W”));
} 

  2. - **Function apply接口**
  4.          Function 接口中主要的抽象方法为： R apply(T t) ，根据类型T的参数获取类型R的结果。
  5. ```java
  6. public class Demo11FunctionApply {
  7.     private static void method(Function<String, Integer> function) {
  8.         int num = function.apply("10");         
  9.         System.out.println(num + 20);     
  10.     }       
  11.     public static void main(String[] args) {         
  12.         method(s ‐> Integer.parseInt(s));     
  13.     } 
  14. }