我们知道，对于一个Java变量，我们可以赋给其一个“值”。 如果你想把“一块代码”赋给一个Java变量，应该怎么做呢？
比如，我想把右边那块代码，赋给一个叫做aBlockOfCode的Java变量： 在Java 8之前，这个是做不到的。但是Java 8问世之后，利用Lambda特性，就可以做到了。 当然，这个并不是一个很简洁的写法。所以，为了使这个赋值操作更加elegant, 我们可以移除一些没用的声明。 这样，我们就成功的非常优雅的把“一块代码”赋给了一个变量。而“这块代码”，或者说“这个被赋给一个变量的函数”，就是一个Lambda表达式。
但是这里仍然有一个问题，就是变量aBlockOfCode的类型应该是什么？
在Java 8里面，所有的Lambda的类型都是一个接口，而Lambda表达式本身，也就是”那段代码“，需要是这个接口的实现。这是我认为理解Lambda的一个关键所在，简而言之就是，Lambda表达式本身就是一个接口的实现。直接这样说可能还是有点让人困扰，我们继续看看例子。我们给上面的aBlockOfCode加上一个类型： 这种只有一个接口函数需要被实现的接口类型，我们叫它”函数式接口“。为了避免后来的人在这个接口中增加接口函数导致其有多个接口函数需要被实现，变成"非函数接口”，我们可以在这个上面加上一个声明@FunctionalInterface, 这样别人就无法在里面添加新的接口函数了： 这样，我们就得到了一个完整的Lambda表达式声明：
最直观的作用就是使得代码变得异常简洁。
我们可以对比一下Lambda表达式和传统的Java对同一个接口的实现： 这两种写法本质上是等价的。但是显然，Java 8中的写法更加优雅简洁。并且，由于Lambda可以直接赋值给一个变量，我们就可以直接把Lambda作为参数传给函数, 而传统的Java必须有明确的接口实现的定义，初始化才行： 有些情况下，这个接口实现只需要用到一次。传统的Java 7必须要求你定义一个“污染环境”的接口实现MyInterfaceImpl，而相较之下Java 8的Lambda, 就显得干净很多。
直接上例子。
假设Person的定义和List的值都给定。 现在需要你打印出guiltyPersons List里面所有LastName以"Z"开头的人的FirstName。
原生态Lambda写法：定义两个函数式接口，定义一个静态函数，调用静态函数并给参数赋值Lambda表达式。 这个代码实际上已经比较简洁了，但是我们还可以更简洁么？当然可以。在Java 8中有一个函数式接口的包，里面定义了大量可能用到的函数式接口（java.util.function (Java Platform SE 8 )）。所以，我们在这里压根都不需要定义NameChecker和Executor这两个函数式接口，直接用Java 8函数式接口包里的Predicate和Consumer就可以了——因为他们这一对的接口定义和NameChecker/Executor其实是一样的。
第一步简化 - 利用函数式接口包：
静态函数里面的for each循环其实是非常碍眼的。这里可以利用Iterable自带的forEach()来替代。forEach()本身可以接受一个Consumer 参数。
第二步简化 - 用Iterable.forEach()取代foreach loop：
由于静态函数其实只是对List进行了一通操作，这里我们可以甩掉静态函数，直接使用stream()特性来完成。stream()的几个方法都是接受Predicate，Consumer等参数的（java.util.stream (Java Platform SE 8 )）。你理解了上面的内容，stream()这里就非常好理解了，并不需要多做解释。
第三步简化 - 利用stream()替代静态函数： 对比最开始的Lambda写法，这里已经非常非常简洁了。但是如果，我们的要求变一下，变成print这个人的全部信息，及p -> System.out.println§; 那么还可以利用Method reference来继续简化。所谓Method reference, 就是用已经写好的别的Object/Class的method来代替Lambda expression。格式如下：
第四步简化 - 如果是println§，则可以利用Method reference代替forEach中的Lambda表达式： 这基本上就是能写的最简洁的版本了。
这里假设我们有一个person object，以及一个person object的Optional wrapper: Optional如果不结合Lambda使用的话，并不能使原来繁琐的null check变的简单。 只有当Optional结合Lambda一起使用的时候，才能发挥出其真正的威力！
我们现在就来对比一下下面四种常见的null处理中，Java 8的Lambda+Optional和传统Java两者之间对于null的处理差异。
情况一 - 存在则开干 情况二 - 存在则返回，无则返回UNKNOWN_PERSON 情况三 - 存在则返回，无则由函数产生 情况四 - 夺命连环null检查 由上述四种情况可以清楚地看到，Optional+Lambda可以让我们少写很多ifElse块。尤其是对于情况四那种夺命连环null检查，传统java的写法显得冗长难懂，而新的Optional+Lambda则清新脱俗，清楚简洁。
代码部分： Test01:
/** * 1.Lambda表达式 ----- Java万事万物皆对象 ？？？ 语法糖 真香 */ public interface TestInterface { void testMethod(); } class MyClass implements TestInterface{ @Override public void testMethod() { System.out.println("我重新实现了testMethod方法。耶！"); } } class Demo{ //这是main方法，程序的入口 public static void main(String[] args) { //创建接口对应的实现类的对象： /*TestInterface t = new MyClass(); t.testMethod();*/ /*TestInterface t = new TestInterface() { @Override public void testMethod() { System.out.println("我重写了testMethod方法，匿名内部类中的实现"); } }; t.testMethod();*/ TestInterface t = () -> System.out.println("这个是Lambda表达式的实现方式"); t.testMethod(); /* 总结： 1.Lambda表达式是一个新的语法结构 2.语法层面简洁了 3.先睹为快 -》Lambda表达式的本质就是：接口的实现类的具体的对象 4.应用场合：复用性没有那么强的时候 5.语法： -> 箭头操作符 Lambda操作符 ->左侧： Lambda的形参列表 ---等效于 对应的接口的那个抽象方法的 形参列表 ->右侧： 其实就是抽象方法的方法体 */ } }Test02:
/** * 语法结构1：无参，无返回值 */ public interface TestInterface { void testMethod(); } class Test01{ //这是main方法，程序的入口 public static void main(String[] args) { /*TestInterface t = () -> { System.out.println("这是一个无参的，无返回值的方法"); };*/ TestInterface t = () -> System.out.println("这是一个无参的，无返回值的方法"); t.testMethod(); /* 注意1：如果方法体中只有一句话的时候，{}可以省略不写 */ } } /** * 语法结构02：有一个参数，无返回值： */ public interface TestInterface02 { void testMethod(int num); } class Demo01{ //这是main方法，程序的入口 public static void main(String[] args) { /*TestInterface02 t = (x) -> System.out.println("这个方法的参数为：" + x);*/ TestInterface02 t = x -> System.out.println("这个方法的参数为：" + x); t.testMethod(10); /* 注意： 1.参数名字随便起 2.参数的类型可以省略 - 》上下文有类型推断 3.参数只有一个的话，()可以省略 */ } } /** * 语法结构3：两个或者两个以上的参数，有返回值 */ @FunctionalInterface public interface TestInterface03 { int testMethod(int num1,int num2); } class Demo03{ //这是main方法，程序的入口 public static void main(String[] args) { /*TestInterface03 t = (x, y) -> { System.out.println("两个或者两个以上的参数，有返回值" + x + "---" + y); return 666; };*/ TestInterface03 t = (x,y) -> 666; System.out.println(t.testMethod(10, 20)); /* 1.多个参数的话，()不可以省略 2.方法体中有多个逻辑的话，{}也不可以省略 3.如果方法体中只有一句话，并且这句话是返回值那句的话，{}可以省略，return关键字也可以省略的 总结：能省则省 Lambda表达式使用的那个接口 ，有个特点：里面只有一个抽象方法 ----》函数式接口 通过注解：@FunctionalInterface 来限定函数式接口 */ } } /** * * 内置四个基础函数式接口 * 1.消费型接口： * Consumer<T> - void accept(T t) * 2.供给型接口： * Supplier<T> - T get() * 3.函数型结构： * Function<T,R> - R apply(T t) * 4.断言型接口 断定型接口 * Predicate<T> - boolean test(T t) */ public class Test { public static void bath(double money, Consumer<Double> sm){ sm.accept(money); } //这是main方法，程序的入口 public static void main(String[] args) { /*bath(2990, new Consumer<Double>() { public void accept(Double money) { System.out.println("我去洗澡了，来了个波西米亚套餐,花了" + money + "元"); } });*/ bath(2990,x -> System.out.println("我去洗澡了，来了个波西米亚套餐,花了" + x + "元")); } } //消费： /*interface SpendMoney{ void buy(double money); }*/ /** * 方法引用：恶心 * * 三种使用情况： * 1. 对象::实例方法名 （非静态方法） * 2. 类::静态方法名 * 3. 类::实例方法名 * */ public class Demo { //这是main方法，程序的入口 public static void main(String[] args) { //1.对象::实例方法名 //消费型接口： /*Consumer<String> con = x -> System.out.println("明哥又去" + x +"洗澡了"); con.accept("长沙");*/ /* Consumer : 方法 ： void accept(T t); 方法体中用的方法： void println(String x) 如果你满足上面的要求：前面的函数式接口的 参数 和 返回值 和 具体的方法体实现中的 方法的 参数和返回值 如果 一致 那么可以使用 方法引用 */ /* PrintStream ps = System.out; Consumer<String> con2 = ps::println; con2.accept("明哥洗澡去了。。。。。。");*/ //2.类::静态方法名 /*Comparator<Integer> com = (x,y) -> Integer.compare(x,y); System.out.println(com.compare(12, 80));*/ /* int compare(T o1, T o2); int compare(int x, int y) */ /* Comparator<Integer> com2 = Integer::compare; System.out.println(com2.compare(12, 80));*/ ///3. 类::实例方法名 //使用这个方法引用的前提：x作为方法的调用者，y作为方法的实际参数 BiPredicate<String,String> bp = (x,y) -> x.equals(y); System.out.println(bp.test("abc", "abc")); BiPredicate<String,String> bp2 = String::equals; System.out.println(bp2.test("def", "def")); } }nj.zb.kb09.inter.OperationInterface
package nj.zb.kb09.inter; /** * @Author: ChaoKeAiMuZhi * @Date: 2020/10/20 8:47 * @Description:定义一个接口，输入参数是两个Integer类型，返回值是Integer类型 **/ @FunctionalInterface public interface OperationInterface { public Integer operation(Integer a,Integer b); }nj.zb.kb09.inter.OperationInterfaceImpl
package nj.zb.kb09.inter; /** * @Author: ChaoKeAiMuZhi * @Date: 2020/10/20 8:49 * @Description:OperationInterface接口的实现类 **/ public class OperationInterfaceImpl implements OperationInterface { @Override public Integer operation(Integer a, Integer b) { return a+b; } }nj.zb.kb09.inter.TestDemo
package nj.zb.kb09.inter; /** * @Author: ChaoKeAiMuZhi * @Date: 2020/10/20 8:50 * @Description: **/ public class TestDemo { public static void main(String[] args) { /* OperationInterfaceImpl operationInterface = new OperationInterfaceImpl(); Integer sum = operationInterface.operation(10, 10); System.out.println(sum);*/ OperationInterface add=(Integer a,Integer b) -> a+b; OperationInterface jian=(Integer a,Integer b) -> a-b; OperationInterface ji=(Integer a,Integer b) -> a*b; OperationInterface chu=(Integer a,Integer b) -> a/b; /* Integer sum2 = add.operation(10, 20); System.out.println(sum2); */ TestDemo demo = new TestDemo(); Integer result = demo.getResult(20, 10, ji); System.out.println(result); } public Integer getResult(Integer a,Integer b,OperationInterface operationInterface){ return operationInterface.operation(a,b); } }