Java8新特性(Stream)

上期我们分析了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内置了获取流的方法,分别为串行流与并行流

1
2
3
4
5
6
7
default Stream<E> stream() {
return StreamSupport.stream(spliterator(), false);
}
default Stream<E> parallelStream() {
return StreamSupport.stream(spliterator(), true);
}

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

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
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:过滤
1
Stream<T> filter(Predicate<? super T> predicate);

filter

  • distinct:去除重复元素(通过equals和hashCode)
1
Stream<T> distinct();

distinct

  • limit:限制数量
1
Stream<T> limit(long maxSize);

limit

  • skip:跳过
1
Stream<T> skip(long n);

skip

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

2、映射

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

map

  • mapToInt
  • mapToLong
  • mapToDouble

  • flatMap

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

flatMap

  • flatMapToInt
  • flatMapToLong
  • flatMapToDouble

3、排序

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

4、包装

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

peek

终止操作

查找与匹配

  • allMatch:检查是否匹配所有元素
1
boolean allMatch(Predicate<? super T> predicate);
  • anyMatch:检查是否至少匹配一个元素
1
boolean anyMatch(Predicate<? super T> predicate);
  • noneMatch:检查是否没有匹配所有元素
1
boolean noneMatch(Predicate<? super T> predicate);
  • findFirst:返回第一个元素
1
Optional<T> findFirst();
  • findAny:返回当前流中的任意元素
1
Optional<T> findAny();
  • count:返回流中元素总数
1
long count();
  • max:返回流中最大值
1
Optional<T> max(Comparator<? super T> comparator);
  • min:返回流中最小值
1
Optional<T> min(Comparator<? super T> comparator);
  • forEach:内部迭代
1
void forEach(Consumer<? super T> action);

规约

  • reduce
1
2
3
4
5
6
7
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
1
2
3
4
5
<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静态方法
1
2
3
4
5
6
7
8
9
10
11
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中串行流与并行流的性能

坚持原创技术分享,您的支持将鼓励我继续创作!