前言：
本人也是学习lambda不久，可能有些地方描写叙述有误，还请大家谅解及指正！
lambda表达式具体解释
一.问题
1.什么是lambda表达式？
2.lambda表达式用来干什么的？
3.lambda表达式的优缺点？
4.lambda表达式的使用场景？
5.lambda仅仅是一个语法糖吗？
二.概念
lambda表达式是JAVA8中提供的一种新的特性。它支持JAVA也能进行简单的“函数式编程”。
它是一个匿名函数，Lambda表达式基于数学中的λ演算得名。直接相应于当中的lambda抽象(lambda abstraction)，是一个匿名函数，即没有函数名的函数。
三.先看看效果
先看几个样例：
1.使用lambda表达式实现Runnable
package com.lambda;
/**
* 使用lambda表达式替换Runnable匿名内部类
* @author MingChenchen
*
*/
public class RunableTest {
/**
* 普通的Runnable
*/
public static void runSomeThing(){
Runnable runnable = new Runnable() {
@Override
public void run() {
System.out.println("I am running");
}
};
new Thread(runnable).start();
}
/**
* 使用lambda后的
*/
public static void runSomeThingByLambda(){
new Thread(() -> System.out.println("I am running")).start();
}
public static void main(String[] args) {
runSomeThing();
// runSomeThingByLambda();
}
}
上述代码中：
() -> System.out.println("I am running")就是一个lambda表达式，
能够看出，它是替代了new Runnable(){}这个匿名内部类。
2.使用lambda表达式实现Comparator
package com.lambda;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class SortList {
//给入一个List
private static List<String> list =
Arrays.asList("my","name","is","uber","and","uc");
/**
* 对一个String的list进行排序 - 使用老方法
*/
public static void oldSort(){
//排序
Collections.sort(list,new Comparator<String>() {
//使用新的排序规则 依据第二个字符进行逆序排
@Override
public int compare(String a,String b){
if (a.charAt(1) <= b.charAt(1)) {
return 1;
}else{
return -1;
}
}
});
}
/**
* 新的排序方法 - 使用lambda表达式实现
*/
public static void newSort(){
//lambda会自己主动判断出 a,b 的类型
Collections.sort(list, (a, b) -> a.charAt(1) < b.charAt(1) ? 1:-1);
}
public static void main(String[] args) {
// oldSort();
newSort();
}
}
3.使用lambda表达式实现ActionListener
package com.lambda;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
public class ActionEventDemo {
private JButton button = new JButton();
public void bindEvent(){
button.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
System.out.println("你好！
" );
}
});
}
/**
* 使用Lambda表达式 为button加入ActionListener
*/
public void bindEventByLambda(){
button.addActionListener(e -> System.out.println("你好！"));
}
}
四.来由
好了，通过上述的几个样例，大家几乎相同也能明确了lambda是用来干什么以及优点了。
显而易见的。优点就是代码量大大降低了！
程序逻辑也非常清晰明了。
它的用处浅显来说就是替代“内部匿名类”、能够对集合或者数组进行循环操作。
曾经：
面向对象式编程就应该纯粹的面向对象，于是经常看到这样的写法：
假设你想写一个方法，那么就必须把它放到一个类里面。然后new出来对象，对象调用这种方法。
匿名类型最大的问题就在于其冗余的语法。
有人戏称匿名类型导致了“高度问题”（height problem）：
比方大多匿名内部类的多行代码中仅有一行在做实际工作。
因此JAVA8中就提供了这样的“函数式编程”的方法 —— lambda表达式，供我们来更加简明扼要的实现内部匿名类的功能。
五.什么时候能够使用它？
先说一个名词的概念
函数式接口：Functional Interface.
定义的一个接口，接口里面必须 有且仅仅有一个抽象方法 ，这样的接口就成为函数式接口。
在能够使用lambda表达式的地方。方法声明时必须包括一个函数式的接口。
（JAVA8的接口能够有多个default方法）
不论什么函数式接口都能够使用lambda表达式替换。
比如：ActionListener、Comparator、Runnable
lambda表达式仅仅能出如今目标类型为函数式接口的上下文中。
注意：
此处是仅仅能！
！！
意味着假设我们提供的这个接口包括一个以上的Abstract Method，那么使用lambda表达式则会报错。
这点已经验证过了。
场景：
这样的场景事实上非经常见：
你在某处就真的仅仅须要一个能做一件事情的函数而已，连它叫什么名字都无关紧要。
Lambda 表达式就能够用来做这件事。
六.写法、规则
基本的语法:
(parameters) -> expression 或 (parameters) ->{ statements; }
即: 參数 -> 带返回值的表达式/无返回值的陈述
//1. 接收2个int型整数,返回他们的和
(int x, int y) -> x + y;
//2. 接受一个 string 对象,并在控制台打印,不返回不论什么值(看起来像是返回void)
(String s) -> System.out.print(s);七.几个特性
1. 类型推导
编译器负责推导lambda表达式的类型。它利用lambda表达式所在上下文所期待的类型进行推导，
这个被期待的类型被称为目标类型。就是说我们传入的參数能够无需写类型了！
2.变量捕获
在Java SE 7中。编译器对内部类中引用的外部变量（即捕获的变量）要求非常严格：
假设捕获的变量没有被声明为final就会产生一个编译错误。
我们如今放宽了这个限制——对于lambda表达式和内部类，
我们同意在当中捕获那些符合有效仅仅读（Effectively final）的局部变量。
简单的说，假设一个局部变量在初始化后从未被改动过，那么它就符合有效仅仅读的要求，
换句话说。加上final后也不会导致编译错误的局部变量就是有效仅仅读变量。
注意：此处和final关键字一样，指的是引用不可改！（感觉没多大意义，还不是用的final）
3.方法引用
假设我们想要调用的方法拥有一个名字，我们就能够通过它的名字直接调用它。
Comparator byName = Comparator.comparing(Person::getName);
此处无需再传入參数。lambda会自己主动装配成Person类型进来然后运行getName()方法。而后返回getName()的String
方法引用有非常多种，它们的语法例如以下：
静态方法引用：ClassName::methodName
实例上的实例方法引用：instanceReference::methodName
超类上的实例方法引用：super::methodName
类型上的实例方法引用：ClassName::methodName
构造方法引用：Class::new
数组构造方法引用：TypeName[]::new
4.JAVA提供给我们的SAM接口
Java SE 8中添加了一个新的包：java.util.function，它里面包括了经常使用的函数式接口，比如：
Predicate<T>——接收T对象并返回boolean
Consumer<T>——接收T对象。不返回值
Function<T, R>——接收T对象。返回R对象
Supplier<T>——提供T对象（比如工厂），不接收值
UnaryOperator<T>——接收T对象，返回T对象
BinaryOperator<T>——接收两个T对象，返回T对象那么在參数为这些接口的地方，我们就能够直接使用lambda表达式了！
八.很多其它的样例
1.自己定义SAM接口。从而使用lambda表达式
package com.lambda.myaction;
/**
* 自己定义一个函数式接口
* @author MingChenchen
*
*/
public interface MyActionInterface {
public void saySomeThing(String str);
/**
* Java8引入的新特性 接口中能够定义一个default方法的实现 (不是abstract)
*/
default void say(){
System.out.println("default say");
}
}
package com.lambda.myaction;
/**
* 在我们自己定义的函数式接口的地方使用lambda表达式
* @author MingChenchen
*
*/
public class WantSay {
/**
* 运行接口中的saySomeThing方法
* @param action
* @param thing
*/
public static void excuteSay(MyActionInterface action,String thing){
action.saySomeThing(thing);
}
public static void main(String[] args) {
/*
excuteSay(new MyActionInterface(){
@Override
public void saySomeThing(String str) {
System.out.println(str);
}
},"Hello World");
*/
excuteSay((String s) -> System.out.println(s),"Hello world new");
}
}
2.用法引用( ClassName::Method,无括号)
package com.lambda.usebean;
/**
* 实体类Person
* @author MingChenchen
*
*/
public class Person {
private String name; //姓名
private String location; //地址
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getLocation() {
return location;
}
public void setLocation(String location) {
this.location = location;
}
@Override
public String toString() {
// TODO Auto-generated method stub
return "Person:" + name + "," + location;
}
}
//使用String默认的排序规则，比較的是Person的name字段
Comparator<Person> byName = Comparator.comparing(p -> p.getName());
//不用写传入參数,传入的用Person来声明
Comparator<Person> byName2 = Comparator.comparing(Person::getName);3.使用lambda表达式完毕for-each循环操作
//原本的for-each循环写做法
List list = Arrays.asList(....);
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
//使用lambda表达式后的写法
list.forEach(str -> System.out.println(str));list.forEach()是JAVA8的新方法。支持函数式编程，此处使用的參数就是JAVA提供给我们的函数式接口：Consumer< T>
interface List<E> extends Collection<E>
interface Collection<E> extends Iterable<E>
public interface Iterable<T> {
default void forEach(Consumer<? super T> action) {
Objects.requireNonNull(action);
for (T t : this) {
action.accept(t);
}
}
}4.一个完整的样例
//普通写法：
List<Person> people = ...
Collections.sort(people, new Comparator<Person>() {
public int compare(Person x, Person y) {
return x.getLastName().compareTo(y.getLastName());
}
})
//使用lambda表达式写法：
people.sort(comparing(Person::getLastName));化简流程：
第一步：去掉冗余的匿名类
Collections.sort(people,(Person x, Person y) -> x.getLastName().compareTo(y.getLastName()));
第二步：使用Comparator里的comparing方法
Collections.sort(people, Comparator.comparing((Person p) -> p.getLastName()));
第三步：类型推导和静态导入
Collections.sort(people, comparing(p -> p.getLastName()));
第四步：方法引用
Collections.sort(people, comparing(Person::getLastName));
第五步：使用List本身的sort更优
people.sort(comparing(Person::getLastName));;九.优缺点
优点：
1.极大的简化代码。去除了非常多没用的Java代码，使得代码更为简洁明了。
2.比匿名内部类更加高效（不确定）。
编译器会生成专门的lambda方法。能够使用javap -p查看编译过后的代码
缺点：
1.可读性差。在代码简洁的情况下，还有一方面又让大多程序猿非常难读懂。由于非常少程序猿接触使用它。
(只是这个缺点不是本身缺点，并且源于程序猿较少使用)
十.它是一个语法糖吗？
答：
就我自身的理解来说，lambda表达式不算是一个语法糖。
语法糖就是说仅仅是帮助我们程序猿轻松的少写一些代码。之后编译器帮我们把那部分代码生成出来。
可是从编译过后的结果来说，并非自己主动帮我们生成一个内部匿名类，而是生成了一个lambda$X方法。
第二个就是lambda事实上表达的是眼下流行的“函数式编程”这样的思维。差别于我们面向对象的思维方法。
这点我觉得非常有意义，即我们要从各种思维来对待事情。而不是说，面向对象的这样的方法就是最NB的。
可是论坛基本都觉得这是一个语法糖，也没错。毕竟它提倡的仅仅是一种思想，并且jdk底层为lambda生成了新的高效的代码这个事儿并不确定。
接下来介绍 lambda的 好哥们:stream.
stream的方法里面大多都使用了lambda表达式
stream概要
一.什么是stream？
官方解释：
A sequence of elements supporting sequential and parallel aggregate operations.简单来讲，stream就是JAVA8提供给我们的对于元素集合统一、高速、并行操作的一种方式。
它能充分运用多核的优势。以及配合lambda表达式、链式结构对集合等进行很多实用的操作。
概念：
stream:能够支持顺序和并行对元素操作的元素集合。
作用：
提供了一种操作大数据接口。让数据操作更easy和更快
使用stream，我们能够对collection的元素进行过滤、映射、排序、去重等很多操作。
中间方法和终点方法：
它具有过滤、映射以及降低遍历数等方法，这些方法分两种：中间方法和终端方法，
“流”抽象天生就该是持续的，中间方法永远返回的是Stream，因此假设我们要获取终于结果的话。
必须使用终点操作才干收集流产生的终于结果。区分这两个方法是看他的返回值，
假设是Stream则是中间方法，否则是终点方法
二.怎样使用stream?
1.通过Stream接口的静态工厂方法（注意：Java8里接口能够带静态方法）；
2.通过Collection接口的默认方法（默认方法：Default method，也是Java8中的一个新特性，就是接口中的一个带有实现的方法）–stream()，把一个Collection对象转换成Stream
普通情况下，我们都使用Collection接口的 .stream()方法得到stream.
三.常见的几个中间方法
中间方法即是一些列对元素进行的操作。譬如过滤、去重、截断等。
1.Filter（过滤）
//过滤18岁以上的人
List persons = …
Stream personsOver18 = persons.stream().filter(p -> p.getAge() > 18); 2.Map(对元素进行操作)
//把person转成Adult
Stream map = persons.stream().filter(p -> p.getAge() > 18).map(person -> new Adult(person)); 3.limit(截断)
对一个Stream进行截断操作，获取其前N个元素。假设原Stream中包括的元素个数小于N，那就获取其全部的元素
4.distinct(去重)
对于Stream中包括的元素进行去重操作（去重逻辑依赖元素的equals方法），新生成的Stream中没有反复的元素
四.经常使用的终点方法
通过中间方法，我们对stream的元素进行了统一的操作，可是中间方法得到还是一个stream。要想把它转换为新的集合、或者是统计等。
我们须要使用终点方法。
1.count(统计)
count方法是一个流的终点方法，可使流的结果终于统计。返回int，比方我们计算一下满足18岁的总人数
int countOfAdult=persons.stream()
.filter(p -> p.getAge() > 18)
.map(person -> new Adult(person))
.count();2.Collect(收集流的结果)
collect方法也是一个流的终点方法，可收集终于的结果
List adultList= persons.stream()
.filter(p -> p.getAge() > 18)
.map(person -> new Adult(person))
.collect(Collectors.toList());五.顺序流和并行流
每一个Stream都有两种模式：顺序运行和并行运行。
//顺序流：
List <Person> people = list.getStream.collect(Collectors.toList());
//并行流：
List <Person> people = list.getStream.parallel().collect(Collectors.toList());
//能够看出，要使用并行流，仅仅须要.parallel()就可以顾名思义。当使用顺序方式去遍历时。每一个item读完后再读下一个item。
而使用并行去遍历时，数组会被分成多个段，当中每一个都在不同的线程中处理，然后将结果一起输出。
并行流原理：
List originalList = someData;
split1 = originalList(0, mid);//将数据分小部分
split2 = originalList(mid,end);
new Runnable(split1.process());//小部分运行操作
new Runnable(split2.process());
List revisedList = split1 + split2;//将结果合并
性能：假设是多核机器。理论上并行流则会比顺序流快上一倍。
下面是借用他人的一个測试两者性能的Demo.
package com.lambda.stream;
import java.util.stream.IntStream;
public class TestPerformance {
public static void main(String[] args) {
long t0 = System.nanoTime();
//初始化一个范围100万整数流,求能被2整除的数字，toArray（）是终点方法
int a[]=IntStream.range(0, 1_000_000).filter(p -> p % 2==0).toArray();
long t1 = System.nanoTime();
//和上面功能一样，这里是用并行流来计算
int b[]=IntStream.range(0, 1_000_000).parallel().filter(p -> p % 2==0).toArray();
long t2 = System.nanoTime();
//我本机的结果是serial: 0.06s, parallel 0.02s，证明并行流确实比顺序流快
System.out.printf("serial: %.2fs, parallel %.2fs%n", (t1 - t0) * 1e-9, (t2 - t1) * 1e-9);
}
}
运行结果:
serial: 0.07s
parallel 0.02s能够看出，并行流的效率确实提高了3.5倍(我本机是4核,电脑较差.)
进阶学习：
1.Predicate和Consumer接口– Java 8中java.util.function包下的接口：
http://ifeve.com/predicate-and-consumer-interface-in-java-util-function-package-in-java-8/
2.深入理解Java 8 Lambda（语言篇——lambda，方法引用，目标类型和默认方法）
http://zh.lucida.me/blog/java-8-lambdas-insideout-language-features/
參考资料：
1.Java8初体验（二）Stream语法具体解释：
http://ifeve.com/stream/
2.Java8初体验（一）lambda表达式语法
http://ifeve.com/lambda/