主要內容
- 自定義函數式接口
- 函數式編程
- 常用函數式接口
- Stream流
- 方法引用
學習目標
- 能夠使用@FunctionalInterface注解
- 能夠自定義無參無返回函數式接口
- 能夠自定義有參有返回函數式接口
- 能夠理解Lambda延遲執行的特點
- 能夠使用Lambda作為方法的參數
- 能夠使用Lambda作為方法的返回值
- 能夠使用Supplier函數式接口
- 能夠使用Consumer函數式接口
- 能夠使用Function<T, R>函數式接口
- 能夠使用Predicate函數式接口
- 能夠理解流與集合相比的優點
- 能夠理解流的延遲執行特點
- 能夠通過集合、映射或數組獲取流
- 能夠掌握常用的流操作
- 能夠使用輸出語句的方法引用
- 能夠通過4種方式使用方法引用
- 能夠使用類和數組的構造器引用
第一章 函數式接口
1.1 概念
函數式接口在Java中是指：有且僅有一個抽象方法的接口。
函數式接口，即適用於函數式編程場景的接口。而Java中的函數式編程體現就是Lambda，所以函數式接口就是可以適用於Lambda使用的接口。只有確保接口中有且僅有一個抽象方法，Java中的Lambda才能順利地進行推導。
備注：“語法糖”是指使用更加方便，但是原理不變的代碼語法。例如在遍歷集合時使用的for-each語法，其實底層的實現原理仍然是迭代器，這便是“語法糖”。從應用層面來講，Java中的Lambda可以被當做是匿名內部類的“語法糖”，但是二者在原理上是不同的。
1.2 格式
只要確保接口中有且僅有一個抽象方法即可：
修飾符 interface 接口名稱 {
public abstract 返回值類型 方法名稱(可選參數信息);
// 其他非抽象方法內容
}
由於接口當中抽象方法的public abstract是可以省略的，所以定義一個函數式接口很簡單：
public interface MyFunctionalInterface {
void myMethod();
}
1.3 @FunctionalInterface注解
與@Override注解的作用類似，Java 8中專門為函數式接口引入了一個新的注解：@FunctionalInterface。該注解可用於一個接口的定義上：
@FunctionalInterface
public interface MyFunctionalInterface {
void myMethod();
}
一旦使用該注解來定義接口，編譯器將會強制檢查該接口是否確實有且僅有一個抽象方法，否則將會報錯。需要注意的是，即使不使用該注解，只要滿足函數式接口的定義，這仍然是一個函數式接口，使用起來都一樣。
1.4 自定義函數式接口
對於剛剛定義好的MyFunctionalInterface函數式接口，典型使用場景就是作為方法的參數：
public class Demo09FunctionalInterface {
// 使用自定義的函數式接口作為方法參數
private static void doSomething(MyFunctionalInterface inter) {
inter.myMethod(); // 調用自定義的函數式接口方法
}
public static void main(String[] args) {
// 調用使用函數式接口的方法
doSomething(() -> System.out.println("Lambda執行啦！"));
}
}
第二章 函數式編程
在兼顧面向對象特性的基礎上，Java語言通過Lambda表達式與方法引用等，為開發者打開了函數式編程的大門。下面我們做一個初探。
2.1 Lambda的延遲執行
有些場景的代碼執行后，結果不一定會被使用，從而造成性能浪費。而Lambda表達式是延遲執行的，這正好可以作為解決方案，提升性能。
性能浪費的日志案例
注:日志可以幫助我們快速的定位問題，記錄程序運行過程中的情況，以便項目的監控和優化。
一種典型的場景就是對參數進行有條件使用，例如對日志消息進行拼接后，在滿足條件的情況下進行打印輸出：
public class Demo01Logger {
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可以做到更好。
體驗Lambda的更優寫法
使用Lambda必然需要一個函數式接口：
@FunctionalInterface
public interface MessageBuilder {
String buildMessage();
}
然后對log方法進行改造：
public class Demo02LoggerLambda {
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 );
}
}
這樣一來，只有當級別滿足要求的時候，才會進行三個字符串的拼接；否則三個字符串將不會進行拼接。
證明Lambda的延遲
下面的代碼可以通過結果進行驗證：
public class Demo03LoggerDelay {
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.2 使用Lambda作為參數和返回值
如果拋開實現原理不說，Java中的Lambda表達式可以被當作是匿名內部類的替代品。如果方法的參數是一個函數式接口類型，那么就可以使用Lambda表達式進行替代。使用Lambda表達式作為方法參數，其實就是使用函數式接口作為方法參數。
例如java.lang.Runnable接口就是一個函數式接口，假設有一個startThread方法使用該接口作為參數，那么就可以使用Lambda進行傳參。這種情況其實和Thread類的構造方法參數為Runnable沒有本質區別。
public class Demo04Runnable {
private static void startThread(Runnable task) {
new Thread(task).start();
}
public static void main(String[] args) {
startThread(() -> System.out.println("線程任務執行！"));
}
}
類似地，如果一個方法的返回值類型是一個函數式接口，那么就可以直接返回一個Lambda表達式。當需要通過一個方法來獲取一個java.util.Comparator接口類型的對象作為排序器時,就可以調該方法獲取。
import java.util.Arrays;
import java.util.Comparator;
public class Demo06Comparator {
private static Comparator<String> newComparator() {
return (a, b) -> b.length() - a.length();
}
public static void main(String[] args) {
String[] array = { "abc", "ab", "abcd" };
System.out.println(Arrays.toString(array));
Arrays.sort(array, newComparator());
System.out.println(Arrays.toString(array));
}
}
其中直接return一個Lambda表達式即可。
第三章 常用函數式接口
JDK提供了大量常用的函數式接口以豐富Lambda的典型使用場景，它們主要在java.util.function包中被提供。下面是最簡單的幾個接口及使用示例。
3.1 Supplier接口
java.util.function.Supplier<T>接口僅包含一個無參的方法：T get()。用來獲取一個泛型參數指定類型的對象數據。由於這是一個函數式接口，這也就意味着對應的Lambda表達式需要“對外提供”一個符合泛型類型的對象數據。
import java.util.function.Supplier;
public class Demo08Supplier {
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));
}
}
練習：求數組元素最大值
題目
使用Supplier接口作為方法參數類型，通過Lambda表達式求出int數組中的最大值。提示：接口的泛型請使用java.lang.Integer類。
解答
public class Demo02Test {
//定一個方法,方法的參數傳遞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);
}
}
3.3 Consumer接口
java.util.function.Consumer<T>接口則正好與Supplier接口相反，它不是生產一個數據，而是消費一個數據，其數據類型由泛型決定。
抽象方法：accept
Consumer接口中包含抽象方法void accept(T t)，意為消費一個指定泛型的數據。基本使用如：
import java.util.function.Consumer;
public class Demo09Consumer {
private static void consumeString(Consumer<String> function) {
function.accept("Hello");
}
public static void main(String[] args) {
consumeString(s -> System.out.println(s));
}
}
當然，更好的寫法是使用方法引用。
默認方法：andThen
如果一個方法的參數和返回值全都是Consumer類型，那么就可以實現效果：消費數據的時候，首先做一個操作，然后再做一個操作，實現組合。而這個方法就是Consumer接口中的default方法andThen。下面是JDK的源代碼：
default Consumer<T> andThen(Consumer<? super T> after) {
Objects.requireNonNull(after);
return (T t) -> { accept(t); after.accept(t); };
}
備注：java.util.Objects的requireNonNull靜態方法將會在參數為null時主動拋出NullPointerException異常。這省去了重復編寫if語句和拋出空指針異常的麻煩。
要想實現組合，需要兩個或多個Lambda表達式即可，而andThen的語義正是“一步接一步”操作。例如兩個步驟組合的情況：
import java.util.function.Consumer;
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。當然，通過鏈式寫法可以實現更多步驟的組合。
3.4 練習：格式化打印信息
題目
下面的字符串數組當中存有多條信息，請按照格式“姓名：XX。性別：XX。”的格式將信息打印出來。要求將打印姓名的動作作為第一個Consumer接口的Lambda實例，將打印性別的動作作為第二個Consumer接口的Lambda實例，將兩個Consumer接口按照順序“拼接”到一起。
public static void main(String[] args) {
String[] array = { "迪麗熱巴,女", "古力娜扎,女", "馬爾扎哈,男" };
}
解答
import java.util.function.Consumer;
public class DemoConsumer {
public static void main(String[] args) {
String[] array = { "迪麗熱巴,女", "古力娜扎,女", "馬爾扎哈,男" };
printInfo(s -> System.out.print("姓名：" + s.split(",")[0]),
s -> System.out.println("。性別：" + s.split(",")[1] + "。"),
array);
}
private static void printInfo(Consumer<String> one, Consumer<String> two, String[] array) {
for (String info : array) {
one.andThen(two).accept(info); // 姓名：迪麗熱巴。性別：女。
}
}
}
3.5 Predicate接口
有時候我們需要對某種類型的數據進行判斷，從而得到一個boolean值結果。這時可以使用java.util.function.Predicate<T>接口。
抽象方法：test
Predicate接口中包含一個抽象方法：boolean test(T t)。用於條件判斷的場景：
import java.util.function.Predicate;
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則認為很長。
默認方法：and
既然是條件判斷，就會存在與、或、非三種常見的邏輯關系。其中將兩個Predicate條件使用“與”邏輯連接起來實現“並且”的效果時，可以使用default方法and。其JDK源碼為：
default Predicate<T> and(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) && other.test(t);
}
如果要判斷一個字符串既要包含大寫“H”，又要包含大寫“W”，那么：
import java.util.function.Predicate;
public class Demo16PredicateAnd {
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"));
}
}
默認方法：or
與and的“與”類似，默認方法or實現邏輯關系中的“或”。JDK源碼為：
default Predicate<T> or(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) || other.test(t);
}
如果希望實現邏輯“字符串包含大寫H或者包含大寫W”，那么代碼只需要將“and”修改為“or”名稱即可，其他都不變：
import java.util.function.Predicate;
public class Demo16PredicateAnd {
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"));
}
}
默認方法：negate
“與”、“或”已經了解了，剩下的“非”（取反）也會簡單。默認方法negate的JDK源代碼為：
default Predicate<T> negate() {
return (t) -> !test(t);
}
從實現中很容易看出，它是執行了test方法之后，對結果boolean值進行“!”取反而已。一定要在test方法調用之前調用negate方法，正如and和or方法一樣：
import java.util.function.Predicate;
public class Demo17PredicateNegate {
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);
}
}
3.6 練習：集合信息篩選
題目
數組當中有多條“姓名+性別”的信息如下，請通過Predicate接口的拼裝將符合要求的字符串篩選到集合ArrayList中，需要同時滿足兩個條件：
-
必須為女生。
-
姓名為4個字。
public class DemoPredicate {
public static void main(String[] args) {
String[] array = { "迪麗熱巴,女", "古力娜扎,女", "馬爾扎哈,男", "趙麗穎,女" };
}
}
解答
import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;
public class DemoPredicate {
public static void main(String[] args) {
String[] array = { "迪麗熱巴,女", "古力娜扎,女", "馬爾扎哈,男", "趙麗穎,女" };
List<String> list = filter(array,
s -> "女".equals(s.split(",")[1]),
s -> s.split(",")[0].length() == 4);
System.out.println(list);
}
private static List<String> filter(String[] array, Predicate<String> one,
Predicate<String> two) {
List<String> list = new ArrayList<>();
for (String info : array) {
if (one.and(two).test(info)) {
list.add(info);
}
}
return list;
}
}
3.7 Function接口
java.util.function.Function<T,R>接口用來根據一個類型的數據得到另一個類型的數據，前者稱為前置條件，后者稱為后置條件。
抽象方法：apply
Function接口中最主要的抽象方法為：R apply(T t)，根據類型T的參數獲取類型R的結果。
使用的場景例如：將String類型轉換為Integer類型。
import java.util.function.Function;
public class Demo11FunctionApply {
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));
}
}
當然，最好是通過方法引用的寫法。
默認方法：andThen
Function接口中有一個默認的andThen方法，用來進行組合操作。JDK源代碼如：
default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
Objects.requireNonNull(after);
return (T t) -> after.apply(apply(t));
}
該方法同樣用於“先做什么，再做什么”的場景，和Consumer中的andThen差不多：
import java.util.function.Function;
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.8 練習：自定義函數模型拼接
題目
請使用Function進行函數模型的拼接，按照順序需要執行的多個函數操作為：
String str = "趙麗穎,20";
- 將字符串截取數字年齡部分，得到字符串；
- 將上一步的字符串轉換成為int類型的數字；
- 將上一步的int數字累加100，得到結果int數字。
解答
import java.util.function.Function;
public class DemoFunction {
public static void main(String[] args) {
String str = "趙麗穎,20";
int age = getAgeNum(str, s -> s.split(",")[1],
s ->Integer.parseInt(s),
n -> n += 100);
System.out.println(age);
}
private static int getAgeNum(String str, Function<String, String> one,
Function<String, Integer> two,
Function<Integer, Integer> three) {
return one.andThen(two).andThen(three).apply(str);
}
}
第四章 Stream流
說到Stream便容易想到I/O Stream，而實際上，誰規定“流”就一定是“IO流”呢？在Java 8中，得益於Lambda所帶來的函數式編程，引入了一個全新的Stream概念，用於解決已有集合類庫既有的弊端。
4.1 引言
傳統集合的多步遍歷代碼
幾乎所有的集合（如Collection接口或Map接口等）都支持直接或間接的遍歷操作。而當我們需要對集合中的元素進行操作的時候，除了必需的添加、刪除、獲取外，最典型的就是集合遍歷。例如：
import java.util.ArrayList;
import java.util.List;
public class Demo01ForEach {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("張無忌");
list.add("周芷若");
list.add("趙敏");
list.add("張強");
list.add("張三豐");
for (String name : list) {
System.out.println(name);
}
}
}
這是一段非常簡單的集合遍歷操作：對集合中的每一個字符串都進行打印輸出操作。
循環遍歷的弊端
Java 8的Lambda讓我們可以更加專注於做什么（What），而不是怎么做（How），這點此前已經結合內部類進行了對比說明。現在，我們仔細體會一下上例代碼，可以發現：
- for循環的語法就是“怎么做”
- for循環的循環體才是“做什么”
為什么使用循環？因為要進行遍歷。但循環是遍歷的唯一方式嗎？遍歷是指每一個元素逐一進行處理，而並不是從第一個到最后一個順次處理的循環。前者是目的，后者是方式。
試想一下，如果希望對集合中的元素進行篩選過濾：
- 將集合A根據條件一過濾為子集B；
- 然后再根據條件二過濾為子集C。
那怎么辦？在Java 8之前的做法可能為：
import java.util.ArrayList;
import java.util.List;
public class Demo02NormalFilter {
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);
}
}
}
這段代碼中含有三個循環，每一個作用不同：
- 首先篩選所有姓張的人；
- 然后篩選名字有三個字的人；
- 最后進行對結果進行打印輸出。
每當我們需要對集合中的元素進行操作的時候，總是需要進行循環、循環、再循環。這是理所當然的么？不是。循環是做事情的方式，而不是目的。另一方面，使用線性循環就意味着只能遍歷一次。如果希望再次遍歷，只能再使用另一個循環從頭開始。
Stream的更優寫法
下面來看一下借助Java 8的Stream API，什么才叫優雅：
import java.util.ArrayList;
import java.util.List;
public class Demo03StreamFilter {
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 流式思想概述
注意：請暫時忘記對傳統IO流的固有印象！
整體來看，流式思想類似於工廠車間的“生產流水線”。
當需要對多個元素進行操作（特別是多步操作）的時候，考慮到性能及便利性，我們應該首先拼好一個“模型”步驟方案，然后再按照方案去執行它。
這張圖中展示了過濾、映射、跳過、計數等多步操作，這是一種集合元素的處理方案，而方案就是一種“函數模型”。圖中的每一個方框都是一個“流”，調用指定的方法，可以從一個流模型轉換為另一個流模型。而最右側的數字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<T>是Java 8新加入的最常用的流接口。（這並不是一個函數式接口。）
獲取一個流非常簡單，有以下幾種常用的方式：
- 所有的
Collection集合都可以通過stream默認方法獲取流； Stream接口的靜態方法of可以獲取數組對應的流。
根據Collection獲取流
首先，java.util.Collection接口中加入了default方法stream用來獲取流，所以其所有實現類均可獲取流。
import java.util.*;
import java.util.stream.Stream;
public class Demo04GetStream {
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();
}
}
根據Map獲取流
java.util.Map接口不是Collection的子接口，且其K-V數據結構不符合流元素的單一特征，所以獲取對應的流需要分key、value或entry等情況：
import java.util.HashMap;
import java.util.Map;
import java.util.stream.Stream;
public class Demo05GetStream {
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();
}
}
根據數組獲取流
如果使用的不是集合或映射而是數組，由於數組對象不可能添加默認方法，所以Stream接口中提供了靜態方法of，使用很簡單：
import java.util.stream.Stream;
public class Demo06GetStream {
public static void main(String[] args) {
String[] array = { "張無忌", "張翠山", "張三豐", "張一元" };
Stream<String> stream = Stream.of(array);
}
}
備注：
of方法的參數其實是一個可變參數，所以支持數組。
4.4 常用方法
流模型的操作很豐富，這里介紹一些常用的API。這些方法可以被分成兩種：
-
延遲方法：返回值類型仍然是
Stream接口自身類型的方法，因此支持鏈式調用。（除了終結方法外，其余方法均為延遲方法。） -
終結方法：返回值類型不再是
Stream接口自身類型的方法，因此不再支持類似StringBuilder那樣的鏈式調用。本小節中，終結方法包括count和forEach方法。
備注：本小節之外的更多方法，請自行參考API文檔。
逐一處理：forEach
雖然方法名字叫forEach，但是與for循環中的“for-each”昵稱不同。
void forEach(Consumer<? super T> action);
該方法接收一個Consumer接口函數，會將每一個流元素交給該函數進行處理。
復習Consumer接口
java.util.function.Consumer<T>接口是一個消費型接口。
Consumer接口中包含抽象方法void accept(T t)，意為消費一個指定泛型的數據。
基本使用：
import java.util.stream.Stream;
public class Demo12StreamForEach {
public static void main(String[] args) {
Stream<String> stream = Stream.of("張無忌", "張三豐", "周芷若");
stream.forEach(name-> System.out.println(name));
}
}
過濾：filter
可以通過filter方法將一個流轉換成另一個子集流。方法簽名：
Stream<T> filter(Predicate<? super T> predicate);
該接口接收一個Predicate函數式接口參數（可以是一個Lambda或方法引用）作為篩選條件。
復習Predicate接口
在上面我們已經學習過java.util.stream.Predicate函數式接口，其中唯一的抽象方法為：
boolean test(T t);
該方法將會產生一個boolean值結果，代表指定的條件是否滿足。如果結果為true，那么Stream流的filter方法將會留用元素；如果結果為false，那么filter方法將會舍棄元素。
基本使用
Stream流中的filter方法基本使用的代碼如：
import java.util.stream.Stream;
public class Demo07StreamFilter {
public static void main(String[] args) {
Stream<String> original = Stream.of("張無忌", "張三豐", "周芷若");
Stream<String> result = original.filter(s -> s.startsWith("張"));
}
}
在這里通過Lambda表達式來指定了篩選的條件：必須姓張。
映射：map
如果需要將流中的元素映射到另一個流中，可以使用map方法。方法簽名：
<R> Stream<R> map(Function<? super T, ? extends R> mapper);
該接口需要一個Function函數式接口參數，可以將當前流中的T類型數據轉換為另一種R類型的流。
復習Function接口
在上面我們已經學習過java.util.stream.Function函數式接口，其中唯一的抽象方法為：
R apply(T t);
這可以將一種T類型轉換成為R類型，而這種轉換的動作，就稱為“映射”。
基本使用
Stream流中的map方法基本使用的代碼如：
import java.util.stream.Stream;
public class Demo08StreamMap {
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類對象）。
統計個數：count
正如舊集合Collection當中的size方法一樣，流提供count方法來數一數其中的元素個數：
long count();
該方法返回一個long值代表元素個數（不再像舊集合那樣是int值）。基本使用：
import java.util.stream.Stream;
public class Demo09StreamCount {
public static void main(String[] args) {
Stream<String> original = Stream.of("張無忌", "張三豐", "周芷若");
Stream<String> result = original.filter(s -> s.startsWith("張"));
System.out.println(result.count()); // 2
}
}
取用前幾個：limit
limit方法可以對流進行截取，只取用前n個。方法簽名：
Stream<T> limit(long maxSize);
參數是一個long型，如果集合當前長度大於參數則進行截取；否則不進行操作。基本使用：
import java.util.stream.Stream;
public class Demo10StreamLimit {
public static void main(String[] args) {
Stream<String> original = Stream.of("張無忌", "張三豐", "周芷若");
Stream<String> result = original.limit(2);
System.out.println(result.count()); // 2
}
}
跳過前幾個：skip
如果希望跳過前幾個元素，可以使用skip方法獲取一個截取之后的新流：
Stream<T> skip(long n);
如果流的當前長度大於n，則跳過前n個；否則將會得到一個長度為0的空流。基本使用：
import java.util.stream.Stream;
public class Demo11StreamSkip {
public static void main(String[] args) {
Stream<String> original = Stream.of("張無忌", "張三豐", "周芷若");
Stream<String> result = original.skip(2);
System.out.println(result.count()); // 1
}
}
組合：concat
如果有兩個流，希望合並成為一個流，那么可以使用Stream接口的靜態方法concat：
static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)
備注：這是一個靜態方法，與
java.lang.String當中的concat方法是不同的。
該方法的基本使用代碼如：
import java.util.stream.Stream;
public class Demo12StreamConcat {
public static void main(String[] args) {
Stream<String> streamA = Stream.of("張無忌");
Stream<String> streamB = Stream.of("張翠山");
Stream<String> result = Stream.concat(streamA, streamB);
}
}
4.5 練習：集合元素處理（傳統方式）
題目
現在有兩個ArrayList集合存儲隊伍當中的多個成員姓名，要求使用傳統的for循環（或增強for循環）依次進行以下若干操作步驟：
- 第一個隊伍只要名字為3個字的成員姓名；存儲到一個新集合中。
- 第一個隊伍篩選之后只要前3個人；存儲到一個新集合中。
- 第二個隊伍只要姓張的成員姓名；存儲到一個新集合中。
- 第二個隊伍篩選之后不要前2個人；存儲到一個新集合中。
- 將兩個隊伍合並為一個隊伍；存儲到一個新集合中。
- 根據姓名創建Person對象；存儲到一個新集合中。
- 打印整個隊伍的Person對象信息。
兩個隊伍（集合）的代碼如下：
import java.util.ArrayList;
import java.util.List;
public class DemoArrayListNames {
public static void main(String[] args) {
//第一支隊伍
ArrayList<String> one = new ArrayList<>();
one.add("迪麗熱巴");
one.add("宋遠橋");
one.add("蘇星河");
one.add("石破天");
one.add("石中玉");
one.add("老子");
one.add("庄子");
one.add("洪七公");
//第二支隊伍
ArrayList<String> two = new ArrayList<>();
two.add("古力娜扎");
two.add("張無忌");
two.add("趙麗穎");
two.add("張三豐");
two.add("尼古拉斯趙四");
two.add("張天愛");
two.add("張二狗");
// ....
}
}
而Person類的代碼為：
public class Person {
private String name;
public Person() {}
public Person(String name) {
this.name = name;
}
@Override
public String toString() {
return "Person{name='" + name + "'}";
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
解答
既然使用傳統的for循環寫法，那么：
public class DemoArrayListNames {
public static void main(String[] args) {
List<String> one = new ArrayList<>();
// ...
List<String> two = new ArrayList<>();
// ...
// 第一個隊伍只要名字為3個字的成員姓名；
List<String> oneA = new ArrayList<>();
for (String name : one) {
if (name.length() == 3) {
oneA.add(name);
}
}
// 第一個隊伍篩選之后只要前3個人；
List<String> oneB = new ArrayList<>();
for (int i = 0; i < 3; i++) {
oneB.add(oneA.get(i));
}
// 第二個隊伍只要姓張的成員姓名；
List<String> twoA = new ArrayList<>();
for (String name : two) {
if (name.startsWith("張")) {
twoA.add(name);
}
}
// 第二個隊伍篩選之后不要前2個人；
List<String> twoB = new ArrayList<>();
for (int i = 2; i < twoA.size(); i++) {
twoB.add(twoA.get(i));
}
// 將兩個隊伍合並為一個隊伍；
List<String> totalNames = new ArrayList<>();
totalNames.addAll(oneB);
totalNames.addAll(twoB);
// 根據姓名創建Person對象；
List<Person> totalPersonList = new ArrayList<>();
for (String name : totalNames) {
totalPersonList.add(new Person(name));
}
// 打印整個隊伍的Person對象信息。
for (Person person : totalPersonList) {
System.out.println(person);
}
}
}
運行結果為：
Person{name='宋遠橋'}
Person{name='蘇星河'}
Person{name='石破天'}
Person{name='張天愛'}
Person{name='張二狗'}
4.6 練習：集合元素處理（Stream方式）
題目
將上一題當中的傳統for循環寫法更換為Stream流式處理方式。兩個集合的初始內容不變，Person類的定義也不變。
解答
等效的Stream流式處理代碼為：
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;
public class DemoStreamNames {
public static void main(String[] args) {
List<String> one = new ArrayList<>();
// ...
List<String> two = new ArrayList<>();
// ...
// 第一個隊伍只要名字為3個字的成員姓名；
// 第一個隊伍篩選之后只要前3個人；
Stream<String> streamOne = one.stream().filter(s -> s.length() == 3).limit(3);
// 第二個隊伍只要姓張的成員姓名；
// 第二個隊伍篩選之后不要前2個人；
Stream<String> streamTwo = two.stream().filter(s -> s.startsWith("張")).skip(2);
// 將兩個隊伍合並為一個隊伍；
// 根據姓名創建Person對象；
// 打印整個隊伍的Person對象信息。
Stream.concat(streamOne, streamTwo).map(Person::new).forEach(System.out::println);
}
}
運行效果完全一樣：
Person{name='宋遠橋'}
Person{name='蘇星河'}
Person{name='石破天'}
Person{name='張天愛'}
Person{name='張二狗'}
雙冒號（::）運算符在Java 8中被用作方法引用（method reference），方法引用是與lambda表達式相關的一個重要特性。它提供了一種不執行方法的方法。在下面詳細介紹。
第五章 方法引用
在使用Lambda表達式的時候，我們實際上傳遞進去的代碼就是一種解決方案：拿什么參數做什么操作。那么考慮一種情況：如果我們在Lambda中所指定的操作方案，已經有地方存在相同方案，那是否還有必要再寫重復邏輯？
5.1 冗余的Lambda場景
來看一個簡單的函數式接口以應用Lambda表達式：
@FunctionalInterface
public interface Printable {
void print(String str);
}
在Printable接口當中唯一的抽象方法print接收一個字符串參數，目的就是為了打印顯示它。那么通過Lambda來使用它的代碼很簡單：
public class Demo01PrintSimple {
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（類型可推導，所以可省略）數據后，在控制台中輸出它。
5.2 問題分析
這段代碼的問題在於，對字符串進行控制台打印輸出的操作方案，明明已經有了現成的實現，那就是System.out對象中的println(String)方法。既然Lambda希望做的事情就是調用println(String)方法，那何必自己手動調用呢？
5.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);
}
}
其中的雙冒號::寫法，這被稱為“方法引用”，而雙冒號是一種新的語法。
5.4 方法引用符
雙冒號::為引用運算符，而它所在的表達式被稱為方法引用。如果Lambda要表達的函數方案已經存在於某個方法的實現中，那么則可以通過雙冒號來引用該方法作為Lambda的替代者。
語義分析
例如上例中，System.out對象中有一個重載的println(String)方法恰好就是我們所需要的。那么對於printString方法的函數式接口參數，對比下面兩種寫法，完全等效：
- Lambda表達式寫法：
s -> System.out.println(s) - 方法引用寫法：
System.out::println
第一種語義是指：拿到參數之后經Lambda之手，繼而傳遞給System.out.println方法去處理。
第二種等效寫法的語義是指：直接讓System.out中的println方法來取代Lambda。兩種寫法的執行效果完全一樣，而第二種方法引用的寫法復用了已有方案，更加簡潔。
注:Lambda 中 傳遞的參數 一定是方法引用中 的那個方法可以接收的類型,否則會拋出異常
推導與省略
如果使用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) {
printInteger(System.out::println);
}
}
這次方法引用將會自動匹配到println(int)的重載形式。
5.5 通過對象名引用成員方法
這是最常見的一種用法，與上例相同。如果一個類中已經存在了一個成員方法：
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 Demo04MethodRef {
private static void printString(Printable lambda) {
lambda.print("Hello");
}
public static void main(String[] args) {
MethodRefObject obj = new MethodRefObject();
printString(obj::printUpperCase);
}
}
5.6 通過類名稱引用靜態方法
由於在java.lang.Math類中已經存在了靜態方法abs，所以當我們需要通過Lambda來調用該方法時，有兩種寫法。首先是函數式接口：
@FunctionalInterface
public interface Calcable {
int calc(int num);
}
第一種寫法是使用Lambda表達式：
public class Demo05Lambda {
private static void method(int num, Calcable lambda) {
System.out.println(lambda.calc(num));
}
public static void main(String[] args) {
method(-10, n -> Math.abs(n));
}
}
但是使用方法引用的更好寫法是：
public class Demo06MethodRef {
private static void method(int num, Calcable lambda) {
System.out.println(lambda.calc(num));
}
public static void main(String[] args) {
method(-10, Math::abs);
}
}
在這個例子中，下面兩種寫法是等效的：
- Lambda表達式：
n -> Math.abs(n) - 方法引用：
Math::abs
5.7 通過super引用成員方法
如果存在繼承關系，當Lambda中需要出現super調用時，也可以使用方法引用進行替代。首先是函數式接口：
@FunctionalInterface
public interface Greetable {
void greet();
}
然后是父類Human的內容：
public class Human {
public void sayHello() {
System.out.println("Hello!");
}
}
最后是子類Man的內容，其中使用了Lambda的寫法：
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方法,使用Lambda表達式
method(()->{
//創建Human對象,調用sayHello方法
new Human().sayHello();
});
//簡化Lambda
method(()->new Human().sayHello());
//使用super關鍵字代替父類對象
method(()->super.sayHello());
}
}
但是如果使用方法引用來調用父類中的sayHello方法會更好，例如另一個子類Woman：
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);
}
}
在這個例子中，下面兩種寫法是等效的：
- Lambda表達式：
() -> super.sayHello() - 方法引用：
super::sayHello
5.8 通過this引用成員方法
this代表當前對象，如果需要引用的方法就是當前類中的成員方法，那么可以使用“this::成員方法”的格式來使用方法引用。首先是簡單的函數式接口：
@FunctionalInterface
public interface Richable {
void buy();
}
下面是一個丈夫Husband類：
public class Husband {
private void marry(Richable lambda) {
lambda.buy();
}
public void beHappy() {
marry(() -> System.out.println("買套房子"));
}
}
開心方法beHappy調用了結婚方法marry，后者的參數為函數式接口Richable，所以需要一個Lambda表達式。但是如果這個Lambda表達式的內容已經在本類當中存在了，則可以對Husband丈夫類進行修改：
public class Husband {
private void buyHouse() {
System.out.println("買套房子");
}
private void marry(Richable lambda) {
lambda.buy();
}
public void beHappy() {
marry(() -> this.buyHouse());
}
}
如果希望取消掉Lambda表達式，用方法引用進行替換，則更好的寫法為：
public class Husband {
private void buyHouse() {
System.out.println("買套房子");
}
private void marry(Richable lambda) {
lambda.buy();
}
public void beHappy() {
marry(this::buyHouse);
}
}
在這個例子中，下面兩種寫法是等效的：
- Lambda表達式：
() -> this.buyHouse() - 方法引用：
this::buyHouse
5.9 類的構造器引用
由於構造器的名稱與類名完全一樣，並不固定。所以構造器引用使用類名稱::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);
}
要使用這個函數式接口，可以通過Lambda表達式：
public class Demo09Lambda {
public static void printName(String name, PersonBuilder builder) {
System.out.println(builder.buildPerson(name).getName());
}
public static void main(String[] args) {
printName("趙麗穎", name -> new Person(name));
}
}
但是通過構造器引用，有更好的寫法：
public class Demo10ConstructorRef {
public static void printName(String name, PersonBuilder builder) {
System.out.println(builder.buildPerson(name).getName());
}
public static void main(String[] args) {
printName("趙麗穎", Person::new);
}
}
在這個例子中，下面兩種寫法是等效的：
- Lambda表達式：
name -> new Person(name) - 方法引用：
Person::new
5.10 數組的構造器引用
數組也是Object的子類對象，所以同樣具有構造器，只是語法稍有不同。如果對應到Lambda的使用場景中時，需要一個函數式接口：
@FunctionalInterface
public interface ArrayBuilder {
int[] buildArray(int length);
}
在應用該接口的時候，可以通過Lambda表達式：
public class Demo11ArrayInitRef {
private static int[] initArray(int length, ArrayBuilder builder) {
return builder.buildArray(length);
}
public static void main(String[] args) {
int[] array = initArray(10, length -> new 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);
}
}
在這個例子中，下面兩種寫法是等效的：
- Lambda表達式：
length -> new int[length] - 方法引用：
int[]::new