Java8新特性系列(Stream)

题图:by pixel2013 From pixabay

上期我们分析了Java8中的引用,本期我们将分析Java8中的另一个重要的新特性:流Stream。
本文图片转载自并发编程网

Stream是什么?

在Java8源代码中,是这么定义Stream的:

A sequence of elements supporting sequential and parallel aggregate operations.

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

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

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

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

几个注意点:

    1. Stream自己不会存储元素。
    1. Stream不会改变原对象。相反,他们会返回一个持有结果的新Stream。
    1. 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);
filter
  • distinct:去除重复元素(通过equals和hashCode)
Stream<T> distinct();
distinct
  • limit:限制数量
Stream<T> limit(long maxSize);
limit
  • skip:跳过
Stream<T> skip(long n);
skip

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

2、映射

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

  • mapToLong

  • mapToDouble

  • flatMap

<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);
flatMap
  • flatMapToInt
  • flatMapToLong
  • flatMapToDouble

3、排序

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

4、包装

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

终止操作

查找与匹配

  • 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中串行流与并行流的性能

最后编辑于
©著作权归作者所有,转载或内容合作请联系作者
平台声明:文章内容(如有图片或视频亦包括在内)由作者上传并发布,文章内容仅代表作者本人观点,简书系信息发布平台,仅提供信息存储服务。