前言
Java8新增的Stream API是一個(gè)強(qiáng)大的特性，它可以簡(jiǎn)化集合中的常用操作，包括過(guò)濾、映射、分組等。下面就來(lái)實(shí)現(xiàn)一個(gè)簡(jiǎn)易版的Stream。
從表面上看，流似乎和列表很接近，但實(shí)際上它們有著本質(zhì)的區(qū)別。
列表是多個(gè)元素的容器，當(dāng)列表被創(chuàng)建出來(lái)時(shí)，它里面的每個(gè)元素也已經(jīng)被創(chuàng)建出來(lái)了。
流是一種計(jì)算結(jié)構(gòu)，它封裝了內(nèi)部元素如何產(chǎn)生的計(jì)算過(guò)程，但是并沒(méi)有包含實(shí)際的元素?cái)?shù)據(jù)。換句話說(shuō)，當(dāng)一個(gè)流被創(chuàng)建出來(lái)時(shí)，它內(nèi)部的元素并沒(méi)有被創(chuàng)建，但是我們可以通過(guò)調(diào)用流的方法來(lái)按順序生成每個(gè)元素。
所以，流具有惰性計(jì)算的特性，它可以表示普通列表無(wú)法表示的一些結(jié)構(gòu)，如無(wú)限流。
流的定義
流的定義看起來(lái)很像鏈表，一個(gè)流由兩部分組成：第一個(gè)元素（first）和剩余元素組成的流（remain）。定義如下：
public interface Stream<T> {
/**
* 流中第一個(gè)元素
*/
T first();
/**
* 剩余元素組成的流
*/
Stream<T> remain();
/**
* 創(chuàng)建流
* @param firstSupplier 第一個(gè)元素的工廠
* @param remainSupplier 剩余元素組成的流的工廠
* @param <T> 元素類(lèi)型
* @return 流
*/
static <T> Stream<T> create(Supplier<T> firstSupplier, Supplier<Stream<T>> remainSupplier) {
return new Stream<>() {
@Override
public T first() {
return firstSupplier.get();
}
@Override
public Stream<T> remain() {
return remainSupplier.get();
}
};
}
}
這種遞歸的定義非常有利于使用遞歸算法來(lái)操作流。下面可以看到，流的大多數(shù)相關(guān)操作都是用遞歸算法實(shí)現(xiàn)的。
假設(shè)我們已經(jīng)有了一個(gè)流，那么如何獲取流中的元素呢？首先調(diào)用first來(lái)獲取第一個(gè)元素，然后調(diào)用remain().first()來(lái)獲取第二個(gè)元素，依此類(lèi)推：
Stream<Integer> stream = ...
Integer first = stream.first(); // 第一個(gè)元素
Integer second = stream.remain().first(); // 第二個(gè)元素
Integer third = stream.remain().remain().first(); // 第三個(gè)元素
// 依此類(lèi)推...
當(dāng)然，我們不會(huì)用這種方法來(lái)訪問(wèn)流中的元素。具體如何訪問(wèn)，請(qǐng)繼續(xù)往下看。
空流
空流是最簡(jiǎn)單的流，無(wú)法從空流中獲取任何元素?？樟饕矘?biāo)志著一個(gè)流的結(jié)束。下面是空流的實(shí)現(xiàn)：
Stream<?> EMPTY = create(
() -> {throw new IllegalStateException("當(dāng)前流已結(jié)束");},
() -> {throw new IllegalStateException("當(dāng)前流已結(jié)束");}
);
/**
* 獲取空流
*/
@SuppressWarnings("unchecked")
static <T> Stream<T> empty() {
return (Stream<T>) EMPTY;
}
/**
* 判斷當(dāng)前流是否結(jié)束
*/
default boolean end() {
return this == EMPTY;
}
有限流的生成
有限流可以通過(guò)多種方式生成，包括從數(shù)組生成、從迭代器生成、從集合生成。
從數(shù)組生成流
/**
* 從數(shù)組生成流
* @param arr 數(shù)組
* @param <T> 元素類(lèi)型
* @return 流
*/
@SafeVarargs
static <T> Stream<T> of(T... arr) {
return fromArray(0, arr);
}
/**
* 從數(shù)組和起始索引生成流
* @param startIndex 起始索引
* @param arr 數(shù)組
* @param <T> 元素類(lèi)型
* @return 流
*/
static <T> Stream<T> fromArray(int startIndex, T[] arr) {
return startIndex == arr.length
? empty()
: create(() -> arr[startIndex], () -> fromArray(startIndex + 1, arr));
}
從迭代器生成流
/**
* 從迭代器生成流
* @param iterator 迭代器
* @param <T> 元素類(lèi)型
* @return 流
*/
static <T> Stream<T> fromIterator(Iterator<T> iterator) {
return iterator.hasNext()
? create(iterator::next, () -> fromIterator(iterator))
: empty();
}
從集合生成流
/**
* 從集合生成流
* @param collection 集合
* @param <T> 元素類(lèi)型
* @return 流
*/
static <T> Stream<T> fromCollection(Collection<T> collection) {
return fromIterator(collection.iterator());
}
示例
Stream<Integer> s1 = Stream.of(1, 2, 3); // 從數(shù)組生成
Stream<Integer> s2 = Stream.fromIterator(List.of(1, 2, 3).iterator()); // 從迭代器生成
Stream<Integer> s3 = Stream.fromCollection(Set.of(1, 2, 3)); // 從集合生成
無(wú)限流的生成
無(wú)限流意味著流中的元素個(gè)數(shù)沒(méi)有限制，也就是永遠(yuǎn)都不會(huì)結(jié)束，所以end方法調(diào)用永遠(yuǎn)為false。有以下兩種方法生成無(wú)限流。
從工廠方法生成流
/**
* 從工廠方法生成流
* @param supplier 生成流中元素的工廠方法
* @param <T> 元素類(lèi)型
* @return 流
*/
static <T> Stream<T> fromSupplier(Supplier<T> supplier) {
return create(supplier, () -> fromSupplier(supplier));
}
從生成器生成流
/**
* 迭代生成流
* @param initial 初始值
* @param generator 生成器
* @param <T> 元素類(lèi)型
* @return 流
*/
static <T> Stream<T> fromGenerator(T initial, UnaryOperator<T> generator) {
return create(() -> initial, () -> generate(generator.apply(initial), generator));
}
示例
Stream<Integer> s1 = Stream.fromSupplier(() -> 1); // 無(wú)限個(gè)1組成的流
Stream<Integer> s2 = Stream.fromGenerator(1, n -> n + 1); // 全體自然數(shù)組成的流
遍歷流中的元素
知道了如何創(chuàng)建流，那么如何遍歷或輸出流中的元素呢？可以實(shí)現(xiàn)下面的forEach方法：
/**
* 遍歷流中所有元素
* @param consumer 遍歷操作
*/
default void forEach(Consumer<T> consumer) {
Stream<T> s = this;
while (!s.end()) {
consumer.accept(s.first());
s = s.remain();
}
}
然后就可以像下面這樣輸出流中的元素：
Stream<Integer> s = Stream.of(1, 2, 3, 4, 5);
s.forEach(System.out::println); // 輸出1 2 3 4 5
流的截?cái)嗪推?/h2>
上面的forEach方法只適用于有限流，如果在無(wú)限流上調(diào)用forEach方法，會(huì)導(dǎo)致死循環(huán)。所以，我們需要對(duì)無(wú)限流進(jìn)行截取操作，這樣就能做到遍歷無(wú)限流的一部分。
/**
* 截取流中前n個(gè)元素
* @param n 要截取的元素個(gè)數(shù)
* @return 流
*/
default Stream<T> limit(int n) {
return n <= 0 || end()
? empty()
: create(this::first, () -> remain().limit(n - 1));
}
/**
* 跳過(guò)流中的元素
* @param n 跳過(guò)的個(gè)數(shù)
* @return 流
*/
default Stream<T> skip(int n) {
return end() || n <= 0
? this
: remain().skip(n - 1);
}
limit用于提取流的前n個(gè)元素，skip用于忽略流的前n個(gè)元素，有了這兩個(gè)方法，我們就能隨心所欲地截取任何流中的任意一段。
流的變換操作
熟悉Java8 Stream API的讀者一定用過(guò)map和filter這兩個(gè)常用的流操作，下面我們就來(lái)實(shí)現(xiàn)它們。
map
map用于對(duì)流中的所有元素進(jìn)行轉(zhuǎn)換操作。
/**
* 映射流中的元素
* @param mapper 映射器
* @param <U> 映射后的元素類(lèi)型
* @return 流
*/
default <U> Stream<U> map(Function<T, U> mapper) {
return end()
? empty()
: create(() -> mapper.apply(first()), () -> remain().map(mapper));
}
filter
filter用于過(guò)濾流中的元素。
/**
* 過(guò)濾流中的元素
* @param predicate 斷言
* @return 流
*/
default Stream<T> filter(Predicate<T> predicate) {
if (end()) {
return empty();
}
T e = first();
if (predicate.test(e)) {
return Stream.create(() -> e, () -> remain().filter(predicate));
} else {
return remain().filter(predicate);
}
}
示例
Stream<String> s = Stream.of(1, 2, 3, 4, 5, 6)
.filter(n -> n % 2 == 0) // 2, 4, 6
.map(n -> "hello " + n); // hello 2, hello 4, hello 6
流的聚合操作
有時(shí)候我們像將整個(gè)流聚合成某種數(shù)據(jù)結(jié)構(gòu)，如列表、集合等，這就需要用到流的聚合操作。
collect
對(duì)流進(jìn)行自定義聚合操作。
/**
* 流的聚合操作
* @param initial 初始值
* @param accumulator 聚合操作
* @param <U> 聚合后的類(lèi)型
* @return 流
*/
default <U> U collect(U initial, BiFunction<U, T, U> accumulator) {
U result = initial;
Stream<T> s = this;
while (!s.end()) {
result = accumulator.apply(result, s.first());
s = s.remain();
}
return result;
}
toList
將流轉(zhuǎn)換成列表。
/**
* 將流轉(zhuǎn)換成列表
* @return 列表
*/
default List<T> toList() {
return collect(new ArrayList<>(), (list, e) -> {
list.add(e);
return list;
});
}
toSet
將流轉(zhuǎn)換成集合。
/**
* 將流轉(zhuǎn)換成集合
* @return 集合
*/
default Set<T> toSet() {
return collect(new HashSet<>(), (set, e) -> {
set.add(e);
return set;
});
}
toMap
將流轉(zhuǎn)換成Map。
/**
* 將流轉(zhuǎn)換成map
* @param keyGenerator key生成器
* @param valueGenerator value生成器
* @param <K> key的類(lèi)型
* @param <V> value的類(lèi)型
* @return map
*/
default <K, V> Map<K, V> toMap(Function<T, K> keyGenerator, Function<T, V> valueGenerator) {
return collect(new HashMap<>(), (map, e) -> {
map.put(keyGenerator.apply(e), valueGenerator.apply(e));
return map;
});
}
count
對(duì)流中的元素進(jìn)行計(jì)數(shù)。
/**
* 獲取流中元素個(gè)數(shù)
* @return 元素個(gè)數(shù)
*/
default int count() {
return collect(0, (cnt, e) -> cnt + 1);
}
流的高級(jí)操作
下面是流的一些高級(jí)操作。
concat
concat用于將兩個(gè)流首尾連接在一起。
/**
* 首尾連接兩個(gè)流
* s1[0] -> s1[1] -> s2[2] -> ... -> s2[0] -> s2[1] -> s2[2] -> ...
* @param s1 s1
* @param s2 s2
* @param <T> 元素類(lèi)型
* @return 流
*/
static <T> Stream<T> concat(Stream<T> s1, Stream<T> s2) {
return s1.end()
? s2
: create(s1::first, () -> concat(s1.remain(), s2));
}
/**
* 首尾連接兩個(gè)流
* @param s 要連接的流
* @return 流
*/
default Stream<T> concat(Stream<T> s) {
return concat(this, s);
}
示例：
Stream<Integer> s1 = Stream.of(1, 2, 3, 4);
Stream<Integer> s2 = Stream.of(5, 6, 7);
Stream<Integer> s = s1.concat(s2); // 1, 2, 3, 4, 5, 6, 7
interleave
interleave用于將兩個(gè)流交錯(cuò)連接在一起。
/**
* 交錯(cuò)連接兩個(gè)流
* s1[0] -> s2[0] -> s1[1] -> s2[1] -> ...
* @param s1 s1
* @param s2 s2
* @param <T> 元素類(lèi)型
* @return 流
*/
static <T> Stream<T> interleave(Stream<T> s1, Stream<T> s2) {
return s1.end()
? s2
: create(s1::first, () -> interleave(s2, s1.remain()));
}
/**
* 交錯(cuò)連接兩個(gè)流
* @param s 要連接的流
* @return 流
*/
default Stream<T> interleave(Stream<T> s) {
return interleave(this, s);
}
示例：
Stream<Integer> s1 = Stream.of(1, 3, 5, 7);
Stream<Integer> s2 = Stream.of(2, 4, 6);
Stream<Integer> s = s1.interleave(s2); // 1, 2, 3, 4, 5, 6, 7
flatMap
flatMap用于將流中的每個(gè)元素都映射成一個(gè)流，然后將所有流連接起來(lái)。
/**
* 扁平化流
* @param mapper 元素到流的映射器
* @param <U> 扁平化后的元素類(lèi)型
* @return 流
*/
default <U> Stream<U> flatMap(Function<T, Stream<U>> mapper) {
return collect(empty(), (s, e) -> s.concat(mapper.apply(e)));
}
示例：
Stream<Integer> s = Stream.of(10, 20)
.flatMap(n -> Stream.of(n + 1, n + 2, n + 3)); // 11, 12, 13, 21, 22, 23
