JDK1.8之後，得益於lambda表示式帶來的函數語言程式設計，引入了全新的Stream概念

以前想篩選一個集合中的元素，需要遍歷集合，然後判斷是否滿足條件再刪除

可有了Stream流後，可以直接使用函數語言程式設計的Predicate介面來篩選

集合獲取流：所有的Collection 集合都可以通過stream 預設方法獲取流

ArrayList<Integer> list = new ArrayList<>();
Stream<Integer> s = list.stream();

若要獲取Map集合的Stream流物件，只能獲取keySet集合和entrySet集合再獲取Stram

陣列獲取流：Stream 介面的靜態方法of 可以獲取陣列對應的流

Stream<Integer> s = Stream.of(12,4,124,12,4);

常用方法：

Stream<T> filter(Predicate<T> predicate)                                     過濾流內元素，返回新的Stream物件

Stream<Integer> s1 = Stream.of(12, 4, 124, 12, 4);
Stream<Integer> s2 =s1.filter((integer) -> integer > 10);    //過濾掉大於10的元素
 

long count()                                                                                             返回一個long值代表元素個數

Stream<Integer> s1 = Stream.of(12, 4, 124, 12, 4);
Stream<Integer> s2 =s1.filter((integer) -> integer > 10);
System.out.println(s2.count());              //輸出:3
 

Stream<T> limit(long maxSize)                                                          只取流前面的幾個元素，返回新的Stream物件

Stream<Integer> s1 = Stream.of(12, 4, 124, 12, 4);
Stream<Integer> s2 = s1.limit(3);            //流中剩12 4 124三個元素

Stream<T> skip(long n)                                                                          跳過前面幾個元素，返回新的Stream物件

Stream<Integer> s1 = Stream.of(12, 4, 124, 12, 4);
Stream<Integer> s2 = s1.skip(3);            //流中剩12 4 兩個元素

<R> Stream<R> map(Function<T,R> mapper)                                   將Stream流的T型別轉換成R型別

Stream<Integer> s1 = Stream.of(12, 4, 124, 12, 4);
Stream<String> s2 = s1.map((integer)->integer.toString());  //得到一個String型別的流物件

static <T> Stream<T> concat(Stream<T> a, Stream<T> b)           將兩個流物件合成一個Stream物件

Stream<Integer> s1 = Stream.of(12, 4, 124, 12, 4);
Stream<Integer> s2 = Stream.of(62,426,5,23,5);
Stream<Integer> s3 = Stream.concat(s1,s2);        //將s1和s2兩個流合成一個流物件

void forEach(Consumer<T> action)                                                       對流中元素進行逐一處理

Stream<Integer> s1 = Stream.of(12, 4, 124, 12, 4);
s1.forEach(System.out::println);            //逐一列印流的元素

注意：

方法能返回一個流物件的屬於函式拼接，支援鏈式呼叫，

可是一個流通過方法產生新流後，就不能再使用原來的流了!!

方法不返回流物件，則為終結方法，例：count、forEach

只要呼叫了終結方法，流物件就不能再使用

集合轉成Stream流物件後，可以將其轉回集合或陣列

public static <T> Collector<T, ?, List<T>> toList()                                         轉換為List集合

Stream<Integer> s1 = Stream.of(12, 4, 124, 12, 4);
List<Integer> list1 = s1.collect(Collectors.toList());
System.out.println(list1);

public static <T> Collector<T, ?, Set<T>> toSet()                                          轉換為Set集

Stream<Integer> s2 = Stream.of(1, 512, 4, 326, 2, 35, 23);
Set<Integer> set = s2.collect(Collectors.toSet());

<A> A[] toArray(IntFunction<A[]> generator)                                                  轉換為陣列

Stream<Integer> s2 = Stream.of(1, 512, 4, 326, 2, 35, 23);
Integer[] arr2 = s2.toArray(Integer[]::new);
System.out.println(Arrays.toString(arr2));

使用Stream流物件，就可以很輕鬆的對集合或陣列內的元素進行變更

不需要像傳統的遍歷一樣，要找到元素的起止條件再對元素是否滿足要求作判斷

最後再講流物件轉回集合，就能達到以前傳統模式完全一樣的效果

序列流：

上述介紹的例子，全是序列流即使用集合物件或陣列物件呼叫Stream()方法獲取的Stream物件都是序列流

並行流：

直接獲取並行流

Stream parallelStream()                    返回並行流

ArrayList<Integer> list = new ArrayList<>();
Collections.addAll(list, 12, 4, 124, 12);
Stream<Integer> s = list.parallelStream();

間接獲取並行流：序列流轉換成並行流

Stream parallel()                                    序列流轉換成並行流

Stream<Integer> s1 = Stream.of(12, 4, 124, 12, 4);
Stream<Integer> s2 = s1.parallel();