Java 提效神器 Stream 的冷門技巧

Stream

使用這個方法建立一個 Stream 物件。

new ArrayList<>（）。stream（）

Filter

過濾器，裡面傳遞一個函式，這個函式的返回結果如果為 true 則保留這個元素，否則的話丟棄這個元素。

stringCollection 。stream（）。filter（（s） -> s。startsWith（“a”））。forEach（System。out：：println）；

Foreach

遍歷，消費。

stringCollection 。stream（）。filter（（s） -> s。startsWith（“a”））。forEach（System。out：：println）；

Map

這個功能也是遍歷，但是他是有返回值的，而上面的 Foreach 是沒有返回值的，僅僅是單純的消費。而且 Foreach 不能夠鏈式呼叫，因為沒有返回值，但是 Map 沒問題。

stringCollection 。stream（）。map（String：：toUpperCase）。sorted（Comparator。reverseOrder（））。forEach（System。out：：println）；

Sorted

這個方法是用來排序的，裡面傳遞的函式就是一個比較器，也可以不傳遞引數，使用預設的就好。

stringCollection 。stream（）。sorted（（ x， y）-> y。length（）-x。length（））。filter（（s） -> s。startsWith（“a”））。forEach（System。out：：println）；

Match

根據在給定的 stream 物件中是否含有指定內容返回 true 或者 false 。

具體的有：

allMatch

anyMatch

noneMatch

boolean anyStartsWithA = stringCollection 。stream（）。anyMatch（（s） -> s。startsWith（“a”））； boolean allStartsWithA = stringCollection 。stream（）。allMatch（（s） -> s。startsWith（“a”））； boolean noneStartsWithZ = stringCollection 。stream（）。noneMatch（（s） -> s。startsWith（“z”））；

count

計算集合中的元素的個數。

long startsWithB = stringCollection 。stream（）。filter（（s） -> s。startsWith（“b”））。count（）；

reduce

這個函式就是類似於斐波那契數列，每次傳遞的引數是上一次的結果和從集合中取出的新元素。第一次預設取出了第一個元素和第二個元素。

簡單的例子就是，第一次取出 0，1 第二次取出第一次reduce的結果作為第一個引數，取出 2 作為第二個引數，以此類推。

Optional reduced = stringCollection 。stream（）。sorted（）。reduce（（s1， s2） -> s1 + “#” + s2）；

parallelStream

並行的 steam 流，可以進行並行處理，這樣會效率更高。在使用stream。foreach時這個遍歷沒有執行緒安全問題，但是使用parallelStream就會有執行緒安全問題，所有在parallelStream裡面使用的外部變數，比如集合一定要使用執行緒安全集合，不然就會引發多執行緒安全問題。如果說需要保證安全性需要使用 reduce 和 collect，不過這個用起來超級麻煩！！！

long count = values。parallelStream（）。sorted（）。count（）；

IntStream。range（a，b）

可以直接生成從 a 到 b 的整數這裡還是遵循程式語言的大多數約定，那就是含頭不含尾。

IntStream。range（0， 10）。forEach（System。out：：println）；

輸出的結果是

0123456789

new Random（）。ints（）

獲取一系列的隨機值，這個接口出來的資料是連續不斷的，所以需要用limit來限制一下。

new Random（）。ints（）。limit（10）。forEach（System。out：：println）；

Supplier

Supplier stringSupplier=String：：new；stringSupplier。get（）；

該介面就一個抽象方法get方法，不用傳入任何引數，直接返回一個泛型T的例項。就如同無參構造一樣

Consumer

1。 accept方法

該函式式介面的唯一的抽象方法，接收一個引數，沒有返回值。

2。 andThen方法

在執行完呼叫者方法後再執行傳入引數的方法。

public class ConsumerTest { public static void main（String［］ args） { Consumer consumer = （x） -> { int num = x * 2； System。out。println（num）； }； Consumer consumer1 = （x） -> { int num = x * 3； System。out。println（num）； }； consumer。andThen（consumer1）。accept（10）； }

先執行了 consumer。accept（10）然後執行了 consumer1。accept（10）

ifPresent

針對一個optional 如果有值的話就執行否則不執行。

IntStream 。builder（）。add（1）。add（3）。add（5）。add（7）。add（11）。build（）。average（）。ifPresent（System。out：：println）；

average 執行結果就是一個 optional

Collect

他有兩種呼叫方式

R collect（Supplier supplier， BiConsumer accumulator， BiConsumer combiner）； R collect（Collector<？ super T， A， R> collector）；

下面主要介紹一下這兩種方式的使用方法：

1。函式

第一種呼叫方式的介面如下

R collect（Supplier supplier， BiConsumer accumulator， BiConsumer combiner）；

supplier 這個引數就是提供一個容器，可以看到最後 collect 操作的結果是一個 R 型別變數，而 supplier 介面最後需要返回的也是一個 R 型別的變數，所以說這裡返回的是收集元素的容器。

accumulator 引數，看到這個函式的定義是傳入一個 R 容器，後面則是 T 型別的元素，需要將這個 T 放到 R 容器中，即這一步是用來將元素新增到容器中的操作。

conbiner 這個引數是兩個容器，即當出現多個容器的時候容器如何進行聚合。

一個簡單的例子：

String concat = stringStream。collect（StringBuilder：：new， StringBuilder：：append，StringBuilder：：append）。toString（）；//等價於上面，這樣看起來應該更加清晰String concat = stringStream。collect（（） -> new StringBuilder（），（l， x） -> l。append（x），（r1， r2） -> r1。append（r2））。toString（）；

2。 Collector 介面

第二種方案是更高階的用法採用了 Collector 介面：

R collect（Collector<？ super T， A， R> collector）；

可以看到他返回的還是一個 R 型別的變數，也就是容器。

Collector

介面是使得

collect

操作強大的終極武器，對於絕大部分操作可以分解為旗下主要步驟，

提供初始容器->加入元素到容器->併發下多容器聚合->對聚合後結果進行操作

static class CollectorImpl implements Collector { private final Supplier supplier； private final BiConsumer accumulator； private final BinaryOperator combiner； private final Function finisher； private final Set characteristics； CollectorImpl（Supplier supplier， BiConsumer accumulator， BinaryOperator combiner， Function finisher， Set characteristics） { this。supplier = supplier； this。accumulator = accumulator； this。combiner = combiner； this。finisher = finisher； this。characteristics = characteristics； } CollectorImpl（Supplier supplier， BiConsumer accumulator， BinaryOperator combiner， Set characteristics） { this（supplier， accumulator， combiner， castingIdentity（）， characteristics）； } @Override public BiConsumer accumulator（） { return accumulator； } @Override public Supplier supplier（） { return supplier； } @Override public BinaryOperator combiner（） { return combiner； } @Override public Function finisher（） { return finisher； } @Override public Set characteristics（） { return characteristics； } }