（部分转自：https://www.cnblogs.com/xiaoxi/p/7099667.html）
1. lambda表达式
以前定义一个Thread：
1 final int i = 0;
2 new Thread(new Runnable() {
3 @Override
4 public void run() {
5 System.out.println("i = " + i);
6 }
7 }).start();
lambda表达式定义：
1 int i = 0;
2 new Thread(() -> System.out.println("i = " + i));
概述：lambda表达式除了使代码简洁外，还为了消除单方法接口实现的匿名内部类。
结构：
注意：
- lambda要求实现的接口中只有一个方法（该接口称为函数式接口），可以知道如果要得到一个接口的对象，则需要创建一个类并实现接口再实例化对象，而lambda则可以直接提供对象。
- 参数体内如果只有一个参数则可以省略小括号，方法体内如果只有一条语句则可以省略花括号。
- 参数体内可以省略数据类型，编译器可以推导出参数类型，例如：（first, second）-> {first.length() - second.length()}。
- 方法体内必须有return含义，即可以显式地return或隐式地return（编译器会根据上下文推导得出return返回的数据类型）,例如上。
- lambda内部引用外部的变量，该变量必须是最终变量，即初始化后不再为它赋新值。
2. 方法引用
方法引用是直接访问类或者实例的方法、类方法、静态方法；提供了一种引用而不执行方法的方式；计算时，方法引用会创建函数式接口的一个实例。
方法引用等价于lambda表达式，只是lambda表达式更为简洁的写法，当lambda表达式只是执行一个方法调用时则不用lambda。lambda中如果参数和方法内使用的参数一致即可在方法引用中忽略参数。
// lambda写法： Arrays.sort(stringsArray,(s1,s2)->s1.compareToIgnoreCase(s2)); // 方法引用写法 Arrays.sort(stringsArray, String::compareToIgnoreCase);
详细的例子，首先定义一个Person类，如下：
package com.demo.model;
import java.time.LocalDate;
public class Person {
public Person(String name, LocalDate birthday) {
this.name = name;
this.birthday = birthday;
}
String name;
LocalDate birthday;
public LocalDate getBirthday() {
return birthday;
}
public static int compareByAge(Person a, Person b) {
return a.birthday.compareTo(b.birthday);
}
@Override
public String toString() {
return this.name;
}
}
假设我们有一个Person数组，并且想对它进行排序，这时候，我们可能会这样写：
其中，Arrays类的sort方法定义如下：
public static <T> void sort(T[] a, Comparator<? super T> c)
这里，我们首先要注意Comparator接口是一个函数式接口，因此我们可以使用Lambda表达式，而不需要定义一个实现Comparator接口的类，并创建它的实例对象，传给sort方法。
使用Lambda表达式，未调用已存在的方法
public void test1() {
Person[] pArr = new Person[]{
new Person("003", LocalDate.of(2016,9,1)),
new Person("001", LocalDate.of(2016,2,1)),
new Person("002", LocalDate.of(2016,3,1)),
new Person("004", LocalDate.of(2016,12,1))};
//使用lambda表达式
Arrays.sort(pArr, (Person a, Person b) -> {
return a.getBirthday().compareTo(b.getBirthday());
});
System.out.println(Arrays.asList(pArr));
}
然而，在以上代码中，关于两个人生日的比较方法在Person类中已经定义了，因此，我们可以直接使用已存在的Person.compareByAge方法。
使用Lambda表达式，调用已存在的方法
public void test2() {
Person[] pArr = new Person[]{
new Person("003", LocalDate.of(2016,9,1)),
new Person("001", LocalDate.of(2016,2,1)),
new Person("002", LocalDate.of(2016,3,1)),
new Person("004", LocalDate.of(2016,12,1))};
//使用lambda表达式和类的静态方法
Arrays.sort(pArr, (a ,b) -> Person.compareByAge(a, b));
System.out.println(Arrays.asList(pArr));
}
因为这个Lambda表达式调用了一个已存在的方法，因此，我们可以直接使用方法引用来替代这个Lambda表达式。
使用方法引用
public void test3() {
Person[] pArr = new Person[]{
new Person("003", LocalDate.of(2016,9,1)),
new Person("001", LocalDate.of(2016,2,1)),
new Person("002", LocalDate.of(2016,3,1)),
new Person("004", LocalDate.of(2016,12,1))};
//使用方法引用，引用的是类的静态方法
Arrays.sort(pArr, Person::compareByAge);
System.out.println(Arrays.asList(pArr));
}
3. 方法引用几种类型：
(1) 静态方法引用
组成语法格式：ClassName::staticMethodName
我们前面举的例子Person::compareByAge就是一个静态方法引用。
例子：
String::valueOf 等价于lambda表达式 (s) -> String.valueOf(s)
Math::pow 等价于lambda表达式 (x, y) -> Math.pow(x, y);
(2) 对象方法引用
a.实例上的实例方法引用
组成语法格式：instanceReference::methodName
如下示例，引用的方法是myComparisonProvider 对象的compareByName方法。
class ComparisonProvider{
public int compareByName(Person a, Person b){
return a.getName().compareTo(b.getName());
}
public int compareByAge(Person a, Person b){
return a.getBirthday().compareTo(b.getBirthday());
}
}
ComparisonProvider myComparisonProvider = new ComparisonProvider();
Arrays.sort(rosterAsArray, myComparisonProvider::compareByName);
b.超类上的实例方法引用
组成语法格式：super::methodName
方法的名称由methodName指定，通过使用super，可以引用方法的超类版本。
例子：
还可以捕获this 指针，this :: equals 等价于lambda表达式 x -> this.equals(x);
c.类型上的实例方法引用
组成语法格式：ClassName::methodName
注意：
若类型的实例方法是泛型的，就需要在::分隔符前提供类型参数，或者（多数情况下）利用目标类型推导出其类型。
静态方法引用和类型上的实例方法引用拥有一样的语法。编译器会根据实际情况做出决定。一般我们不需要指定方法引用中的参数类型，因为编译器往往可以推导出结果，但如果需要我们也可以显式在::分隔符之前提供参数类型信息。
例子：
String::toString 等价于lambda表达式 (s) -> s.toString()
这里不太容易理解，实例方法要通过对象来调用，方法引用对应Lambda，Lambda的第一个参数会成为调用实例方法的对象。
(3) 任意对象（属于同一个类）的实例方法引用
如下示例，这里引用的是字符串数组中任意一个对象的compareToIgnoreCase方法。
String[] stringArray = { "Barbara", "James", "Mary", "John", "Patricia", "Robert", "Michael", "Linda" };
Arrays.sort(stringArray, String::compareToIgnoreCase);
(4) 构造方法引用
构造方法引用又分构造方法引用和数组构造方法引用。
a. 构造方法引用（也可以称作构造器引用）
组成语法格式：Class::new
构造函数本质上是静态方法，只是方法名字比较特殊，使用的是new 关键字。
例子：
String::new， 等价于lambda表达式 () -> new String()
package com.demo;
public interface MyFunc1 {
MyClass func(int n);
}
package com.demo;
public class MyClass {
private int val;
MyClass(int v) {
val = v;
}
MyClass(){
val = 0;
}
public int getValue() {
return val;
}
}
package com.demo;
public class ConstructorRefDemo {
public static void main(String[] args) {
MyFunc1 myClassCons = MyClass :: new;
MyClass mc = myClassCons.func(100);
System.out.println("val in mc is: " + mc.getValue());
}
}
输出结果：
val in mc is: 100
b.数组构造方法引用
组成语法格式：TypeName[]::new
例子：
int[]::new 是一个含有一个参数的构造器引用，这个参数就是数组的长度。等价于lambda表达式 x -> new int[x]。
假想存在一个接收int参数的数组构造方法
IntFunction<int[]> arrayMaker = int[]::new; int[] array = arrayMaker.apply(10) // 创建数组 int[10]
原文地址：https://www.cnblogs.com/chenloveslife/p/9313305.html