Stream流式編程
Stream流
- 說到Stream便容易想到I/O Stream，而實際上，誰規定“流”就一定是“IO流”呢？在Java 8中，得益於Lambda所帶來的函數式編程，引入了一個全新的Stream概念，用於解決已有集合類庫既有的弊端。
- 當需要對多個元素進行操作（特別是多步操作）的時候，考慮到性能及便利性，我們應該首先拼好一個“模型”步驟方案，然后再按照方案去執行它。
- 諸如
filter、map、skip都是在對函數模型進行操作，集合元素並沒有真正被處理。只有當終結方法 類似於count,forEach執行的時候，整個模型才會按照指定策略執行操作。而這得益於Lambda的延遲執行特性。就相當於現將流水線硬件先建立好，然后再啟動流水線！
“Stream流”其實是一個集合元素的函數模型(處理的步驟方法)，它並不是集合，也不是數據結構，其本身並不存儲任何元素（或其地址值）。
Stream（流）是一個來自數據源的元素隊列
- 元素是特定類型的對象，形成一個隊列，Java中的Stream並不會存儲元素，而是按需計算。
- 數據源流的來源，可以使集合、數組等。
和以前的Collection操作不同， Stream操作還有兩個基礎的特征
- Pipelining:中間操作都會返回流對象本身。 這樣多個操作可以串聯成一個管道， 如同流式風格（
fluentstyle）。 這樣做可以對操作進行優化， 比如延遲執行(laziness)和短路( short-circuiting) - 內部迭代：以前對集合遍歷都是通過
Iterator或者增強for的方式, 顯式的在集合外部進行迭代， 這叫做外部迭代。 Stream提供了內部迭代的方式，流可以直接調用遍歷方法。
通常使用流的三個基本步驟
- 獲取一個數據源(Source)
- 數據轉換
- 執行操作獲取險要的結果
每次轉換原有 Stream 對象不改變，返回一個新的 Stream 對象（可以有多次轉換），這就允許對其操作可以像鏈條一樣排列，變成一個管道
一、獲取流
java.util.stream.Stream<T> 是Java 8新加入的最常用的流接口。【這並不是一個函數式接口。】，獲取流有一下幾種方式
- 所有的
Collection集合都可以通過stream默認方法獲取流 Stream接口的靜態方法of可以獲取數組對應的流
1.根據Collection獲取流
java.util.Collection 接口中加入了默認方法default stream 用來獲取流，所以其所有實現類均可獲取流
List<String> list = new ArrayList<>(); Stream<String> st1 = list.stream(); Set<String> set = new HashSet<>(); Stream<String> st2 = set.stream(); Vector<String> vector = new Vector<>(); Stream<String> st3 = vector.stream(); 2.根據Map獲取流
java.util.Map 接口不是 Collection 的子接口，且其K-V數據結構不符合流元素的單一特征，所以獲取對應的流需要分key、value或entry等情況
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(); 3.根據數組獲取流
如果使用的不是集合或映射而是數組，由於數組對象不可能添加默認方法，所以 Stream接口中提供了靜態方法of ，使用很簡單
of方法的簽名是可變長參數
String[] array = {"張三","李四","王二","麻子"}; Stream<String> st1 = Stream.of(array); 二、常用方法
流模型的操作很豐富，這里介紹一些常用的API。這些方法可以被分成兩種：
- 延遲方法：返回值任然是Stream接口自身類型的方法，因此支持鏈式調用(除了終結方法外，其他都是方法均為延遲方法)
- 終結方法：返回值類型不再是Stream接口自身類型的方法，因此不再支持類似StringBuilder【add的鏈式調用】那樣的鏈式調用，這里介紹
count和forEach方法其他終結方法請參考API
1.逐一處理:forEach
雖然方法名字叫forEach ，但是與for循環中的“for-each”昵稱不同。
void forEach(Consumer<? super T> action);
java.util.function.Consumer<T>接口是一個消費型接口。Consumer接口中包含抽象方法void accept(T t)，意為消費一個指定泛型的數據。
基本使用：
Stream<String> st1 = Stream.of("張三","李四","王二","麻子"); st1.forEach(System.out::println); // 等同於如下代碼 // st1.forEach(s -> System.out.println(s)); 2.過濾:filter
可以通過filter方法將一個流轉換成另一個子集流。方法簽名
Stream<T> filter(Predicate<? super T> predicate); 該接口接收一個 Predicate 函數式接口參數（可以是一個Lambda或方法引用）作為篩選條件。
java.util.stream.Predicate函數式接口唯一的抽象方法為boolean test(T t);,該方法將會產生一個boolean值結果，代表指定的條件是否滿足。如果結果為true，那么Stream流的 filter 方法將會留用元素；如果結果為false，那么 filter 方法將會舍棄元素。
基本使用：
Stream.of("張三","李四","王二","麻子","張三豐","張無忌") .filter(s -> s.startsWith("張")) .forEach(System.out::println); 3.映射:map
如果需要將流中的元素映射到另一個流中，可以使用map方法，方法簽名：
<R> Stream<R> map(Function<? super T, ? extends R> mapper); 該接口需要一個Function函數式接口，可以將當前流中的T類型數據轉換為另一種R類型的流
此前我們已經學習過 java.util.stream.Function 函數式接口，其中唯一的抽象方法為：
R apply(T t);,這可以將一種T類型轉換成為R類型，而這種轉換的動作，就稱為“映射”。
Stream.of("1","2","3","4","5","6") .map(Integer::parseInt) .forEach(s -> System.out.println(s*10)); 這段代碼中， map 方法的參數通過方法引用，將字符串類型轉換成為了int類型（並自動裝箱為 Integer 類對象）。
4.統計個數:count
正如舊集合Collection當中的size方法一樣，流提供count方法來數一數其中的元素個數：
long count(); 該方法返回一個long值代表元素個數（不再像舊集合那樣是int值）。基本使用：
System.out.println(Stream.of("1", "2", "3", "4", "5", "6") .map(Integer::parseInt) .count()); 5.取前幾個:limit
limit方法可以對流進行截取，只取用前n個。方法簽名：
Stream<T> limit(long maxSize); 參數是一個long型，如果集合當前長度大於參數則進行截取；否則不進行操作。基本使用
Stream.of("1", "2", "3", "4", "5", "6") .limit(1) .forEach(System.out::println); 6.跳過前幾個:skip
如果希望跳過前幾個元素，可以使用skip方法獲取一個截取之后的新流；
Stream<T> skip(long n); 如果流的當前長度大於n,則跳過前n個；否則將會得到一個長度為0的空流。
Stream.of("1", "2", "3", "4", "5", "6") .skip(5) .forEach(System.out::println); 7.組合:count
如果有兩個流，希望合並成為一個流，那么可以使用Stream接口的靜態方法concat
static <T> Stream<T> concat(Stream<? extend T> a, Stream<? extends T> b) 這是一個靜態方法，與
java.lang.String當中的concat方法是不同的。
Stream.concat(
Stream.of("1", "2", "3", "4", "5", "6"), Stream.of("7") ).forEach(System.out::println); 8.驗證流的工作方式
流的工作方式為：先建立流水線[Lambda表達式的延遲執行]，然后通過內部迭代迭代一個走一個，。。。
ArrayList<String> arr = new ArrayList<>(); arr.add("張翠山"); arr.add("張無忌"); arr.add("張大俠"); arr.add("張三豐"); arr.add("張傻屌"); arr.stream().filter(s -> { System.out.println("@1"); return s.startsWith("張"); }).filter(s -> { System.out.println("#2"); return s.length() == 3; }).forEach(System.out::println); 運行結果
@1 #2 張翠山 @1 #2 張無忌 @1 #2 張大俠 @1 #2 張三豐 @1 #2 張傻屌 9.並發流的兩種獲取方式
並發流就是把多擴展幾個流水線，將數據成幾段交給這些流水線執行。每個流水線拿到上每次只有一個數據在跑。
並發流的兩種獲取方式：
Collection<String> coll = new ArrayList<>(); Stream<String> parallelStream1 = coll.parallelStream(); Stream<Integer> parallelStram2 = Stream.of(100,200,300,400,500).parallel(); 單線程流和並發流的案例
int n = 100000000; Integer[] arr = new Integer[n]; for (int i = 0; i < arr.length; i++) { arr[i] = i; } ArrayList<Integer> first = new ArrayList<>(); ArrayList<Integer> second = new ArrayList<>(); long start1 = System.currentTimeMillis(); Stream.of(arr) .filter(a -> a % 2 == 0) .filter(b -> b % 3 == 0) .filter(c -> c % 5 == 0) .filter(d -> d % 7 == 0) .forEach(first::add); long end1 = System.currentTimeMillis(); System.out.println("單線程流：" + (end1 - start1) + "ms"); long start2 = System.currentTimeMillis(); Stream.of(arr).parallel() .filter(a -> a % 2 == 0) .filter(b -> b % 3 == 0) .filter(c -> c % 5 == 0) .filter(d -> d % 7 == 0) .forEach(second::add); long end2 = System.currentTimeMillis(); System.out.println("並發流耗時：" + (end2 - start2) + "ms"); 執行結果
單線程流：1890ms 並發流耗時：828ms 三、綜合應用
- 第一個隊伍只要名字為3個字的成員姓名；存儲到一個新集合中。
- 第一個隊伍篩選之后只要前3個人；存儲到一個新集合中。
- 第二個隊伍只要姓張的成員姓名；存儲到一個新集合中。
- 第二個隊伍篩選之后不要前2個人；存儲到一個新集合中。
- 將兩個隊伍合並為一個隊伍；存儲到一個新集合中。
- 根據姓名創建 Person 對象；存儲到一個新集合中。
- 打印整個隊伍的Person對象信息。
import java.util.*; import java.util.stream.Stream; public class Main { public static void main(String[] args) { List<String> one = new ArrayList<>(); one.add("迪麗熱巴"); one.add("宋遠橋"); one.add("蘇星河"); one.add("石破天"); one.add("石中玉"); one.add("老子"); one.add("庄子"); one.add("洪七公"); List<String> two = new ArrayList<>(); two.add("古力娜扎"); two.add("張無忌"); two.add("趙麗穎"); two.add("張三豐"); two.add("尼古拉斯趙四"); two.add("張天愛"); two.add("張二狗"); Stream.concat( one.stream().filter(s -> s.length() == 3).limit(3), two.stream().filter(s -> s.startsWith("張")).skip(2) ).map(Person::new).forEach(System.out::println); } } class Person{ private String name; public Person(String name) { this.name = name; } @Override public String toString() { return "person{" + "name='" + name + '\'' + '}'; } }
原創：https://www.jianshu.com/p/5b97e86aa1ee