理解Functional Interface（函数式接口）是学习Java8 lambda表达式的关键所在。
函数式接口的定义其实很简单：任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口。对于函数式接口，我们可以通过lambda表达式来创建该接口的对象。
为了让编译器帮助我们确保一个接口满足函数式接口的要求，也就是说有且仅有一个抽象方法。Java8提供了@FunctionalInterface注解。举个简单的例子，Runnable接口就是一个FI，下面是它的源代码：
@FunctionalInterface public interface Runnable { public abstract void run(); }
使用@FunctionalInterface注解并不强制要求。但是使用注解会让代码看上去更清楚。
Java中lambda表达式的格式：参数、箭头->、一个表达式。
为了演示lambda表达式的语法糖，我们通过Comparator作为例子。在Java8之前，可以借助匿名内部类来实现。
public static List<String> compareTest1(){ List<String> wordList = Arrays.asList("lianggzone", "spring", "summer", "autumn", "winter"); wordList.sort(new Comparator<String>() { @Override public int compare(String w1, String w2) { return Integer.compare(w1.length(), w2.length()); } }); return wordList; }
Comparator是个函数式接口，我们可以用Lambda表达式来实现。Lambda表达式，很像一个匿名的方法，只是小括号内的参数列表和花括号内的代码被->分隔开了。
public static List<String> compareTest2(){ List<String> wordList = Arrays.asList("lianggzone", "spring", "summer", "autumn", "winter"); wordList.sort((String w1, String w2) -> { return Integer.compare(w1.length(), w2.length()); }); return wordList; }
如果一个lambda表达式的参数类型是可以被推导的，那么就可以省略它们的类型。
public static List<String> compareTest3(){ List<String> wordList = Arrays.asList("lianggzone", "spring", "summer", "autumn", "winter"); wordList.sort((w1, w2) -> { return Integer.compare(w1.length(), w2.length()); }); return wordList; }
如果一个lambda表达式的代码块只是return后面跟一个表达式，那么还可以进一步简化。
public static List<String> compareTest4(){ List<String> wordList = Arrays.asList("lianggzone", "spring", "summer", "autumn", "winter"); wordList.sort((w1, w2) -> Integer.compare(w1.length(), w2.length())); return wordList; }
如果某个方法只含有一个参数，并且该参数的类型可以被推导出来，你甚至可以省略小括号。
public static List<String> compareTest5(){ List<String> wordList = Arrays.asList("lianggzone", "spring", "summer", "autumn", "winter"); wordList.forEach(word -> System.out.println(word)); return wordList; }
当我们要在另外一个独立线程中执行一些逻辑时，通常会将代码放在一个实现Runable接口的类的run方法中。
public static void runnableTest1(){ Executors.newSingleThreadExecutor().execute(new Runnable() { @Override public void run() { for (int i = 0; i < 10; i++) { System.out.println(i); } } }); }
如果lambda表达式没有参数，你仍可以提供一对空的小括号，如同不含参数的方法。
public static void runnableTest2(){ Executors.newSingleThreadExecutor().execute(() -> { for (int i = 0; i < 10; i++) { System.out.println(i); } }); }
注意点
有些时候，lambda表达式的代码就只是一个简单的方法调用而已，遇到这种情况，lambda表达式还可以进一步简化为方法引用。
：：操作符将方法名和对象或类的名字分隔开来。
在Java8之前，我们打印List内容，正常是这样做的。
public static void print1(){ List<String> wordList = Arrays.asList("lianggzone", "spring", "summer", "autumn", "winter"); wordList.forEach(new Consumer<String>() { @Override public void accept(String word) { System.out.println(word); } }); }
因为Consumer是函数式接口，我们通过lambda表达式改造下。
public static void print2(){ List<String> wordList = Arrays.asList("lianggzone", "spring", "summer", "autumn", "winter"); wordList.forEach(word -> System.out.println(word)); }
如果改造成方法引用，表达式 System.out::println, 等价于word -> System.out.println(word)。
public static void print3(){ List<String> wordList = Arrays.asList("lianggzone", "spring", "summer", "autumn", "winter"); wordList.forEach(System.out::println); }
例如，我们不区分大小写对字符串进行排序。
public static String[] sort1(){ String[] words = new String[]{"lianggzone", "spring", "summer", "autumn", "winter"}; Arrays.sort(words, (x, y) -> x.compareToIgnoreCase(y)); return words; }
如果改造成方法引用，表达式: String::compareToIgnoreCase,等价于(x, y) -> x.compareToIgnoreCase(y),第一参数会成为执行方法的对象。
public static String[] sort2(){ String[] words = new String[]{"lianggzone", "spring", "summer", "autumn", "winter"}; Arrays.sort(words, String::compareToIgnoreCase); return words; }
例如，我们对集合进行排序。
public static List<Integer> sortList1(){ List<Integer> wordList = Arrays.asList(21, 53); wordList.sort((w1, w2) -> Integer.compare(w1, w2)); return wordList; }
如果改造成方法引用，表达式: Integer::compare,等价于(w1, w2) -> Integer.compare(w1, w2),第一参数会成为执行方法的对象。
public static List<Integer> sortList2(){ List<Integer> wordList = Arrays.asList(21, 53); wordList.sort(Integer::compare); return wordList; }
// lambda words.stream().map(word -> { return new StringBuilder(word); }); // constructor reference words.stream().map(StringBuilder::new);
在Java8之前， 内部类只能访问final的局部变量 ，为了适应lambda表达式，Java8放宽了这种限制，只要变量实际上不可变（effectively final）就可以。
public static void effectivelyFinal(){ int a = 100; Executors.newSingleThreadExecutor().execute(() -> { System.out.println(a); }); }
在lambda表达式中，被引用的变量的值不能被修改。做出这个约束的是有原因的，因为lambda表达式中的变量不是线程安全的。
从Java8开始，接口也可以有静态方法了。有了这个语法，我们就可以把和接口相关的帮助方法直接定义在接口里。
比如Function接口就定义了一个工厂方法indentity()。表示， 一个功能接口，可以作为赋值的目标一个lambda表达式或方法参考。
T -函数输入的类型
R -函数的结果的类型
public interface Function<T, R> { static <T> Function<T, T> identity() { return t -> t; } }
事实上，Java8中，很多接口已经添加了静态方法，例如，Java8中的一个使用案例
public interface Path { public static Path get(String first, String... more) { return FileSystems.getDefault().getPath(first, more); } }
所以，重要的事情，再说一遍哟，从Java8开始，接口也可以有静态方法了。
原文链接：http://blog.720ui.com/2016/java_se8_01_lambda/
原文标题及作者：Java8 特性详解（一） Lambda | 梁桂钊的博客
原文：https://www.cnblogs.com/improver/p/11675036.html