Java8新特性之函数式接口

Java8是 Java 语言的一个重要版本，该版本于2014年3月发布，是自Java5以来最具革命性的版本，这个版本包含语言、编译器、库、工具和JVM等方面的十多个新特性。

函数式接口

• 函数式接口主要指只包含一个抽象方法的接口，如：java.lang.Runnable、java.util.Comparator 等
• Java8提供@FunctionalInterface注解来定义函数式接口，若定义的接口不符合函数式的规范便会报错
• Java8中增加了java.util.function包，该包包含了常用的函数式接口
• 

匿名内部类实现函数式接口

public class FunctionalInterfaceTest {

    public static void main(String[] args) {

        // 匿名内部类的语法格式：父类/接口类型 引用变量名 = new 父类/接口类型(){ 方法的重写 };
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("我是既没有参数又没有返回值的方法！");
            }
        };
        runnable.run(); // 我是既没有参数又没有返回值的方法！
    }
    
    	System.out.println("----------------------------------------------------------------------");
        Consumer consumer = new Consumer() {
            @Override
            public void accept(Object o) {
                System.out.println(o + "有参但没有返回值的方法就是我！");
            }
        };
        consumer.accept("友情提示："); // 友情提示：有参但没有返回值的方法就是我！
    
    	System.out.println("----------------------------------------------------------------------");
        Supplier supplier = new Supplier() {
            @Override
            public Object get() {
                return "无参有返回值！";
            }
        };
        System.out.println(supplier.get()); // 无参有返回值
}

Lambda表达式实现函数式接口

public class FunctionalInterfaceTest {

    public static void main(String[] args) {

        // 使用lambda表达式实现函数式接口对象的创建: (参数列表)->{方法体;}
        Runnable runnable1 = () -> { System.out.println("我是既没有参数又没有返回值的方法！"); };
        runnable1.run();
        
        System.out.println("----------------------------------------------------------------------");
        //Consumer consumer1 = (Object o) -> {System.out.println(o + "有参但没有返回值的方法就是我！");};
        //Consumer consumer1 = (o) -> System.out.println(o + "有参但没有返回值的方法就是我！");
        // 省略了()、参数类型、{}  自动类型推断
        Consumer consumer1 = o -> System.out.println(o + "有参但没有返回值的方法就是我！");
        consumer1.accept("友情提示：");
        
        System.out.println("----------------------------------------------------------------------");
        //Supplier supplier1 = () -> {return "无参有返回值！";};
        Supplier supplier1 = () -> "无参有返回值！";
        System.out.println(supplier1.get());
    }
}

方法引用实现函数式接口

• 方法引用主要指通过方法的名字来指向一个方法而不需要为方法引用提供方法体，该方法的调用交给函数式接口执行

• 方法引用是在特定场景下lambda表达式的一种简化表示，可以进一步简化代码的编写使代码更加紧凑简洁，从而减少冗余代码

• 方法引用使用一对冒号 :: 将类或对象与方法名进行连接，通常使用方式如下：

  • 对象的非静态方法引用 ObjectName :: MethodName

  • 类的静态方法引用 ClassName :: StaticMethodName

  • 类的非静态方法引用 ClassName :: MethodName

    • 其中一个参数对象作为调用对象来调用方法时，可以使用上述方式

    • Comparator<Integer> comparator3 = new Comparator<Integer>() {
          @Override
          // compare两个参数
          public int compare(Integer o1, Integer o2) {
              // 其中一个参数对象作为调用对象来调用方法
              return o1.compareTo(o2);
          }
      };
      System.out.println(comparator3.compare(10, 20)); // -1
      
      // 可以使用类的非静态方法引用 ClassName :: MethodName 
      // Comparator一个参数
      Comparator<Integer> comparator5 = Integer::compareTo;
      System.out.println(comparator5.compare(10, 20)); // -1
      

  • 构造器的引用 ClassName :: new

  • 数组的引用 TypeName[] :: new

• 举例：对象的非静态方法引用

  public class Person {
      private String name;
      private int age;
  
      public Person() {
      }
  
      public Person(String name, int age) {
          this.name = name;
          this.age = age;
      }
  
      public String getName() {
          return name;
      }
  
      public void setName(String name) {
          this.name = name;
      }
  
      public int getAge() {
          return age;
      }
  
      public void setAge(int age) {
          this.age = age;
      }
  
      public void show() {
          System.out.println("没事出来秀一下哦");
      }
  
      @Override
      public String toString() {
          return "Person{" +
                  "name='" + name + '\'' +
                  ", age=" + age +
                  '}';
      }
  }
  

• 无参无返回值

  public class MethodReferenceTest {
  
      public static void main(String[] args) {
  
          // 1.使用匿名内部类的方式通过函数式接口Runnable中的方法实现对Person类中show方法的调用
          Person person = new Person("zhangfei", 30);
          Runnable runnable = new Runnable() {
              @Override
              public void run() {
                  person.show();
              }
          };
          runnable.run(); // 没事出来秀一下哦
  
          // 2.使用lambda表达式的方式实现Person类中show方法的调用
          Runnable runnable1 = () -> person.show();
          runnable1.run(); // 没事出来秀一下哦
         
          // 3.使用方法引用的方式实现Person类中show方法的调用
          // Person类中show方法和Runnable接口中run方法都是无参无返回值 结构一致 引用容易
          Runnable runnable2 = person::show;
          runnable2.run();
      }
  }
  

• 有参无返回值

  public class MethodReferenceTest {
  
      public static void main(String[] args) {
          
          // 4.使用匿名内部类的方式通过函数式接口Consumer中的方法来实现Person类中setName方法的调用
          Consumer<String> consumer = new Consumer<String>() {
              @Override
              public void accept(String s) {
                  person.setName(s);
              }
          };
          consumer.accept("guanyu");
          System.out.println("person = " + person); // guanyu 30
          
          // 5.使用lambda表达式的方式实现Person类中setName方法的调用
          Consumer<String> consumer1 = s -> person.setName(s);
          consumer1.accept("liubei");
          System.out.println("person = " + person); // liubei 30
  
          // 6.使用方法引用的方式实现Person类中setName方法的调用
          Consumer<String> consumer2 = person::setName;
          consumer2.accept("zhangfei");
          System.out.println("person = " + person); // zhangfei 30
      }
  }