2019獨(dú)角獸企業(yè)重金招聘Python工程師標(biāo)準(zhǔn)>>>

Stream是 Java 8新增加的類，用來(lái)補(bǔ)充集合類。

Stream代表數(shù)據(jù)流，流中的數(shù)據(jù)元素的數(shù)量可能是有限的，也可能是無(wú)限的。

Stream和其它集合類的區(qū)別在于：其它集合類主要關(guān)注與有限數(shù)量的數(shù)據(jù)的訪問(wèn)和有效管理(增刪改)，而Stream并沒(méi)有提供訪問(wèn)和管理元素的方式，而是通過(guò)聲明數(shù)據(jù)源的方式，利用可計(jì)算的操作在數(shù)據(jù)源上執(zhí)行，當(dāng)然BaseStream.iterator() 和 BaseStream.spliterator()操作提供了遍歷元素的方法。

Java Stream提供了提供了串行和并行兩種類型的流，保持一致的接口，提供函數(shù)式編程方式，以管道方式提供中間操作和最終執(zhí)行操作，為Java語(yǔ)言的集合提供了現(xiàn)代語(yǔ)言提供的類似的高階函數(shù)操作，簡(jiǎn)化和提高了Java集合的功能。

本文首先介紹Java Stream的特點(diǎn)，然后按照功能分類逐個(gè)介紹流的中間操作和終點(diǎn)操作，最后會(huì)介紹第三方為Java Stream做的擴(kuò)展。

介紹

Stream接口還包含幾個(gè)基本類型的子接口如IntStream, LongStream 和 DoubleStream。

關(guān)于流和其它集合具體的區(qū)別，可以參照下面的列表：

不存儲(chǔ)數(shù)據(jù)。流是基于數(shù)據(jù)源的對(duì)象，它本身不存儲(chǔ)數(shù)據(jù)元素，而是通過(guò)管道將數(shù)據(jù)源的元素傳遞給操作。

函數(shù)式編程。流的操作不會(huì)修改數(shù)據(jù)源，例如filter不會(huì)將數(shù)據(jù)源中的數(shù)據(jù)刪除。

延遲操作。流的很多操作如filter,map等中間操作是延遲執(zhí)行的，只有到終點(diǎn)操作才會(huì)將操作順序執(zhí)行。

可以解綁。對(duì)于無(wú)限數(shù)量的流，有些操作是可以在有限的時(shí)間完成的，比如limit(n) 或 findFirst()，這些操作可是實(shí)現(xiàn)"短路"(Short-circuiting)，訪問(wèn)到有限的元素后就可以返回。

純消費(fèi)。流的元素只能訪問(wèn)一次，類似Iterator，操作沒(méi)有回頭路，如果你想從頭重新訪問(wèn)流的元素，對(duì)不起，你得重新生成一個(gè)新的流。

流的操作是以管道的方式串起來(lái)的。流管道包含一個(gè)數(shù)據(jù)源，接著包含零到N個(gè)中間操作，最后以一個(gè)終點(diǎn)操作結(jié)束。

并行 Parallelism

所有的流操作都可以串行執(zhí)行或者并行執(zhí)行。除非顯示地創(chuàng)建并行流，否則Java庫(kù)中創(chuàng)建的都是串行流。 Collection.stream()為集合創(chuàng)建串行流而Collection.parallelStream()為集合創(chuàng)建并行流。IntStream.range(int, int)創(chuàng)建的是串行流。通過(guò)parallel()方法可以將串行流轉(zhuǎn)換成并行流,sequential()方法將流轉(zhuǎn)換成串行流。

一般，除非方法的Javadoc中指明了方法在并行執(zhí)行的時(shí)候結(jié)果是不確定(比如findAny、forEach)，否則串行和并行執(zhí)行的結(jié)果應(yīng)該是一樣的。

Non-interference

流可以從非線程安全的集合中創(chuàng)建，當(dāng)流的管道執(zhí)行的時(shí)候，非concurrent數(shù)據(jù)源不應(yīng)該被改變。下面的代碼會(huì)拋出java.util.ConcurrentModificationException異常：

List<String> l = new ArrayList(Arrays.asList("one", "two")); Stream<String> sl = l.stream(); sl.forEach(s -> l.add("three"));

在設(shè)置中間操作的時(shí)候，可以更改數(shù)據(jù)源，只有在執(zhí)行終點(diǎn)操作的時(shí)候，才有可能出現(xiàn)并發(fā)問(wèn)題(拋出異常，或者不期望的結(jié)果)，比如下面的代碼不會(huì)拋出異常(并且結(jié)果中包含新加入的數(shù)據(jù))：

List<String> l = new ArrayList(Arrays.asList("one", "two")); Stream<String> sl = l.stream(); l.add("three"); sl.forEach(System.out::println);

此處的中間操作指的是在流操作開(kāi)始前的操作。 流對(duì)象對(duì)數(shù)據(jù)源的操作在一條語(yǔ)句中操作完成，完成后可轉(zhuǎn)為結(jié)果或者轉(zhuǎn)為其他流的數(shù)據(jù)源，但是該流對(duì)象再繼續(xù)操作（相當(dāng)于一個(gè)流對(duì)象開(kāi)始有數(shù)據(jù)源，后來(lái)數(shù)據(jù)流轉(zhuǎn)給別的流，自己沒(méi)有數(shù)據(jù)源，不能操作原數(shù)據(jù)源了）。

對(duì)于concurrent數(shù)據(jù)源，不會(huì)有這樣的問(wèn)題，比如下面的代碼很正常：

List<String> l = new CopyOnWriteArrayList<>(Arrays.asList("one", "two")); Stream<String> sl = l.stream(); sl.forEach(s -> l.add("three"));

雖然我們上面例子是在終點(diǎn)操作中對(duì)非并發(fā)數(shù)據(jù)源進(jìn)行修改，但是非并發(fā)數(shù)據(jù)源也可能在其它線程中修改，同樣會(huì)有并發(fā)問(wèn)題。

無(wú)狀態(tài) Stateless behaviors

大部分流的操作的參數(shù)都是函數(shù)式接口，可以使用Lambda表達(dá)式實(shí)現(xiàn)。它們用來(lái)描述用戶的行為，稱之為行為參數(shù)(behavioral parameters)。

如果這些行為參數(shù)有狀態(tài)，則流的操作的結(jié)果可能是不確定的，比如下面的代碼:

List<String> l = new ArrayList(Arrays.asList("one", "two", ……)); class State {boolean s; } final State state = new State(); Stream<String> sl = l.stream().map(e -> {if (state.s)return "OK";else {state.s = true;return e;} }); sl.forEach(System.out::println);

上面的代碼在并行執(zhí)行時(shí)多次的執(zhí)行結(jié)果可能是不同的。這是因?yàn)檫@個(gè)lambda表達(dá)式是有狀態(tài)的。

副作用 Side-effects

有副作用的行為參數(shù)是被鼓勵(lì)使用的。

副作用指的是行為參數(shù)在執(zhí)行的時(shí)候有輸入輸入，比如網(wǎng)絡(luò)輸入輸出等。

行為參數(shù)指的是stream的操作函數(shù)中的lambda參數(shù)，例如filter方法中的參數(shù)。

這是因?yàn)镴ava不保證這些副作用對(duì)其它線程可見(jiàn)，也不保證相同流管道上的同樣的元素的不同的操作運(yùn)行在同一個(gè)線程中。

很多有副作用的行為參數(shù)可以被轉(zhuǎn)換成無(wú)副作用的實(shí)現(xiàn)。一般來(lái)說(shuō)println()這樣的副作用代碼不會(huì)有害。

ArrayList<String> results = new ArrayList<>(); stream.filter(s -> pattern.matcher(s).matches()).forEach(s -> results.add(s)); // 副作用代碼

上面的代碼可以改成無(wú)副作用的。

List<String>results =stream.filter(s -> pattern.matcher(s).matches()).collect(Collectors.toList()); // No side-effects!

排序 Ordering

某些流的返回的元素是有確定順序的，我們稱之為 encounter order。這個(gè)順序是流提供它的元素的順序，比如數(shù)組的encounter order是它的元素的排序順序，List是它的迭代順序(iteration order)，對(duì)于HashSet,它本身就沒(méi)有encounter order。

一個(gè)流是否是encounter order主要依賴數(shù)據(jù)源和它的中間操作，比如數(shù)據(jù)源List和Array上創(chuàng)建的流是有序的(ordered)，但是在HashSet創(chuàng)建的流不是有序的。

sorted()方法可以將流轉(zhuǎn)換成有序的，unordered()可以將流轉(zhuǎn)換成無(wú)序的。 除此之外，一個(gè)操作可能會(huì)影響流的有序,比如map方法，它會(huì)用不同的值甚至類型替換流中的元素，所以輸入元素的有序性已經(jīng)變得沒(méi)有意義了，但是對(duì)于filter方法來(lái)說(shuō)，它只是丟棄掉一些值而已，輸入元素的有序性還是保障的。

對(duì)于串行流，流有序與否不會(huì)影響其性能，只是會(huì)影響確定性(determinism)，無(wú)序流在多次執(zhí)行的時(shí)候結(jié)果可能是不一樣的。

對(duì)于并行流，去掉有序這個(gè)約束可能會(huì)提供性能，比如distinct、groupingBy這些聚合操作。

結(jié)合性 Associativity

一個(gè)操作或者函數(shù)op滿足結(jié)合性意味著它滿足下面的條件：

(a op b) op c == a op (b op c) 對(duì)于并發(fā)流來(lái)說(shuō)，如果操作滿足結(jié)合性，我們就可以并行計(jì)算：

a op b op c op d == (a op b) op (c op d) 比如min、max以及字符串連接都是滿足結(jié)合性的。

創(chuàng)建Stream

可以通過(guò)多種方式創(chuàng)建流：

1、通過(guò)集合的stream()方法或者parallelStream()，比如Arrays.asList(1,2,3).stream()。 2、通過(guò)Arrays.stream(Object[])方法, 比如Arrays.stream(new int[]{1,2,3})。 3、使用流的靜態(tài)方法，比如Stream.of(Object[]), IntStream.range(int, int) 或者 Stream.iterate(Object, UnaryOperator)，如Stream.iterate(0, n -> n * 2)，或者generate(Supplier<T> s)如Stream.generate(Math::random)。 4、BufferedReader.lines()從文件中獲得行的流。 5、Files類的操作路徑的方法，如list、find、walk等。 6、隨機(jī)數(shù)流Random.ints()。 7、其它一些類提供了創(chuàng)建流的方法，如BitSet.stream(), Pattern.splitAsStream(java.lang.CharSequence), 和 JarFile.stream()。 8、更底層的使用StreamSupport，它提供了將Spliterator轉(zhuǎn)換成流的方法。

中間操作 intermediate operations

中間操作會(huì)返回一個(gè)新的流，并且操作是延遲執(zhí)行的(lazy)，它不會(huì)修改原始的數(shù)據(jù)源，而且是由在終點(diǎn)操作開(kāi)始的時(shí)候才真正開(kāi)始執(zhí)行。 Java的這種設(shè)計(jì)會(huì)減少中間對(duì)象的生成。

下面介紹流的這些中間操作：

distinct

distinct保證輸出的流中包含唯一的元素，它是通過(guò)Object.equals(Object)來(lái)檢查是否包含相同的元素。

List<String> l = Stream.of("a","b","c","b").distinct().collect(Collectors.toList()); System.out.println(l); //[a, b, c]

filter

filter返回的流中只包含滿足斷言(predicate)的數(shù)據(jù)。

下面的代碼返回流中的偶數(shù)集合。

List<Integer> l = IntStream.range(1,10).filter( i -> i % 2 == 0).boxed().collect(Collectors.toList()); System.out.println(l); //[2, 4, 6, 8]

map

map方法將流中的元素映射成另外的值，新的值類型可以和原來(lái)的元素的類型不同。

下面的代碼中將字符元素映射成它的哈希碼(ASCII值)。

List<Integer> l = Stream.of('a','b','c').map( c -> c.hashCode()).collect(Collectors.toList()); System.out.println(l); //[97, 98, 99]

flatmap

flatmap方法混合了map + flattern的功能，它將映射后的流的元素全部放入到一個(gè)新的流中。它的方法定義如下：

<R> Stream<R> flatMap(Function<? super T,? extends Stream<? extends R>> mapper)

可以看到mapper函數(shù)會(huì)將每一個(gè)元素轉(zhuǎn)換成一個(gè)流對(duì)象，而flatMap方法返回的流是將原流中元素的每一個(gè)子元素組合成的流對(duì)象。

下面這個(gè)例子中將一首詩(shī)生成一個(gè)按行分割的流，然后在這個(gè)流上調(diào)用flatmap得到單詞的小寫(xiě)形式的集合，去掉重復(fù)的單詞然后打印出來(lái)。

String poetry = "Where, before me, are the ages that have gone?\n" +"And where, behind me, are the coming generations?\n" +"I think of heaven and earth, without limit, without end,\n" +"And I am all alone and my tears fall down."; Stream<String> lines = Arrays.stream(poetry.split("\n")); Stream<String> words = lines.flatMap(line -> Arrays.stream(line.split(" "))); List<String> l = words.map( w -> {if (w.endsWith(",") || w.endsWith(".") || w.endsWith("?"))return w.substring(0,w.length() -1).trim().toLowerCase();elsereturn w.trim().toLowerCase(); }).distinct().sorted().collect(Collectors.toList()); System.out.println(l); //[ages, all, alone, am, and, are, before, behind, coming, down, earth, end, fall, generations, gone, have, heaven, i, limit, me, my, of, tears, that, the, think, where, without]

flatMapToDouble、flatMapToInt、flatMapToLong提供了轉(zhuǎn)換成特定流的方法。

limit

limit方法指定數(shù)量的元素的流。對(duì)于串行流，這個(gè)方法是有效的，這是因?yàn)樗恍璺祷厍皀個(gè)元素即可，但是對(duì)于有序的并行流，它可能花費(fèi)相對(duì)較長(zhǎng)的時(shí)間，如果你不在意有序，可以將有序并行流轉(zhuǎn)換為無(wú)序的，可以提高性能。

List<Integer> l = IntStream.range(1,100).limit(5).boxed().collect(Collectors.toList()); System.out.println(l);//[1, 2, 3, 4, 5]

peek

peek方法方法會(huì)使用一個(gè)Consumer消費(fèi)流中的元素，但是返回的流還是包含原來(lái)的流中的元素。

可實(shí)現(xiàn)與forEach相同的功能，但是forEach是terminal 操作，執(zhí)行后流就結(jié)束了，使用peek會(huì)返回原來(lái)的流。

String[] arr = new String[]{"a","b","c","d"}; Arrays.stream(arr).peek(System.out::println) //a,b,c,d.count();

sorted

sorted()將流中的元素按照自然排序方式進(jìn)行排序，如果元素沒(méi)有實(shí)現(xiàn)Comparable，則終點(diǎn)操作執(zhí)行時(shí)會(huì)拋出java.lang.ClassCastException異常。 sorted(Comparator<? super T> comparator)可以指定排序的方式。

對(duì)于有序流，排序是穩(wěn)定的。對(duì)于非有序流，不保證排序穩(wěn)定。

String[] arr = new String[]{"b_123","c+342","b#632","d_123"}; List<String> l = Arrays.stream(arr).sorted((s1,s2) -> {if (s1.charAt(0) == s2.charAt(0))return s1.substring(2).compareTo(s2.substring(2));elsereturn s1.charAt(0) - s2.charAt(0);}).collect(Collectors.toList()); System.out.println(l); //[b_123, b#632, c+342, d_123]

skip

skip返回丟棄了前n個(gè)元素的流，如果流中的元素小于或者等于n，則返回空的流。

終點(diǎn)操作 terminal operations

Match

public boolean allMatch(Predicate<? super T> predicate) public boolean anyMatch(Predicate<? super T> predicate) public boolean noneMatch(Predicate<? super T> predicate)

這一組方法用來(lái)檢查流中的元素是否滿足斷言。

• allMatch只有在所有的元素都滿足斷言時(shí)才返回true,否則flase,流為空時(shí)總是返回true
• anyMatch只有在任意一個(gè)元素滿足斷言時(shí)就返回true,否則flase,
• noneMatch只有在所有的元素都不滿足斷言時(shí)才返回true,否則flase,

System.out.println(Stream.of(1,2,3,4,5).allMatch( i -> i > 0)); //true System.out.println(Stream.of(1,2,3,4,5).anyMatch( i -> i > 0)); //true System.out.println(Stream.of(1,2,3,4,5).noneMatch( i -> i > 0)); //false System.out.println(Stream.<Integer>empty().allMatch( i -> i > 0)); //true System.out.println(Stream.<Integer>empty().anyMatch( i -> i > 0)); //false System.out.println(Stream.<Integer>empty().noneMatch( i -> i > 0)); //true

count

count方法返回流中的元素的數(shù)量。它實(shí)現(xiàn)為：

mapToLong(e -> 1L).sum();

collect

<R,A> R collect(Collector<? super T,A,R> collector) <R> R collect(Supplier<R> supplier, BiConsumer<R,? super T> accumulator, BiConsumer<R,R> combiner)

使用一個(gè)collector執(zhí)行mutable reduction操作。輔助類Collectors提供了很多的collector，可以滿足我們?nèi)粘５男枨?#xff0c;你也可以創(chuàng)建新的collector實(shí)現(xiàn)特定的需求。它是一個(gè)值得關(guān)注的類，你需要熟悉這些特定的收集器，如聚合類averagingInt、最大最小值maxBy minBy、計(jì)數(shù)counting、分組groupingBy、字符串連接joining、分區(qū)partitioningBy、匯總summarizingInt、化簡(jiǎn)reducing、轉(zhuǎn)換toXXX等。

第二個(gè)方法提供了更底層的功能，它的邏輯類似下面的偽代碼：

R result = supplier.get(); for (T element : this stream)accumulator.accept(result, element); return result;

例子：

List<String> asList = stringStream.collect(ArrayList::new, ArrayList::add,ArrayList::addAll); String concat = stringStream.collect(StringBuilder::new, StringBuilder::append,StringBuilder::append).toString();

find

findAny()返回任意一個(gè)元素，如果流為空，返回空的Optional，對(duì)于并行流來(lái)說(shuō)，它只需要返回任意一個(gè)元素即可，所以性能可能要好于findFirst()，但是有可能多次執(zhí)行的時(shí)候返回的結(jié)果不一樣。 findFirst()返回第一個(gè)元素，如果流為空，返回空的Optional。

forEach、forEachOrdered

forEach遍歷流的每一個(gè)元素，執(zhí)行指定的action。它是一個(gè)終點(diǎn)操作，和peek方法不同。這個(gè)方法不擔(dān)保按照流的encounter order順序執(zhí)行，如果對(duì)于有序流按照它的encounter order順序執(zhí)行，你可以使用forEachOrdered方法。

Stream.of(1,2,3,4,5).forEach(System.out::println);

max、min

max返回流中的最大值， min返回流中的最小值。

reduce

reduce是常用的一個(gè)方法，事實(shí)上很多操作都是基于它實(shí)現(xiàn)的。 它有幾個(gè)重載方法：

pubic Optional<T> reduce(BinaryOperator<T> accumulator) pubic T reduce(T identity, BinaryOperator<T> accumulator) pubic <U> U reduce(U identity, BiFunction<U,? super T,U> accumulator, BinaryOperator<U> combiner)

第一個(gè)方法使用流中的第一個(gè)值作為初始值，后面兩個(gè)方法則使用一個(gè)提供的初始值。

Optional<Integer> total = Stream.of(1,2,3,4,5).reduce( (x, y) -> x +y); Integer total2 = Stream.of(1,2,3,4,5).reduce(0, (x, y) -> x +y);

值得注意的是accumulator應(yīng)該滿足結(jié)合性(associative)。

toArray()

將流中的元素放入到一個(gè)數(shù)組中。

組合

concat用來(lái)連接類型一樣的兩個(gè)流。

public static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)

轉(zhuǎn)換

toArray方法將一個(gè)流轉(zhuǎn)換成數(shù)組，而如果想轉(zhuǎn)換成其它集合類型，需要調(diào)用collect方法，利用Collectors.toXXX方法進(jìn)行轉(zhuǎn)換：

public static <T,C extends Collection<T>> Collector<T,?,C> toCollection(Supplier<C> collectionFactory) public static ... toConcurrentMap(...) public static <T> Collector<T,?,List<T>> toList() public static ... toMap(...) public static <T> Collector<T,?,Set<T>> toSet()

Stream開(kāi)源工具

protonpack

• takeWhile and takeUntil(無(wú)限數(shù)據(jù)流上截取數(shù)據(jù)流)
• skipWhile and skipUntil（無(wú)限數(shù)據(jù)流上截取數(shù)據(jù)流）
• zip and zipWithIndex（將2數(shù)據(jù)流相同位置對(duì)應(yīng)建立關(guān)系）
• unfold
• MapStream
• aggregate
• Streamable
• unique collector

java8-utils

轉(zhuǎn)載于:https://my.oschina.net/hgfdoing/blog/712886

總結(jié)

以上是生活随笔為你收集整理的JDK1.8 之Stream API总结的全部?jī)?nèi)容，希望文章能夠幫你解決所遇到的問(wèn)題。

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