一，Java8新特性簡介
1，速度更快
2，代碼更少（增加了新的語法Lambda表達式）
3，強大的Stream API
4,便於並行
5，最大化減少空指針異常Optional
二，Lambda表達式
1，爲什麼使用Lambda表達式
Lambda 是一個匿名函數，我們可以把 Lambda表達式理解爲是一段可以傳遞的代碼（將代碼像數據一樣進行傳遞）。可以寫出更簡潔、更靈活的代碼。作爲一種更緊湊的代碼風格，使Java的語言表達能力得到了提升。
2，Lambda表達式的關鍵：從匿名類到 Lambda 的轉換
示例：
3，Lambda表達式語法
Lambda表達式在Java 語言中引入了一個新的語法元
素和操作符。這個操作符爲 “->” ， 該操作符被稱
爲 Lambda 操作符或剪頭操作符。它將 Lambda 分爲
兩個部分：
左側： 指定了 Lambda 表達式需要的所有參數
右側： 指定了 Lambda 體，即 Lambda 表達式要執行
的功能。
（1）語法格式一：無參，無返回值，Lambda 體只需一條語句
示例：Runnable r1 = () -> System.out.println("Hello Lambda!");
（2）語法格式二：Lambda 需要一個參數
示例：Consumer<String> con = （x） -> System.out.println(x);
（3）語法格式三：Lambda 只需要一個參數時，參數的小括號可以省略
示例：Consumer<String> con = x -> System.out.println(x);
（4）語法格式四：Lambda 需要兩個參數，並且有返回值
示例：
Comparator<Integer> com = (x, y) -> {
System.out.println("函數式接口");
return Integer.compare(x, y);
};
（5）語法格式五：當 Lambda 體只有一條語句時，return 與大括號可以省略
示例：Comparator<Integer> com = (x, y) -> Integer.compare(x, y);
（6）Lambda 表達式的參數列表的數據類型可以省略不寫，因爲JVM編譯器通過上下文推斷出，數據類型，即“類型推斷”
示例：
Comparator<Integer> com = (Integerx,
Integery) -> { //Integer 類型可以省略
System.out.println("函數式接口");
return Integer.compare(x, y);
};
類型推斷：Lambda 表達式中的參數類型都是由編譯器推斷 得出的。 Lambda 表達式中無需指定類型，程序依然可 以編譯，這是因爲 javac 根據程序的上下文，在後臺 推斷出了參數的類型。 Lambda 表達式的類型依賴於上 下文環境，是由編譯器推斷出來的。這就是所謂的 “類型推斷”
三，函數式接口
1，什麼是函數式接口
（1）只包含一個抽象方法的接口，稱爲函數式接口。
（2）你可以通過 Lambda 表達式來創建該接口的對象。（若 Lambda 表達式拋出一個受檢異常，那麼該異常需要在目標接口的抽象方 法上進行聲明）。
（3）我們可以在任意函數式接口上使用 @FunctionalInterface 註解， 這樣做可以檢查它是否是一個函數式接口，同時 javadoc 也會包 含一條聲明，說明這個接口是一個函數式接口。
2，自定義函數接口
3，作爲參數傳遞的Lambda表達式
作爲參數傳遞 Lambda 表達式：爲了將 Lambda 表達式作爲參數傳遞，接
收Lambda 表達式的參數類型必須是與該 Lambda 表達式兼容的函數式接口
的類型。
4，Java 內置四大核心函數式接口
（1），Consumer<T> : 消費型接口
void accept(T t);
示例：
//Consumer<T> 消費型接口 :
@Test
public void test1(){
happy(10000, (m) -> System.out.println("你們剛哥喜歡大寶劍，每次消費：" + m + "元"));
}
public void happy(double money, Consumer<Double> con){
con.accept(money);
}
（2），Supplier<T> : 供給型接口 T get();
示例：
//Supplier<T> 供給型接口 :
@Test
public void test2(){
List<Integer> numList = getNumList(10, () -> (int)(Math.random() * 100));
for (Integer num : numList) {
System.out.println(num);
}
}
//需求：產生指定個數的整數，並放入集合中
public List<Integer> getNumList(int num, Supplier<Integer> sup){
List<Integer> list = new ArrayList<>();
for (int i = 0; i < num; i++) {
Integer n = sup.get();
list.add(n);
}
return list;
}
(3)，Function<T, R> : 函數型接口 R apply(T t);
示例：
//Function<T, R> 函數型接口：
@Test
public void test3(){
String newStr = strHandler("\t\t\t 我大尚硅谷威武 ", (str) -> str.trim());
System.out.println(newStr);
String subStr = strHandler("我大尚硅谷威武", (str) -> str.substring(2, 5));
System.out.println(subStr);
}
//需求：用於處理字符串
public String strHandler(String str, Function<String, String> fun){
return fun.apply(str);
}
(4)，Predicate<T> : 斷言型接口 boolean test(T t);
示例：
//Predicate<T> 斷言型接口：
@Test
public void test4(){
List<String> list = Arrays.asList("Hello", "atguigu", "Lambda", "www", "ok");
List<String> strList = filterStr(list, (s) -> s.length() > 3);
for (String str : strList) {
System.out.println(str);
}
}
//需求：將滿足條件的字符串，放入集合中
public List<String> filterStr(List<String> list, Predicate<String> pre){
List<String> strList = new ArrayList<>();
for (String str : list) {
if(pre.test(str)){
strList.add(str);
}
}
return strList;
}
5,其它接口
6，方法引用和構造器引用
方法引用：
當要傳遞給Lambda體的操作，已經有實現的方法了，可以使用方法引用！
（實現抽象方法的參數列表，必須與方法引用方法的參數列表保持一致！ ）
方法引用：使用操作符 “::” 將方法名和對象或類的名字分隔開來。
如下三種主要使用情況：
（1）對象::實例方法
例如：
@Test
public void test1(){
PrintStream ps = System.out;
Consumer<String> con = (str) -> ps.println(str);
con.accept("Hello World！");
System.out.println("--------------------------------");
Consumer<String> con2 = ps::println;
con2.accept("Hello Java8！");
Consumer<String> con3 = System.out::println;
}
@Test
public void test2(){
Employee emp = new Employee(101, "張三", 18, 9999.99);
Supplier<String> sup = () -> emp.getName();
System.out.println(sup.get());
System.out.println("----------------------------------");
Supplier<String> sup2 = emp::getName;
System.out.println(sup2.get());
}
（2）類::靜態方法
例如：
@Test
public void test3(){
BiFunction<Double, Double, Double> fun = (x, y) -> Math.max(x, y);
System.out.println(fun.apply(1.5, 22.2));
System.out.println("--------------------------------------------------");
BiFunction<Double, Double, Double> fun2 = Math::max;
System.out.println(fun2.apply(1.2, 1.5));
}
@Test
public void test4(){
Comparator<Integer> com = (x, y) -> Integer.compare(x, y);
System.out.println("-------------------------------------");
Comparator<Integer> com2 = Integer::compare;
}
（3）類::實例方法
例如：
@Test
public void test5(){
BiPredicate<String, String> bp = (x, y) -> x.equals(y);
System.out.println(bp.test("abcde", "abcde"));
System.out.println("-----------------------------------------");
BiPredicate<String, String> bp2 = String::equals;
System.out.println(bp2.test("abc", "abc"));
System.out.println("-----------------------------------------");
Function<Employee, String> fun = (e) -> e.show();
System.out.println(fun.apply(new Employee()));
System.out.println("-----------------------------------------");
Function<Employee, String> fun2 = Employee::show;
System.out.println(fun2.apply(new Employee()));
}
注意：
* ①方法引用所引用的方法的參數列表與返回值類型，需要與函數式接口中抽象方法的參數列表和返回值類型保持一致！
* ②若Lambda 的參數列表的第一個參數，是實例方法的調用者，第二個參數(或無參)是實例方法的參數時，格式： ClassName::MethodName
構造器引用：構造器的參數列表，需要與函數式接口中參數列表保持一致！
格式： ClassName::new
與函數式接口相結合，自動與函數式接口中方法兼容。
可以把構造器引用賦值給定義的方法，與構造器參數
列表要與接口中抽象方法的參數列表一致！
數組引用：
