大数据之路week06--day03（jdk8新特性 Lambda表达式）

为什么使用Lambda表达式？（做为初学者接触这个新的语法，会很懵逼，说道理，我在接触到这一块的时候，语法规则我看到了也很懵逼，因为这个和逻辑的关系不是很大，但就是作为一种新的语法出现，一时间很难接受。所以，只要我们多加练习，熟悉了就会接受了，记住，要多加练习！！就像你和一个刚刚学习Java的人来说，你和他说100遍地Hello world 的格式，他也不会写，这个需要自己去敲。）

Lambda是一个匿名函数，我们可以把Lambda表达式理解为是一段可以传递的代码（将代码像数据一样传递）。使用它可以写出更简介、更灵活的代码。作为一种更为紧凑的代码风格，使Java的语言表达能力得到了提升。

Lambda表达式：在Java8语言中引入的一种新的语法元素和操作符。这个操作符为 “->” ,该操作符被称为Lambda操作符或箭头操作符。它将Lambda分为两个部分：

　　左侧：指定了Lambda表达式需要的参数列表。

　　右侧：指定了Lambda体，是抽象方法的实现逻辑，也即Lambda表达式要执行的功能。

Lambda表达式的本质：接口的具体实现类的实现对象。

那么接下来介绍Lambda表达式的六种语法格式：

在介绍学习之前，先看一些例子，感受一下Lambda表达式。还是，要多加练习，慢慢地我们就会习惯。

在学习Lambda表达式之前，我们学过Compared

 Comparator<Integer> com1 = new Comparator<Integer>() {

             @Override
             public int compare(Integer o1, Integer o2) {
                 return Integer.compare(o1, o2);
             }
         };

         int compar1 = com1.compare(12, 21);
         System.out.println(compar1);

再将它改为Lambda表达式写法：

Comparator<Integer> com2 =(o1,o2) ->Integer.compare(o1, o2);

2 int compar2 = com2.compare(41, 21);

3 System.out.println("lambda表达式写法:"+compar2);

我们会发现很神奇，本来一大段地代码，Lambda表达式一行搞定。

1、语法格式一：无参，无返回值。

 // lambda格式一 无参无返回值的
     @Test
     public void test1() {
         Runnable r = new Runnable() {
             @Override
             public void run() {
                 System.out.println("改之前:  这是lambda格式一修改之前无参无返回值的输出结果");
             }
         };

         r.run();

         System.out.println("**************************");

         Runnable r1 = () -> {
             System.out.println("改之后:  这是lambda格式一修改之后无参无返回值的输出结果");
         };

         r1.run();
     }

2、语法格式二：Lambda表达式需要一个参数，但是没有返回值。

 // lambda格式一 带参无返回值的
     @Test
     public void test2() {
         Consumer<String> c = new Consumer<String>() {
             @Override
             public void accept(String s) {
                 System.out.println(s);
             }
         };
         c.accept("改之前:  这是lambda格式二修改之前带参无返回值的输出结果");

         System.out.println("************************");

         Consumer<String> c1 = (String s2) -> {
             System.out.println(s2);
         };
         c1.accept("改之后:  这是lambda格式二修改之后带参无返回值的输出结果");
     }

3、语法格式三：数据类型可以省略，因为可由编译器推断得出，称为“类型推断”。

 // lambda格式三 类型推断
     @Test
     public void test3() {
         Consumer<String> c1 = (s2) -> {
             System.out.println(s2);
         };
         c1.accept("改之后:  这是lambda格式三对格式二优化类型推断之后带参无返回值的输出结果");
     }

     //类型推断举例理解
     @Test
     public void test4(){
         List<String> list = new ArrayList<>();//类型自动推断
         int[] arr = {1,2,3};//类型自动推断
     }

4、若Lambda表达式只需要一个参数的时候，参数的小括号可以省略。

 //格式四 当lambda只需要一个参数的时候，参数小括号可以省略
     @Test
     public void test5(){
         //
         Consumer<Integer> con = new Consumer<Integer>() {
             @Override
             public void accept(Integer i) {
                 System.out.println("格式四修改之前:"+(i+4));
             }
         };
         con.accept(5);

         System.out.println("**************");
         Consumer<Integer> con1 = i -> {
             System.out.println("格式四修改之后:"+(i+4));
         };
         con1.accept(6);

     }

5、语法格式五：Lambda表达式需要两个或者两个以上的时候，多条执行语句，并且可以有返回值。（小括号不能省略）

 //格式五  lambda需要2个或者2个以上的参数 多条执行语句，并且可以有返回值
     @Test
     public void test6(){
         Comparator<Integer> com = new Comparator<Integer>() {
             @Override
             public int compare(Integer o1, Integer o2) {
                 System.out.println(o1);
                 System.out.println(o2);
                 return o1.compareTo(o2);
             }
         };
         System.out.println(com.compare(12, 21));

         System.out.println("*********************");
         Comparator<Integer> com1 = (o1,o2) ->{
             System.out.println(o1);
             System.out.println(o2);
             return o1.compareTo(o2);
         };
         System.out.println(com1.compare(12, 6));
     }

6、语法格式六：当Lambda体只有一条语句的时候，return与大括号若有，都可以省略。

 //格式六  对于lambda体而言，lambda体只有一条语句，return和大括号都可省略
     @Test
     public void test7(){
         Comparator<Integer> com1 = (o1,o2) ->{
             return o1.compareTo(o2);
         };
         System.out.println(com1.compare(6, 6));    

         System.out.println("****************");
         Comparator<Integer> com2 = (o1,o2) -> o1.compareTo(o2);
         System.out.println(com2.compare(12, 6));
     }

什么是函数式（Function）接口？

只包含一个抽象方法的接口，称之为函数式接口。

你可以通过Lambda表达式来创建该接口的对象，（若Lambda表达式抛出一个受检异常（即：非运行时异常），那么该异常需要在目标接口的抽象方法上进行声明。） @FunctionlInterface 注解

Java内置的四大核心函数式接口：

1、Consumer

 @Test
     public void test1(){
         happyTime(500.0, new Consumer<Double>() {

             @Override
             public void accept(Double doubled) {
                 System.out.println("今天去了一趟天上人间，消费"+doubled);
             }
         });

         System.out.println("**************");
         happyTime(400.0, money -> System.out.println("今天去了一趟天上人间，消费"+money));
     }

     public void happyTime(Double money,Consumer<Double> con){
         con.accept(money);
     }

2、Supplier

 @Test
     public void test6(){
         Student s1 = new Student();
         Function<Student, String> fun = s -> s.getName();
         System.out.println(fun.apply(s1));

     }

 //学生类

 package com.wyh.方法引用;

 /**

  * 创建时间：2019年12月11日 下午5:22:16

  * 项目名称：practise13_JAVA8新特性

  * @author WYH

  * @version 1.0

  * @since JDK 1.8.0

  * 文件名称：Student.java

  * 类说明：

  */

 public class Student {
     private String name = "王友虎";
     private int age = 22;
     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;
     }

 }

3、Function

 @Test
     public void test4(){//

         //Math类中有个静态方法round() 四舍五入，取整数部分
         Function<Double,Long> fun = d -> Math.round(d);
         System.out.println(fun.apply(500.25));
     }

4、Predicate

 @Test
     public void test7(){
         Predicate<String> pre = s -> s.equals("abc");
         System.out.println(pre.test("abc"));
     }

方法引用

当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用！

方法引用可以看作是Lambda表达式深层次的表达。换句话说，方法引用就是Lambda表达式，也就是函数式接口的一个实例，通过方法的名字来指向一个方法，可以认为是Lambda表达式的一个语法糖。

要求：实现接口的抽象方法的参数列表和返回值类型相同，必须与方法引用的方法参数列表和返回值类型保持一致。（针对于接下来说的情况1和情况2）

格式：使用操作符 “::”将类（或对象）与方法名分割开来

具体分为如下的三种情况：

　　情况1  对象::非静态方法

　　情况2  类::静态方法

　　情况3  类::非静态方法（较为难理解）

情况1：

 @Test
     public void test1(){
         Consumer<String> con = s -> System.out.println(s);
         con.accept("北京欢迎你");

         System.out.println("方法引用方式一    对象::非静态方法****************");

         PrintStream pin = System.out;
         Consumer<String> con1 = pin::println;
         con1.accept("这个是方法引用。。");
     }

     @Test
     public void test2(){
         Object obj = new Object();
         Supplier<Class> sup = () -> obj.getClass();
         System.out.println(sup.get());

         System.out.println("方法引用方式一    对象::非静态方法***********");

         Supplier<Class> sup2 = obj::getClass;
         System.out.println(sup2.get());

     }

情况2：

 @Test
     public void test3(){
         Comparator<Integer> com = (t1,t2) -> Integer.compare(t1,t2);
         System.out.println(com.compare(12, 21));

         System.out.println("方法引用方式二    类::静态方法**************");
         Comparator<Integer> com1 = Integer::compare;
         System.out.println(com1.compare(21, 21));
     }

     @Test
     public void test4(){//

         //Math类中有个静态方法round() 四舍五入，取整数部分
         Function<Double,Long> fun = d -> Math.round(d);
         System.out.println(fun.apply(500.25));

         System.out.println("方法引用方式二    类::静态方法**************************");
         Function<Double,Long> fun1 = Math::round;
         System.out.println(fun1.apply(500.65));
     }

情况3：

 @Test
     public void test5(){
         Comparator<String> com = (t1,t2) -> t1.compareTo(t2);
         System.out.println(com.compare("abc", "cbd"));

         System.out.println("方法引用方式三   类::非静态方法********************");
         //如果一个方法有两个参数，调用方法的时候，其中有一个参数去调方法的时候，我们可以将这个参数看作为一个类，然后观察这个参数的数据类型，改变成方法引用如下
         Comparator<String> com1 = String::compareTo;
         System.out.println(com1.compare("abc", "cbd"));
     }

     @Test
     public void test6(){
         Student s1 = new Student();
         Function<Student, String> fun = s -> s.getName();
         System.out.println(fun.apply(s1));

         Function<Student, String> fun1 = Student::getName;
         System.out.println(fun1.apply(s1));
     }