Java Stream 流式處理
一、流概念
1. 結構
流獲取
轉換操作 : 可以有多個
終止操作 : 只能有一個
2. 類型
stream() : 單管道
parallelStream()
多管道，并行流式處理，底層使用 ForkJoinPool 實現
強制要求有序 : forEachOrdered()
List list = Arrays.asList(1,2,3,4,5,6,7);//結果：1234567list.stream().forEach(System.out::print);//結果：5726134list.parallelStream().forEach(System.out::print);//結果：1234567list.parallelStream().forEachOrdered(System.out::print);復制代碼
3. 函數式接口
接口中有且僅有一個抽象方法
常見接口
接口參數返回值類別
ConsumerTvoid消費型接口
SupplierNoneT供給型接口
FunctionTR函數型接口
PredicateTboolean斷言型接口
4. Lambda 表達式
結構 : (參數) ‐> { 代碼語句 }
用于簡化 函數式接口 的編寫
可以延遲運行，提升性能
二、流 獲取
1. Collection 子接口
直接調用 stream() 方法
List
Set
Vector
List list =newArrayList<>();Stream stream1 = list.stream();Set set =newHashSet<>();Stream stream2 = set.stream();Vector vector =newVector<>();Stream stream3 = vector.stream();復制代碼
2. Map
不是 Collection 子接口，其 K-V 數據結構不符合流元素特征，所以需根據 Key、Value、Entry 分別獲取
Map map =newHashMap<>();// ...Stream keyStream = map.keySet().stream();Stream valueStream = map.values().stream();Stream> entryStream = map.entrySet().stream();復制代碼
3. Array
數組無法添加默認方法，故使用 Stream.of() 方法獲取
String[] array = {"張無忌","張翠山","張三豐","張一元"};Stream stream = Stream.of(array);復制代碼
二、轉換 操作
1. filter( T -> boolean )
過濾數據，保留條件為 true 的元素
List list = Arrays.asList(20,23,25,28,30,33,37,40);//從指定數據集合中過濾出大于等于30的數據集合List collect = list.stream().filter(x -> x >=30).collect(Collectors.toList());//結果：[30, 33, 37, 40]System.out.println(collect);復制代碼
2. map( T -> R )
轉換數據，將轉換后的數據存回流中
List list = Arrays.asList("1","2","3","4","5","6");List collect1 = list.stream().map(x -> Long.parseLong(x)).collect(Collectors.toList());//結果：[1, 2, 3, 4, 5, 6]System.out.println(collect1);//結果：111111list.stream().mapToInt(x -> x.length()).forEach(System.out::print);System.out.println("");//結果：111111list.stream().mapToLong(x -> x.length()).forEach(System.out::print);System.out.println("");//結果：1.01.01.01.01.01.0list.stream().mapToDouble(x -> x.length()).forEach(System.out::print);復制代碼
3. flatMap( T -> Stream )
將流中的 元素 映射為一個 流，再把每個流連接為一個流
List>? list =newArrayList>(){{? ? ? ? ? ? add(Lists.newArrayList("a","b","c"));? ? ? ? ? ? add(Lists.newArrayList("d","e","f"));? ? ? ? ? ? add(Lists.newArrayList("j","k","y"));? ? ? ? }};//結果：[[a, b, c], [d, e, f], [j, k, y]]System.out.println(list);List collect = list.stream().flatMap(List::stream).collect(Collectors.toList());//結果：[a, b, c, d, e, f, j, k, y]System.out.println(collect);復制代碼
4. distinct()
元素去重，底層使用 equals() 方法做比較
List list = Arrays.asList("a","b","ab","abc","a","ab","a","abcd","bd","abc");List collect = list.stream().distinct().collect(Collectors.toList());//結果：[a, b, ab, abc, abcd, bd]System.out.println(collect);復制代碼
5. sorted( T -> boolean )
元素排序，需事前 實現 Comparable 接口 或 自定義比較器
List list = Arrays.asList(5,3,7,1,4,6);List collect = list.stream().sorted((a, b) -> a.compareTo(b)).collect(Collectors.toList());//結果：[1, 3, 4, 5, 6, 7]System.out.println(collect);復制代碼
6. limit( num )
限制返回的元素個數
List list = Arrays.asList("a","b","ab","abc","a","ab","a","abcd","bd","abc");List collect = list.stream().limit(3).collect(Collectors.toList());//結果：[a, b, ab]System.out.println(collect);復制代碼
7. skip( num )
跳過元素
List list = Arrays.asList("a","b","ab","abc","a","ab","a","abcd","bd","abc");List collect = list.stream().skip(5).collect(Collectors.toList());//結果：[ab, a, abcd, bd, abc]System.out.println(collect);復制代碼
8. peek( T -> void )
挑出元素進行操作，但操作后的元素不返回到流中
List list = Arrays.asList("a","b","ab","abc","a","ab","a","abcd","bd","abc");//結果：abababcaabaabcdbdabclist.stream().peek(x -> x.toUpperCase()).forEach(System.out::print);//結果：ABABABCAABAABCDBDABClist.stream().map(x -> x.toUpperCase()).forEach(System.out::print);復制代碼
三、終止 操作
1. forEach
forEach : 支持并行處理
forEachOrdered : 強制要求有序處理，速度較慢
List list = Arrays.asList("a","b","ab");//結果：a b ablist.stream().forEach(x -> System.out.print(x+' '));System.out.println("");//可以簡化//結果：a b ablist.forEach(x -> System.out.print(x+' '));System.out.println("");//結果：a b ablist.stream().forEachOrdered(x -> System.out.print(x+' '));復制代碼
2. collect
toMap : 將 數據流 轉換成 Map，里面包含的元素是 key / value 形式
toSet : 將 數據流 轉換成 Set，里面包含的 元素不可重復
toList : 將 數據流 轉換成 List，里面包含的 元素有序
joining : 元素間 拼接 分割符，并返回 字符串
groupingBy : 分組，可以將 List 轉換成 Map
couting : 統計 元素數量
maxBy : 獲取 最大的元素
minBy : 獲取 最小的元素
summarizingInt : 匯總 Integer 類型的元素，返回 IntSummaryStatistics，可再調用具體方法進行統計
getCount : 統計數量
getSum : 求和
getMin : 獲取最小值
getMax : 獲取最大值
getAverage : 獲取平均值
summarizingLong : 匯總 Long 類型元素，用法同 summarizingInt
summarizingDouble : 匯總 Double 類型元素，用法同 summarizingInt
averagingInt : 獲取 Integer 元素平均值，返回一個 Double 類型數據
averagingLong : 獲取 Long 元素平均值，返回一個 Double 類型數據
averagingDouble : 獲取 Double 元素平均值，返回一個 Double 類型數據
mapping : 獲取映射，可以將原始元素的一部分內容作為一個新元素返回
List list0 = Arrays.asList("a","b","ab");Map collect0 = list0.stream().collect(Collectors.toMap(String::new, Function.identity()));//結果：{ab=ab, a=a, b=b}System.out.println(collect0);List list = Arrays.asList("a","b","ab","a","b","ab");List collect1 = list.stream().collect(Collectors.toList());//結果：
[a, b, ab, a, b, ab]System.out.println(collect1);//結果：
[a, ab, b]Set collect2 = list.stream().collect(Collectors.toSet());
System.out.println(collect2);String collect3 = list.stream().collect(Collectors.joining(","));//結果：a,b,ab,a,b,abSystem.out.println(collect3);
Map collect4 = list.stream().collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
//結果：{ab=2, a=2, b=2}System.out.println(collect4);
Long collect = list.stream().collect(Collectors.counting());
//結果：6System.out.println(collect);
List list1 = Arrays.asList(1,3,5,7,9,11);
Integer collect5 = list1.stream().collect(Collectors.maxBy((a, b) -> a.compareTo(b))).orElse(null);
System.out.println(collect5);
//結果：11System.out.println(collect5);
String collect6 = list1.stream().collect(Collectors.minBy((a, b) -> a.compareTo(b))).orElse(null);
//結果：1System.out.println(collect6);List list2 = Arrays.asList("2","3","5");
IntSummaryStatistics summaryStatistics = list2.stream().collect(Collectors.summarizingInt(x -> Integer.parseInt(x)));longsum = summaryStatistics.getSum();
//結果：10System.out.println(sum);
Double collect7 = list2.stream().collect(Collectors.averagingInt(x -> Integer.parseInt(x)));
//結果：3.3333333333333335System.out.println(collect7);
List userList =newArrayList() {{? add(newUser("jack",23));?
add(newUser("james",30));?
add(newUser("curry",28));}};List collect8 = userList.stream().collect(Collectors.mapping(User::getName, Collectors.toList()));
//[jack, james, curry]System.out.println(collect8);復制代碼
3. find
findFirst : 查找第一個元素，返回的類型為 Optional
findAny : 一般返回第一個元素，返回的類型為 Optional，但如果是并行情況，則不保證是第一個
List lst1 = Arrays.asList("Jhonny","David","Jack","Duke","Jill","Dany","Julia","Jenish","Divya");List lst2 = Arrays.asList("Jhonny","David","Jack","Duke","Jill","Dany","Julia","Jenish","Divya"); Optional findFirst = lst1.parallelStream().filter(s -> s.startsWith("D")).findFirst();Optional fidnAny = lst2.parallelStream().filter(s -> s.startsWith("J")).findAny(); System.out.println(findFirst.get());// 總是打印出 DavidSystem.out.println(fidnAny.get());// 會隨機打印出 Jack/Jill/Julia復制代碼
4. match
allMatch : 所有元素都滿足條件，返回 boolean 類型
anyMatch : 任意一個元素滿足條件，返回 boolean 類型
noneMatch : 所有元素都不滿足條件，返回 boolean 類型
List list = Arrays.asList(2,3,5,7);booleanallMatch = list.stream().allMatch(x -> x >1);//結果：trueSystem.out.println(allMatch);booleanallMatch2 = list.stream().allMatch(x -> x >2);//結果：falseSystem.out.println(allMatch2);booleananyMatch = list.stream().anyMatch(x -> x >2);//結果：trueSystem.out.println(anyMatch);booleannoneMatch1 = list.stream().noneMatch(x -> x >5);//結果：falseSystem.out.println(noneMatch1);booleannoneMatch2 = list.stream().noneMatch(x -> x >7);//結果：trueSystem.out.println(noneMatch2);復制代碼
5. count
統計數量，返回 long 類型，與集合的 size() 方法類似
List list = Arrays.asList("a","b","ab");longcount = list.stream().count();//結果：3System.out.println(count);復制代碼
6. max、min
max : 獲取最大值，返回 Optional 類型
min : 獲取最小值，返回 Optional 類型
List list = Arrays.asList(2,3,5,7);Optional max = list.stream().max((a, b) -> a.compareTo(b));//結果：7System.out.println(max.get());Optional min = list.stream().min((a, b) -> a.compareTo(b));//結果：2System.out.println(min.get());復制代碼
7. reduce
規約操作，將整個數據流規約成一個值
兩個參數 : 循環計算的初始值、計算累加器
count、max、min 底層就是使用 reduce 實現
List list = Arrays.asList(2,3,5,7);Integer sum1 = list.stream().reduce(0, Integer::sum);//結果：17System.out.println(sum1);Optional reduce = list.stream().reduce((a, b) -> a + b);//結果：17System.out.println(reduce.get());Integer max = list.stream().reduce(0, Integer::max);//結果：7System.out.println(max);Integer min = list.stream().reduce(0, Integer::min);//結果：0System.out.println(min);Optional reduce1 = list.stream().reduce((a, b) -> a > b ? b : a);//2System.out.println(reduce1.get());復制代碼
8. toArray
數組操作，將 數據流 轉換成 數組
List list = Arrays.asList("a","b","ab");String[] strings = list.stream().toArray(String[]::new);//結果：a b abfor(inti =0; i < strings.length; i++) {? System.out.print(strings[i]+" ");}復制代碼
9. concat
將 兩個流 合并為 一個流
Stream streamA = Stream.of("張無忌");Stream streamB = Stream.of("張翠山");Stream result = Stream.concat(streamA, streamB);
