溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
這篇文章主要講解了“Java8中怎么使用Stream流式編程”，文中的講解內容簡單清晰，易于學習與理解，下面請大家跟著小編的思路慢慢深入，一起來研究和學習“Java8中怎么使用Stream流式編程”吧！
Stream的中間操作是指在流鏈當中，可以對數據進行處理操作，包括filter過濾、map映射轉換、flatMap合并、distinct去重、sorted排序等操作。這些操作都會返回一個新的Stream流對象，可以通過鏈式調用多個中間操作進行復雜的數據處理。需要注意的是，中間操作需要具有終止操作才會觸發。
下面按類別講解Stream常見的中間操作。
filter()方法常用于實現數據過濾，即可以對集合、數組等數據源篩選出符合指定條件的元素，并返回一個新的流。
假設有一個黑名單手機號列表，需要篩選出其中所有開頭為“133”的元素，那么可以通過filter()實現——
//將數組轉換為一個字符串列表
List<String> numbers = Arrays.asList("13378520000","13278520000","13178520000","13358520000");
//通過stream()方法創建一個流，接著使用filter()方法過濾出前綴為“133”的元素，最終通過collect() 方法將結果收集到一個新列表中
List<String> filterdNumbers = numbers.stream().filter(s -> s.startsWith("133")).collect(Collectors.toList());
System.out.println(filterdNumbers);
//打印結果：[13378520000, 13358520000]map()方法用于對流中的每個元素進行映射操作，將其轉換為另一個元素或者提取其中的信息，并返回一個新的流。
根據以下兩個案例分別學習map()將元素轉換為另一個元素以及提取元素其中的信息——
1.2.1、轉換元素
假設有一個手機號字符列表，需要根據前7位來確定手機號歸屬地，那么就需要獲取所有手機號前7位子字符串，可以使用map()方法實現：
List<String> numbers = Arrays.asList("13378520000","13278520000","13178520000","13558520000");
//通過stream()方法創建一個流，使用map()方法將每個字符串轉換為截取前7位的字符，最后使用collect()方法將結果收集到一個新列表中
List<String> filterdNumbers = numbers.stream().map(s -> s.substring(0,7)).collect(Collectors.toList());
System.out.println(filterdNumbers);
//打印結果：[1337852, 1327852, 1317852, 1355852]1.2.2、提取元素信息
假設有一個用戶對象列表，我們需要提取其中每個對象的手機號，可以使用map()方法實現：
List<People> peopleList = Arrays.asList(
new People("王二","13378520000"),
new People("李二","13278520000"),
new People("張四","13178520000")
);
//通過stream()方法創建一個流，使用map()方法提取每個用戶的手機號，最后使用collect()方法將結果收集到一個新列表中
List<String> tel = peopleList.stream().map(People::getTel).collect(Collectors.toList());
System.out.println(tel);
//打印結果：[13378520000, 13278520000, 13178520000]flatMap()方法可以實現多對多的映射，或者將多個列表合并成一個列表操作。
1.3.1、實現多對多的映射
假設有兩組余額列表A和B，需要將A組每個元素都與B組所有元素依次進行相加，可以使用flatMap實現該多對多的映射——
List<Integer> listA = Arrays.asList(1, 2, 3); List<Integer> listB = Arrays.asList(4, 5, 6); List<Integer> list = listA.stream().flatMap(a -> listB.stream().map(b -> a +b)).collect(Collectors.toList()); System.out.println(list); //打印結果: [5, 6, 7, 6, 7, 8, 7, 8, 9]
1.3.2、將多個列表合并成一個列表
假設有一個包含多個手機號字符串列表的列表，現在需要合并所有手機號字符串成為一個列表，可以使用flatMap()方法實現：
List<List<String>> listOfLists = Arrays.asList(
Arrays.asList("13378520000", "13278520000"),
Arrays.asList("13178520000", "13558520000"),
Arrays.asList("15138510000", "15228310000")
);
List<String> flatMapList = listOfLists.stream().flatMap(Collection::stream).collect(Collectors.toList());
System.out.println(flatMapList);
//打印結果：[13378520000, 13278520000, 13178520000, 13558520000, 15138510000, 15228310000]distinct()方法可以用來去除流中的重復元素，生成無重復的列表。
假設有一個包含重復手機號字符串的列表，可以使用distinct()去重操作——
List<String> numbers = Arrays.asList("13378520000", "15138510000","13178520000", "15138510000");
List<String> disNumbers = numbers.stream().distinct().collect(Collectors.toList());
System.out.println(disNumbers);
//打印結果：[13378520000, 15138510000, 13178520000] 注意一點的是，distinct用于針對流作去重操作時，需要確定流中元素實現了equals()和hashCode()方法，因為這兩個方法是判斷兩個對象是否相等的標準。
sorted()方法用于對流中的元素進行排序。
假設需要對一組People對象按照年齡排序，下面分別按照升序排序和降序排序——
1.5.1、升序排序
默認情況下，是升序排序——
List<People> peopleList = Arrays.asList(
new People("王二",20),
new People("李二",30),
new People("張四",31)
);
List<People> newpeopleList=peopleList.stream().sorted(Comparator.comparing(People::getAge)).collect(Collectors.toList());
//打印結果
newpeopleList.stream().forEach(System.out::println);打印結果：
People{name='王二', age=20}
People{name='李二', age=30}
People{name='張四', age=31}
1.5.2、降序排序
通過reversed()方法進行逆序排序，也就是將升序排序進行倒序排序——
List<People> peopleList = Arrays.asList(
new People("王二",20),
new People("李二",30),
new People("張四",31)
);
List<People> newpeopleList = peopleList.stream().sorted(Comparator.comparing(People::getAge).reversed()).collect(Collectors.toList());
//打印結果
newpeopleList.stream().forEach(System.out::println);打印結果：
People{name='張四', age=31}
People{name='李二', age=30}
People{name='王二', age=20}
peek()方法用于查看流中的元素而不會修改流中元素的狀態，可以在流中的任何階段使用，不會影響到流的操作，也不會終止流的操作。
List<String> telList = Arrays.asList("13378520000","13278520000","13178520000","13558520000");
telList.stream().peek(t -> System.out.println(t))
.map(t -> t.substring(0,3))
.peek(t -> System.out.println(t))
.collect(Collectors.toList());打印結果：
13378520000
133
13278520000
132
peek()方法和forEach很類似，都是可以用于遍歷流中的元素，但是，兩者之間存在較大的區別。主要一點是，forEach在流中是一個終止操作，一旦調用它，就意味著Stream流已經被處理完成，不能再進行任何操作，例如，無法在forEach之后針對流進行map、filter等操作，但peek方法可以，以上的案例可以看出，在第一次調用peek打印一個元素后，該元素還可以接著進行map操作，進行字符串的前三位截取。
這是peek()方法和forEach最大的區別。
limit()和skip()都是用于截取Stream流中部分元素的方法，兩者區別在于，limit()返回一個包含前n個元素的新流，skip()則返回一個丟棄前n個元素后剩余元素組成的新流。
int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
System.out.print("取數組前5個元素:");
Arrays.stream(arr).limit(5).forEach(n -> System.out.print(n + " ")); // 輸出結果為：1 2 3 4 5
System.out.print("跳過前3個元素，取剩余數組元素:");
Arrays.stream(arr).skip(3).forEach(n -> System.out.print(n + " ")); // 輸出結果為：4 5 6 7 8 9 10Stream的終止操作是指執行Stream流鏈中最后一個步驟，到這一步就會結束整個流處理。在Java8中，Stream終止操作包括forEach、toArray、reduce、collect、min、max、count、anyMatch、allMatch、noneMatch、findFirst和findAny等。這些終止操作都有返回值。需要注意一點是，如果沒有執行終止操作的話，Stream流是不會觸發執行的，例如，一個沒有終止操作的peek()方法代碼是不會執行進而打印——
list.stream().peek(t -> System.out.println("ddd"))當加上終止操作話，例如加上collect，就會打印出“ddd”——
list.stream().peek(t -> System.out.println("ddd")).collect(Collectors.toList());下面按類別分別講解各個終止操作的使用。
該forEach前面已經提到，這里不做過多介紹。
count可以統計流中元素的數量并返回結果。
假設有一個包含多個手機號字符串的列表，需要統計去重后的手機號數量，就可以使用count方法——
List<String> numbers = Arrays.asList("13378520000", "15138510000","13178520000", "15138510000");
long count = numbers.stream()
.distinct()//去重
.count();//統計去重后的手機號
System.out.println(count);
//打印結果：3reduce()可以將流中的所有元素根據指定規則歸約成一個結果，并將該結果返回。
常用語法格式如下：
Optional<T> result = stream.reduce(BinaryOperator<T> accumulator);
可見，reduce方法會返回一個Optional類型的值，表示歸約后的結果，需要通過get()方法獲取Optional里的值。
假設有一個包含多個手機號字符串的List列表，需要在去重之后，再將列表所有字符串拼按照逗號間隔接成一個字符串返回，那么就可以通過reduce來實現——
List<String> numbers = Arrays.asList("13378520000", "15138510000","13178520000", "15138510000");
Optional result = numbers.stream()
.distinct() //去重
.reduce((a ,b) -> a+","+b);//指定規則為，相臨兩個字符通過逗號“，”間隔
System.out.println(result.get());
//打印結果：13378520000,15138510000,13178520000collect的作用是將流中的元素收集到一個新的容器中，返回該容器。打個比喻，它就像一個采摘水果的工人，負責將水果一個個采摘下來，然后放進一個籃子里，最后將籃子交給你。我在前面的案例當中，基本都有用到collect，例如前面2.1的filter過濾用法中的List filterdNumbers = numbers.stream().filter(s -> s.startsWith("133")).collect(Collectors.toList())，就是將過濾出前綴為“133”的字符串，將這些過濾處理后的元素交給collect這個終止操作。這時collect就像采摘水果的員工，把采摘為前綴“133”的“水果”通過toList()方法收集到一個新的List容器當中，然后交給你。最后你就可以得到一個只裝著前綴為“133”的元素集合。
在Java8的collect方法中，除里toList()之外，還提供了例如toSet，toMap等方法滿足不同的場景，根據名字就可以知道，toSet()返回的是一個Set集合，toMap()返回的是一個Map集合。
min和max用來查找流中的最小值和最大值。
假設需要在查找出用戶列表中年齡最小的用戶，可以按照以下代碼實現——
List<People> peopleList = Arrays.asList(
new People("王二",20),
new People("李二",30),
new People("張四",31)
);
//查找年齡最小的用戶，若沒有則返回一個null
People people = peopleList.stream().min(Comparator.comparing(People::getAge)).orElse(null);
System.out.println(people);
//打印結果：People{name='王二', age=20}max的用法類似，這里不做額外說明。
2.6.1、anyMatch
anyMatch用于判斷，如果流中至少有一個元素滿足給定條件，那么返回true，反之返回false，即 true||false為true這類的判斷。
假設在一個手機號字符串的List列表當中，判斷是否包含前綴為“153”的手機號，就可以使用anyMatch——
List<String> numbers = Arrays.asList("13378520000", "15138510000","13178520000", "15338510000");
boolean hasNum = numbers.stream().anyMatch(n -> n.startsWith("153"));
System.out.println(hasNum);
//打印結果：true2.6.2、allMatch
allMatch用于判斷，流中的所有元素是否都滿足給定條件，滿足返回true，反之false，即true&&false為false這類判斷。
假設在一個手機號字符串的List列表當中，判斷手機號是否都滿足前綴為“153”的手機號，就可以用allMatch——
List<String> numbers = Arrays.asList("13378520000", "15138510000","13178520000", "15338510000");
boolean hasNum = numbers.stream().allMatch(n -> n.startsWith("153"));
System.out.println(hasNum);
//打印結果：false2.6.3、noneMatch
noneMatch用于判斷，如果流中沒有任何元素滿足給定的條件，返回true，如果流中有任意一個條件滿足給定條件，返回false，類似!true為false的判斷。
假設在一個手機號字符串的List列表當中，判斷手機號是否都不滿足前綴為“153”的手機號，就可以用noneMatch——
List<String> numbers = Arrays.asList("13378520000", "15138510000","13178520000", "1238510000");
//numbers里沒有前綴為“153”的手機號
boolean hasNum = numbers.stream().noneMatch(n -> n.startsWith("153"));
System.out.println(hasNum);
//打印結果：true這三個方法其實存在一定互相替代性，例如在3.6.1中，滿足!anyMatch表示所有手機號都不為“153”前綴，才得到true，這不就是noneMatch，主要看在項目當中如何靈活應用。
2.7.1、findFirst
findFirst用于返回流中第一個元素，如果流為空話，則返回一個空的Optional對象——
假設需要對一批同手機號的黑名單用戶按照時間戳降序排序，然后取出第一個即時間戳為最早的用戶，就可以使用findFirst——
List<People> peopleList = Arrays.asList(
new People("王二","13178520000","20210409"),
new People("李二","13178520000","20230401"),
new People("張四","13178520000","20220509"),
new People("趙六","13178520000","20220109")
);
/**
* 先按照時間升序排序，排序后的結果如下：
* People{name='王二', tel='13178520000', time='20210409'}
* People{name='趙六', tel='13178520000', time='20220109'}
* People{name='張四', tel='13178520000', time='20220509'}
* People{name='李二', tel='13178520000', time='20230401'}
*
*排序后，People{name='王二', tel='13178520000', time='20210409'}成了流中的第一個元素
*/
People people = peopleList.stream().sorted(Comparator.comparing(People::getTime)).findFirst().orElse(null);
System.out.println(people);
//打印結果：People{name='王二', tel='13178520000', time='20210409'}2.7.2、findAny
findAny返回流中的任意一個元素，如果流為空，則通過Optional對象返回一個null。
假設有一個已經存在的黑名單手機號列表blackList，現在有一批新的手機號列表phoneNumber，需要基于blackList列表過濾出phoneNumber存在的黑名單手機號，最后從過濾出來的黑名單手機號當中挑選出來出來任意一個，即可以通過findAny實現——
//blackList是已經存在的黑名單列表
List<String> blackList = Arrays.asList("13378520000", "15138510000");
//新來的手機號列表
List<String> phoneNumber = Arrays.asList("13378520000", "13178520000", "1238510000","15138510000","13299920000");
String blackPhone = phoneNumber.stream()
//過濾出phoneNumber有包含在blackList的手機號，這類手機號即為黑名單手機號。
.filter(phone -> blackList.contains(phone))
//獲取過濾確定為黑名單手機號的任意一個
.findAny()
//如果沒有則返回一個null
.orElse(null);
System.out.println(blackPhone);
//打印結果：13378520000前面的案例主要都是以順序流來講解，接下來，就是講解Stream的并行流。在大數據量處理場景下，使用并行流可以提高某些操作效率，但同樣存在一些需要考慮的問題，并非所有情況下都可以使用。
3.1、什么是并行流：并行流的概念和原理
并行流是指通過將數據按照一定的方式劃分成多個片段分別在多個處理器上并行執行，這就意味著，可能處理完成的數據順序與原先排序好的數據情況是不一致的。主要是用在比較大的數據量處理情況，若數據量太少，效率并不比順序流要高，因為底層其實就使用到了多線程的技術。
并行流的流程原理如下：
1、輸入數據：并行流的初始數據一般是集合或者數組，例如Arrays.asList("13378520000", "13178520000", "1238510000","15138510000","13299920000")；
2、劃分數據：將初始數據平均分成若干個子集，每個子集可以在不同的線程中獨立進行處理，這個過程通常叫“分支”（Forking），默認情況下，Java8并行流使用到了ForkJoinPool框架，會將Arrays.asList("13378520000", "13178520000", "1238510000","15138510000","13299920000")劃分成更小的顆粒進行處理，可能會將該數組劃分成以下三個子集：
[13378520000, 13178520000] [1238510000, 13338510000] [13299920000]
3、處理數據：針對劃分好的子集并行進行相同的操作，例如包括過濾(filter)、映射(map)、去重(distinct)等，這個過程通常叫“計算”（Computing），例如需要過濾為前綴包括“133”的字符集合，那么，各個子集，就會處理得到以下結果：
[13378520000] [13338510000] []
4、合并結果：將所有子集處理完成的結果進行匯總，得到最終結果。這個過程通常叫“合并”（Merging），結果就會合并如下：
[13378520000，13338510000]
5、返回結果：返回最終結果。
通俗而言，就是順序流中，只有一個工人在摘水果，并行流中，是多個工人同時在摘水果。
3.2、創建并行流：通過 parallel() 方法將串行流轉換為并行流
可以通過parallel()方法將順序流轉換為并行流，操作很簡單，只需要在順序流上調用parallel()即可。
List<String> numbers = Arrays.asList("13378360000","13278240000","13178590000","13558120000");
//通過stream().parallel()方法創建一個并行流，使用map()方法將每個字符串轉換為截取前7位的字符，最后使用collect()方法將結果收集到一個新列表中
List<String> filNums = numbers.stream().parallel().map(s -> s.substring(0,7)).collect(Collectors.toList());
System.out.println(filNums);
//打印結果：[1337836, 1327824, 1317859, 1355812]3.3、并行流的注意事項：并行流可能引發的線程安全，以及如何避免這些問題
在使用并發流的過程中，可能會引發以下線程安全問題：并行流中的每個子集都在不同線程運行，可能會導致對共享狀態的競爭和沖突。
避免線程問題的方法如下：避免修改共享狀態，即在處理集合過程當中，避免被其他線程修改集合數據，可以使用鎖來保證線程安全。
使用無狀態操作：在并行流處理過程盡量使用無狀態操作，例如filter、map之類的，可以盡量避免線程安全和同步問題。
4.1、什么是 Optional：Optional 類型的作用和使用場景
在實際開發當中，Optional類型通常用于返回可能為空的方法、避免null值的傳遞和簡化復雜的判斷邏輯等場景。調用Optional對象的方法，需要通過isPresent()方法判斷值是否存在，如果存在則可以通過get()方法獲取其值，如果不存在則可以通過orElse()方法提供默認值，或者拋出自定義異常處理。
4.2、如何使用 Optional：如何使用 Optional 類型
使用Optional類型主要目的是在數據可能為空的情況下，提供一種更安全、更優雅的處理方式。
以下是使用Optional類型的常用方法：
4.2.1、ofNullable()和isPresent()方法
將一個可能為null的對象包裝成Optional類型的對象，然后根據isPresent方法判斷對象是否包含空值——
String str = null;
Optional<String> optStr = Optional.ofNullable(str);
if (optStr.isPresent()){
System.out.println("Optional對象不為空");
}else {
System.out.println("Optional對象為空");
}
//打印結果：Optional對象為空4.2.2、get()方法
獲取Optional對象中的值，如果對象為空則拋出NoSuchElementException異常——
String str = null;
Optional<String> optStr = Optional.ofNullable(str);
if (optStr.isPresent()){
System.out.println("Optional對象不為空");
}else {
System.out.println("Optional對象為空");
optStr.get();
}控制臺打印結果：
Exception in thread "main" java.util.NoSuchElementException: No value present
at java.util.Optional.get(Optional.java:135)
at com.zhu.fte.biz.test.StreamTest.main(StreamTest.java:144)
Optional對象為空
4.2.4、orElse()方法
獲取Optional對象中的值，如果對象為空則返回指定的默認值——
String str = null;
Optional<String> optStr = Optional.ofNullable(str);
if (optStr.isPresent()){
System.out.println("Optional對象不為空");
}else {
System.out.println("Optional對象為空，返回默認值：" + optStr.orElse("null"));
}
//打印結果：Optional對象為空，返回默認值：null當然，如果不為空的話，則能正常獲取對象中的值——
String str = "測試";
Optional<String> optStr = Optional.ofNullable(str);
if (optStr.isPresent()){
System.out.println("Optional對象不為空，返回值：" + optStr.orElse("null"));
}else {
System.out.println("Optional對象為空，返回默認值：" + optStr.orElse("null"));
}
//打印結果：Optional對象不為空，返回值：測試那么，問題來了，它是否能判斷“ ”這類空格的字符串呢，我實驗了一下，
String str = " ";
Optional<String> optStr = Optional.ofNullable(str);
if (optStr.isPresent()){
System.out.println("Optional對象不為空，返回值：" + optStr.orElse("null"));
}else {
System.out.println("Optional對象為空，返回默認值：" + optStr.orElse("null"));
}
//打印結果：Optional對象不為空，返回值：可見，這類空字符串，在orElse判斷當中，跟StringUtils.isEmpty()類似，都是把它當成非空字符串，但是StringUtils.isBlank()則判斷為空字符串。
4.2.5、orElseGet()方法
orElseGet()和orElse()類似，都可以提供一個默認值。兩者區別在于，orElse方法在每次調用時都會創建默認值，而orElseGet只在需要時才會創建默認值。
4.3、Optional 和 null 的區別： Optional 類型與 null 值的異同
兩者都可以表示缺失值的情況，兩者主要區別為：Optional類型是一種包裝器對象，可以將一個可能為空的對象包裝成一個Optional對象。這個對象可以通過調用ofNullable()、of()或其他方法來創建。而null值則只是一個空引用，沒有任何實際的值。
Optional類型還可以避免出現NullPointerException異常，具體代碼案例如下：
String str = null;
//錯誤示范：直接調用str.length()方法會觸發NullPointerException
//int length = str.length()
//通過Optional類型避免NullPointerException
Optional<String> optionalStr = Optional.ofNullable(str);
if (optionalStr.isPresent()){//判斷Optional對象是否都包含非空值
int length = optionalStr.get().length();
System.out.println("字符串長度為：" + length);
}else {
System.out.println("字符串為空！");
}
//使用map()方法對Optional對象進行轉換時，確保返回對結果不為null
Optional<Integer> optionalLength = optionalStr.map(s -> s.length());
System.out.println("字符串長度為：" + optionalLength.orElse(-1)); // 使用orElse()方法提供默認值除里以上常用的流處理之外，Java8還新增了一些專門用來處理基本類型的流，例如IntStream、LongStream、DoubleStream等，其對應的Api接口基本與前面案例相似，讀者可以自行研究。
最后，需要注意一點是，在流處理過程當中，盡量使用原始類型數據，避免裝箱操作，因為裝箱過程會有性能開銷、內存占用等問題，例如，當原始數據int類型被裝箱成Integer包裝類型時，這個過程會涉及到對象的創建、初始化、垃圾回收等過程，需要額外的性能開銷。
感謝各位的閱讀，以上就是“Java8中怎么使用Stream流式編程”的內容了，經過本文的學習后，相信大家對Java8中怎么使用Stream流式編程這一問題有了更深刻的體會，具體使用情況還需要大家實踐驗證。這里是億速云，小編將為大家推送更多相關知識點的文章，歡迎關注！
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
