jdk1.8新增特性

接口的默认方法 default关键字

可以在接口中定义方法的默认实现，并且实现类也可以选择是否重新默认实现。

lambda表达式

新增了@FunctionalInterface注解，该注解添加在只有一个抽象方法的接口上，表示可以作为函数传入。如果被添加该注解的接口有多个抽象方法，则会编译不通过。

函数式编程

以前在使用像Comparator这种接口时，一般是使用匿名内部类来实现，还有就是实现Runable接口等。

1.8之前：

 ArrayList students = new ArrayList<>(10);
        students.sort(new Comparator() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.getName().compareTo(o2.getName());
            }
        });

lambda:

        ArrayList students = new ArrayList<>(10);
        students.sort((Student o1,Student o2) -> o1.getName().compareTo(o2.getName()));

lambda简化：省去参数类型等定义

 ArrayList students = new ArrayList<>(10);
        students.sort((o1,o2) -> o1.getName().compareTo(o2.getName()));

使用Comparator的静态方法，传入比较的key的方法函数

ArrayList students = new ArrayList<>(10);
        students.sort(Comparator.comparing(Student::getName));

引入lambda表达式后，可以使这种实现更为简单。

lambda表达式内可以对静态变量和对象变量进行读写，对局部变量只能够读，并且被表达式内读的局部变量在之后不能被改变（类似于final）。

双冒号::的使用

可以使用双冒号来访问类的构造函数，静态函数和对象函数.

1. 构造函数：

定义Person类

public class Person {
Person(String nikename,String username){
        this.nikename=nikename;
        this.username=username;
    }
    private String nikename;
    private String username;
}

定义PersonFactory接口

@FunctionalInterface
public interface PersonFactory
 {
    P creat(String nikename,String username);
}

访问构造函数

 PersonFactory personFactory = Person::new;
 Person person = personFactory.creat("羊肉小笼包", "大哥你好");

在上面的代码中，Person::new相当于create(String,String)方法的实现，而这个实现就是Person类的构造函数，相当于使用构造函数实现接口的唯一抽象方法。

2. 静态方法

   Person类中有一个静态方法run

   public class Person {
    public static String run(){
           return "Im running!";
       }
   }
   

   定义Action接口，内有一个抽象方法doThing

   @FunctionalInterface
   public interface Action{
       T doThing();
   }
   

   测试

   Action run = Person::run;
           System.out.println(run.doThing());
   // 打印出"Im running!"
   

3. 实例方法

   Person类中有一个实例方法eat

   public class Person {
   public String eat(String food){
           return food + " is delicious!";
       }
       }
   

   定义接口LifeAction

   @FunctionalInterface
   public interface LifeAction {
       T requiredAction(P something);
   }
   

   测试

   Person person = new Person();
   LifeAction eat = person::eat;
   System.out.println(eat.requiredAction("noodle"));
   // 打印noodle is delicious!
   

新增函数式接口

Predicate接口

   @FunctionalInterface
   public interface Predicate {
       boolean test(T t);
       default Predicate and(Predicate other);
    default Predicate negate();
       default Predicate or(Predicate other);
       static  Predicate isEqual(Object targetRef);
   }

demo

     private static boolean check(Integer num){
           // 使用静态方法根据一个参数初始化
           Predicate