大数据之路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(){
        //1
        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));
    }