JDK8新增特性

Lambda表达式

Lambda表达式是JDK8新增的一种语法形式；作用：用于简化匿名内部类的代码写法。

格式：

被重写方法的形参列表) -> {    

  被重写方法的方法体代码。

}

注意：Lambda只能简化函数式接口的匿名内部类。

什么是函数式接口？ 

• 有且仅有一个抽象方法的接口。
• 注意：将来我们见到的大部分函数式接口，上面都可能会有一个@FunctionalInterface的注解，有该注解的接口就必定是函数式接口。

        // Swimming s1=new Swimming(){
        //   @Override
        //  public void swim() {
        //    System.out.println("学生快乐游泳");
        //}
        //};
        //s1.swim();

        Swimming s=()->{
            System.out.println("学生快乐游泳");
        };
        s.swim();

    }
}
interface Swimming{
    void swim();

Lambda表达式的省略写法（进一步简化Lambda表达式的写法）

• 参数类型可以省略不写。                                                                                                               
•  如果只有一个参数，参数类型可以省略，同时()也可以省略。 
•  如果Lambda表达式中的方法体代码只有一行代码，可以省略大括号不写，同时要省略分号！此时，如果这行代码是return语句，也必须去掉return不写。 

 方法引用 

进一步简化Lambda表达式。 

方法引用的标志性符号“::”

静态方法的引用 

• 类名::静态方法。
• 使用场景 ：如果某个Lambda表达式里只是调用一个静态方法，并且前后参数的形式一致，就可以使用静态方法引用。 

//       原始写法：对数组中的学生对象，按照年龄升序排序
//        Arrays.sort(students, new Comparator<Student>() {
//            @Override
//            public int compare(Student o1, Student o2) {
//                return o1.getAge() - o2.getAge(); // 按照年龄升序排序
//            }
//        });

        // 使用Lambda简化后的形式
           Arrays.sort(students, (o1, o2) -> o1.getAge() - o2.getAge());
           Arrays.sort(students, (o1, o2) -> CompareByData.compareByAge(o1, o2));

 //        静态方法引用
           Arrays.sort(students,  CompareByData::compareByAge);

实例方法引用 

•  对象名::实例方法。
• 使用场景 ：如果某个Lambda表达式里只是调用一个实例方法，并且前后参数的形式一致，就可以使用实例方法引用。

         CompareByData compare = new CompareByData();
        // Arrays.sort(students, (o1, o2) -> compare.compareByAgeDesc(o1, o2)); // 降序
        // 实例方法引用
        Arrays.sort(students, compare::compareByAgeDesc); // 降序

特定类型的方法引用 

• 类型::方法。
• 使用场景 : 如果某个Lambda表达式里只是调用一个实例方法，并且前面参数列表中的第一个参数是作为方法的主调，后面的所有参数都是作为该实例方法的入参的，则此时就可以使用特定类型的方法引用。 

 Arrays.sort(names, new Comparator<String>() {
         @Override
           public int compare(String o1, String o2) {
               //制定比较规则
              return o1.compareToIgnoreCase(o2);
           }
       });


       Arrays.sort(names, (o1,  o2) -> o1.compareToIgnoreCase(o2) );

        //特定方法引用！
        Arrays.sort(names, String::compareToIgnoreCase );

构造器引用 

• 类名::new。
• 使用场景 ：如果某个Lambda表达式里只是在创建对象，并且前后参数情况一致，就可以使用构造器引用。 

         CreatCar cc= new CreatCar(){
            @Override
          public Car creat(String name, double price) {
              return new Car(name,price);
            }
        };

        CreatCar cc= ( name,  price)-> new Car(name,price);

        //构造器引用
        CreatCar cc= Car::new;