java8 stream

這篇關(guān)于java stream的文章寫的特別好赠涮,轉(zhuǎn)載一下溃列,以備自己查看例证。轉(zhuǎn)載自
Java 8 中的 Streams API 詳解

為什么需要 Stream

Stream 作為 Java 8 的一大亮點,它與 java.io 包里的 InputStream 和 OutputStream 是完全不同的概念冠句。它也不同于 StAX 對 XML 解析的 Stream轻掩,也不是 Amazon Kinesis 對大數(shù)據(jù)實時處理的 Stream。Java 8 中的 Stream 是對集合(Collection)對象功能的增強懦底,它專注于對集合對象進行各種非常便利唇牧、高效的聚合操作(aggregate operation),或者大批量數(shù)據(jù)操作 (bulk data operation)聚唐。Stream API 借助于同樣新出現(xiàn)的 Lambda 表達式丐重,極大的提高編程效率和程序可讀性。同時它提供串行和并行兩種模式進行匯聚操作拱层,并發(fā)模式能夠充分利用多核處理器的優(yōu)勢弥臼,使用 fork/join 并行方式來拆分任務(wù)和加速處理過程。通常編寫并行代碼很難而且容易出錯, 但使用 Stream API 無需編寫一行多線程的代碼根灯,就可以很方便地寫出高性能的并發(fā)程序。所以說掺栅,Java 8 中首次出現(xiàn)的 java.util.stream 是一個函數(shù)式語言+多核時代綜合影響的產(chǎn)物烙肺。

什么是聚合操作

在傳統(tǒng)的 J2EE 應(yīng)用中,Java 代碼經(jīng)常不得不依賴于關(guān)系型數(shù)據(jù)庫的聚合操作來完成諸如:

  • 客戶每月平均消費金額
  • 最昂貴的在售商品
  • 本周完成的有效訂單(排除了無效的)
  • 取十個數(shù)據(jù)樣本作為首頁推薦
    這類的操作氧卧。

但在當今這個數(shù)據(jù)大爆炸的時代桃笙,在數(shù)據(jù)來源多樣化、數(shù)據(jù)海量化的今天沙绝,很多時候不得不脫離 RDBMS搏明,或者以底層返回的數(shù)據(jù)為基礎(chǔ)進行更上層的數(shù)據(jù)統(tǒng)計。而 Java 的集合 API 中闪檬,僅僅有極少量的輔助型方法星著,更多的時候是程序員需要用 Iterator 來遍歷集合,完成相關(guān)的聚合應(yīng)用邏輯粗悯。這是一種遠不夠高效虚循、笨拙的方法。在 Java 7 中样傍,如果要發(fā)現(xiàn) type 為 grocery 的所有交易横缔,然后返回以交易值降序排序好的交易 ID 集合,我們需要這樣寫:

清單 1. Java 7 的排序衫哥、取值實現(xiàn)

List<Transaction> groceryTransactions = new Arraylist<>();
for(Transaction t: transactions){
 if(t.getType() == Transaction.GROCERY){
 groceryTransactions.add(t);
 }
}
Collections.sort(groceryTransactions, new Comparator(){
 public int compare(Transaction t1, Transaction t2){
 return t2.getValue().compareTo(t1.getValue());
 }
});
List<Integer> transactionIds = new ArrayList<>();
for(Transaction t: groceryTransactions){
 transactionsIds.add(t.getId());
}

而在 Java 8 使用 Stream茎刚,代碼更加簡潔易讀须眷;而且使用并發(fā)模式间影,程序執(zhí)行速度更快。

清單 2. Java 8 的排序戈稿、取值實現(xiàn)

List<Integer> transactionsIds = transactions.parallelStream().
 filter(t -> t.getType() == Transaction.GROCERY).
 sorted(comparing(Transaction::getValue).reversed()).
 map(Transaction::getId).
 collect(toList());

Stream 總覽

什么是流

Stream 不是集合元素,它不是數(shù)據(jù)結(jié)構(gòu)并不保存數(shù)據(jù)泉沾,它是有關(guān)算法和計算的捞蚂,它更像一個高級版本的 Iterator。原始版本的 Iterator跷究,用戶只能顯式地一個一個遍歷元素并對其執(zhí)行某些操作姓迅;高級版本的 Stream,用戶只要給出需要對其包含的元素執(zhí)行什么操作俊马,比如 “過濾掉長度大于 10 的字符串”丁存、“獲取每個字符串的首字母”等,Stream 會隱式地在內(nèi)部進行遍歷柴我,做出相應(yīng)的數(shù)據(jù)轉(zhuǎn)換解寝。

Stream 就如同一個迭代器(Iterator),單向艘儒,不可往復(fù)聋伦,數(shù)據(jù)只能遍歷一次,遍歷過一次后即用盡了界睁,就好比流水從面前流過觉增,一去不復(fù)返。

而和迭代器又不同的是翻斟,Stream 可以并行化操作逾礁,迭代器只能命令式地、串行化操作访惜。顧名思義嘹履,當使用串行方式去遍歷時,每個 item 讀完后再讀下一個 item债热。而使用并行去遍歷時砾嫉,數(shù)據(jù)會被分成多個段,其中每一個都在不同的線程中處理阳柔,然后將結(jié)果一起輸出焰枢。Stream 的并行操作依賴于 Java7 中引入的 Fork/Join 框架(JSR166y)來拆分任務(wù)和加速處理過程。Java 的并行 API 演變歷程基本如下:

  1. 1.0-1.4 中的 java.lang.Thread
  2. 5.0 中的 java.util.concurrent
  3. 6.0 中的 Phasers 等
  4. 7.0 中的 Fork/Join 框架
  5. 8.0 中的 Lambda

Stream 的另外一大特點是舌剂,數(shù)據(jù)源本身可以是無限的济锄。

流的構(gòu)成

當我們使用一個流的時候,通常包括三個基本步驟:

獲取一個數(shù)據(jù)源(source)→ 數(shù)據(jù)轉(zhuǎn)換→執(zhí)行操作獲取想要的結(jié)果霍转,每次轉(zhuǎn)換原有 Stream 對象不改變荐绝,返回一個新的 Stream 對象(可以有多次轉(zhuǎn)換),這就允許對其操作可以像鏈條一樣排列避消,變成一個管道低滩,如下圖所示召夹。

圖 1. 流管道 (Stream Pipeline) 的構(gòu)成


Stream Pipeline

有多種方式生成 Stream Source:

  • 從 Collection 和數(shù)組
    • Collection.stream()
    • Collection.parallelStream()
    • Arrays.stream(T array) or Stream.of()
      從 BufferedReader
    • java.io.BufferedReader.lines()
  • 靜態(tài)工廠
  • java.util.stream.IntStream.range()
  • java.nio.file.Files.walk()
  • 自己構(gòu)建
    • java.util.Spliterator
      其他
    • Random.ints()
    • BitSet.stream()
    • Pattern.splitAsStream(java.lang.CharSequence)
    • JarFile.stream()

流的操作類型分為兩種:

  • Intermediate:一個流可以后面跟隨零個或多個 intermediate 操作。其目的主要是打開流恕沫,做出某種程度的數(shù)據(jù)映射/過濾监憎,然后返回一個新的流,交給下一個操作使用婶溯。這類操作都是惰性化的(lazy)鲸阔,就是說,僅僅調(diào)用到這類方法迄委,并沒有真正開始流的遍歷褐筛。
  • Terminal:一個流只能有一個 terminal 操作,當這個操作執(zhí)行后叙身,流就被使用“光”了渔扎,無法再被操作。所以這必定是流的最后一個操作信轿。Terminal 操作的執(zhí)行晃痴,才會真正開始流的遍歷,并且會生成一個結(jié)果虏两,或者一個 side effect愧旦。

在對于一個 Stream 進行多次轉(zhuǎn)換操作 (Intermediate 操作),每次都對 Stream 的每個元素進行轉(zhuǎn)換定罢,而且是執(zhí)行多次,這樣時間復(fù)雜度就是 N(轉(zhuǎn)換次數(shù))個 for 循環(huán)里把所有操作都做掉的總和嗎旁瘫?其實不是這樣的祖凫,轉(zhuǎn)換操作都是 lazy 的,多個轉(zhuǎn)換操作只會在 Terminal 操作的時候融合起來酬凳,一次循環(huán)完成惠况。我們可以這樣簡單的理解,Stream 里有個操作函數(shù)的集合宁仔,每次轉(zhuǎn)換操作就是把轉(zhuǎn)換函數(shù)放入這個集合中稠屠,在 Terminal 操作的時候循環(huán) Stream 對應(yīng)的集合,然后對每個元素執(zhí)行所有的函數(shù)翎苫。

還有一種操作被稱為 short-circuiting权埠。用以指:

  • 對于一個 intermediate 操作,如果它接受的是一個無限大(infinite/unbounded)的 Stream煎谍,但返回一個有限的新 Stream攘蔽。
  • 對于一個 terminal 操作,如果它接受的是一個無限大的 Stream呐粘,但能在有限的時間計算出結(jié)果满俗。

當操作一個無限大的 Stream转捕,而又希望在有限時間內(nèi)完成操作,則在管道內(nèi)擁有一個 short-circuiting 操作是必要非充分條件唆垃。

清單 3. 一個流操作的示例

int sum = widgets.stream()
.filter(w -> w.getColor() == RED)
 .mapToInt(w -> w.getWeight())
 .sum();

stream() 獲取當前小物件的 source五芝,filter 和 mapToInt 為 intermediate 操作,進行數(shù)據(jù)篩選和轉(zhuǎn)換辕万,最后一個 sum() 為 terminal 操作枢步,對符合條件的全部小物件作重量求和。

流的使用詳解

簡單說蓄坏,對 Stream 的使用就是實現(xiàn)一個 filter-map-reduce 過程价捧,產(chǎn)生一個最終結(jié)果,或者導(dǎo)致一個副作用(side effect)涡戳。

流的構(gòu)造與轉(zhuǎn)換

下面提供最常見的幾種構(gòu)造 Stream 的樣例结蟋。

清單 4. 構(gòu)造流的幾種常見方法

// 1. Individual values
Stream stream = Stream.of("a", "b", "c");
// 2. Arrays
String [] strArray = new String[] {"a", "b", "c"};
stream = Stream.of(strArray);
stream = Arrays.stream(strArray);
// 3. Collections
List<String> list = Arrays.asList(strArray);
stream = list.stream();

需要注意的是,對于基本數(shù)值型渔彰,目前有三種對應(yīng)的包裝類型 Stream:

IntStream嵌屎、LongStream、DoubleStream恍涂。當然我們也可以用 Stream<Integer>宝惰、Stream<Long> >、Stream<Double>再沧,但是 boxing 和 unboxing 會很耗時尼夺,所以特別為這三種基本數(shù)值型提供了對應(yīng)的 Stream。

Java 8 中還沒有提供其它數(shù)值型 Stream炒瘸,因為這將導(dǎo)致擴增的內(nèi)容較多淤堵。而常規(guī)的數(shù)值型聚合運算可以通過上面三種 Stream 進行。

清單 5. 數(shù)值流的構(gòu)造

IntStream.of(new int[]{1, 2, 3}).forEach(System.out::println);
IntStream.range(1, 3).forEach(System.out::println);
IntStream.rangeClosed(1, 3).forEach(System.out::println);

清單 6. 流轉(zhuǎn)換為其它數(shù)據(jù)結(jié)構(gòu)

// 1. Array
String[] strArray1 = stream.toArray(String[]::new);
// 2. Collection
List<String> list1 = stream.collect(Collectors.toList());
List<String> list2 = stream.collect(Collectors.toCollection(ArrayList::new));
Set set1 = stream.collect(Collectors.toSet());
Stack stack1 = stream.collect(Collectors.toCollection(Stack::new));
// 3. String
String str = stream.collect(Collectors.joining()).toString();

一個 Stream 只可以使用一次顷扩,上面的代碼為了簡潔而重復(fù)使用了數(shù)次拐邪。

流的操作

接下來,當把一個數(shù)據(jù)結(jié)構(gòu)包裝成 Stream 后隘截,就要開始對里面的元素進行各類操作了扎阶。常見的操作可以歸類如下。

  • Intermediate:
    map (mapToInt, flatMap 等)婶芭、 filter东臀、 distinct、 sorted雕擂、 peek啡邑、 limit、 skip井赌、 parallel谤逼、 sequential贵扰、 unordered

  • Terminal:
    forEach、 forEachOrdered流部、 toArray戚绕、 reduce、 collect枝冀、 min舞丛、 max、 count果漾、 anyMatch球切、 allMatch、 noneMatch绒障、 findFirst吨凑、 findAny、 iterator

  • Short-circuiting:
    anyMatch户辱、 allMatch鸵钝、 noneMatch、 findFirst庐镐、 findAny恩商、 limit

我們下面看一下 Stream 的比較典型用法。

map/flatMap

我們先來看 map必逆。如果你熟悉 scala 這類函數(shù)式語言怠堪,對這個方法應(yīng)該很了解,它的作用就是把 input Stream 的每一個元素名眉,映射成 output Stream 的另外一個元素研叫。

清單 7. 轉(zhuǎn)換大寫

List<String> output = wordList.stream().
map(String::toUpperCase).
collect(Collectors.toList());

這段代碼把所有的單詞轉(zhuǎn)換為大寫。

清單 8. 平方數(shù)

List<Integer> nums = Arrays.asList(1, 2, 3, 4);
List<Integer> squareNums = nums.stream().
map(n -> n * n).
collect(Collectors.toList());

這段代碼生成一個整數(shù) list 的平方數(shù) {1, 4, 9, 16}璧针。

從上面例子可以看出,map 生成的是個 1:1 映射渊啰,每個輸入元素探橱,都按照規(guī)則轉(zhuǎn)換成為另外一個元素。還有一些場景绘证,是一對多映射關(guān)系的隧膏,這時需要 flatMap。

清單 9. 一對多

Stream<List<Integer>> inputStream = Stream.of(
 Arrays.asList(1),
 Arrays.asList(2, 3),
 Arrays.asList(4, 5, 6)
 );
Stream<Integer> outputStream = inputStream.
flatMap((childList) -> childList.stream());

flatMap 把 input Stream 中的層級結(jié)構(gòu)扁平化嚷那,就是將最底層元素抽出來放到一起胞枕,最終 output 的新 Stream 里面已經(jīng)沒有 List 了,都是直接的數(shù)字魏宽。

filter

filter 對原始 Stream 進行某項測試腐泻,通過測試的元素被留下來生成一個新 Stream决乎。

清單 10. 留下偶數(shù)

Integer[] sixNums = {1, 2, 3, 4, 5, 6};
Integer[] evens =
Stream.of(sixNums).filter(n -> n%2 == 0).toArray(Integer[]::new);

經(jīng)過條件“被 2 整除”的 filter,剩下的數(shù)字為 {2, 4, 6}派桩。

清單 11. 把單詞挑出來

List<String> output = reader.lines().
 flatMap(line -> Stream.of(line.split(REGEXP))).
 filter(word -> word.length() > 0).
 collect(Collectors.toList());

這段代碼首先把每行的單詞用 flatMap 整理到新的 Stream构诚,然后保留長度不為 0 的,就是整篇文章中的全部單詞了铆惑。

forEach

forEach 方法接收一個 Lambda 表達式范嘱,然后在 Stream 的每一個元素上執(zhí)行該表達式。

清單 12. 打印姓名(forEach 和 pre-java8 的對比)

// Java 8
roster.stream()
 .filter(p -> p.getGender() == Person.Sex.MALE)
 .forEach(p -> System.out.println(p.getName()));
// Pre-Java 8
for (Person p : roster) {
 if (p.getGender() == Person.Sex.MALE) {
 System.out.println(p.getName());
 }
}

對一個人員集合遍歷员魏,找出男性并打印姓名丑蛤。可以看出來撕阎,forEach 是為 Lambda 而設(shè)計的受裹,保持了最緊湊的風(fēng)格。而且 Lambda 表達式本身是可以重用的闻书,非常方便名斟。當需要為多核系統(tǒng)優(yōu)化時,可以 parallelStream().forEach()魄眉,只是此時原有元素的次序沒法保證砰盐,并行的情況下將改變串行時操作的行為,此時 forEach 本身的實現(xiàn)不需要調(diào)整坑律,而 Java8 以前的 for 循環(huán) code 可能需要加入額外的多線程邏輯岩梳。

但一般認為,forEach 和常規(guī) for 循環(huán)的差異不涉及到性能晃择,它們僅僅是函數(shù)式風(fēng)格與傳統(tǒng) Java 風(fēng)格的差別冀值。

另外一點需要注意,forEach 是 terminal 操作宫屠,因此它執(zhí)行后列疗,Stream 的元素就被“消費”掉了,你無法對一個 Stream 進行兩次 terminal 運算浪蹂。下面的代碼是錯誤的:

stream.forEach(element -> doOneThing(element));
stream.forEach(element -> doAnotherThing(element));

相反抵栈,具有相似功能的 intermediate 操作 peek 可以達到上述目的。如下是出現(xiàn)在該 api javadoc 上的一個示例坤次。

清單 13. peek 對每個元素執(zhí)行操作并返回一個新的 Stream

Stream.of("one", "two", "three", "four")
 .filter(e -> e.length() > 3)
 .peek(e -> System.out.println("Filtered value: " + e))
 .map(String::toUpperCase)
 .peek(e -> System.out.println("Mapped value: " + e))
 .collect(Collectors.toList());

forEach 不能修改自己包含的本地變量值古劲,也不能用 break/return 之類的關(guān)鍵字提前結(jié)束循環(huán)。

findFirst

這是一個 termimal 兼 short-circuiting 操作缰猴,它總是返回 Stream 的第一個元素产艾,或者空。

這里比較重點的是它的返回值類型:Optional。這也是一個模仿 Scala 語言中的概念闷堡,作為一個容器隘膘,它可能含有某值,或者不包含缚窿。使用它的目的是盡可能避免 NullPointerException棘幸。

清單 14. Optional 的兩個用例

String strA = " abcd ", strB = null;
print(strA);
print("");
print(strB);
getLength(strA);
getLength("");
getLength(strB);
public static void print(String text) {
 // Java 8
 Optional.ofNullable(text).ifPresent(System.out::println);
 // Pre-Java 8
 if (text != null) {
 System.out.println(text);
 }
 }
public static int getLength(String text) {
 // Java 8
return Optional.ofNullable(text).map(String::length).orElse(-1);
 // Pre-Java 8
// return if (text != null) ? text.length() : -1;
 };

在更復(fù)雜的 if (xx != null) 的情況中,使用 Optional 代碼的可讀性更好倦零,而且它提供的是編譯時檢查误续,能極大的降低 NPE 這種 Runtime Exception 對程序的影響,或者迫使程序員更早的在編碼階段處理空值問題扫茅,而不是留到運行時再發(fā)現(xiàn)和調(diào)試蹋嵌。

Stream 中的 findAny、max/min葫隙、reduce 等方法等返回 Optional 值栽烂。還有例如 IntStream.average() 返回 OptionalDouble 等等。

reduce

這個方法的主要作用是把 Stream 元素組合起來恋脚。它提供一個起始值(種子)腺办,然后依照運算規(guī)則(BinaryOperator),和前面 Stream 的第一個糟描、第二個怀喉、第 n 個元素組合。從這個意義上說船响,字符串拼接躬拢、數(shù)值的 sum、min见间、max聊闯、average 都是特殊的 reduce。例如 Stream 的 sum 就相當于

Integer sum = integers.reduce(0, (a, b) -> a+b); 或

Integer sum = integers.reduce(0, Integer::sum);

也有沒有起始值的情況米诉,這時會把 Stream 的前面兩個元素組合起來菱蔬,返回的是 Optional。

清單 15. reduce 的用例

// 字符串連接史侣,concat = "ABCD"
String concat = Stream.of("A", "B", "C", "D").reduce("", String::concat); 
// 求最小值汗销,minValue = -3.0
double minValue = Stream.of(-1.5, 1.0, -3.0, -2.0).reduce(Double.MAX_VALUE, Double::min); 
// 求和,sumValue = 10, 有起始值
int sumValue = Stream.of(1, 2, 3, 4).reduce(0, Integer::sum);
// 求和抵窒,sumValue = 10, 無起始值
sumValue = Stream.of(1, 2, 3, 4).reduce(Integer::sum).get();
// 過濾,字符串連接叠骑,concat = "ace"
concat = Stream.of("a", "B", "c", "D", "e", "F").
 filter(x -> x.compareTo("Z") > 0).
 reduce("", String::concat);

上面代碼例如第一個示例的 reduce()李皇,第一個參數(shù)(空白字符)即為起始值,第二個參數(shù)(String::concat)為 BinaryOperator。這類有起始值的 reduce() 都返回具體的對象掉房。而對于第四個示例沒有起始值的 reduce()茧跋,由于可能沒有足夠的元素,返回的是 Optional卓囚,請留意這個區(qū)別瘾杭。

limit/skip

limit 返回 Stream 的前面 n 個元素;skip 則是扔掉前 n 個元素(它是由一個叫 subStream 的方法改名而來)哪亿。

清單 16. limit 和 skip 對運行次數(shù)的影響

public void testLimitAndSkip() {
 List<Person> persons = new ArrayList();
 for (int i = 1; i <= 10000; i++) {
 Person person = new Person(i, "name" + i);
 persons.add(person);
 }
List<String> personList2 = persons.stream().
map(Person::getName).limit(10).skip(3).collect(Collectors.toList());
 System.out.println(personList2);
}
private class Person {
 public int no;
 private String name;
 public Person (int no, String name) {
 this.no = no;
 this.name = name;
 }
 public String getName() {
 System.out.println(name);
 return name;
 }
}

輸出結(jié)果為:

name1
name2
name3
name4
name5
name6
name7
name8
name9
name10
[name4, name5, name6, name7, name8, name9, name10]

這是一個有 10粥烁,000 個元素的 Stream,但在 short-circuiting 操作 limit 和 skip 的作用下蝇棉,管道中 map 操作指定的 getName() 方法的執(zhí)行次數(shù)為 limit 所限定的 10 次讨阻,而最終返回結(jié)果在跳過前 3 個元素后只有后面 7 個返回。

有一種情況是 limit/skip 無法達到 short-circuiting 目的的篡殷,就是把它們放在 Stream 的排序操作后钝吮,原因跟 sorted 這個 intermediate 操作有關(guān):此時系統(tǒng)并不知道 Stream 排序后的次序如何,所以 sorted 中的操作看上去就像完全沒有被 limit 或者 skip 一樣板辽。

清單 17. limit 和 skip 對 sorted 后的運行次數(shù)無影響

 for (int i = 1; i <= 5; i++) {
 Person person = new Person(i, "name" + i);
 persons.add(person);
 }
List<Person> personList2 = persons.stream().sorted((p1, p2) -> 
p1.getName().compareTo(p2.getName())).limit(2).collect(Collectors.toList());
System.out.println(personList2);

上面的示例對清單 13 做了微調(diào)奇瘦,首先對 5 個元素的 Stream 排序,然后進行 limit 操作劲弦。輸出結(jié)果為:

name2
name1
name3
name2
name4
name3
name5
name4
[stream.StreamDW$Person@816f27d, stream.StreamDW$Person@87aac27]

即雖然最后的返回元素數(shù)量是 2耳标,但整個管道中的 sorted 表達式執(zhí)行次數(shù)沒有像前面例子相應(yīng)減少。

最后有一點需要注意的是瓶您,對一個 parallel 的 Steam 管道來說麻捻,如果其元素是有序的,那么 limit 操作的成本會比較大呀袱,因為它的返回對象必須是前 n 個也有一樣次序的元素贸毕。取而代之的策略是取消元素間的次序,或者不要用 parallel Stream夜赵。

sorted

對 Stream 的排序通過 sorted 進行明棍,它比數(shù)組的排序更強之處在于你可以首先對 Stream 進行各類 map、filter寇僧、limit摊腋、skip 甚至 distinct 來減少元素數(shù)量后,再排序嘁傀,這能幫助程序明顯縮短執(zhí)行時間兴蒸。我們對清單 14 進行優(yōu)化:

清單 18. 優(yōu)化:排序前進行 limit 和 skip

List<Person> persons = new ArrayList();
 for (int i = 1; i <= 5; i++) {
 Person person = new Person(i, "name" + i);
 persons.add(person);
 }
List<Person> personList2 = persons.stream().limit(2).sorted((p1, p2) -> p1.getName().compareTo(p2.getName())).collect(Collectors.toList());
System.out.println(personList2);

結(jié)果會簡單很多:

name2
name1
[stream.StreamDW$Person@6ce253f1, stream.StreamDW$Person@53d8d10a]

當然,這種優(yōu)化是有 business logic 上的局限性的:即不要求排序后再取值细办。

min/max/distinct

min 和 max 的功能也可以通過對 Stream 元素先排序橙凳,再 findFirst 來實現(xiàn),但前者的性能會更好,為 O(n)岛啸,而 sorted 的成本是 O(n log n)钓觉。同時它們作為特殊的 reduce 方法被獨立出來也是因為求最大最小值是很常見的操作。

清單 19. 找出最長一行的長度

BufferedReader br = new BufferedReader(new FileReader("c:\\SUService.log"));
int longest = br.lines().
 mapToInt(String::length).
 max().
 getAsInt();
br.close();
System.out.println(longest);

下面的例子則使用 distinct 來找出不重復(fù)的單詞坚踩。

清單 20. 找出全文的單詞荡灾,轉(zhuǎn)小寫,并排序

List<String> words = br.lines().
 flatMap(line -> Stream.of(line.split(" "))).
 filter(word -> word.length() > 0).
 map(String::toLowerCase).
 distinct().
 sorted().
 collect(Collectors.toList());
br.close();
System.out.println(words);

Match

Stream 有三個 match 方法瞬铸,從語義上說:

  • allMatch:Stream 中全部元素符合傳入的 predicate批幌,返回 true
  • anyMatch:Stream 中只要有一個元素符合傳入的 predicate,返回 true
  • noneMatch:Stream 中沒有一個元素符合傳入的 predicate赴捞,返回 true

它們都不是要遍歷全部元素才能返回結(jié)果逼裆。例如 allMatch 只要一個元素不滿足條件,就 skip 剩下的所有元素赦政,返回 false胜宇。對清單 13 中的 Person 類稍做修改,加入一個 age 屬性和 getAge 方法恢着。

清單 21. 使用 Match

List<Person> persons = new ArrayList();
persons.add(new Person(1, "name" + 1, 10));
persons.add(new Person(2, "name" + 2, 21));
persons.add(new Person(3, "name" + 3, 34));
persons.add(new Person(4, "name" + 4, 6));
persons.add(new Person(5, "name" + 5, 55));
boolean isAllAdult = persons.stream().
 allMatch(p -> p.getAge() > 18);
System.out.println("All are adult? " + isAllAdult);
boolean isThereAnyChild = persons.stream().
 anyMatch(p -> p.getAge() < 12);
System.out.println("Any child? " + isThereAnyChild);

輸出結(jié)果:

All are adult? false
Any child? true

進階:自己生成流

Stream.generate

通過實現(xiàn) Supplier 接口桐愉,你可以自己來控制流的生成。這種情形通常用于隨機數(shù)掰派、常量的 Stream从诲,或者需要前后元素間維持著某種狀態(tài)信息的 Stream。把 Supplier 實例傳遞給 Stream.generate() 生成的 Stream靡羡,默認是串行(相對 parallel 而言)但無序的(相對 ordered 而言)系洛。由于它是無限的,在管道中略步,必須利用 limit 之類的操作限制 Stream 大小描扯。

清單 22. 生成 10 個隨機整數(shù)

Random seed = new Random();
Supplier<Integer> random = seed::nextInt;
Stream.generate(random).limit(10).forEach(System.out::println);
//Another way
IntStream.generate(() -> (int) (System.nanoTime() % 100)).
limit(10).forEach(System.out::println);

Stream.generate() 還接受自己實現(xiàn)的 Supplier。例如在構(gòu)造海量測試數(shù)據(jù)的時候趟薄,用某種自動的規(guī)則給每一個變量賦值绽诚;或者依據(jù)公式計算 Stream 的每個元素值。這些都是維持狀態(tài)信息的情形杭煎。

清單 23. 自實現(xiàn) Supplier

Stream.generate(new PersonSupplier()).
limit(10).
forEach(p -> System.out.println(p.getName() + ", " + p.getAge()));
private class PersonSupplier implements Supplier<Person> {
 private int index = 0;
 private Random random = new Random();
 @Override
 public Person get() {
 return new Person(index++, "StormTestUser" + index, random.nextInt(100));
 }
}

輸出結(jié)果:

StormTestUser1, 9
StormTestUser2, 12
StormTestUser3, 88
StormTestUser4, 51
StormTestUser5, 22
StormTestUser6, 28
StormTestUser7, 81
StormTestUser8, 51
StormTestUser9, 4
StormTestUser10, 76

Stream.iterate

iterate 跟 reduce 操作很像恩够,接受一個種子值,和一個 UnaryOperator(例如 f)羡铲。然后種子值成為 Stream 的第一個元素蜂桶,f(seed) 為第二個,f(f(seed)) 第三個也切,以此類推屎飘。

清單 24. 生成一個等差數(shù)列

Stream.iterate(0, n -> n + 3).limit(10). forEach(x -> System.out.print(x + " "));

輸出結(jié)果:

0 3 6 9 12 15 18 21 24 27

與 Stream.generate 相仿妥曲,在 iterate 時候管道必須有 limit 這樣的操作來限制 Stream 大小脐湾。

進階:用 Collectors 來進行 reduction 操作

java.util.stream.Collectors 類的主要作用就是輔助進行各類有用的 reduction 操作墙贱,例如轉(zhuǎn)變輸出為 Collection戴陡,把 Stream 元素進行歸組。

groupingBy/partitioningBy

清單 25. 按照年齡歸組

Map<Integer, List<Person>> personGroups = Stream.generate(new PersonSupplier()).
 limit(100).
 collect(Collectors.groupingBy(Person::getAge));
Iterator it = personGroups.entrySet().iterator();
while (it.hasNext()) {
 Map.Entry<Integer, List<Person>> persons = (Map.Entry) it.next();
 System.out.println("Age " + persons.getKey() + " = " + persons.getValue().size());
}

上面的 code押桃,首先生成 100 人的信息,然后按照年齡歸組导犹,相同年齡的人放到同一個 list 中唱凯,可以看到如下的輸出:

Age 0 = 2
Age 1 = 2
Age 5 = 2
Age 8 = 1
Age 9 = 1
Age 11 = 2
……

清單 26. 按照未成年人和成年人歸組

Map<Boolean, List<Person>> children = Stream.generate(new PersonSupplier()).
 limit(100).
 collect(Collectors.partitioningBy(p -> p.getAge() < 18));
System.out.println("Children number: " + children.get(true).size());
System.out.println("Adult number: " + children.get(false).size());

輸出結(jié)果:

Children number: 23 
Adult number: 77

在使用條件“年齡小于 18”進行分組后可以看到,不到 18 歲的未成年人是一組谎痢,成年人是另外一組磕昼。partitioningBy 其實是一種特殊的 groupingBy,它依照條件測試的是否兩種結(jié)果來構(gòu)造返回的數(shù)據(jù)結(jié)構(gòu)节猿,get(true) 和 get(false) 能即為全部的元素對象票从。

結(jié)束語

總之,Stream 的特性可以歸納為:

  • 不是數(shù)據(jù)結(jié)構(gòu)
  • 它沒有內(nèi)部存儲滨嘱,它只是用操作管道從 source(數(shù)據(jù)結(jié)構(gòu)峰鄙、數(shù)組、generator function太雨、IO channel)抓取數(shù)據(jù)吟榴。
  • 它也絕不修改自己所封裝的底層數(shù)據(jù)結(jié)構(gòu)的數(shù)據(jù)。例如 Stream 的 filter 操作會產(chǎn)生一個不包含被過濾元素的新 Stream囊扳,而不是從 source 刪除那些元素吩翻。
  • 所有 Stream 的操作必須以 lambda 表達式為參數(shù)
  • 不支持索引訪問
  • 你可以請求第一個元素,但無法請求第二個锥咸,第三個狭瞎,或最后一個。不過請參閱下一項她君。
  • 很容易生成數(shù)組或者 List
  • 惰性化
  • 很多 Stream 操作是向后延遲的脚作,一直到它弄清楚了最后需要多少數(shù)據(jù)才會開始。
  • Intermediate 操作永遠是惰性化的缔刹。
  • 并行能力
  • 當一個 Stream 是并行化的球涛,就不需要再寫多線程代碼,所有對它的操作會自動并行進行的校镐。
  • 可以是無限的
    • 集合有固定大小亿扁,Stream 則不必。limit(n) 和 findFirst() 這類的 short-circuiting 操作可以對無限的 Stream 進行運算并很快完成鸟廓。

相關(guān)主題

?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
  • 序言:七十年代末仿吞,一起剝皮案震驚了整個濱河市,隨后出現(xiàn)的幾起案子捡偏,更是在濱河造成了極大的恐慌唤冈,老刑警劉巖,帶你破解...
    沈念sama閱讀 216,651評論 6 501
  • 序言:濱河連續(xù)發(fā)生了三起死亡事件银伟,死亡現(xiàn)場離奇詭異你虹,居然都是意外死亡,警方通過查閱死者的電腦和手機枣申,發(fā)現(xiàn)死者居然都...
    沈念sama閱讀 92,468評論 3 392
  • 文/潘曉璐 我一進店門售葡,熙熙樓的掌柜王于貴愁眉苦臉地迎上來,“玉大人忠藤,你說我怎么就攤上這事挟伙。” “怎么了模孩?”我有些...
    開封第一講書人閱讀 162,931評論 0 353
  • 文/不壞的土叔 我叫張陵尖阔,是天一觀的道長。 經(jīng)常有香客問我榨咐,道長介却,這世上最難降的妖魔是什么? 我笑而不...
    開封第一講書人閱讀 58,218評論 1 292
  • 正文 為了忘掉前任块茁,我火速辦了婚禮齿坷,結(jié)果婚禮上,老公的妹妹穿的比我還像新娘数焊。我一直安慰自己永淌,他們只是感情好,可當我...
    茶點故事閱讀 67,234評論 6 388
  • 文/花漫 我一把揭開白布佩耳。 她就那樣靜靜地躺著遂蛀,像睡著了一般。 火紅的嫁衣襯著肌膚如雪干厚。 梳的紋絲不亂的頭發(fā)上李滴,一...
    開封第一講書人閱讀 51,198評論 1 299
  • 那天螃宙,我揣著相機與錄音,去河邊找鬼所坯。 笑死谆扎,一個胖子當著我的面吹牛,可吹牛的內(nèi)容都是我干的芹助。 我是一名探鬼主播燕酷,決...
    沈念sama閱讀 40,084評論 3 418
  • 文/蒼蘭香墨 我猛地睜開眼,長吁一口氣:“原來是場噩夢啊……” “哼周瞎!你這毒婦竟也來了?” 一聲冷哼從身側(cè)響起饵蒂,我...
    開封第一講書人閱讀 38,926評論 0 274
  • 序言:老撾萬榮一對情侶失蹤声诸,失蹤者是張志新(化名)和其女友劉穎,沒想到半個月后退盯,有當?shù)厝嗽跇淞掷锇l(fā)現(xiàn)了一具尸體彼乌,經(jīng)...
    沈念sama閱讀 45,341評論 1 311
  • 正文 獨居荒郊野嶺守林人離奇死亡,尸身上長有42處帶血的膿包…… 初始之章·張勛 以下內(nèi)容為張勛視角 年9月15日...
    茶點故事閱讀 37,563評論 2 333
  • 正文 我和宋清朗相戀三年渊迁,在試婚紗的時候發(fā)現(xiàn)自己被綠了慰照。 大學(xué)時的朋友給我發(fā)了我未婚夫和他白月光在一起吃飯的照片。...
    茶點故事閱讀 39,731評論 1 348
  • 序言:一個原本活蹦亂跳的男人離奇死亡琉朽,死狀恐怖毒租,靈堂內(nèi)的尸體忽然破棺而出,到底是詐尸還是另有隱情箱叁,我是刑警寧澤墅垮,帶...
    沈念sama閱讀 35,430評論 5 343
  • 正文 年R本政府宣布,位于F島的核電站耕漱,受9級特大地震影響算色,放射性物質(zhì)發(fā)生泄漏。R本人自食惡果不足惜螟够,卻給世界環(huán)境...
    茶點故事閱讀 41,036評論 3 326
  • 文/蒙蒙 一灾梦、第九天 我趴在偏房一處隱蔽的房頂上張望。 院中可真熱鬧妓笙,春花似錦若河、人聲如沸。這莊子的主人今日做“春日...
    開封第一講書人閱讀 31,676評論 0 22
  • 文/蒼蘭香墨 我抬頭看了看天上的太陽。三九已至淆九,卻和暖如春统锤,著一層夾襖步出監(jiān)牢的瞬間毛俏,已是汗流浹背。 一陣腳步聲響...
    開封第一講書人閱讀 32,829評論 1 269
  • 我被黑心中介騙來泰國打工饲窿, 沒想到剛下飛機就差點兒被人妖公主榨干…… 1. 我叫王不留煌寇,地道東北人。 一個月前我還...
    沈念sama閱讀 47,743評論 2 368
  • 正文 我出身青樓逾雄,卻偏偏與公主長得像阀溶,于是被迫代替她去往敵國和親。 傳聞我的和親對象是個殘疾皇子鸦泳,可洞房花燭夜當晚...
    茶點故事閱讀 44,629評論 2 354

推薦閱讀更多精彩內(nèi)容