stream and lambda(7) - stream 的創建

語言: CN / TW / HK

Stream 的創建, Stream 接口本身提供了一些方法來完成這個操作。而除此之外,JDK 本身也提供了其他類來完成這個操作。考慮到 Stream 的集合息息相關,合理猜測 ArraysCollectionMap 可能會提供創建 stream 的方法。但 Stream<T> 只有單泛型,而 Map<K,V> 是鍵值對,目測 Map 中不含有 Stream 相關的方法。來,大家可以看源碼驗證一下。

通過查看 JDK 源碼發現, ArraysCollection 均提供 stream 相關的方法,而 Map 並未提供對應的方法。

Arrays

從方法來看,Arrays 提供了多個重載方法,可以將 intlongdouble 以及實例對象數組轉為 Stream ,並且提供了截取數組區間的功能。如以下用例,就是將數組轉成 stream。

public void arraysCreateTest() {
    String[] strings = {"I", "am", "arrays", "demo"};
    int[] nums = {1, 0, 0, 8, 6};
    Arrays.stream(strings).forEach(System.out::println);
    Arrays.stream(nums, 2, 5).forEach(System.out::println);
}

Collection

Collection 提供的 stream()parallelStream() 方法已經在接口內實現,其子類,如 ListSet 可以直接使用。

public void collectionCreateTest() {
    List<Integer> integers = Arrays.asList(1, 2, 9, 11, 5, 7, 3);
    integers.stream().sorted().forEach(System.out::println);
    integers.parallelStream().sorted().forEachOrdered(System.out::println);
}

Stream

empty

empty() 方法,返回的是一個空的 stream。既然沒有任何元素,那這個 stream 的意義又在哪裏?

不報 NPE 異常,還不夠你臭屁的?要知道, java.util.Collections 還單獨提供了 emptySet()emptyList() 方法呢。

來試一試,下面的代碼能不能正常運行。

public void emptyTest(){
    Stream<Integer> empty = Stream.empty();
    System.out.println(empty.findFirst().orElse(-1));
        
    empty = Stream.empty();
    empty.forEach(System.out::println);
}

generate

generate 是個可以產生無盡流的方法。首先,我們先看看下面的代碼的運行結果。

public void endlessGenerateTest() {
    Stream<Integer> generate = Stream.generate(() -> new SecureRandom().nextInt());
    AtomicLong al = new AtomicLong(0);
    generate.forEach(integer -> System.out.println(al.incrementAndGet() + " : " + integer));
}

怎麼樣,讓我聽到你們電腦的歡呼聲(此處應有滑稽表情)。好了,效果大家也看到了,我們來看下方法的定義:

static <T> Stream<T> generate(Supplier<T> s)

通過傳入一個 Supplier ,來生成一個 stream。生成內部元素的時候,每生成一個,就會向 Supplier 再要一個,如此下來產生的就是無盡流。

不過,也不用擔心使用該方法後程序就停不下來,或者是 Supplier 產生了過量的元素導致性能低下。

public void limitGenerateTest() {
    Stream<Integer> generate = Stream.generate(() -> {
        System.out.println("#######");
        return new SecureRandom().nextInt();
    });
    AtomicLong al = new AtomicLong(0);
    generate.limit(3).forEach(integer -> System.out.println(al.incrementAndGet() + " : " + integer));
}

輸出結果如下:

####### 1 : -35704083
####### 2 : -1875554696
####### 3 : 541096732

可以看出來,使用 limit(3) 的時候,是每次需要時才產生新元素。

of

先看方法定義:

static <T> Stream<T> of(T t) static <T> Stream<T> of(T… values)

好的食材,往往通過最簡單的烹飪即可;而好用的方法,往往是一看就知道,一上手就會。 of 方法,傳入可變個數的參數,均可以轉為 stream。

public void ofTest() {
    Stream<String> strStream = Stream.of("this is stream.of demo");
    strStream.forEach(System.out::println);

    Stream<Integer> intStream = Stream.of(1, 0, 0, 8, 6);
    intStream.forEach(System.out::println);

    List<String> list = Arrays.asList("i", "am", "list", "of", "method");
    Stream<List<String>> listStream = Stream.of(list);
    listStream.forEach(System.out::println);
}

注意:如果傳入的參數是一個集合,如 List 或者 Set,流內的元素也是隻有一個,而不是集合內的元素。流內的元素,就是那個集合。

iterate

iterate 聽起來是不是有那麼點熟悉?再想想,集合的迭代是怎麼實現的?如果還沒想到,再提示下,關鍵字 hasNext 。雖然集合有不少不用 Iterator 的遍歷寫法,但是這個迭代器還是要了解的。來先看下 iterate 方法定義:

static <T> Stream<T> iterate(T seed, UnaryOperator<T> f)

其中, T seed 是第一個元素,後續元素通過迭代計算出來。這樣滾動迭代,就產生了無限流。這點和 generate 其實有些相似,只不過 generate 的前後元素沒有關聯。

Stream.iterate(1, iter -> iter + 3).limit(5).forEach(System.out::print);

比如這個例子,將依次輸出 1,4,7,10,13

concat

嚴格來説, concat 並不算是創建類型的,畢竟創建類型是從無到有,是創造;而 concat 站在了前人的肩膀上,是創新,將已有的兩個流合併到一起。

照例,我們先看方法定義:

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

concat,將已有的兩個流合併到一起。文檔更明確的説了以下的點:

  1. 更準確的説,是將第二個流放到第一個流屁股後面。
  2. 如果兩個流都是 ordered,那麼得到的新流也是 ordered。
  3. 如果兩個流有一個是並行流,則得到的新流是並行流。
  4. 關閉合並結果流時,會調用兩個輸入流的關閉方法。

當然,看源碼的實現,上面的這些點是可以看出來的。拋開源碼,我們來驗證一下。

合成新流的元素順序

public void concatTest1() {
    Stream<Integer> first = Stream.of(1, 3, 5);
    Stream<Integer> second = Stream.of(2, 3, 4);
    System.out.println(Stream.concat(first, second).collect(Collectors.toList()));
}

經驗證,輸出的內容是:

[1, 3, 5, 2, 3, 4]

就這驗證了,合成的流,順序確實是第一個流 + 第二個流, 並且不會去重

什麼是 ordered

流是 ordered, 並不是指對流的元素進行排序 。而是指流內的元素,是有固定的順序約束的。比如 List ,元素是有約束順序的: ArrayList 有數組座標, LinkedList 有鏈表連接。所以, List 生成的流是 ordered。

更詳細的內容,下次單獨再説吧。

合併後的並行流

public void concatTest2() {
    Stream<Integer> first = Stream.of(1, 3, 5).parallel();
    Stream<Integer> second = Stream.of(2, 3, 4);
    Stream.concat(first, second).map(i -> i + " ").forEach(System.out::print);
}

這次的測試,把第一個流換成了並行流。如果合併後的流不是並行,那麼輸出的內容應該是原定的順序 1 3 5 2 3 4

驗證後的結果卻是輸出是無序的,説明了合併後的流是並行流:

合併後流的關閉

public void concatTest3() {
    Stream<Integer> first = Stream.of(1, 3, 5);
    Stream<Integer> second = Stream.of(2, 3, 4);
    System.out.println(Stream.concat(first, second).collect(Collectors.toList()));
    Stream.concat(first, second).map(i -> i + " ").forEach(System.out::print);
}

為了驗證這個問題,我們把流合併兩次看一下。在執行的時候,實際拋瞭如下異常:

java.lang.IllegalStateException: stream has already been operated upon or closed

其實,從源碼來看,在合併成新流之後,first 和 second 兩個流都執行了 close 。

總結

Stream 的創建, ArraysCollection 也是出了一把力的。打鐵還需自身硬, Stream 本身提供的這些創建方法,覆蓋面也是極廣的。畢竟出門靠朋友, Stream 就這麼和集合打成一片了。

注:本文配套代碼可在 github 查看: stream-and-lambda