java8新特性Lambda表达式

什么是Lambda表达式：

Lambda是java8引入的新特性，相当于一个语法糖
语法糖是编程中的一个概念，指的是一种在语法上更简洁，更易读，更易书写，但实际上并没有引入新的功能或特性的语法结构。
**使用条件：**只要是函数式接口就可以用Lambda表达式简化
函数式接口：接口中有且只有一个未实现的方法。
可以用jdk中的检查注解_@Functionallnterface__来检查该接口是否为函数式接口_
正常用法

错误用法

为什么要使用Lambda表达式：

举例：
有一个接口Animal,里面有一个方法eat()

interface Animal{
    void eat();
}

实现这个接口，使用两种方法

1. 传统方法

类实现

class Dog implements Animal{
    @Override
    public void eat(){
        System.out.println("小狗吃饭");
    }
}

调用

public class A{
    public static void main(String[] args){
        Animal animal = new Dog();
        animal.eat();
    }
}

2. 创建匿名实现类

如果每个接口都要写实现类的，会有些麻烦，并且实现的方法不固定，实现繁琐，采用匿名实现类，动态实现接口

public class A {
    public static void main(String[] args) {
       Animal animal = new Animal(){
           @Override
           public void eat(){
               System.out.println("猫吃饭");
           }
       };
       animal.eat();
    }
}

发现问题

可以发现每次创建匿名实现类时，格式上有很多是冗余的，Lambda表达式只保留动态的东西，把死的部分去掉。
使用Lambda表达式方式实现接口：

public class A {
    public static void main(String[] args) {
       Animal animal = () ->{
               System.out.println("猫吃饭");
       };
       animal.eat();
    }
}

怎么使用Lambda表达式：

使用举例：
（o1,o2） ->Interger.compare(o1,o1);
格式举例：
-> :lambda箭头操作符
-> 的左边 : 重写的接口中的抽象方法的形参列表。
-> 的右边 : 接口的实现类要重写的方法的方法体。
总结：
->的左边：

• 参数类型可以不写，只写参数名，参数变量名随意定义
• 参数部分最少可以只有一个（），但不能不写括号，或者在只有一个参数的时候，只有一个参数名，括号可以省略

->的右边:

• 方法体只有一句话时，{}和return可以省略。

实例 ：

1. 无参，无返回值

@Test
    public void test1(){
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("我爱北京天安门");
            }
        };
        r1.run();
        //使用lambda表达式
        Runnable r2 = () ->{
            System.out.println("我爱北京故宫");
        };
        r2.run();
    }

2. 一个参数，没有返回值

@Test
    public void test2(){
        Consumer<String> con = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        con.accept("谎言和誓言的区别是什么");

        //使用lambda表达式
        Consumer<String> con1 = s -> System.out.println(s);
        con1.accept("一个是听的人当真了，一个是说的人当真了");
    }

3. 两个及以上参数，有返回值

@Test
    public void test3() {
        Comparator<Integer> comparator = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1.compareTo(o2);
            }
        };
        int compare = comparator.compare(12, 21);
        System.out.println(compare);
        //使用lambda表达式
        Comparator<Integer> comparator1 = (o1,o2) -> Integer.compare(o1,o2);
        int compare1 = comparator1.compare(23, 21);
        System.out.println(compare1);
    }

over!😃