譯：GentlemanTsao，2020-7-7

文章目錄

• • Java Steam 定義
  • Steam 處理
  • 獲取Steam
  • 終結(jié)操作和中間操作
  • 中間操作
  • • filter()
    • map()
    • flatMap()
    • distinct()
    • limit()
    • peek()
  • 終結(jié)操作
  • • anyMatch()
    • allMatch()
    • noneMatch()
    • collect()
    • count()
    • findAny()
    • findFirst()
    • forEach()
    • min()
    • max()
    • reduce()
    • toArray()
    • 串聯(lián)steam
  • 從數(shù)組創(chuàng)建Steam
  • 評判Java Stream API
  • • Steam是批處理，不是流式處理
    • Steam是鏈狀，而非圖狀
    • Steam是內(nèi)部迭代，而非外部迭代
  • 翻譯花絮：

Java Stream API提供了一種處理對象集合的函數(shù)式方法。 Java Stream API是在Java 8中添加的，同時還具有其他一些函數(shù)式編程功能。 本Java Stream教程將解釋這些函數(shù)式流的工作方式以及使用方法。

Java Stream API與Java IO的Java InputStream和Java OutputStream無關(guān)。 InputStream和OutputStream與字節(jié)流有關(guān)。 Java Stream API用于處理對象流，而不是字節(jié)流。

Java Steam 定義

Java Stream是一個能夠?qū)ζ湓剡M行內(nèi)部迭代的組件，這意味著它可以對元素本身進行迭代。 相反，當(dāng)您使用Java Collections迭代功能（例如，Java Iterator或使用Java Iterable的for-each循環(huán)）時，你必須自己實現(xiàn)元素的迭代。

Steam 處理

您可以將listener附加到Steam。 當(dāng)Stream在內(nèi)部迭代元素時，將調(diào)用這些listener。 Steam中的每個元素都將調(diào)用一次listener。 這樣，每個listener都可以處理Steam中的每個元素。 這稱為流式處理（stream processing）。

Steam的listener形成一條鏈。 鏈中的第一個listener可以處理流中的元素，然后為鏈中的下一個listener返回一個新元素以進行處理。 listener可以返回相同的元素，也可以返回新的元素，具體取決于該listener（處理器）的用途。

獲取Steam

有很多方法來獲取Java Steam，最常見方法是從Java集合獲取。 如下是從Java List獲取Steam的示例：

List<String> items = new ArrayList<String>();items.add("one"); items.add("two"); items.add("three");Stream<String> stream = items.stream();

本示例首先創(chuàng)建一個Java列表，然后向其中添加三個字符串。 最后，調(diào)用stream（）方法以獲得Stream實例。

終結(jié)操作和中間操作

Stream接口可以選擇終結(jié)和中間操作。 中間操作將listener添加到Stream而無需執(zhí)行其他任何操作。 終結(jié)流操作啟動元素的內(nèi)部迭代，調(diào)用所有Stream并返回結(jié)果。

如下是一個Java Stream示例，其中包含一個中間操作和一個終結(jié)操作：

import java.util.ArrayList; import java.util.List; import java.util.stream.Stream;public class StreamExamples {public static void main(String[] args) {List<String> stringList = new ArrayList<String>();stringList.add("ONE");stringList.add("TWO");stringList.add("THREE");Stream<String> stream = stringList.stream();long count = stream.map((value) -> { return value.toLowerCase(); }).count();System.out.println("count = " + count);} }

Stream接口的map（）方法是中間操作。 它僅在Stream上設(shè)置一個lambda表達式，將每個元素轉(zhuǎn)換為小寫。 map（）方法將在后面詳細(xì)介紹。

count（）方法是終結(jié)操作。 此調(diào)用在內(nèi)部啟動迭代，將每個元素轉(zhuǎn)換為小寫字母然后進行計數(shù)。

元素轉(zhuǎn)換到小寫實際上并不影響元素的數(shù)量。 轉(zhuǎn)換部分只是作為中間操作的示例。

中間操作

Java Stream API的中間流操作是對流中的元素進行轉(zhuǎn)換或過濾的操作。 當(dāng)向流添加中間操作時，將得到一個新的流。 新流是應(yīng)用了中間操作的原始流產(chǎn)生的元素流。 如下是添加到流中的中間操作的示例，這會產(chǎn)生新的流：

List<String> stringList = new ArrayList<String>();stringList.add("ONE"); stringList.add("TWO"); stringList.add("THREE");Stream<String> stream = stringList.stream();Stream<String> stringStream =stream.map((value) -> { return value.toLowerCase(); });

注意對Steam map（）的調(diào)用。 該調(diào)用實際上返回一個新的Stream實例，該實例是已應(yīng)用map操作的原始字符串流。

你只能將單個操作添加到給定的Stream實例。 如果需要將多個操作彼此鏈接在一起，則需要將第二個操作應(yīng)用于第一個操作產(chǎn)生的Stream實例。 如下所示：

Stream<String> stringStream1 =stream.map((value) -> { return value.toLowerCase(); });Stream<?String> stringStream2 =stringStream1.map((value) -> { return value.toUpperCase(); });

請注意，第二個Stream map（）調(diào)用是在第一個map（）調(diào)用返回的Stream上。

在Java Stream上鏈?zhǔn)秸{(diào)用中間操作是很常見的。 如下是在Java流上鏈?zhǔn)秸{(diào)用中間操作的示例：

Stream<String> stream1 = stream.map((value) -> { return value.toLowerCase(); }).map((value) -> { return value.toUpperCase(); }).map((value) -> { return value.substring(0,3); });

許多中間Stream操作可以將Java Lambda表達式作為參數(shù)。 該lambda表達式實現(xiàn)了適合給定中間操作的Java函數(shù)式接口。 例如，Function或Predicate接口。 中間操作方法參數(shù)的參數(shù)通常是函數(shù)式接口，這就是為什么它也可以由Java lambda表達式實現(xiàn)的原因。

filter()

Java Stream filter（）可用于過濾Java Stream中的元素。 filter方法輸入一個Predicate，該Predicate被Stream中的每個元素調(diào)用。 如果元素要包含在結(jié)果流中，則Predicate應(yīng)返回true。 如果不應(yīng)包含該元素，則Predicate應(yīng)返回false。

如下是調(diào)用Java Stream filter（）方法的示例：

Stream<String> longStringsStream = stream.filter((value) -> {return value.length() >= 3; });

map()

Java Stream map（）方法將一個元素轉(zhuǎn)換（映射）到另一個對象。 例如，如果你有一個字符串列表，則可以將每個字符串轉(zhuǎn)換為小寫，大寫或原始字符串的子字符串，或者完全轉(zhuǎn)換成其他字符串。如下是一個Java Stream map（）示例：

List<String> list = new ArrayList<String>(); Stream<String> stream = list.stream();Stream<String> streamMapped = stream.map((value) -> value.toUpperCase());

flatMap()

Java Stream flatMap（）方法將單個元素映射到多個元素。 該理念是將每個元素從由多個內(nèi)部元素組成的復(fù)雜結(jié)構(gòu)“展平”到僅由這些內(nèi)部元素組成的“展平”流。

例如，假設(shè)您有一個帶有嵌套對象（子對象）的對象。 那么你可以將該對象映射到一個“平面”流，該流由自身加上其嵌套對象（或僅嵌套對象）組成。 你還可以將元素列表流映射到元素本身。 或?qū)⒆址饔成涞竭@些字符串中的單詞流，或映射到這些字符串中的各個Character實例。

如下是將字符串列表平面映射到每個字符串中的單詞的示例。 這個例子展示了flatMap（）如何將一個元素映射成多個元素。

List<String> stringList = new ArrayList<String>();stringList.add("One flew over the cuckoo's nest"); stringList.add("To kill a muckingbird"); stringList.add("Gone with the wind");Stream<String> stream = stringList.stream();stream.flatMap((value) -> {String[] split = value.split(" ");return (Stream<String>) Arrays.asList(split).stream(); }) .forEach((value) -> System.out.println(value)) ;

此Java Stream flatMap（）示例首先創(chuàng)建一個List，包含3個書名的字符串。 然后獲取List的Stream，并調(diào)用flatMap（）。

在Stream上調(diào)用的flatMap（）操作必須返回另一個平坦映射元素的Stream。 在上面的示例中，每個原始字符串都被分解為多個單詞，并變成一個列表，然后從該列表中獲取并返回Steam。

請注意，此示例調(diào)用終結(jié)操作forEach（）作為結(jié)束。 該調(diào)用僅在此處觸發(fā)內(nèi)部迭代，從而觸發(fā)平面映射操作。 如果在Stream鏈上未調(diào)用任何終結(jié)操作，則不會發(fā)生任何事情。 實際上不會進行平面映射。

distinct()

Java Stream distinct（）方法是一種中間操作，它返回一個新的Stream，僅包含與原始流不同的元素。 任何重復(fù)將被消除。 如下是Java Stream distinct（）方法的示例：

List<String> stringList = new ArrayList<String>();stringList.add("one"); stringList.add("two"); stringList.add("three"); stringList.add("one");Stream<String> stream = stringList.stream();List<String> distinctStrings = stream.distinct().collect(Collectors.toList());System.out.println(distinctStrings);

在此示例中，元素“one”在原始流中出現(xiàn)2次。由distinct（）返回的Stream中僅包括第一次出現(xiàn)的元素。 因此，結(jié)果列表（通過調(diào)用collect（））將僅包含one，two和three。 此示例打印的輸出是：

[one, two, three]

limit()

Java Stream limit（）方法可以將流中的元素數(shù)量限制為指定給limit（）方法的數(shù)量。 limit（）方法返回一個新的Stream，該Stream最多包含給定數(shù)量的元素。 如下是一個Java Stream limit（）示例：

List<String> stringList = new ArrayList<String>();stringList.add("one"); stringList.add("two"); stringList.add("three"); stringList.add("one");Stream<String> stream = stringList.stream(); stream.limit(2).forEach( element -> { System.out.println(element); });

本示例首先創(chuàng)建一個Stream，然后在其上調(diào)用limit（），然后使用帶有l(wèi)ambda的forEach（）來打印出該流中的元素。 由于調(diào)用了limit（2），僅將打印前兩個元素。

peek()

Java Stream peek（）方法是一種中間操作，它以Consumer（java.util.function.Consumer）作為參數(shù)，將為流中的每個元素調(diào)用Consumer。 peek（）方法返回一個新的Stream，其中包含原始流中的所有元素。

顧名思義，peek（）方法的目的是窺視Steam中的元素，而不是對其進行轉(zhuǎn)換。 請記住，peek方法不會啟動Steam中元素的內(nèi)部迭代。 你還需要調(diào)用終結(jié)操作。 如下是一個Java Stream peek（）示例：

List<String> stringList = new ArrayList<String>();stringList.add("abc"); stringList.add("def");Stream<String> stream = stringList.stream();Stream<String> streamPeeked = stream.peek((value) -> {System.out.println("value"); });

終結(jié)操作

Java Stream接口的終結(jié)操作通常返回單個值。 一旦在Stream上調(diào)用了終結(jié)操作，就將啟動Stream的迭代以及鏈接流。 迭代完成后，將返回終結(jié)操作的結(jié)果。

終結(jié)操作通常不返回新的Stream實例。 因此，一旦在Stream上調(diào)用了終結(jié)操作，來自中間操作的Stream實例鏈就結(jié)束了。 這是在Java Stream上調(diào)用終結(jié)操作的示例：

long count = stream.map((value) -> { return value.toLowerCase(); }).map((value) -> { return value.toUpperCase(); }).map((value) -> { return value.substring(0,3); }).count();

該示例末尾的count（）調(diào)用是終結(jié)操作。 由于count（）返回long，因此中間操作的Stream鏈（map（）調(diào)用）結(jié)束了。

anyMatch()

Java Stream anyMatch（）方法是一個終結(jié)操作，它以單個Predicate作為參數(shù)，啟動Stream的內(nèi)部迭代，并將Predicate參數(shù)應(yīng)用于每個元素。 如果Predicate對任何元素返回true，則anyMatch（）方法返回true。 如果沒有元素與Predicate匹配，則anyMatch（）將返回false。 如下是一個Java Stream anyMatch（）示例：

List<String> stringList = new ArrayList<String>();stringList.add("One flew over the cuckoo's nest"); stringList.add("To kill a muckingbird"); stringList.add("Gone with the wind");Stream<String> stream = stringList.stream();boolean anyMatch = stream.anyMatch((value) -> { return value.startsWith("One"); }); System.out.println(anyMatch);

在上面的示例中，anyMatch（）方法將返回true，因為stream中的第一個字符串元素以“ One”開頭。

allMatch()

Java Stream allMatch（）方法是一個終端操作，它以單個Predicate作為參數(shù)，啟動Stream中元素的內(nèi)部迭代，并將Predicate參數(shù)應(yīng)用于每個元素。 如果Predicate對于Stream中的所有元素都返回true，則allMatch（）將返回true。 如果不是所有元素都與謂詞匹配，則allMatch（）方法將返回false。 如下是一個Java Stream allMatch（）示例：

List<String> stringList = new ArrayList<String>();stringList.add("One flew over the cuckoo's nest"); stringList.add("To kill a muckingbird"); stringList.add("Gone with the wind");Stream<String> stream = stringList.stream();boolean allMatch = stream.allMatch((value) -> { return value.startsWith("One"); }); System.out.println(allMatch);

在上面的示例中，allMatch（）方法將返回false，因為Stream中只有一個字符串以“ One”開頭。

noneMatch()

Java Stream noneMatch（）方法是一個終結(jié)操作，它將對Stream中的元素進行迭代并返回true或false，這取決于Stream中是否有元素與參數(shù)Predicate相匹配。 如果Predicate不匹配任何元素，則noneMatch（）方法將返回true；如果匹配一個或多個元素，則方法將返回false。 如下是一個Java Stream noneMatch（）示例：

List<String> stringList = new ArrayList<String>();stringList.add("abc"); stringList.add("def");Stream<String> stream = stringList.stream();boolean noneMatch = stream.noneMatch((element) -> {return "xyz".equals(element); });System.out.println("noneMatch = " + noneMatch);

collect()

Java Stream collect（）方法是一個終結(jié)操作，它啟動元素的內(nèi)部迭代，并以集合或某種類型的對象收集流中的元素。 如下是一個簡單的Java Stream collect（）方法示例：

List<String> stringList = new ArrayList<String>();stringList.add("One flew over the cuckoo's nest"); stringList.add("To kill a muckingbird"); stringList.add("Gone with the wind");Stream<String> stream = stringList.stream();List<String> stringsAsUppercaseList = stream .map(value -> value.toUpperCase()) .collect(Collectors.toList());System.out.println(stringsAsUppercaseList);

collect（）方法采用Collectors（java.util.stream.Collector）作為參數(shù)。 實現(xiàn)Collectors需要對Collectors接口進行一些研究。 幸運的是，Java類java.util.stream.Collectors包含一組預(yù)先實現(xiàn)的Collectors，可以用于大多數(shù)常見操作的。 在上面的示例中，使用的是Collectors.toList（）返回的Collector實現(xiàn)。 該Collectors只是將stream中的所有元素收集到標(biāo)準(zhǔn)Java List中。

count()

Java Stream count（）方法是一個終結(jié)操作，用于啟動Stream中元素的內(nèi)部迭代并計算元素數(shù)量。如下是一個Java Stream count（）示例：

List<String> stringList = new ArrayList<String>();stringList.add("One flew over the cuckoo's nest"); stringList.add("To kill a muckingbird"); stringList.add("Gone with the wind");Stream<String> stream = stringList.stream();long count = stream.flatMap((value) -> {String[] split = value.split(" ");return (Stream<String>) Arrays.asList(split).stream(); }) .count();System.out.println("count = " + count);

此示例首先創(chuàng)建一個字符串列表，然后獲取該列表的Stream，為其添加一個flatMap（）操作，然后完成對count（）的調(diào)用。 count（）方法將啟動Stream中元素的迭代，在flatMap（）操作中將字符串元素拆分為單詞，然后進行計數(shù)。 最終打印出來的結(jié)果是14。

findAny()

Java Stream findAny（）方法可以從Stream中查找單個元素。 找到的元素可以來自Stream中的任何位置， 所以無法保證從流中何處獲取元素。 如下是一個Java Stream findAny（）示例：

List<String> stringList = new ArrayList<String>();stringList.add("one"); stringList.add("two"); stringList.add("three"); stringList.add("one");Stream<String> stream = stringList.stream();Optional<String> anyElement = stream.findAny();System.out.println(anyElement.get());

注意findAny（）方法返回Optional。 Stream可能為空，因此無法返回任何元素。可以使用Optional isPresent()方法檢查是否找到了元素。

findFirst()

如果Stream中存在元素，則Java Stream findFirst（）方法將找到Stream中的第一個元素。 findFirst（）方法返回一個Optional，可以從中獲取元素（如果存在）。 如下是一個Java Stream findFirst（）示例：

List<String> stringList = new ArrayList<String>();stringList.add("one"); stringList.add("two"); stringList.add("three"); stringList.add("one");Stream<String> stream = stringList.stream();Optional<String> result = stream.findFirst();System.out.println(result.get());

可以通過isPresent（）方法檢查Optional返回是否包含元素。

forEach()

Java Stream forEach（）方法是一個終結(jié)操作，它啟動Stream中元素的內(nèi)部迭代，并將Consumer（java.util.function.Consumer）應(yīng)用于Stream中的每個元素。 forEach（）方法返回void。 如下是一個Java Stream forEach（）示例：

List<String> stringList = new ArrayList<String>();stringList.add("one"); stringList.add("two"); stringList.add("three"); stringList.add("one");Stream<String> stream = stringList.stream();stream.forEach( element -> { System.out.println(element); });

min()

Java Stream min（）方法是一個終結(jié)操作，它返回Stream中的最小元素。 哪個元素最小是由傳遞給min（）方法的Comparator實現(xiàn)確定的。 如下是一個Java Stream min（）示例：

List<String> stringList = new ArrayList<String>();stringList.add("abc"); stringList.add("def");Stream<String> stream = stringList.stream();Optional<String> min = stream.min((val1, val2) -> {return val1.compareTo(val2); });String minString = min.get();System.out.println(minString);

注意min（）方法返回一個Optional，它可能包含也可能不包含結(jié)果。 如果Stream為空，則Optional get（）方法將拋出NoSuchElementException。

max()

Java Stream max（）方法是一個終結(jié)操作，它返回Stream中最大的元素。 哪個元素最大，取決于傳遞給max（）方法的Comparator實現(xiàn)。 如下是一個Java Stream max（）示例：

List<String> stringList = new ArrayList<String>();stringList.add("abc"); stringList.add("def");Stream<String> stream = stringList.stream();Optional<String> max = stream.max((val1, val2) -> {return val1.compareTo(val2); });String maxString = max.get();System.out.println(maxString);

注意max（）方法返回一個Optional，它可以包含也可以不包含結(jié)果。 如果Stream為空，則Optional get（）方法將拋出NoSuchElementException。

reduce()

Java Stream reduce（）方法是一個終結(jié)操作，可以將Stream中的所有元素縮減為單個元素。 如下是一個Java Stream reduce（）示例：

List<String> stringList = new ArrayList<String>();stringList.add("One flew over the cuckoo's nest"); stringList.add("To kill a muckingbird"); stringList.add("Gone with the wind");Stream<String> stream = stringList.stream();Optional<String> reduced = stream.reduce((value, combinedValue) -> {return combinedValue + " + " + value; });System.out.println(reduced.get());

請注意reduce（）方法返回的Optional。 此Optional包含傳遞給reduce（）方法的lambda表達式返回的值（如果有）。 可以通過調(diào)用Optional get（）方法獲得該值。

toArray()

Java Stream toArray（）方法是一個終結(jié)操作，它啟動Stream中元素的內(nèi)部迭代，并返回包含所有元素的Object數(shù)組。 如下是一個Java Stream toArray（）示例：

List<String> stringList = new ArrayList<String>();stringList.add("One flew over the cuckoo's nest"); stringList.add("To kill a muckingbird"); stringList.add("Gone with the wind");Stream<String> stream = stringList.stream();Object[] objects = stream.toArray();

串聯(lián)steam

Java Stream接口包含一個稱為concat（）的靜態(tài)方法，該方法可以將兩個Stream連接為一個。從而新的Stream包含第一個Stream中的所有元素和第二個Stream中的所有元素。 如下是使用Java Stream concat（）方法的示例：

List<String> stringList = new ArrayList<String>();stringList.add("One flew over the cuckoo's nest"); stringList.add("To kill a muckingbird"); stringList.add("Gone with the wind");Stream<String> stream1 = stringList.stream();List<String> stringList2 = new ArrayList<>(); stringList2.add("Lord of the Rings"); stringList2.add("Planet of the Rats"); stringList2.add("Phantom Menace");Stream<String> stream2 = stringList2.stream();Stream<String> concatStream = Stream.concat(stream1, stream2);List<String> stringsAsUppercaseList = concatStream.collect(Collectors.toList());System.out.println(stringsAsUppercaseList);

從數(shù)組創(chuàng)建Steam

Java Stream接口包含一個稱為of（）的靜態(tài)方法，該方法可用于從一個或多個對象創(chuàng)建Stream。 如下是使用Java Stream of（）方法的示例：

Stream<String> streamOf = Stream.of("one", "two", "three");

評判Java Stream API

在使用過其他數(shù)據(jù)流API（例如Apache Kafka Streams API）之后，我想分享下對Java Stream API的評判。 這些不是嚴(yán)重的評判，但是當(dāng)你嘗試進行流處理時，有助于多一分警惕。

Steam是批處理，不是流式處理

盡管名為Steam，Java Stream API并不是真正的流處理API。 Java Stream API的終結(jié)操作返回該流中所有元素迭代的最終結(jié)果，并為這些元素提供中間和終結(jié)操作。 在處理完流中的最后一個元素之后，將返回終結(jié)操作的結(jié)果。

只有知道流中的最后一個元素是什么，才有可能在處理完流的最后一個元素之后返回最終結(jié)果。 知道給定元素是否是流中的最后一個元素的唯一方法是，你處理的是具有最后一個元素的批處理。 相反，真正的流沒有最后一個元素。 你永遠(yuǎn)不知道給定的元素是否是最后一個。 因此，不可能對流執(zhí)行終結(jié)操作。 最好的辦法是在處理給定元素之后收集臨時結(jié)果，但這屬于采樣，而不是最終結(jié)果。

Steam是鏈狀，而非圖狀

Java Stream API的設(shè)計使Stream實例只能作用一次。 換句話說，只能將單個中間操作添加到Stream中，從而產(chǎn)生一個新的Stream對象。 你可以將另一個中間操作添加到生成的Stream對象，但不能添加到第一個Stream對象。 于是中間Stream實例的結(jié)構(gòu)形成一條鏈。

在真正的流處理API中，根流（root stream）和事件偵聽器（event listeners）通常可以形成圖，而不僅僅是鏈。 多個偵聽器可以偵聽根流，并且每個偵聽器都可以以自己的方式處理流中的元素，并因此可以回傳轉(zhuǎn)換后的元素作為結(jié)果。 因此，每個偵聽器（中間操作）通常可以作為流本身供其他偵聽器偵聽其結(jié)果。 這就是Apache Kafka Streams的設(shè)計方式。 每個偵聽器（中間流）也可以有多個偵聽器。 最終的結(jié)構(gòu)形成了一個帶有監(jiān)聽器的監(jiān)聽器的監(jiān)聽器等的圖。

相對于鏈，流處理圖中沒有單個最終操作。 最終操作是指可以保證是處理鏈中的最后一個操作。 相反，流處理圖可以有多個最終操作。 圖中的每個“葉子”都是最終操作。

當(dāng)流處理結(jié)構(gòu)可以是具有多個最終操作的圖形時，流式API不能像Java Stream API那樣輕松地支持終結(jié)操作。 為了輕松支持終結(jié)操作，必須有一個最終操作，從中返回最終結(jié)果。 基于圖的流處理API可以支持“采樣”操作，在該操作中，要求流處理圖中的每個節(jié)點詢問其內(nèi)部保留的任何值（例如總和，如果有的話——純轉(zhuǎn)換偵聽器節(jié)點不具有任何內(nèi)部狀態(tài)） 。

Steam是內(nèi)部迭代，而非外部迭代

Java Stream API專門設(shè)計為具有Stream中元素的內(nèi)部迭代。 在Stream上調(diào)用終結(jié)操作時，將開始迭代。 實際上，為了使終結(jié)操作能夠返回結(jié)果，終結(jié)操作必須啟動Stream中元素的迭代。

一些基于圖的流處理API也同樣設(shè)計為某種程度上向API用戶隱藏元素的迭代（例如Apache Kafka Streams和RxJava）。 但是，個人而言，我更喜歡這樣一種設(shè)計：每個流節(jié)點（根流和偵聽器）可以通過方法將元素傳遞給它們，進而將該元素在整個圖中傳遞并進行處理。 這樣的設(shè)計將使測試圖形中的每個偵聽器變得更加容易，因為你可以配置圖并在其后推送元素，最后檢查結(jié)果（圖的采樣狀態(tài)）。 這種設(shè)計還可以使流處理圖可以通過圖中的多個節(jié)點（而不僅僅是通過根流）推入元素到其中。

翻譯花絮：

原文：
They aren’t big, important points of critique, but they are useful to have in the back of your head as you venture into stream processing.

譯文：
這些不是嚴(yán)重的批判，但是當(dāng)你嘗試進行流式處理時，有助于讓你多一分警惕。

總結(jié)

以上是生活随笔為你收集整理的Java函数式编程教程（五）：Java Steam API的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。