Oracle 公司于 2014 年 3 月 18 日发布 Java 8，它支持函数式编程。
Java 8 新增了非常多的特性，这里主要介绍以下几个：

该章学习方法：练习一遍文中的Demo能更好的理解深意

1、Lambda 表达式

Lambda 允许把函数作为一个方法的参数（函数作为参数传递到方法中）
语法
lambda 表达式的语法格式如下：
(parameters) -> expression 或 (parameters) -> { statements;}
以下是lambda表达式的重要特征：

• 可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。
• 可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。
• 可选的大括号：如果主体包含了一个语句，就不需要使用大括号
• 可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指明表达式返回了一个数值。

1.1 表达式实例

public static void main(String args[]){
      Java8Tester tester = new Java8Tester();
        
      // 类型声明
      MathOperation addition = (int a, int b) -> a + b;
        
      // 不用类型声明
      MathOperation subtraction = (a, b) -> a - b;
        
      // 大括号中的返回语句
      MathOperation multiplication = (int a, int b) -> { return a * b; };
        
      // 没有大括号及返回语句
      MathOperation division = (int a, int b) -> a / b;
        
      System.out.println("10 + 5 = " + tester.operate(10, 5, addition));
      System.out.println("10 - 5 = " + tester.operate(10, 5, subtraction));
      System.out.println("10 x 5 = " + tester.operate(10, 5, multiplication));
      System.out.println("10 / 5 = " + tester.operate(10, 5, division));
        
      // 不用括号
      GreetingService greetService1 = message ->
      System.out.println("Hello " + message);
        
      // 用括号
      GreetingService greetService2 = (message) ->
      System.out.println("Hello " + message);
        
      greetService1.sayMessage("Runoob");
      greetService2.sayMessage("Google");
   }
    
   interface MathOperation {
      int operation(int a, int b);
   }
    
   interface GreetingService {
      void sayMessage(String message);
   }
    
   private int operate(int a, int b, MathOperation mathOperation){
      return mathOperation.operation(a, b);
   }

1.2 变量作用域

• lambda 表达式只能引用标记了 final 的外层局部变量，这就是说不能在 lambda 内部修改定义在域外的局部变量，否则会编译错误。

final static String salutation = "Hello! ";

   public static void main(String args[]){
       GreetingService greetService1 = message ->
               System.out.println(salutation + message);
       greetService1.sayMessage("Runoob");
   }

   @FunctionalInterface
   interface GreetingService {
       void sayMessage(String message);
   }

• lambda 表达式的局部变量可以不用声明为final，但是必须不可被后面的代码修改（即隐性的具有final的语义）
• 在Lambda 表达式当中不允许声明一个与局部变量同名的参数或者局部变量。

2、方法引用

方法引用提供了非常有用的语法，可以直接引用已有Java类或对象（实例）的方法或构造器。与Lambda联合使用，方法引用可以使语言的构造更紧凑简洁、减少冗余代码。
方法引用通过方法的名字来指向一个方法，方法引用使用一对冒号 ::

• 构造器引用：它的语法是Class::new，或者更一般的Class< T >::new实例如下：
  final Car car = Car.create( Car::new );
  final List< Car > cars = Arrays.asList( car );
• 静态方法引用：它的语法是Class::static_method，实例如下：
  cars.forEach( Car::collide );
• 特定类的任意对象的方法引用：它的语法是Class::method实例如下：
  cars.forEach( Car::repair );
• 特定对象的方法引用：它的语法是instance::method实例如下：
  final Car police = Car.create( Car::new );
  cars.forEach( police::follow );

3、函数式接口

3.1 函数式接口（Functional Interface)就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。
函数式接口可以被隐式转换为Lambda表达式。

public static void main(String[] args) {
        // Java 8 之前用匿名内部类实现
        GreetingService greetingService = new GreetingService() {
            @Override
            public void sayMessage(String message) {
                System.out.println("hello");
            }
        };

        // Java 8 之后可以用 Lambda 表达式实现
        GreetingService greetingService1 = str -> System.out.println("hello" + str);
    }

    @FunctionalInterface
    interface GreetingService {
        void sayMessage(String message);
    }

3.2 Predicate<T>接口是一个函数式接口，它接受一个输入参数T，返回一个布尔值结果。

public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
        Predicate<Integer> predicate = new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) {
                return false;
            }
        };

        //Predicate<Integer> predicate1 = n -> true;
        System.out.println("输出所有的数字：");
        eval(list, n -> true);

        //Predicate<Integer> predicate2 = n -> n / 2 == 0;
        System.out.println("输出所有的偶数：");
        eval(list, n -> n % 2 == 0);

        //Predicate<Integer> predicate3 = n -> n > 3;
        System.out.println("输出所有大于3的数：");
        eval(list, n -> n > 3);
    }

    public static void eval(List<Integer> list, Predicate<Integer> predicate) {
        for (Integer i : list) {
            if (predicate.test(i)) {
                System.out.print(i + " ");
            }
        }
        System.out.println();
    }

函数式接口可以对现有的函数友好地支持lambda
JDK 1.8 之前已有的函数式接口
java.lang.Runnable
java.util.concurrent.Callable
java.security.PrivilegedAction
java.util.Comparator
java.io.FileFilter
java.nio.file.PathMatcher
java.lang.reflect.InvocationHandler
java.beans.PropertyChangeListener
java.awt.event.ActionListener
javax.swing.event.ChangeListener

JDK 1.8 新增加的函数接口：
java.util.function
java.util.function 它包含了很多类，用来支持 Java的 函数式编程

4、默认方法

默认方法就是接口可以有实现方法，而且不需要实现类去实现其方法。我们只需在方法名前面加个 default 关键字即可实现默认方法。

4.1 语法

默认方法语法格式如下：

public interface Vehicle {
   default void print(){
      System.out.println("我是一辆车!");
   }
}

4.2 静态默认方法

Java 8 的另一个特性是接口可以声明（并且可以提供实现）静态方法