主要內容:
1: Stream流
1.1: Filter
1.2: Map
1.3: limit
1.4: skip
2: 方法引用
2.1 : 系統類方法引用
2.2 : 構造器方法引用
2.3 : 靜態方法引用
2.4 : 數組的方法引用
2.5 : 對象的方法引用
2.6 : 通過this super 引用成員方法
1: Stream流
說到Stream便容易想到I/O Stream，而實際上，誰規定“流”就一定是“IO流”呢？在Java 8中，得益於Lambda所帶
來的函數式編程，引入了一個全新的Stream概念，用於解決已有集合類庫既有的弊端。(操作按照流程化進行 關注與具體邏輯)
1.1 引言
傳統集合的多步遍歷代碼
幾乎所有的集合（如 Collection 接口或 Map 接口等）都支持直接或間接的遍歷操作。而當我們需要對集合中的元
素進行操作的時候，除了必需的添加、刪除、獲取外，最典型的就是集合遍歷。例如：
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循環的循環體才是“做什么”
舉例:
試想一下，如果希望對集合中的元素進行篩選過濾：
1. 將集合A根據條件一過濾為子集B；
2. 然后再根據條件二過濾為子集C。
那怎么辦？在Java 8之前之后的的做法可能為：
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); } // java8之后的風格一句代碼搞定 並且多核性能也有優勢 list.stream().filter(s->s.startsWith("張")) .filter(s->s.length()==3).forEach(System.out::println); }
1.2 流式思想概述
lStream的方法這里的 filter 、 map 、 skip 都是在對函數模型進行操作，集合元素並沒有真正被處理。只有當終結方法 count
執行的時候，整個模型才會按照指定策略執行操作。而這得益於Lambda的延遲執行特性。
備注：“Stream流”其實是一個集合元素的函數模型，它並不是集合，也不是數據結構，其本身並不存儲任何
元素（或其地址值）。
Stream（流）是一個來自數據源的元素隊列
元素是特定類型的對象，形成一個隊列。 Java中的Stream並不會存儲元素，而是按需計算。
數據源 流的來源。 可以是集合，數組 等。
和以前的Collection操作不同， Stream操作還有兩個基礎的特征：
- Pipelining: 中間操作都會返回流對象本身。 這樣多個操作可以串聯成一個管道， 如同流式風格（flfluent
style）。 這樣做可以對操作進行優化， 比如延遲執行(laziness)和短路( short-circuiting)。一個流管道 包含一個流來源、0 或多個中間操作，
以及一個終止操作。流來源可以是集合、數組、生成器函數或其他任何適當地提供了其元素的訪問權的數據源。中間操作將流轉換為其他流
— 通過過濾元素 (filter())，轉換元素 (map())，排序元素 (sorted())，將流截斷為一定大小 (limit())，等等。終止操作包括聚合（reduce()、collect()），搜索 (findFirst()) 和迭代 (forEach())
- 內部迭代： 以前對集合遍歷都是通過Iterator或者增強for的方式, 顯式的在集合外部進行迭代， 這叫做外部迭
代。 Stream提供了內部迭代的方式，流可以直接調用遍歷方法。
當使用一個流的時候，通常包括三個基本步驟：獲取一個數據源（source）→ 數據轉換→執行操作獲取想要的結
果，每次轉換原有 Stream 對象不改變，返回一個新的 Stream 對象（可以有多次轉換），這就允許對其操作可以
像鏈條一樣排列，變成一個管道。
1.3 獲取流
java.util.stream.Stream<T> 是Java 8新加入的最常用的流接口。（這並不是一個函數式接口。）
獲取一個流非常簡單，有以下幾種常用的方式：
所有的 Collection 集合都可以通過 stream 默認方法獲取流；
Stream 接口的靜態方法 of 可以獲取數組對應的流。
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(); // 靜態方法相關 //備注： of 方法的參數其實是一個可變參數，所以支持數組。 Stream<Integer> stream4 = Stream.of(1,2,3,3); Stream<String> stream5 = Stream.generate(()->"sss"); String [] x=new String[] {"a","b","c"}; Stream<String> stream6 = Stream.of(x); }
根據Map獲取流
java.util.Map 接口不是 Collection 的子接口，且其K-V數據結構不符合流元素的單一特征，所以獲取對應的流
需要分key、value或entry等情況：
// map接口 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();
1.4 常用方法
延遲方法：返回值類型仍然是 Stream 接口自身類型的方法，因此支持鏈式調用。（除了終結方法外，其余方
法均為延遲方法。）
終結方法：返回值類型不再是 Stream 接口自身類型的方法，因此不再支持類似 StringBuilder 那樣的鏈式調
用。本小節中，終結方法包括 count 和 forEach 方法。
逐一處理：forEach
\
public static void main(String[] args) { Stream<String> stream = Stream.of("張無忌", "張三豐", "周芷若"); stream.forEach(name‐> System.out.println(name)); }
過濾：fifilter
public static void main(String[] args) { Stream<String> original = Stream.of("張無忌", "張三豐", "周芷若"); Stream<String> result = original.filter(s ‐> s.startsWith("張")); }
映射：map
如果需要將流中的元素映射到另一個流中，可以使用 map 方法。
public static void main(String[] args) { Stream<String> original = Stream.of("10", "12", "18"); Stream<Integer> result = original.map(str‐>Integer.parseInt(str)); }
統計個數：count
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
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 方法獲取一個截取之后的新流：
public static void main(String[] args) { Stream<String> original = Stream.of("張無忌", "張三豐", "周芷若"); Stream<String> result = original.skip(2); System.out.println(result.count()); // 1
流組合：concat
public static void main(String[] args) { Stream<String> streamA = Stream.of("A"); Stream<String> streamB = Stream.of("B"); Stream<String> result = Stream.concat(streamA, streamB); }
1.5 練習：集合元素處理
題目
現在有兩個 ArrayList 集合存儲隊伍當中的多個成員姓名，要求使用傳統的for循環（或增強for循環）依次進行以
下若干操作步驟：
- 1. 第一個隊伍只要名字為3個字的成員姓名；存儲到一個新集合中。
- 2. 第一個隊伍篩選之后只要前3個人；存儲到一個新集合中。
- 3. 第二個隊伍只要姓張的成員姓名；存儲到一個新集合中。
- 4. 第二個隊伍篩選之后不要前2個人；存儲到一個新集合中。
- 5. 將兩個隊伍合並為一個隊伍；存儲到一個新集合中。
- 6. 根據姓名創建 Person 對象；存儲到一個新集合中。
- 7. 打印整個隊伍的Person對象信息。
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("張二狗"); Stream<String> s1 = one.stream().filter((t) -> 3 == t.length()).limit(3); Stream<String> s2 = two.stream().filter((t) -> t.startsWith("張")).skip(2); Stream.concat(s1, s2).map(Person::new).forEach(System.out::println); }
2:方法引用
在使用Lambda表達式的時候，我們實際上傳遞進去的代碼就是一種解決方案：拿什么參數做什么操作。那么考慮
一種情況：如果我們在Lambda中所指定的操作方案，已經有地方存在相同方案
2.1 冗余的Lambda場景
@FunctionalInterface interface Printable { void print(String s); } public class Repent_Lambda { private static void printString(Printable data) { data.print("Hello, World!"); } public static void main(String[] args) { printString((str)->System.out.println(str)); printString(System.out::println);// 使用方法引用直接調用 } }
其中 printString 方法只管調用 Printable 接口的 print 方法，而並不管 print 方法的具體實現邏輯會將字符串
打印到什么地方去。而 main 方法通過Lambda表達式指定了函數式接口 Printable 的具體操作方案為：拿到
String（類型可推導，所以可省略）數據后，在控制台中輸出它
2.2 方法引用符
雙冒號 :: 為引用運算符，而它所在的表達式被稱為方法引用。如果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，那么根據“可推導就是可省略”的原則，無需指定參數類型，也無需指定的重載形式——它們都
將被自動推導。而如果使用方法引用，也是同樣可以根據上下文進行推導。
@FunctionalInterface interface Printable { //void print(String s); void print(int s); } public class Repent_Lambda { private static void printString(Printable data) { data.print(2); } public static void main(String[] args) { printString((int str)->System.out.println(str)); // 參數類型 可以推斷 printString(System.out::println); // 方法引用 連 方法重載也推導了 } }
總結:
- Lambda 可以推導參數類型 直接處理業務邏輯代碼
- :: 方法引用 可以推導函數重載,
2.3 通過對象名引用成員方法
如果一個類中已經存在了一個成員方法：可以吧這個方法實現通過引用直接傳遞過去
解釋:
public class Obj_Lambda { private static void printString(Printable lambda) { lambda.print("Hello"); } public static void main(String[] args) { MethodRefObject obj = new MethodRefObject(); printString((str)->System.out.println(str)); printString(obj::printUpperCase);// 具體代碼 /** printString 需要一個Printable函數接口,這里傳統方法就是將自己實現的Lambda傳遞過去, 如果引用 MethodRefObject 類的對象實例，則可以通過對象名引用成員方法 將實現傳遞過去， */ } } class MethodRefObject { public void printUpperCase(String str) { System.out.println(str.toUpperCase()); } }
2.4 通過類名稱引用靜態方法
調用: java.lang.Math 類中已經存在了靜態方法 abs
public class Static_Lambda { private static void method(int num, Calcable lambda) { System.out.println(lambda.calc(num)); } public static void main(String[] args) { method(-10, num->Math.abs(num)); method(-10, Math::abs); // 靜態調用方式 } } @FunctionalInterface interface Calcable { int calc(int num); }
2.5 通過super引用成員方法
@FunctionalInterface interface Greetable { void useToolsEat(); } class Animal { void eat() { System.out.println("Animal eat----"); } } class FemalAnimal extends Animal { protected int age; public FemalAnimal(int age) { this.age = age; } void eat() { System.out.println(" FemalAnimal eat----"); } } class Cat extends FemalAnimal { private String name; public Cat(int age, String name) { super(age); this.name = name; } @Override void eat() { System.out.println(super.age + " " + this.name + " " + "吃飯"); } public static void method(Greetable g) { g.useToolsEat(); } void show(){ method(super::eat); // 調用直接父類的方法 method(()->new FemalAnimal(0).eat()); // } }
2.6 通過this引用成員方法
public class This_Lambda { @FunctionalInterface interface Richable{ void buy(); } private void buyHouse() { System.out.println("買套房子"); } private static void marry(Richable lambda) { lambda.buy(); } public void beHappy() { marry(()->buyHouse()); marry(this::buyHouse); // 直接引用本類存在的方法 } }
2.7 類的構造器引用
public class Construtor_Lambda { @FunctionalInterface interface PersonBuilder{ P buildPerson(String name); } public static void printName(String name, PersonBuilder builder) { System.out.println(builder.buildPerson(name).getName()); } public static void main(String[] args) { printName("Tom", (name)->new P(name)); // 傳遞的參數name 將會被自動推導 printName("Tom", P::new); } }
2.8 數組的構造器引用
數組 List Set Map 等其他類似的數據結構都可以進行推導
public class Array_Lambda { @FunctionalInterface interface GenerateIntArr{ int[] BuilderArr(int length); } @FunctionalInterface interface GenerateIntList{ ArrayList<Integer> BuilderArr(int length); } private static void method(int length,GenerateIntArr gArr) { System.out.println(Arrays.toString(gArr.BuilderArr(length))); } private static void method1(int length,GenerateIntList gArr) { System.out.println(gArr.BuilderArr(length)); } public static void main(String[] args) { method(10, (num)->new int[num]); method(10,int[]::new); method1(10, ArrayList<Integer>::new); } }
