Java 8 Stream 流用法

1.簡介

Stream流 最全的用法
Stream 能用來干什么？用來處理集合，通過 使用Stream API 對集合數據進行操作，就類似于使用 SQL 執行的數據庫查詢，Stream API 提供了一種高效且易于使用的處理數據的方式

為什么用Java 8 Stream ？因為 操作簡單
為什么操作簡單?因為 Lambda 表達式，它極大的提高了編程效率和程序可讀性
怎么操作流？ 首先你的有個數據源(數組、集合)，操作會產生新的流對象，原來的流對象不會改變
流用法有結束操作，這種代碼不是你寫了一個方法就執行一個方法，而是最后觸發結束操作的時候才統一執行的，collect、foreach 方法就是一種結束方法，詳情看代碼及結果參考 2.映射map、flatMap用法 部分

---

2.具體用法

2.1 創建流

// 集合創建流List<String> list = new ArrayList<>();// 獲取一個順序流Stream<String> listStream = list.stream();// 獲取一個并行流Stream<String> parallelListStream = list.parallelStream();// 數組創建流Integer[] nums = new Integer[] { 1, 2, 3, 4, 5 };Stream<Integer> arrStream = Arrays.stream(nums);arrStream.forEach(System.out::println);// 1 2 3 4 5// 靜態方法of創建流Stream<Integer> ofStream = Stream.of(1, 2, 3, 4, 5);ofStream.forEach(System.out::println);// 1 2 3 4 5// 靜態方法iterate 創建流Stream<Integer> iterateStream = Stream.iterate(1, (x) -> x + 10).limit(4);iterateStream.forEach(System.out::println); // 1 11 21 31// 靜態方法generate 創建流Stream<Double> generateStream = Stream.generate(Math::random).limit(2);generateStream.forEach(System.out::println);

2.2 操作流

1.過濾

• filter：過濾流中的某些元素(可以做一些基本的判空、替換、判斷邏輯操作)
• limit(n)：獲取n個元素，結果獲取幾個元素
• skip(n)：跳過n元素，配合limit(n)可實現分頁
• distinct：通過流中元素的 hashCode() 和 equals() 去除重復元素

//filter 判空Stream<Integer> notNullStreamObj = Stream.of(1, 2, null, 4, 5, 6, 7, null, 2);Stream<Integer> notNullStream = notNullStreamObj.filter(i -> (null != i));notNullStream.forEach(System.out::println);//1 2 4 5 6 7 2//filter 邏輯判斷Stream<Integer> logicStreamObj = Stream.of(1, 2, null, 4, 5, 6, 7, null, 2);Stream<Integer> logicStream = logicStreamObj.filter(i -> (i != null && i > 5));logicStream.forEach(System.out::println); // 6 7//filter 替換Stream<String> strStreamObj = Stream.of("aa", "ab", null, "ac", "bd", "ee");Stream<String> strStream = strStreamObj.filter(str -> (null != str && str.contains("a")));strStream.forEach(System.out::println); // aa ab ac//skip 跳過Stream<String> skipStreamObj = Stream.of("aa", "ab", null, "ac", "bd", "ee");Stream<String> skipStream = skipStreamObj.skip(2);skipStream.forEach(System.out::println); // null ac bd ee//distinct 去重Stream<String> disStreamObj = Stream.of("aa", "ab", null, "ac", "aa", "ab", null, "ee");Stream<String> disStream = disStreamObj.distinct();disStream.forEach(System.out::println); // aa ab null ac ee

2.映射

• map：接收一個函數作為參數，該函數會被應用到每個元素上，映射成一個新的元素。
• flatMap：接收一個函數作為參數，將流中的每個值都換成另一個流，然后把所有流連接成一個流。
• peek：這個操作很騷，類似map只不過map 是Func函數，提供返回值，而peer是取出元素，Consumer表達式設值，我個人覺得沒啥區別呢，官方文檔提示：該方法主要用于調試，做一些消耗這個對象但不修改它的東西，沒啥事不要用

很想問一下 這倆map、flatMap 區別 ，細品，你細品，你細細品

map是將每個元素 映射成一個新元素，除非你過濾了，否則不會改變元素個數
flatMap是將原流中的每個值都變成另一個流，然后把流合并串起來，必須有返回值，拼裝成新的流

//map 把包含a的元素，替換成| 注意，注意， 元素還是一個整體，對每個元素Stream<String> mapStreamObj = Stream.of("a,b,c", "a,e,f", "g,h,i");Stream<String> mapStream = mapStreamObj.map(str -> str.replaceAll(",", "|"));mapStream.forEach(System.out::println); // a|b|c a|e|f h|i|j//flatMap 可以把元素 切分后，再按照新元素組成新的字符串Stream<String> flatMapStreamObj = Stream.of("a,b,c", "a,e,f", "g,h,i");Stream<String> flatMapStream = flatMapStreamObj.flatMap(str -> {String[] arr = str.split(",");Stream<String> result = Arrays.stream(arr);return result;});flatMapStream.forEach(System.out::println); //a b c d e f g h iSystem.out.println("1===========");Stream<String> peekStreamObj = Stream.of("a,b,c", "a,e,f", "g,h,i");Stream<String> peekStream = peekStreamObj.peek(e -> System.out.println("Filtered value: " + e)).map(String::toUpperCase).peek(e -> System.out.println("Mapped value: " + e));System.out.println("2=========== peek代碼結束，但是日志沒打印");Set<String> stringSet = peekStream.collect(Collectors.toSet());System.out.println("3=========== collect結束操作，代碼日志打印");stringSet.forEach(System.out::println);

map執行結果

//看下執行結果，說明 collect才是結束操作，代碼結束，但是并不是真正結束 1=========== 2=========== peek代碼結束，但是日志沒打印 Filtered value: a,b,c Mapped value: A,B,C Filtered value: a,e,f Mapped value: A,E,F Filtered value: g,h,i Mapped value: G,H,I 3=========== collect結束操作，代碼日志打印 A,B,C A,E,F G,H,I

3.排序

• sorted()：自然排序，流中元素需實現Comparable接口
• sorted(Comparator com)：定制排序，自定義Comparator排序器

先構建一個User類

public static class User {private String name;private Integer age;public User(String name, Integer age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public Integer getAge() {return age;}public void setAge(Integer age) {this.age = age;}@Overridepublic String toString() {return "User{" +"name='" + name + '\'' +", age=" + age +'}';}}

然后 看下sort用法

//按字母排序Stream<String> sortStreamObj = Stream.of("a,e,f", "a,d,c", "a,b,i");Stream<String> sortStream = sortStreamObj.sorted();sortStream.forEach(System.out::println); //abi adc aefUser u1 = new User("bb", 1);User u2 = new User("aa", 2);User u3 = new User("cc", 3);User u4 = new User("aa", 4);Set<User> userSet = Sets.newHashSet(u1, u2, u3, u4);Stream<User> userStream = userSet.stream().sorted((obj1, obj2) -> {if (obj1.getName().equals(obj2.getName())) {//name相等 按agereturn obj1.getAge() - obj2.getAge();}return obj1.getName().compareTo(obj2.getName());});userStream.forEach(System.out::println);// u2 u4 u1 u3

sort 執行結果

a,b,i a,d,c a,e,f User{name='aa', age=2} User{name='aa', age=4} User{name='bb', age=1} User{name='cc', age=3}

4.流匹配

• allMatch：接收一個 Predicate 函數，當流中每個元素都符合該斷言時才返回true，否則返回false
• noneMatch：接收一個 Predicate 函數，當流中每個元素都不符合該斷言時才返回true，否則返回false
• anyMatch：接收一個 Predicate 函數，只要流中有一個元素滿足該斷言則返回true，否則返回false
• findFirst：返回流中第一個元素
• findAny：返回流中的任意元素
• count：返回流中元素的總個數
• max：返回流中元素最大值
• min：返回流中元素最小值

List<Integer> numLists = Arrays.asList(3, 4, 5, 6, 10);// 全部匹配 - trueboolean allMatch1 = numLists.stream().allMatch(e -> e > 2); //trueSystem.out.println("allMatch1：" + allMatch1);// 全部匹配 - trueboolean allMatch2 = numLists.stream().allMatch(e -> e > 5); //falseSystem.out.println("allMatch2：" + allMatch2);// 全部都不符合 - trueboolean noneMatch = numLists.stream().noneMatch(e -> e > 20); //trueSystem.out.println("noneMatch：" + noneMatch);// 任一元素符合 - trueboolean anyMatch = numLists.stream().anyMatch(e -> e > 4); //trueSystem.out.println("anyMatch：" + anyMatch);//返回第一個Integer findFirst = numLists.stream().findFirst().get(); //3System.out.println("findFirst：" + findFirst);//返回任一個Integer findAny = numLists.stream().findAny().get(); System.out.println("findAny：" + findAny);//返回 countlong count = numLists.stream().count(); //5System.out.println("count：" + count);//返回maxInteger max = numLists.stream().max(Integer::compareTo).get(); //10System.out.println("max：" + max);//返回minInteger min = numLists.stream().min(Integer::compareTo).get();//3System.out.println("min：" + min);

匹配執行結果

allMatch1：true allMatch2：false noneMatch：true anyMatch：true findFirst：3 findAny：3 count：5 max：10 min：3

5.組合操作

• Reduce 就是組合操作
• Reduce（BinaryOperator accumulator） 沒有起始值，按照運算規則進行運算操作
  解釋：第一次執行時，accumulator函數的第一個參數為流中的第一個元素，第二個參數為流中元素的第二個元素，按照函數進行操作；
  第二次執行時，第一個參數為第一次函數執行操作的結果，第二個參數為流中的第三個元素；往下依次類推，返回Optinal 通過get()方法獲取結果
• Reduce（T identity, BinaryOperator accumulator）含有初始值，第二個是第一個的變形，跟第一個方法對比，不同的是此次這個會接受一個identity參數，用來指定Stream循環的初始值。如果Stream為空，就直接返回該值，特殊：該方法不會返回 Optional

Optional sumResult = Stream.of(1, 2, 3, 4).reduce((sum, item) -> {System.out.println("sum : " + sum);sum += item;System.out.println("item: " + item);System.out.println("sum+ : " + sum);System.out.println("-----——---");return sum;});System.out.println("========sumResult: " + sumResult.get());Integer sumDefineResult = Stream.of(1, 2, 3, 4).reduce(100, (sum, item) -> {System.out.println("sum : " + sum);sum += item;System.out.println("item: " + item);System.out.println("sum+ : " + sum);System.out.println("---——-----");return sum;});System.out.println("========sumDefineResult: " + sumDefineResult);

reduce 執行結果

//下面是執行結果 //查看執行結果 sum : 1 item: 2 sum+ : 3 -----——--- sum : 3 item: 3 sum+ : 6 -----——--- sum : 6 item: 4 sum+ : 10 -----——--- ========sumResult: 10 sum : 100 item: 1 sum+ : 101 ---——----- sum : 101 item: 2 sum+ : 103 ---——----- sum : 103 item: 3 sum+ : 106 ---——----- sum : 106 item: 4 sum+ : 110 ---——----- ========sumDefineResult: 110

6. 收集轉換操作

這是個最最最最最基本的操作，10個流操作 9個都會使用到當前操作

• collect(Collectors.toList()) 轉換List
• collect(Collectors.toSet()) 轉換Set
• Collectors.toMap(key, value) 轉換Map ，如果key重復，！！！報錯
• Collectors.joining() join進行拼接
• Collectors.groupingBy(key) 以Key為map的 key分組
• Collectors.partitioningBy(規則) 以規則分區 比如 >5 ，map key為true，false

User s1 = new User("aa", 1);User s2 = new User("bb", 2);User s3 = new User("cc", 3);User s4 = new User("dd", 2);List<User> list = Arrays.asList(s1, s2, s3, s4);//轉換listList<Integer> ageList = list.stream().map(User::getAge).collect(Collectors.toList()); // [1, 2, 3]System.out.println(ageList.toString());//轉成setSet<Integer> ageSet = list.stream().map(User::getAge).collect(Collectors.toSet()); // [1, 2, 3]System.out.println(ageSet);//轉成map,注:key不能相同，否則報錯Map<String, Integer> userMap = list.stream().collect(Collectors.toMap(User::getName, User::getAge)); // {cc=10, bb=20, aa=10}System.out.println(userMap);//字符串分隔符連接String joinName = list.stream().map(User::getName).collect(Collectors.joining(",", "(", ")")); // (aa,bb,cc)System.out.println(joinName);//分組Map<Integer, List<User>> ageMap = list.stream().collect(Collectors.groupingBy(User::getAge));System.out.println(ageMap);//多重分組,先根據類型分再根據年齡分Map<Integer, Map<Integer, List<User>>> typeAgeMap = list.stream().collect(Collectors.groupingBy(User::getAge, Collectors.groupingBy(User::getAge)));System.out.println(typeAgeMap);//分區//分成兩部分，true 一部分age大于2歲， false 一部分age小于等于2歲Map<Boolean, List<User>> partMap = list.stream().collect(Collectors.partitioningBy(v -> v.getAge() > 2));System.out.println(partMap);

collect 執行結果

[1, 2, 3, 2] [1, 2, 3] {dd=2, cc=3, bb=2, aa=1} (aa,bb,cc,dd) {1=[User{name='aa', age=1}], 2=[User{name='bb', age=2}, User{name='dd', age=2}], 3=[User{name='cc', age=3}]} {1={1=[User{name='aa', age=1}]}, 2={2=[User{name='bb', age=2}, User{name='dd', age=2}]}, 3={3=[User{name='cc', age=3}]}} {false=[User{name='aa', age=1}, User{name='bb', age=2}, User{name='dd', age=2}], true=[User{name='cc', age=3}]}

總結

以上是生活随笔為你收集整理的Java 8 Stream 流用法及语法的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。