Java 基础复习 Day 25

Java 基础复习 Day 25

常见函数式接口（2）

JDK自带的函数式接口一般放在java.util.function 包下

本次主要学习function包下的Supplier,Consumer,Predicate,Function接口

• Supplier接口 Interface Supplier

  接口抽象方法：T get()

  • 用来获取一个泛型参数指定类型的对象数据。意味着Lambda表达式需要向外提供一个符合泛型类型的对象数据类型

  • 生产型接口：泛型指定啥类型，就生产什么类型的数据

    //生产String类型的数据
    public class DemoSupplier {
        //定义一个方法，方法的参数传递Supplier接口，指定泛型为String
        public static String makeString(Supplier<String> supplier){
            return supplier.get();
        }
    
        public static void main(String[] args) {
            //main方法调用makeString，可用Lambda表达式
         String result =  makeString(() -> {
                //生产一个字符串并返回
                return "Karen is made";
            });
         System.out.println(result);
        }
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16

• Consumer接口 Interface Consumer

  1. 接口抽象方法是：void accept(T t)

     正好和Supplier接口的get方法相反，Consumer用来使用或者消费指定泛型的数据

     //定义一个方法，参数是一个字符串和Consumer接口
     public static void showName(String lastN, Consumer<String> consumer){
         consumer.accept(lastN);//没有返回值
     }
     
     public static void main(String[] args) {
         //最简单消费方式：输出
         showName("Kou",(name) -> System.out.println("Karen" + name));
         //字符串反转输出
         showName("KarenKou",(name) -> {
             StringBuilder build = new StringBuilder(name);
             build.reverse();
             System.out.println(build);
         });
     }
     1
     2
     3
     4
     5
     6
     7
     8
     9
     10
     11
     12
     13
     14
     15

  2. 接口的默认方法 andThen

     default Consumer andThen(Consumer after) 返回一个组合的 Consumer ，按顺序执行该操作，然后执行 after操作。

     JDK 源码

     default Consumer<T> andThen(Consumer<? super T> after) {
         Objects.requireNonNull(after);
         return (T t) -> { accept(t); after.accept(t); };
     }
     1
     2
     3
     4

• 返回一个组合的Consumer ， Consumer执行该操作，后跟after操作。 如果执行任一操作会抛出异常，它将被转发到组合操作的调用者。 如果执行此操作抛出一个异常， after操作将不被执行。

  • 参数

    after - 此操作后执行的操作

  • 结果

    一个组合的 Consumer按顺序执行该操作，后跟 after操作

  • 异常

    NullPointerException - if after is null

  • 作用：需要两个Consumer接口，可以把两个Consumer接口组合在一起，在对数据进行消费

  • 例子：Consumer con1；

    ​ Consumer con2;

    ​ String s = “Hello”

    ​ con1.accept(s);

    ​ con2.accept(s);

    等价于：con1.andThen(con2).accept(s)//写在前面的先消费，就是先消费con1再消费con2

    public class DemoAndThen {
        //定义一个方法，参数传递一个字符串，和两个Consumer接口
        public static void consumeStrings(String str, Consumer<String> con1,Consumer<String> con2){
            con1.andThen(con2).accept(str);
        }
    
        public static void main(String[] args) {
            consumeStrings("Hello World",(str1)-> System.out.println(str1.toLowerCase()),(str2)-> System.out.println( str2.toUpperCase()));
        }
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10

• Predicate接口 Interface Predicate

  有时候需要对某种数据类型的数据进行判断，从而得到一个boolean值，此时可以用Predicate接口

  Predicate中的抽象方法boolean test(T t) 对某种数据类型的数据进行判断 ,符合返回true，

  不符合返回false

  public class DemoPredicate {
      //定义一个方法，参数传递一个String类型的字符串
      //传递一个Predicate接口，泛型使用String
      //使用test（）对字符串进行判断并返回判断结果
      public static boolean checkString(String str, Predicate<String> predicate){
          return predicate.test(str);
      }
  
      public static void main(String[] args) {
          boolean flag = checkString("KarenKou is cool", (str) -> str.contains("K"));
          System.out.println(flag);
      }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13

• Predicate中的or，negate，and方法

  相当于对两个指定数据类型的数据进行 &&，||，！操作

  1. and

     public static boolean checkStrings(String str, Predicate<String> pred1, Predicate<String> pred2){
        // return pred1.test(str) && pred2.test(str); and方法就等价于两个pred接口的test结果做且运算
         return pred1.and(pred2).test(str);
     }
     
     public static void main(String[] args) {
         boolean result = checkStrings("SDFEFED", (str) -> str.contains("T"), (str) -> str.length() == 5);
         System.out.println(result);//false
     }
     1
     2
     3
     4
     5
     6
     7
     8
     9

  2. or

     public class DemoPreidicate_or {
         public static boolean checkStrings(String str, Predicate<String> pred1, Predicate<String> pred2){
            // return pred1.test(str) || pred2.test(str); or方法就等价于两个pred接口的test结果做或运算
             return pred1.or(pred2).test(str);
         }
     
         public static void main(String[] args) {
             boolean result = checkStrings("SDFEFED", (str) -> str.contains("E"), (str) -> str.length() == 5);
             System.out.println(result);//true
         }
     }
     1
     2
     3
     4
     5
     6
     7
     8
     9
     10
     11

  3. negate

     public class DemoPredicate_negate {
         public static boolean checkStrings(String str, Predicate<String> pred){
             //return !pred.test(str); negate就是相对于pred的结果做取反
             return pred.negate().test(str);
         }
     
         public static void main(String[] args) {
             boolean result = checkStrings("SDFEFED", (str) -> str.length() > 5);
             System.out.println(result);//false
         }
     }
     1
     2
     3
     4
     5
     6
     7
     8
     9
     10
     11

• Function接口Interface Function

  Function接口用来根据一个类型的数据得到另外一个数据的类型，T称为前置条件，R称为后置条件

  Function中最主要的方法时apply：根据类型T的参数获取类型为R的结果

  使用场景：将String转为Integer类型

  public class DemoFunction {
      //定义一个方法，参数传递一个String类型
      //参数传递一个Function接口
      public static void changeString(String str, Function<String,Integer> fun){
          Integer afterResult = fun.apply(str);
          System.out.println(afterResult);
      }
  
      public static void main(String[] args) {
          changeString("45",(str) -> Integer.parseInt(str));//45
      }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12

• Function中的默认方法andThen，和Consumer中的一样用来组合操作

  进行两次数据类型的转换组合

  String str ⇒　Integer a +10 ⇒ String

  public class DemoFunctionAndThen {
      public static void changeStrings(String str, Function<String,Integer> fun1, Function<Integer,String> fun2){
          String apply = fun1.andThen(fun2).apply(str);
          System.out.println(apply);
      }
  
      public static void main(String[] args) {
          changeStrings("234",(str)-> Integer.parseInt(str)+10,(str)->str +"" );//244
      }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10