Java Stream 詳解

Stream是 Java 8新增加的類，用來補充集合類。
Stream代表資料流，流中的資料元素的數量可能是有限的，也可能是無限的。

Stream和其它集合類的區別在於：其它集合類主要關注與有限數量的資料的訪問和有效管理(增刪改)，而Stream並沒有提供訪問和管理元素的方式，而是透過宣告資料來源的方式，利用可計算的操作在資料來源上執行，當然BaseStream.iterator() 和 BaseStream.spliterator()操作提供了遍歷元素的方法。

Java Stream提供了提供了序列和並行兩種型別的流，保持一致的介面，提供函數語言程式設計方式，以管道方式提供中間操作和最終執行操作，為Java語言的集合提供了現代語言提供的類似的高階函式操作，簡化和提高了Java集合的功能。

本文首先介紹Java Stream的特點，然後按照功能分類逐個介紹流的中間操作和終點操作，最後會介紹第三方為Java Stream做的擴充套件。

前年年底的時候我寫了一些關於Java 8 Lambda和Stream的文章，本文應該在那個時候完成。後來忙於專案和寫《Scala集合技術手冊》(Scala Collections Cookbook)這本書，一直沒來得及寫Java Stream的文章，現在這篇文章算是對 Java Stream的一個總結吧。

介紹

本節翻譯整理自Javadoc，並對流的這些特性做了進一步的解釋。

Stream介面還包含幾個基本型別的子介面如IntStream, LongStream 和 DoubleStream。

關於流和其它集合具體的區別，可以參照下面的列表：

不儲存資料。流是基於資料來源的物件，它本身不儲存資料元素，而是透過管道將資料來源的元素傳遞給操作。
函數語言程式設計。流的操作不會修改資料來源，例如filter不會將資料來源中的資料刪除。
延遲操作。流的很多操作如filter,map等中間操作是延遲執行的，只有到終點操作才會將操作順序執行。
可以解綁。對於無限數量的流，有些操作是可以在有限的時間完成的，比如limit(n) 或 findFirst()，這些操作可是實現”短路”(Short-circuiting)，訪問到有限的元素後就可以返回。
純消費。流的元素只能訪問一次，類似Iterator，操作沒有回頭路，如果你想從頭重新訪問流的元素，對不起，你得重新生成一個新的流。

流的操作是以管道的方式串起來的。流管道包含一個資料來源，接著包含零到N箇中間操作，最後以一個終點操作結束。

並行 Parallelism

所有的流操作都可以序列執行或者並行執行。
除非顯示地建立並行流，否則Java庫中建立的都是序列流。 Collection.stream()為集合建立序列流而Collection.parallelStream()為集合建立並行流。IntStream.range(int, int)建立的是序列流。透過parallel()方法可以將序列流轉換成並行流,sequential()方法將流轉換成序列流。

除非方法的Javadoc中指明瞭方法在並行執行的時候結果是不確定(比如findAny、forEach)，否則序列和並行執行的結果應該是一樣的。

Non-interference

流可以從非執行緒安全的集合中建立，當流的管道執行的時候，非concurrent資料來源不應該被改變。下面的程式碼會丟擲java.util.ConcurrentModificationException異常：

| 123 | List l = new ArrayList(Arrays.asList(“one”, “two”));Stream sl = l.stream();sl.forEach(s -> l.add(“three”)); |

在設定中間操作的時候，可以更改資料來源，只有在執行終點操作的時候，才有可能出現併發問題(丟擲異常，或者不期望的結果)，比如下面的程式碼不會丟擲異常：

| 1234 | List l = new ArrayList(Arrays.asList(“one”, “two”));Stream sl = l.stream();l.add(“three”);sl.forEach(System.out::println); |

對於concurrent資料來源，不會有這樣的問題，比如下面的程式碼很正常：

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

雖然我們上面例子是在終點操作中對非併發資料來源進行修改，但是非併發資料來源也可能在其它執行緒中修改，同樣會有併發問題。

無狀態 Stateless behaviors

大部分流的操作的引數都是函式式介面，可以使用Lambda表示式實現。它們用來描述使用者的行為，稱之為行為引數(behavioral parameters)。

如果這些行為引數有狀態，則流的操作的結果可能是不確定的，比如下面的程式碼:

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

上面的程式碼在並行執行時多次的執行結果可能是不同的。這是因為這個lambda表示式是有狀態的。

副作用 Side-effects

有副作用的行為引數是被不鼓勵使用的。

副作用指的是行為引數在執行的時候有輸入輸入，比如網路輸入輸出等。

這是因為Java不保證這些副作用對其它執行緒可見，也不保證相同流管道上的同樣的元素的不同的操作執行在同一個執行緒中。

很多有副作用的行為引數可以被轉換成無副作用的實現。一般來說println()這樣的副作用程式碼不會有害。

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

上面的程式碼可以改成無副作用的。

| 123 | Listresults = stream.filter(s -> pattern.matcher(s).matches()) .collect(Collectors.toList()); // No side-effects! |

排序 Ordering

某些流的返回的元素是有確定順序的，我們稱之為 encounter order。這個順序是流提供它的元素的順序，比如陣列的encounter order是它的元素的排序順序，List是它的迭代順序(iteration order)，對於HashSet,它本身就沒有encounter order。

一個流是否是encounter order主要依賴資料來源和它的中間操作，比如資料來源List和Array上建立的流是有序的(ordered)，但是在HashSet建立的流不是有序的。

sorted()方法可以將流轉換成encounter order的，unordered可以將流轉換成encounter order的。

注意，這個方法並不是對元素進行排序或者打散，而是返回一個是否encounter order的流。

stackoverflow.com/questions/213501...
If a stream is ordered, repeated execution of identical stream pipelines on an identical source will produce an identical result; if it is not ordered, repeated execution might produce different results.
謝謝 imekaku lee 指出

除此之外，一個操作可能會影響流的有序,比如map方法，它會用不同的值甚至型別替換流中的元素，所以輸入元素的有序性已經變得沒有意義了，但是對於filter方法來說，它只是丟棄掉一些值而已，輸入元素的有序性還是保障的。

對於序列流，流有序與否不會影響其效能，只是會影響確定性(determinism)，無序流在多次執行的時候結果可能是不一樣的。

對於並行流，去掉有序這個約束可能會提供效能，比如distinct、groupingBy這些聚合操作。

結合性 Associativity

一個操作或者函式op滿足結合性意味著它滿足下面的條件：

| 1 | (a op b) op c == a op (b op c) |

對於併發流來說，如果操作滿足結合性，我們就可以平行計算：

| 1 | a op b op c op d == (a op b) op (c op d) |

比如min、max以及字串連線都是滿足結合性的。

建立Stream

可以透過多種方式建立流：

1、透過集合的stream()方法或者parallelStream()，比如Arrays.asList(1,2,3).stream()。
2、透過Arrays.stream(Object[])方法, 比如Arrays.stream(new int[]{1,2,3})。
3、使用流的靜態方法，比如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、隨機數流Random.ints()。
7、其它一些類提供了建立流的方法，如BitSet.stream(), Pattern.splitAsStream(java.lang.CharSequence), 和 JarFile.stream()。
8、更底層的使用StreamSupport，它提供了將Spliterator轉換成流的方法。

中間操作 intermediate operations

中間操作會返回一個新的流，並且操作是延遲執行的(lazy)，它不會修改原始的資料來源，而且是由在終點操作開始的時候才真正開始執行。
這個Scala集合的轉換操作不同，Scala集合轉換操作會生成一個新的中間集合，顯而易見Java的這種設計會減少中間物件的生成。

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

distinct

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

| 1234 | List l = Stream.of(“a”,”b”,”c”,”b”) .distinct() .collect(Collectors.toList());System.out.println(l); //[a, b, c] |

filter

filter返回的流中只包含滿足斷言(predicate)的資料。

下面的程式碼返回流中的偶數集合。

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

map

map方法將流中的元素對映成另外的值，新的值型別可以和原來的元素的型別不同。

下面的程式碼中將字元元素對映成它的雜湊碼(ASCII值)。

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

flatmap

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

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

可以看到mapper函式會將每一個元素轉換成一個流物件，而flatMap方法返回的流包含的元素為mapper生成的所有流中的元素。

下面這個例子中將一首唐詩生成一個按行分割的流，然後在這個流上呼叫flatmap得到單詞的小寫形式的集合，去掉重複的單詞然後列印出來。

| 1234567891011121314 | 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 lines = Arrays.stream(poetry.split(“\n”));Stream words = lines.flatMap(line -> Arrays.stream(line.split(“ “)));List l = words.map( w -> { if (w.endsWith(“,”) || w.endsWith(“.”) || w.endsWith(“?”)) return w.substring(0,w.length() -1).trim().toLowerCase(); else return 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提供了轉換成特定流的方法。

limit

limit方法指定數量的元素的流。對於序列流，這個方法是有效的，這是因為它只需返回前n個元素即可，但是對於有序的並行流，它可能花費相對較長的時間，如果你不在意有序，可以將有序並行流轉換為無序的，可以提高效能。

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

peek

peek方法方法會使用一個Consumer消費流中的元素，但是返回的流還是包含原來的流中的元素。

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

sorted

sorted()將流中的元素按照自然排序方式進行排序，如果元素沒有實現Comparable，則終點操作執行時會丟擲java.lang.ClassCastException異常。
sorted(Comparator<? super T> comparator)可以指定排序的方式。

對於有序流，排序是穩定的。對於非有序流，不保證排序穩定。

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

skip

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

終點操作 terminal operations

Match

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

這一組方法用來檢查流中的元素是否滿足斷言。
allMatch只有在所有的元素都滿足斷言時才返回true,否則flase,流為空時總是返回true

anyMatch只有在任意一個元素滿足斷言時就返回true,否則flase,

noneMatch只有在所有的元素都不滿足斷言時才返回true,否則flase,

| 1234567 | 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)); //falseSystem.out.println(Stream.empty().allMatch( i -> i > 0)); //true System.out.println(Stream.empty().anyMatch( i -> i > 0)); //false System.out.println(Stream.empty().noneMatch( i -> i > 0)); //true |

count

count方法返回流中的元素的數量。它實現為：

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

collect

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

使用一個collector執行mutable reduction操作。輔助類Collectors提供了很多的collector，可以滿足我們日常的需求，你也可以建立新的collector實現特定的需求。它是一個值得關注的類，你需要熟悉這些特定的收集器，如聚合類averagingInt、最大最小值maxBy minBy、計數counting、分組groupingBy、字串連線joining、分割槽partitioningBy、彙總summarizingInt、化簡reducing、轉換toXXX等。

第二個提供了更底層的功能，它的邏輯類似下面的虛擬碼：

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

例子：

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

find

findAny()返回任意一個元素，如果流為空，返回空的Optional，對於並行流來說，它只需要返回任意一個元素即可，所以效能可能要好於findFirst()，但是有可能多次執行的時候返回的結果不一樣。
findFirst()返回第一個元素，如果流為空，返回空的Optional。

forEach、forEachOrdered

forEach遍歷流的每一個元素，執行指定的action。它是一個終點操作，和peek方法不同。這個方法不擔保按照流的encounter order順序執行，如果對於有序流按照它的encounter order順序執行，你可以使用forEachOrdered方法。

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

max、min

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

reduce

reduce是常用的一個方法，事實上很多操作都是基於它實現的。
它有幾個過載方法：

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

第一個方法使用流中的第一個值作為初始值，後面兩個方法則使用一個提供的初始值。

| 12 | Optional 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應該滿足結合性(associative)。

toArray()

將流中的元素放入到一個陣列中。

組合

concat用來連線型別一樣的兩個流。

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

轉換

toArray方法將一個流轉換成陣列，而如果想轉換成其它集合型別，西需要呼叫collect方法，利用Collectors.toXXX方法進行轉換：

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

更進一步

雖然Stream提供了很多的操作，但是相對於Scala等語言，似乎還少了一些。一些開源專案提供了額外的一些操作，比如protonpack專案提供了下列方法：

takeWhile and takeUntil
skipWhile and skipUntil
zip and zipWithIndex
unfold
MapStream
aggregate
Streamable
unique collector

java8-utils 也提供了一些有益的輔助方法。

上週看同事程式碼，看到了Collectors.groupingBy的一些使用，由於時間限制，不允許做太多學習，所以週末研究一下。

先祭出VO：

@Getter
@Setter
@ToString
class Fruit {
    private String name;
    private Double price;

    public Fruit(String name, Double price) {
        this.name = name;
        this.price = price;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Fruit fruit = (Fruit) o;
        return java.util.Objects.equals(name, fruit.name) &&
                java.util.Objects.equals(price, fruit.price);
    }

    @Override
    public int hashCode() {
        return java.util.Objects.hash(name, price);
    }
    // 注意equals和hashCode必須成對出現
}

1）計數

List<Fruit> fruitList = Lists.newArrayList(new Fruit("apple", 6),
        new Fruit("apple", 6),
        new Fruit("banana", 7), new Fruit("banana", 7),
        new Fruit("banana", 7), new Fruit("grape",8));

Map<String, Long> map = fruitList.stream().
   collect(Collectors.groupingBy(Fruit::getName,Collectors.counting()));

輸出結果是：{banana=3, apple=2, grape=1}
換一種囉嗦、複雜的寫法，但能加深理解。

Map<String, Long> map = fruitList.stream().map(Fruit::getName).
  collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));

2）排序
現在要按照水果map中value的數量逆序列印每個entry

map.entrySet().stream().sorted(Map.Entry.<String, Long>comparingByValue().reversed())
         .forEachOrdered(System.out::println);

3）累加求和

Map<String, Integer> sumMap = fruitList.stream().collect.
(Collectors.groupingBy(Fruit::getName, Collectors.summingInt(Fruit::getPrice)));

輸出結果是：{banana=21, apple=12, grape=8}
4）分組

Map<String, List<Fruit>> groupMap = 
fruitList.stream().collect(Collectors.groupingBy(Fruit::getName));

上述程式碼根據name將list分組，如果name是唯一的，那麼上述程式碼就會顯得囉嗦。我們需要知道，Guava補JDK之不足，現在改Guava一顯身手了。

Map<String, Fruit> map = Maps.uniqueIndex(fruitList, Fruit::getName);

生成的Map是ImmutableMap，不可更改裡面的值。比如map.remove(“apple”)會丟擲異常：java.lang.UnsupportedOperationException

根據不同的名字分為若干組

// group by price, uses 'mapping' to convert List<Fruit> to List<String>
Map<String, List<Integer>> groupMap = 
fruitList.stream().collect(Collectors.groupingBy(Fruit::getName, 
Collectors.mapping(Fruit::getPrice, Collectors.toList())));

上面一段程式碼可以用Guava代替

Multimap<String, Integer> multiMap = ArrayListMultimap.create();
fruitList.forEach(fruit -> multiMap.put(fruit.getName(), fruit.getPrice()));

鳴謝：Stream Collectors groupingBy 例子

24人點贊

Java

作者：packet
連結：www.jianshu.com/p/21b20c375599

本作品採用《CC 協議》，轉載必須註明作者和本文連結