1.9函数式接口

函数式接口

概念

• 函数式接口在Java中是指：有且仅有一个抽象方法的接口。(当然接口中可以包含其他的方法，但只能有一个抽象方法)
• 而Java中的函数式编程体现就是Lambda，所以函数式接口就是可 以适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导。

备注：“语法糖”是指使用更加方便，但是原理不变的代码语法。例如在遍历集合时使用的for-each语法，其实 底层的实现原理仍然是迭代器，这便是“语法糖”。从应用层面来讲，Java中的Lambda可以被当做是匿名内部 类的“语法糖”，但是二者在原理上是不同的。 Lambda表达式不会生成匿名内部类的class文件，而持久匿名内部类时会生成一个class文件

格式

 修饰符 interface 接口名称 {     
    public abstract 返回值类型 方法名称(可选参数信息);     
    // 其他非抽象方法内容
}

@FunctionalInterface注释

• 作用：可以检测接口是否是函数式接口

是：编译成功
否：编译失败（抽象方法的个数多余1个）

@FunctionalInterface 
public interface MyFunctionalInterface { 
     void myMethod();      
}

使用

• 对于刚刚定义好的 MyFunctionalInterface函数式接口，典型使用场景就是作为方法的参数：

public class Demo09FunctionalInterface {     
   // 使用自定义的函数式接口作为方法参数      
   private static void doSomething(MyFunctionalInterface inter) {      
       inter.myMethod(); // 调用自定义的函数式接口方法          
   }           
   public static void main(String[] args) {      
      // 调用使用函数式接口的方法,使用简化的Lambda表达式          
      doSomething(() ‐> System.out.println("Lambda执行啦！"));          
   }      
 }

函数式编程

Lambda的延迟执行

• 有些场景的代码执行后，结果不一定会被使用，从而造成性能浪费。而Lambda表达式是延迟执行的，这正好可以 作为解决方案，提升性能。

性能浪费的日志案例

• 一种典型的场景就是对参数进行有条件使用，例如对日志消息进行拼接后，在满足条件的情况下进行打印输出：

public class Demo01Logger {     
    private static void log(int level, String msg) {         
       if (level == 1) {            
           System.out.println(msg);            
        }    
    }       
    public static void main(String[] args) {         
       String msgA = "Hello";         
       String msgB = "World";         
       String msgC = "Java";           
       log(1, msgA + msgB + msgC);     
    } 
}

• 这段代码存在问题：无论级别是否满足要求，作为 log 方法的第二个参数，三个字符串一定会首先被拼接并传入方 法内，然后才会进行级别判断。如果级别不符合要求，那么字符串的拼接操作就白做了，存在性能浪费。

使用Lambda表达式优化日志案例

public class Demo03LoggerDelay {     
   private static void log(int level, MessageBuilder builder) {         
      if (level == 1) {            
         System.out.println(builder.buildMessage());            
       }     
   }       
   public static void main(String[] args) {         
      String msgA = "Hello";         
      String msgB = "World";         
      String msgC = "Java";           
      log(2, () ‐> {             
         System.out.println("Lambda执行！");             
         return msgA + msgB + msgC;        
      });     
   } 
}
//结果：只有当level=1时，才会调用buildMessage()进行字符串的拼接，当level为其他值时，不会进行字符串拼接

函数式接口作为方法的参数案例

• 例如 java.lang.Runnable 接口就是一个函数式接口，假设有一个 startThread 方法使用该接口作为参数，那么就 可以使用Lambda进行传参。这种情况其实和 Thread 类的构造方法参数为 Runnable 没有本质区别。

public class Demo04Runnable {     
    private static void startThread(Runnable task) {        
        new Thread(task).start();        
    }       
    public static void main(String[] args) {        
        startThread(() ‐> System.out.println("线程任务执行！"));        
    } 
}

函数式接口作为方法的返回值

Public class Demo2Comparator {
    //定义一个方法，方法的返回值类型使用函数式接口Comparator
    public static Comparator<String> getComparator(){
        //方法的返回值类型是一个接口，那么我们可以返回这个接口的匿名内部类
        /*return new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.length()-o2.length();
            }
        };*/
        //方法的返回值类型是一个接口，所以我们可以返回一个Lambda表达式
        return (String o1,String o2)->o1.length()-o2.length();
    }
 }

常用函数式接口

• JDK提供了大量常用的函数式接口以丰富Lambda的典型使用场景，它们主要在 java.util.function 包中被提供。 下面是简单的几个接口及使用示例。

Supplier接口

• java.util.function.Supplier<T> 接口仅包含一个无参的方法： T get() 。用来获取一个泛型参数指定类型的对象数据。
• Supplier<T>接口被称之为生产型接口，指定接口的泛型是什么类型，那么接口中的get方法就会产生什么类型的数据

public class Demo01Supplier {
  //定义一个方法，方法参数传递Supplier<T>接口
    public static String getString(Supplier<String> sup){
      return sup.get();
    }

    public static void main(String[] args) {
    //使用Lambda表达式代替函数式接口的匿名对象
        String s=getString(()->"abc");
        System.out.println(s);
    }
}

Consumer接口

• java.util.function.Consumer<T> 接口则正好与Supplier接口相反，它不是生产一个数据，而是消费一个数据， 其数据类型由泛型决定。
• Consumer 接口中包含抽象方法 void accept(T t) ，意为消费一个指定泛型的数据。

public class Demo2Consumer {
    public static void consumerString(String s,Consumer<String> consumer){
        consumer.accept(s);
    }

    public static void main(String[] args) {
    //调用consumerString方法，由于Consumer<T>接口是一个函数式接口，所以可以使用Lambda表达式
        consumerString("赵丽宁",(String name)->{
           //第一种消费：直接将name输出
            System.out.println(name);
            //第二种消费:将字符串反转输出
            String rename=new StringBuffer(name).reverse().toString();
            System.out.println(rename);
        });
    }
}

• 如果一个方法的参数和返回值全都是 Consumer 类型，那么就可以实现效果：消费数据的时候，首先做一个操作， 然后再做一个操作，实现组合。而这个方法就是 Consumer 接口中的default方法 andThen 。
• andThen方法：需要两个Consumer接口，可以把两个Consumer接口组合到一起，在对数据进行消费

举例：
Consumer con1
Consumer con2
String s=“hello”
con1.accept(s)
con2.accept(s)
连接两个consumer接口，再进行消费
con1.andThen(con2).accept(s);谁写前边谁先消费

public class Demo2Consumer {
    public static void consumerAddThen(String s,Consumer<String> con1,Consumer<String> con2){
       //第一种写法
        //con1.accept(s);
        //con2.accept(s);
        //第二种写法
        con1.andThen(con2).accept(s);//con1连接con2，先执行con1消费数据，在执行con2消费数据
    }

    public static void main(String[] args) {
    
        consumerAddThen("Hello",(name)->{
            System.out.println(name.toUpperCase());
        },(name)->{
            System.out.println(name.toLowerCase());
        });
    }
}

Predicate接口

• 有时候我们需要对某种类型的数据进行判断，从而得到一个boolean值结果。这时可以使用 java.util.function.Predicate<T>接口
• Predicate 接口中包含一个抽象方法： boolean test(T t) 。用于条件判断的场景

public class Demo15PredicateTest {     
   private static void method(Predicate<String> predicate) {         
      boolean veryLong = predicate.test("HelloWorld");         
      System.out.println("字符串很长吗：" + veryLong);     
   }       
   public static void main(String[] args) {         
        method(s ‐> s.length() > 5);     
   } 
}

• 默认方法：and
• 既然是条件判断，就会存在与、或、非三种常见的逻辑关系。其中将两个 Predicate 条件使用“与”逻辑连接起来实 现“并且”的效果时，可以使用default方法 and 。

源码：
default Predicate and(Predicate<? super T> other)
{ Objects.requireNonNull(other);
return (t) ‐> test(t) && other.test(t);
}

public class Demo16PredicateAnd {     
     private static void method(Predicate<String> one, Predicate<String> 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"));     
     } 
 }

• 默认方法：or
  与 and 的“与”类似，默认方法 or 实现逻辑关系中的“或”。

源码
default Predicate or(Predicate<? super T> other)
{ Objects.requireNonNull(other);
return (t) ‐> test(t) || other.test(t);
}

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

• 默认方法：negate “非”(取反)

源码
default Predicate negate() {
return (t) ‐> !test(t);
}

public class Demo17PredicateNegate {     
   private static void method(Predicate<String> predicate) {         
      boolean veryLong = predicate.negate().test("HelloWorld");         
      System.out.println("字符串很长吗：" + veryLong);     
   }       
   public static void main(String[] args) {        
      method(s ‐> s.length() < 5);        
   } 
}

Function接口

• java.util.function.Function<T,R> 接口用来根据一个类型的数据得到另一个类型的数据，前者称为前置条件， 后者称为后置条件。
• Function 接口中主要的抽象方法为： R apply(T t)，根据类型T的参数获取类型R的结果。

public class Demo11FunctionApply {     
     private static void method(Function<String, Integer> function) {         
          int num = function.apply("10");         
          System.out.println(num + 20);     
     }       
     public static void main(String[] args) {         
          method(s ‐> Integer.parseInt(s));     
     } 
 }

• 默认方法：andThen
• Function 接口中有一个默认的 andThen 方法，用来进行组合操作。

源码
default Function<T, V> andThen(Function<? super R, ? extends V> after) {
Objects.requireNonNull(after);
return (T t) ‐> after.apply(apply(t));
}

public class Demo04Function {
    //进行两次转换
    //第一次，将字符串转整形并加10
    //第二次,将整形转字符串
    public static void getFunction(String s, Function<String,Integer> f1,Function<Integer,String> f2){
        String ss=f2.apply(f1.apply(s));
        System.out.println(ss);
    }

    public static void main(String[] args) {
        String str="12";
        getFunction(str,(s)->Integer.parseInt(s)+10,(in)->34+""+in);
    }
}
结果：3422