码上论剑 | Java8新特性系列（Stream）

点击上方“中兴开发者社区”，关注我们

 每天读一篇一线开发者原创好文

▍内容来自公众号“码上论剑”。

“码上论剑”分享Java相关技术干货及实践，内容原创，欢迎关注，获取更多精彩内容！

作者简介：

作者史培培,主要关注Java以及云计算方向。插科打诨于前端，后端，产品工程师之间；在现实中分层抽象，在Bug的坟头上蹦迪；常于Github海岸边拾捡贝壳，沾沾自喜；用Java可倚天屠龙，用Shell则庖丁解牛；

常修程序员之道，常读Man文档。欢迎关注我的公众号“码上论剑”，获取更多内容。

上期我们分析了Java8中的引用:Java8新特性系列（引用），本期我们将分析Java8中的另一个重要的新特性：流Stream。

Stream是什么？

在Java8源代码中，是这么定义Stream的：

A sequence of elements supporting sequential and parallel aggregate operations.

简单翻译就是流是支持顺序和并行的汇聚操作的一组元素。

从这个定义上来说，Stream可以说是一个高级版本的Iterator，Iterator只能一个一个遍历元素从而对元素进行操作，但是Stream可以执行非常复杂的查找、过滤和映射数据等操作，并且中间操作可以一直迭代。

Collections是存储元素，Stream是计算。

Stream可以理解为一个管道（Pipeline），数据从管道的一边进入，经过中间各种处理，然后从管道的另一边出来新的数据。

几个注意点：

i.Stream不会自己存储元素

i.Stream不会改变原对象。相反，他们会返回一个持有结果的新Stream。

i.Stream操作是延迟执行。这意味着他们会等到需要结果的时候才执行。

Stream的pipeline

 创建Stream

 中间操作：一个中间操作链，对数据源数据进行处理，但是是延迟执行的

 终止操作：执行中间操作链，并产生结果，正如上面注意点3

创建Stream

1、java.util.Collection内置了获取流的方法，分别为串行流与并行流

default Stream<E> stream() {    
    return StreamSupport.stream(spliterator(), false);
}
default Stream<E> parallelStream() {    
    return StreamSupport.stream(spliterator(), true);
}

2、java.util.Arrays内置了获取流的方法

public static <T> Stream<T> stream(T[] array) {    
    return stream(array, 0, array.length);
}

3、java.util.stream.Stream内置了创建流的方法，分别为通过对象创建流和通过函数创建流

public static<T> Stream<T> of(T t) {    
    return StreamSupport.stream(new Streams.StreamBuilderImpl<>(t), false);
}
public static<T> Stream<T> of(T... values) {    
    return Arrays.stream(values);
}
public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f) {
    Objects.requireNonNull(f);    
    final Iterator<T> iterator = new Iterator<T>() {        
        @SuppressWarnings("unchecked")
        T t = (T) Streams.NONE;        
        @Override
        public boolean hasNext() {            
            return true;
        }        
        @Override
        public T next() {            
            return t = (t == Streams.NONE) ? seed : f.apply(t);
        }
    };    
    return StreamSupport.stream(Spliterators.spliteratorUnknownSize(iterator, Spliterator.ORDERED | Spliterator.IMMUTABLE), false);
}
public static<T> Stream<T> generate(Supplier<T> s) {
    Objects.requireNonNull(s);    
    return StreamSupport.stream(new StreamSpliterators.InfiniteSupplyingSpliterator.OfRef<>(Long.MAX_VALUE, s), false);
}

中间操作（java.util.stream.Stream）

1、截断与切片

filter：过滤

Stream<T> filter(Predicate<? super T> predicate);

distinct：去除重复元素（通过equals和hashCode）

Stream<T> distinct();

limit：限制数量

Stream<T> limit(long maxSize);

skip：跳过

Stream<T> skip(long n);

是不是有点类似SQL语句呢？

2、映射

map

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

mapToInt

mapToLong

mapToDouble

flatMap

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

flatMapToInt

flatMapToLong

flatMapToDouble

3、排序

sorted

Stream<T> sorted();Stream<T> sorted(Comparator<? super T> comparator);

4、包装

peek

Stream<T> peek(Consumer<? super T> action);

终止操作

查找与匹配

allMatch：检查是否匹配所有元素

boolean allMatch(Predicate<? super T> predicate);

anyMatch：检查是否至少匹配一个元素

boolean anyMatch(Predicate<? super T> predicate);

noneMatch：检查是否没有匹配所有元素

boolean noneMatch(Predicate<? super T> predicate);

findFirst：返回第一个元素

Optional<T> findFirst();

findAny：返回当前流中的任意元素

Optional<T> findAny();

count：返回流中元素总数

long count();

max：返回流中最大值

Optional<T> max(Comparator<? super T> comparator);

min：返回流中最小值

Optional<T> min(Comparator<? super T> comparator);

forEach：内部迭代

void forEach(Consumer<? super T> action);

规约

reduce

T reduce(T identity, BinaryOperator<T> accumulator);Optional<T> reduce(BinaryOperator<T> accumulator);

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

收集

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);

Collectors静态方法

List<T> toList()Set<T> toSet()Collection<T> toCollection
Long counting
Integer summingInt
Double averagingInt
IntSummaryStatistics summarizingInt
String joining
Optional<T> maxBy
Optional<T> minBy
...

Stream是不是很方便呢？
下期我们将测试下Stream中串行流与并行流的性能