JDK 8 新特性
1. Lambda 表示式
Lambda 表示式，也可稱為閉包，它是推動 Java 8 釋出的最重要新特性。
Lambda 允許把函式作為一個方法的引數（函式作為引數傳遞進方法中），使用 Lambda 表示式可以使程式碼變的更加簡潔緊湊。
lambda表示式的語法格式為：
(parameters) -> expression
或
(parameters) ->{ statements; }
格式說明：
- 小括號內的語法與傳統方法引數列表一致：無引數則留空；多個引數則用逗號分隔。
- -> 是新引入的語法格式，代表指向動作。
- 大括號內的語法與傳統方法體要求基本一致。
1.1 lambda表示式的使用前提
Lambda的語法非常簡潔，完全沒有面向物件複雜的束縛。
但是使用時有幾個問題需要特別注意：
- 使用Lambda必須具有介面，且要求介面中有且僅有一個抽象方法。 無論是JDK內建的 Runnable 、 Comparator 介面還是自定義的介面，只有當介面中的抽象方法存在且唯一時，才可以使用Lambda。
- 使用Lambda必須具有上下文推斷。 也就是方法的引數或區域性變數型別必須為Lambda對應的介面型別，才能使用Lambda作為該介面的例項。
備註：有且僅有一個抽象方法的介面，稱為“函式式介面”。
1.2 函式式介面
函式式介面，即適用於函數語言程式設計場景的介面。而Java中的函數語言程式設計體現就是Lambda，所以函式式介面就是可以適用於Lambda使用的介面。只有確保介面中有且僅有一個抽象方法，Java中的Lambda才能順利地進行推導。
1.2.1 @FunctionalInterface註解
與 @Override 註解的作用類似，Java 8中專門為函式式介面引入了一個新的註解： @FunctionalInterface 。該註解可用於一個介面的定義上：
@FunctionalInterface
public interface MyFunctionalInterface {
void myMethod();
}
一旦使用該註解來定義介面，編譯器將會強制檢查該介面是否確實有且僅有一個抽象方法，否則將會報錯。需要注意的是，即使不使用該註解，只要滿足函式式介面的定義，這仍然是一個函式式介面，使用起來都一樣。
1.3 lambda表示式的使用場景
回顧我們之前學過的匿名內部類程式碼：
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("多執行緒任務執行！");
}
}).start();
}
儘管匿名內部類可以幫我們省去實現類的定義，但是匿名內部類的語法確實太複雜了。
Runnable是有且僅有一個抽象方法的介面，本質上我們只是要覆蓋這個抽象方法而已，而Lambda 允許把函式作為一個方法的引數。
我們可以用lambda表示式簡化一下程式碼。
public static void main(String[] args) {
new Thread(()->System.out.println("多執行緒任務執行！")).start();
}
我們可以看到使用lambda表示式簡化後的程式碼和之前的程式碼形成了鮮明的對比，簡直是程式設計師的福音。
1.4 lambda表示式的省略規則
以(int a)->{System.out.println(a+"多執行緒任務執行！")}為例，lambda表示式的省略規則如下：
- 小括號內參數的型別可以省略；
- 如果小括號內有且僅有一個參，則小括號可以省略；
- 如果大括號內有且僅有一個語句，則無論是否有返回值，都可以省略大括號、return關鍵字及語句分號。
省略後：a->System.out.println(a+"多執行緒任務執行！")
1.5 lambda的延遲執行
有些場景的程式碼執行後，結果不一定會被使用，從而造成效能浪費。而Lambda表示式是延遲執行的，這正好可以 作為解決方案，提升效能。
1.5.1 效能浪費的日誌案例
注：日誌可以幫助我們快速的定位問題，記錄程式執行過程中的情況，以便專案的監控和優化。
一種典型的場景就是對引數進行有條件使用，例如對日誌訊息進行拼接後，在滿足條件的情況下進行列印輸出（比如級別為1時才打印）：
public class LoggerDemo {
private static void log(int level, String msg) {
if (level == 1) {
System.out.println(msg);
}
}
public static void main(String[] args) {
String msgA = "Hello";
String msgB = "World";
String msgC = "Java";
log(1, msgA + msgB + msgC);
}
}
這段程式碼存在問題：無論級別是否滿足要求，作為 log 方法的第二個引數，三個字串一定會首先被拼接並傳入方法內，然後才會進行級別判斷。如果級別不符合要求，那麼字串的拼接操作就白做了，存在效能浪費。
備註：SLF4J是應用非常廣泛的日誌框架，它在記錄日誌時為了解決這種效能浪費的問題，並不推薦首先進行 字串的拼接，而是將字串的若干部分作為可變引數傳入方法中，僅在日誌級別滿足要求的情況下才會進 行字串拼接。例如： LOGGER.debug("變數{}的取值為{}。", "os", "macOS") ，其中的大括號 {} 為佔位 符。如果滿足日誌級別要求，則會將“os”和“macOS”兩個字串依次拼接到大括號的位置；否則不會進行字 符串拼接。這也是一種可行解決方案，但Lambda可以做到更好。
1.5.2 lambda解決效能浪費
（1）使用Lambda必然需要一個函式式介面
@FunctionalInterface
public interface MessageBuilder {
String buildMessage();
}
（2）對 log 方法進行改造
public class LoggerDemo2 {
private static void log(int level, MessageBuilder builder) {
if (level == 1) {
System.out.println(builder.buildMessage());
}
}
public static void main(String[] args) {
String msgA = "Hello";
String msgB = "World";
String msgC = "Java";
log(1, () ‐> msgA + msgB + msgC );
}
}
這樣一來，只有當級別滿足要求的時候，才會進行三個字串的拼接；否則三個字串將不會進行拼接。
1.5.3 證明Lambda的延遲執行
測試程式碼：
public class LoggerDemo3 {
private static void log(int level, MessageBuilder builder) {
if (level == 1) {
System.out.println(builder.buildMessage());
}
}
public static void main(String[] args) {
String msgA = "Hello";
String msgB = "World";
String msgC = "Java";
log(2, () ‐> {
System.out.println("Lambda執行！");
return msgA + msgB + msgC;
});
}
}
從結果中可以看出，在不符合級別要求的情況下，Lambda將不會執行。從而達到節省效能的效果
2. 常用的函式式介面
JDK提供了大量常用的函式式介面以豐富Lambda的典型使用場景，它們主要在 java.util.function 包中被提供。 下面是最簡單的幾個介面及使用示例。
2.1 Supplier介面
java.util.function.Supplier 介面僅包含一個無參的方法： T get() 。用來獲取一個泛型引數指定型別的物件資料。
由於這是一個函式式介面，這也就意味著對應的Lambda表示式需要“對外提供”一個符合泛型型別的物件資料，即資料的生產者。
程式碼示例：
public class SupplierDemo {
private static String getString(Supplier<String> function) {
return function.get();
}
public static void main(String[] args) {
String msgA = "Hello";
String msgB = "World";
System.out.println(getString(() ‐> msgA + msgB));
}
}
求陣列元素最大值：
public class Demo {
//定一個方法,方法的引數傳遞Supplier,泛型使用Integer
public static int getMax(Supplier<Integer> sup){
return sup.get();
}
public static void main(String[] args) {
int arr[] = {2,3,4,52,333,23};
//呼叫getMax方法,引數傳遞Lambda
int maxNum = getMax(()‐>{
//計算陣列的最大值
int max = arr[0];
for(int i : arr){
if(i>max){
max = i;
}
}
return max;
});
System.out.println(maxNum);
}
}
2.2 Consumer介面
java.util.function.Consumer 介面則正好與Supplier介面相反，它不是生產一個數據，而是消費一個數據， 其資料型別由泛型決定。
2.2.1 抽象方法
Consumer 介面中包含抽象方法 void accept(T t) ，意為消費一個指定泛型的資料。
程式碼示例：
public class ConsumerDemo {
private static void consumeString(Consumer<String> function) {
function.accept("Hello");
}
public static void main(String[] args) {
consumeString(s ‐> System.out.println(s));
}
}
2.2.2 預設方法
如果一個方法的引數和返回值全都是 Consumer 型別，那麼就可以實現效果：
消費資料的時候，首先做一個操作， 然後再做一個操作，實現組合。而這個方法就是 Consumer 介面中的預設方法 andThen 。
andThen 方法的原始碼如下：
default Consumer<T> andThen(Consumer<? super T> after) {
Objects.requireNonNull(after);
return (T t) ‐> { accept(t); after.accept(t); };
}
要想實現組合，需要兩個或多個Lambda表示式即可，而 andThen 的語義正是“一步接一步”操作。例如兩個步驟組合的情況：
public class Demo10ConsumerAndThen {
private static void consumeString(Consumer<String> one, Consumer<String> two) {
one.andThen(two).accept("Hello");
}
public static void main(String[] args) {
consumeString(
s ‐> System.out.println(s.toUpperCase()),
s ‐> System.out.println(s.toLowerCase()));
}
}
執行結果將會首先列印完全大寫的HELLO，然後列印完全小寫的hello。當然，通過鏈式寫法可以實現更多步驟的 組合。
2.3 Predicate介面
有時候我們需要對某種型別的資料進行判斷，從而得到一個boolean值結果。這時可以使用 java.util.function.Predicate 介面。
2.3.1 抽象方法
Predicate 介面中包含一個抽象方法： boolean test(T t) ,用於條件判斷的場景：
public class Demo15PredicateTest {
private static void method(Predicate<String> predicate) {
boolean veryLong = predicate.test("HelloWorld");
System.out.println("字串很長嗎：" + veryLong);
}
public static void main(String[] args) {
method(s ‐> s.length() > 5);
}
}
條件判斷的標準是傳入的Lambda表示式邏輯，只要字串長度大於5則認為很長。
2.3.2 預設方法
既然是條件判斷，就會存在與、或、非三種常見的邏輯關係。
（1）and方法
如果要判斷一個字串既要包含大寫“H”，又要包含大寫“W”，那麼可以使用and方法：
public class PredicateAndDemo {
private static void method(Predicate<String> one, Predicate<String> two) {
boolean isValid = one.and(two).test("Helloworld");
System.out.println("字串符合要求嗎：" + isValid);
}
public static void main(String[] args) {
method(s ‐> s.contains("H"), s ‐> s.contains("W"));
}
}
（2）or方法
如果希望實現邏輯“字串包含大寫H或者包含大寫W”，那麼程式碼只需要將“and”修改為“or”名稱即可
public class PredicateOrDemo {
private static void method(Predicate<String> one, Predicate<String> two) {
boolean isValid = one.or(two).test("Helloworld");
System.out.println("字串符合要求嗎：" + isValid);
}
public static void main(String[] args) {
method(s ‐> s.contains("H"), s ‐> s.contains("W"));
}
}
（3）negate方法
一定要在 test 方法呼叫之前 呼叫 negate 方法，正如 and 和 or 方法一樣：
public class PredicateNegateDemo {
private static void method(Predicate<String> predicate) {
boolean veryLong = predicate.negate().test("HelloWorld");
System.out.println("字串很長嗎：" + veryLong);
}
public static void main(String[] args) {
method(s ‐> s.length() < 5);
}
}
2.4 Function介面
java.util.function.Function 介面用來根據一個型別的資料得到另一個型別的資料，前者稱為前置條件， 後者稱為後置條件。
2.4.1 抽象方法
Function 介面中最主要的抽象方法為： R apply(T t) ，根據型別T的引數獲取型別R的結果。
使用的場景例如：將 String 型別轉換為 Integer 型別。
public class FunctionApplyDemo {
private static void method(Function<String, Integer> function) {
int num = function.apply("10");
System.out.println(num + 20);
}
public static void main(String[] args) {
method(s ‐> Integer.parseInt(s));
}
}
2.4.2 預設方法
Function 介面中有一個預設的 andThen 方法，用來進行組合操作。
該方法同樣用於“先做什麼，再做什麼”的場景，和 Consumer 中的 andThen 差不多：
public class Demo12FunctionAndThen {
private static void method(Function<String, Integer> one, Function<Integer, Integer> two) {
int num = one.andThen(two).apply("10");
System.out.println(num + 20);
}
public static void main(String[] args) {
method(str‐>Integer.parseInt(str)+10, i ‐> i *= 10);
}
}
第一個操作是將字串解析成為int數字，第二個操作是乘以10。兩個操作通過 andThen 按照前後順序組合到了一 起。
注意：Function的前置條件泛型和後置條件泛型可以相同。
3. 方法引用
在使用Lambda表示式的時候，我們實際上傳遞進去的程式碼就是一種解決方案：拿什麼引數做什麼操作。那麼考慮 一種情況：如果我們在Lambda中所指定的操作方案，已經有地方存在相同方案，那是否還有必要再寫重複邏輯？
3.1 冗餘的Lambda場景
來看一個簡單的函式式介面以應用Lambda表示式：
@FunctionalInterface
public interface Printable {
void print(String str);
}
在 Printable 介面當中唯一的抽象方法 print 接收一個字串引數，目的就是為了列印顯示它。那麼通過Lambda 來使用它的程式碼很簡單：
public class PrintDemo {
private static void printString(Printable data) {
data.print("Hello, World!");
}
public static void main(String[] args) {
printString(s ‐> System.out.println(s));
}
}
其中 printString 方法只管呼叫 Printable 介面的 print 方法，而並不管 print 方法的具體實現邏輯會將字串列印到什麼地方去。而 main 方法通過Lambda表示式指定了函式式介面 Printable 的具體操作方案為：拿到 String（型別可推導，所以可省略）資料後，在控制檯中輸出它。
3.2 問題分析
這段程式碼的問題在於，對字串進行控制檯列印輸出的操作方案，明明已經有了現成的實現，那就是 System.out 物件中的 println(String) 方法。既然Lambda希望做的事情就是呼叫 println(String) 方法，那何必自己手動呼叫呢？
3.3 用方法引用改進程式碼
能否省去Lambda的語法格式（儘管它已經相當簡潔）呢？只要“引用”過去就好了：
public class Demo02PrintRef {
private static void printString(Printable data) {
data.print("Hello, World!");
}
public static void main(String[] args) {
printString(System.out::println);
}
}
注意：雙冒號 :: 寫法，這被稱為“方法引用”，而雙冒號是一種新的語法。
3.4 方法引用的分析和推導
（1）語義分析
上例中， System.out 物件中有一個過載的 println(String) 方法恰好就是我們所需要的。那麼對於 printString 方法的函式式介面引數，對比下面兩種寫法，完全等效：
- Lambda表示式寫法： s -> System.out.println(s);
- 方法引用寫法： System.out::println
第一種語義是指：拿到引數之後經Lambda之手，繼而傳遞給 System.out.println 方法去處理。
第二種等效寫法的語義是指：直接讓 System.out 中的 println 方法來取代Lambda。
兩種寫法的執行效果完全一樣，而第二種方法引用的寫法複用了已有方案，更加簡潔。
注意：Lambda 中 傳遞的引數一定是方法引用中的那個方法可以接收的型別，否則會丟擲異常
（2）省略推導
如果使用Lambda，那麼根據“可推導就是可省略”的原則，無需指定引數型別，也無需指定的過載形式——它們都將被自動推導。
而如果使用方法引用，也是同樣可以根據上下文進行推導，無需指定過載形式。 函式式介面是Lambda的基礎，而方法引用是Lambda的孿生兄弟。
下面這段程式碼將會呼叫 println 方法的不同過載形式，將函式式介面改為int型別的引數：
@FunctionalInterface
public interface PrintableInteger {
void print(int str);
}
由於上下文變了之後可以自動推匯出唯一對應的匹配過載，所以方法引用沒有任何變化：
public class Demo03PrintOverload {
private static void printInteger(PrintableInteger data) {
data.print(1024);
}
public static void main(String[] args) {
//這次方法引用將會自動匹配到 println(int) 的過載形式。
printInteger(System.out::println);
}
}
3.5 方法引用的各種方式
3.5.1 通過物件名引用成員方法
這是最常見的一種用法，如果一個類中已經存在了一個成員方法：
public class MethodRefObject {
public void printUpperCase(String str) {
System.out.println(str.toUpperCase());
}
}
函式式介面仍然定義為：
@FunctionalInterface
public interface Printable {
void print(String str);
}
那麼當需要使用這個 printUpperCase 成員方法來替代 Printable 介面的Lambda的時候，已經具有了MethodRefObject 類的物件例項，則可以通過物件名引用成員方法，程式碼為：
public class MethodRefDemo {
private static void printString(Printable lambda) {
lambda.print("Hello");
}
public static void main(String[] args) {
MethodRefObject obj = new MethodRefObject();
printString(obj::printUpperCase);
}
}
3.5.2 通過類名稱引用靜態方法
由於在 java.lang.Math 類中已經存在了靜態方法 abs ，所以當我們可以通過類名稱來引用用該方法：
public class MethodRefDemo2 {
private static void method(int num, Calcable lambda) {
System.out.println(lambda.calc(num));
}
public static void main(String[] args) {
method(‐10, Math::abs);
}
}
3.5.3 通過super引用成員方法
如果存在繼承關係，當Lambda中需要出現super呼叫時，也可以使用方法引用進行替代。
首先是函式式介面：
@FunctionalInterface
public interface Greetable {
void greet();
}
父類：
public class Human {
public void sayHello() {
System.out.println("Hello!");
}
}
通過super引用父類方法
public class Man extends Human {
@Override
public void sayHello() {
System.out.println("大家好,我是Man!");
}
//定義方法method,引數傳遞Greetable介面
public void method(Greetable g){
g.greet();
}
public void show(){
method(super::sayHello);
}
}
3.5.4 通過this引用成員方法
this代表當前物件，如果需要引用的方法就是當前類中的成員方法，那麼可以使用“this::成員方法”的格式來使用方 法引用。
首先是函式式介面：
@FunctionalInterface
public interface Richable {
void buy();
}
下面是一個丈夫 Husband 類，類中通過this引用物件本身成員方法：
public class Husband {
private void buyHouse() {
System.out.println("買套房子");
}
private void marry(Richable lambda) {
lambda.buy();
}
public void beHappy() {
marry(this::buyHouse);
}
}
3.5.5 類的構造器引用
由於構造器的名稱與類名完全一樣，所以構造器引用使用 類名稱::new 的格式表示。
首先是一個簡單 的 Person 類：
public class Person {
private String name;
public Person(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
然後是用來建立 Person 物件的函式式介面：
public interface PersonBuilder {
Person buildPerson(String name);
}
通過構造器引用，建立Person：
public class ConstructorRefDemo {
public static void printName(String name, PersonBuilder builder) {
System.out.println(builder.buildPerson(name).getName());
}
public static void main(String[] args) {
printName("測試", Person::new);
}
}
3.5.6 陣列的構造器引用
陣列也是 Object 的子類物件，所以同樣具有構造器，只是語法稍有不同。
如果對應到Lambda的使用場景中時， 需要一個函式式介面：
@FunctionalInterface
public interface ArrayBuilder {
int[] buildArray(int length);
}
通過陣列構造器引用建立陣列
public class Demo12ArrayInitRef {
private static int[] initArray(int length, ArrayBuilder builder) {
return builder.buildArray(length);
}
public static void main(String[] args) {
int[] array = initArray(10, int[]::new);
}
}
4. Stream流
說到Stream便容易想到I/O Stream，而實際上，誰規定“流”就一定是“IO流”呢？在Java 8中，得益於Lambda所帶 來的函數語言程式設計，引入了一個全新的Stream概念，用於解決已有集合類庫既有的弊端。
4.1 傳統集合遍歷的弊端
幾乎所有的集合（如 Collection 介面或 Map 介面等）都支援直接或間接的遍歷操作。而當我們需要對集合中的元素進行操作的時候，除了必需的新增、刪除、獲取外，最典型的就是集合遍歷。
試想一下，如果希望對集合中的元素進行篩選過濾：
- 將集合A根據條件一過濾為子集B；
- 然後再根據條件二過濾為子集C。
那怎麼辦？在Java 8之前的做法可能為：
public class NormalFilter {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("張三");
list.add("張三丰");
list.add("李四");
list.add("王五");
list.add("趙六六");
List<String> zhangList = new ArrayList<>();
for (String name : list) {
if (name.startsWith("張")) {
zhangList.add(name);
}
}
List<String> shortList = new ArrayList<>();
for (String name : zhangList) {
if (name.length() == 3) {
shortList.add(name);
}
}
for (String name : shortList) {
System.out.println(name);
}
}
}
這段程式碼中含有三個迴圈，每一個作用不同：
- 首先篩選所有姓張的人；
- 然後篩選名字有三個字的人；
- 最後進行對結果進行列印輸出。
每當我們需要對集合中的元素進行操作的時候，總是需要進行迴圈、迴圈、再迴圈。這是理所當然的麼？不是。循 環是做事情的方式，而不是目的。另一方面，使用線性迴圈就意味著只能遍歷一次。如果希望再次遍歷，只能再使用另一個迴圈從頭開始。
那，Lambda的衍生物Stream能給我們帶來怎樣更加優雅的寫法呢？
public class StreamFilter {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("張三");
list.add("張三丰");
list.add("李四");
list.add("王五");
list.add("趙六六");
list.stream()
.filter(s ‐> s.startsWith("張"))
.filter(s ‐> s.length() == 3)
.forEach(System.out::println);
}
}
直接閱讀程式碼的字面意思即可完美展示無關邏輯方式的語義：獲取流、過濾姓張、過濾長度為3、逐一列印。程式碼 中並沒有體現使用線性迴圈或是其他任何演算法進行遍歷，我們真正要做的事情內容被更好地體現在程式碼中。
4.2 流式思想概述
整體來看，流式思想類似於工廠車間的“生產流水線”。
當需要對多個元素進行操作（特別是多步操作）的時候，考慮到效能及便利性，我們應該首先拼好一個“模型”步驟 方案，然後再按照方案去執行它。
這張圖中展示了過濾、對映、跳過、計數等多步操作，這是一種集合元素的處理方案，而方案就是一種“函式模 型”。圖中的每一個方框都是一個“流”，呼叫指定的方法，可以從一個流模型轉換為另一個流模型。而最右側的數字 3是最終結果。
這裡的 filter 、 map 、 skip 都是在對函式模型進行操作，集合元素並沒有真正被處理。只有當終結方法 count 執行的時候，整個模型才會按照指定策略執行操作。而這得益於Lambda的延遲執行特性。
備註：“Stream流”其實是一個集合元素的函式模型，它並不是集合，也不是資料結構，其本身並不儲存任何 元素（或其地址值）。
Stream（流）是一個來自資料來源的元素佇列：
- 元素是特定型別的物件，形成一個佇列。 Java中的Stream並不會儲存元素，而是按需計算。
- 資料來源-流的來源。 可以是集合，陣列等。
和以前的Collection操作不同， Stream操作還有兩個基礎的特徵：
- Pipelining: 中間操作都會返回流物件本身。 這樣多個操作可以串聯成一個管道， 如同流式風格（fluent style）。 這樣做可以對操作進行優化， 比如延遲執行(laziness)和短路( short-circuiting)。
- 內部迭代： 以前對集合遍歷都是通過Iterator或者增強for的方式, 顯式的在集合外部進行迭代， 這叫做外部迭 代。 Stream提供了內部迭代的方式，流可以直接呼叫遍歷方法。
當使用一個流的時候，通常包括三個基本步驟：
獲取一個數據源（source）→ 資料轉換→執行操作獲取想要的結果，每次轉換原有 Stream 物件不改變，返回一個新的 Stream 物件（可以有多次轉換），這就允許對其操作可以像鏈條一樣排列，變成一個管道。
4.3 獲取流的三種方式
java.util.stream.Stream 是Java 8新加入的最常用的流介面。
4.3.1 根據Collection獲取流
java.util.Collection 介面中加入了預設方法 stream 用來獲取流，所以其所有實現類均可獲取流。
public class GetStreamDemo1 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
Stream<String> stream1 = list.stream();
Set<String> set = new HashSet<>();
Stream<String> stream2 = set.stream();
Vector<String> vector = new Vector<>();
Stream<String> stream3 = vector.stream();
}
}
4.3.2 根據Map獲取流
java.util.Map 介面不是 Collection 的子介面，且其K-V資料結構不符合流元素的單一特徵，所以獲取對應的流 需要分key、value或entry等情況：
public class GetStreamDemo2 {
public static void main(String[] args) {
Map<String, String> map = new HashMap<>();
// 三種獲取流的情況
Stream<String> keyStream = map.keySet().stream();
Stream<String> valueStream = map.values().stream();
Stream<Map.Entry<String, String>> entryStream = map.entrySet().stream();
}
}
4.3.3 根據陣列獲取流
如果使用的不是集合或對映而是陣列，由於陣列物件不可能新增預設方法，所以 Stream 介面中提供了靜態方法 of ，使用很簡單：
public class GetStreamDemo3 {
public static void main(String[] args) {
String[] array = { "張三", "李四", "王五", "趙六" };
Stream<String> stream = Stream.of(array);
}
}
4.4 操作流的常用方法
流模型的操作很豐富，這裡介紹一些常用的API。這些方法可以被分成兩種：
- 延遲方法：返回值型別仍然是 Stream 介面自身型別的方法，因此支援鏈式呼叫。（除了終結方法外，其餘方 法均為延遲方法。）
- 終結方法：返回值型別不再是 Stream 介面自身型別的方法，因此不再支援類似 StringBuilder 那樣的鏈式調 用。本小節中，終結方法包括
count和forEach方法。
4.4.1 逐一處理方法： forEach
雖然方法名字叫 forEach ，但是與for迴圈中的“for-each”暱稱不同。該方法接收一個 Consumer 介面函式，會將每一個流元素交給該函式進行處理。
void forEach(Consumer<? super T> action);
java.util.function.Consumer介面是一個消費型介面。 Consumer介面中包含抽象方法void accept(T t)，意為消費一個指定泛型的資料。
基本使用：
public class StreamForEach {
public static void main(String[] args) {
Stream<String> stream = Stream.of("張三", "李四", "王五");
stream.forEach(name-> System.out.println(name));
}
}
4.4.2 過濾方法：filter
可以通過 filter 方法將一個流轉換成另一個子集流。該介面接收一個 Predicate 函式式介面引數（可以是一個Lambda或方法引用）作為篩選條件。
Stream<T> filter(Predicate<? super T> predicate);
java.util.stream.Predicate是函式式介面，其中唯一的抽象方法為： boolean test(T t)；該方法將會產生一個boolean值結果，代表指定的條件是否滿足。如果結果為true，那麼Stream流的 filter 方法 將會留用元素；如果結果為false，那麼 filter 方法將會捨棄元素。
filter方法基本使用：
public class StreamFilter {
public static void main(String[] args) {
Stream<String> original = Stream.of("張三", "李四", "王五");
Stream<String> result = original.filter(s -> s.startsWith("張"));
List<String> list= result.collect(Collectors.toList());
System.out.println(list);
}
}
4.4.3 對映方法：map
如果需要將流中的元素對映到另一個流中，可以使用 map 方法。該介面需要一個 Function 函式式介面引數，可以將當前流中的T型別資料轉換為另一種R型別的流。
<R> Stream<R> map(Function<? super T, ? extends R> mapper);
java.util.stream.Function是函式式介面，其中唯一的抽象方法為：R apply(T t)； 這可以將一種T型別轉換成為R型別，而這種轉換的動作，就稱為“對映”。
map方法的基本使用：
public class StreamMap {
public static void main(String[] args) {
Stream<String> original = Stream.of("10", "12", "18");
Stream<Integer> result = original.map(str‐>Integer.parseInt(str));
}
}
這段程式碼中， map 方法的引數通過方法引用，將字串型別轉換成為了int型別（並自動裝箱為 Integer 類物件）。
4.4.4 統計個數方法：count
正如舊集合 Collection 當中的 size 方法一樣，流提供 count 方法來數一數其中的元素個數，該方法返回一個long值代表元素個數（不再像舊集合那樣是int值）。
long count();
count方法基本使用：
public class StreamCount {
public static void main(String[] args) {
Stream<String> original = Stream.of("張三", "李四", "王五");
Stream<String> result = original.filter(s ‐> s.startsWith("張"));
System.out.println(result.count()); // 1
}
}
4.4.5 取用前幾個方法：limit
limit 方法可以對流進行擷取，只取用前n個。引數是一個long型，如果集合當前長度大於引數則進行擷取；否則不進行操作。
Stream<T> limit(long maxSize);
limit方法基本使用：
public class StreamLimit {
public static void main(String[] args) {
Stream<String> original = Stream.of("張三", "李四", "王五");
Stream<String> result = original.limit(2);
System.out.println(result.count()); // 2
}
}
4.4.6 跳過前幾個方法：skip
如果希望跳過前幾個元素，可以使用 skip 方法獲取一個擷取之後的新流。如果流的當前長度大於n，則跳過前n個；否則將會得到一個長度為0的空流。
Stream<T> skip(long n);
skip方法基本使用：
public class StreamSkip {
public static void main(String[] args) {
Stream<String> original = Stream.of("張三", "李四", "王五");
Stream<String> result = original.skip(2);
System.out.println(result.count()); // 1
}
}
4.6.7 組合方法：concat
如果有兩個流，希望合併成為一個流，那麼可以使用 Stream 介面的靜態方法 concat ：
static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)
concat方法的基本使用：
public class StreamConcat {
public static void main(String[] args) {
Stream<String> streamA = Stream.of("張三");
Stream<String> streamB = Stream.of("李四");
Stream<String> result = Stream.concat(streamA, streamB);
}
}