lambda表达式的核心目的，lambda配合流使用，本质是什么，口语化解释，简写的方式

1、lambda表达式本质是解决匿名内部类的问题

如果你理解了这句话实际上就理解了lambda表达式，如果你不理解那么lambda表达式看得将会特别难受。实际上解决了匿名内部类的问题，代码自然而然就变得简洁了，如果你对lambda表达式理解得不深，那么lambda写出来的程序你将会觉得可读性很差，但是在作者眼中lambda表达式可读性和正常程序一样，甚至看的速度更快，更快上手。

2、说说lambda表达式最入门的应用，实现一个函数式接口，对比匿名内部类

• 匿名内部类写法

Runnable runnable=new Runnable() {
            @Override
            public void run() {
                System.out.println("匿名内部类跑起来了");
            }
        };

• lambda表达式写法

Runnable runnable1=()-> System.out.println("lambda表达式跑起来了");

• 作者写的测试程序

public class Main {


    public static void main(String[] args) {


        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("匿名内部类跑起来了");
            }
        };
        Runnable runnable1 = () -> System.out.println("lambda表达式跑起来了");
        runnable.run();
        runnable1.run();

    }

}

总结：这种程序简单易懂，一看就懂，实际上两种实现方式自己的效果是一样的。lambda表达式最经典的实现一个匿名内部类

3、lambda表达式常常配合stream一起使用，来看看更抽象的使用

• 核心代码

list.stream().filter((e)->e.getAge()>18).forEach(System.out::println);      //打印出年龄大于18的Employees

很多新手看到这个lambda表达式一瞬间就觉得晦涩难懂，不能理解，它是如何工作的，听我细细说来。

• 我们先用传统的思维，看filter方法需要传入什么参数，下面是源码，可知需要传入一个Predicate类型的匿名内部类

    Stream<T> filter(Predicate<? super T> predicate);

• 我们用传统的思维去写一个 Predicate 匿名内部类，再传入filter方法

   Predicate<Employees>  predicate=(e)->e.getAge()>18;
   list.stream().filter(predicate).forEach(System.out::println);	//实现的效果完全和上面的相等

结论：在这一句 list.stream().filter((e)->e.getAge()>18).forEach(System.out::println); 中lambda表达式 (e)->e.getAge()>18 通过反射得知要实现什么函数接口并传入方法中，所以在表达式中没有显示出类型，但是实际上系统已经替我们做了这些。

4、继续深入理解stream中的lambda表达式

程序一：

• lambda表达式

list.stream().filter((e)->e.getAge()>18).forEach(System.out::println);      //打印出年龄大于18的Employees

• filter方法

Stream<T> filter(Predicate<? super T> predicate);

程序二：

• lambda表达式

list.stream().map(e->e.getName()).forEach(System.out::println);   //通过打印出所有名字

• map方法

<R> Stream<R> map(Function<? super T, ? extends R> mapper);

结论：在程序一filter需要传入的Predicate接口实例，所以lambda表达式实现的是Predicate接口，在程序二中map需要传入的是Function接口实例，所以lambda表达式实现的是Function接口。所以在不同的方法中lambda表达式会通过反射得知需要实现什么接口并自动生成。

5、作者的源码程序：

5.1、lambda表达式常常配合stream一起使用

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;

public class Main02 {

    //声明一个静态内部类
    public static class Employees {

        //String类型的类变量name
        private String name;
        //int类型的类变量age
        private int age;
        //double类型的类变量salary
        private double salary;
        //无参数的构造方法
        public Employees() {}
        //带所有类变量的构造方法
        public Employees(String name, int age, double salary) {
            //初始化类变量
            this.name = name;
            //初始化类变量
            this.age = age;
            //初始化类变量
            this.salary = salary;
        }
        //get()/set()方法
        public String getName() {
            return name;
        }
        //get()/set()方法
        public void setName(String name) {
            this.name = name;
        }
        //get()/set()方法
        public int getAge() {
            return age;
        }
        //get()/set()方法
        public void setAge(int age) {
            this.age = age;
        }
        //get()/set()方法
        public double getSalary() {
            return salary;
        }
        //get()/set()方法
        public void setSalary(double salary) {
            this.salary = salary;
        }
        //toString()方法
        public String toString() {
            //返回所有的类变量的值。
            return "Employees [name=" + name + ", age=" + age + ",salary=" + salary + "]";
        }
    }


    public static void main(String[] args) {

        //目标list:
        //利用Employees对象创建一个List类型的集合(这里还使用了类
        //Arrays的方法asList(T...a)进行了转换)。
        //注意使用泛型
        List<Employees> list = Arrays.asList(
                new Employees("张三",18,9999.99),
                new Employees("李四",38,5555.55),
                new Employees("王五",50,6666.66),
                new Employees("赵六",16,3333.33),
                new Employees("田七",8,8888.88)
        );
        list.stream().filter((e)->e.getAge()>18).forEach(System.out::println);      //打印出年龄大于18的Employees
        System.out.println("等效于：");
        Predicate<Employees>  predicate=(e)->e.getAge()>18;
        list.stream().filter(predicate).forEach(System.out::println);
        System.out.println("==============================");
        list.stream().map(e->e.getName()).forEach(System.out::println);   //通过打印出所有名字
    }
}

6、其他

lambda表达式中的::运算符，原理是eta转换

• 双冒号运算就是Java中的[方法引用],[方法引用]的格式是 类名::方法名。一般是用作Lambda表达式
• 简单举例，上面的是lambda表达式，下面的等价的方法引用

number -> Math.abs(number);
Math::abs

person -> person.getName();
Person::getName

() -> new HashMap<>();
HashMap::new

(a, b)->Math.max(a, b);
Math::max

(a, b) -> Person.compareByAge(a, b)
Person::compareByAge

对方法引用的官方理解

• 英文格式双冒号::，读：double colon，双冒号（::）运算符在Java 8中被用作方法引用（method reference），方法引用是与lambda表达式相关的一个重要特性。它提供了一种执行方法的方法,为此，方法引用需要由兼容的函数式接口组成的目标类型上下文。

• Method References（关于方法引用的描述-来自Oracle官网）
  You use lambda expressions to create anonymous methods. Sometimes, however, a lambda expression does nothing but call an existing method. In those cases, it’s often clearer to refer to the existing method by name. Method references enable you to do this; they are compact, easy-to-read lambda expressions for methods that already have a name.

• 大概意思就是，使用lambda表达式会创建匿名函数， 但有时候需要使用一个lambda表达式只调用一个已经存在的方法（不做其它）， 所以这才有了方法引用！

如果需要打好lambda基础，深入学习，可以看看千峰的课程，大致内容如下

• 讲解视频链接
• 笔记链接
  

参考文档：

• java 双冒号是什么操作符?
• 笃学私教：如何理解并使用Java中双冒号(::)运算操作符
• 深入理解Java双冒号(::)运算符的使用