Java8中Stream相关API介绍以及Lambda表达式使用_java8 api

一、关于流

什么是流？

流是Java8引入的全新概念，它用来处理集合中的数据，暂且可以把它理解为一种高级集合。
众所周知，集合操作非常麻烦，若要对集合进行筛选、投影，需要写大量的代码，而流是以声明的形式操作集合，它就像SQL语句，我们只需告诉流需要对集合进行什么操作，它就会自动进行操作，并将执行结果交给你，无需我们自己手写代码。
因此，流的集合操作对我们来说是透明的，我们只需向流下达命令，它就会自动把我们想要的结果给我们。由于操作过程完全由Java处理，因此它可以根据当前硬件环境选择最优的方法处理，我们也无需编写复杂又容易出错的多线程代码了。

流的特点

1. 只能遍历一次
   我们可以把流想象成一条流水线，流水线的源头是我们的数据源(一个集合)，数据源中的元素依次被输送到流水线上，我们可以在流水线上对元素进行各种操作。
   一旦元素走到了流水线的另一头，那么这些元素就被“消费掉了”，我们无法再对这个流进行操作。当然，我们可以从数据源那里再获得一个新的流重新遍历一遍。
2. 采用内部迭代方式
   若要对集合进行处理，则需我们手写处理代码，这就叫做外部迭代。
   而要对流进行处理，我们只需告诉流我们需要什么结果，处理过程由流自行完成，这就称为内部迭代。

流的操作种类

流的操作分为两种，分别为中间操作和终端操作。

1. 中间操作
   当数据源中的数据上了流水线后，这个过程对数据进行的所有操作都称为“中间操作”。
   中间操作仍然会返回一个流对象，因此多个中间操作可以串连起来形成一个流水线。
2. 终端操作
   当所有的中间操作完成后，若要将数据从流水线上拿下来，则需要执行终端操作。
   终端操作将返回一个执行结果，这就是你想要的数据。

流的操作过程

使用流一共需要三步：

1. 准备一个数据源
2. 执行中间操作
   中间操作可以有多个，它们可以串连起来形成流水线。
3. 执行终端操作
   执行终端操作后本次流结束，你将获得一个执行结果。

二、Stream 接口一览

List 转 Stream

// 转stream
list.stream()

// 并发处理
list.parallelStream()
1
2
3
4
5

filter（过滤）

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

map（元素转换）

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

IntStream mapToInt(ToIntFunction<? super T> mapper);

LongStream mapToLong(ToLongFunction<? super T> mapper);

DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper);
1
2
3
4
5
6
7

flatMap（元素转换）

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

IntStream flatMapToInt(Function<? super T, ? extends IntStream> mapper);

LongStream flatMapToLong(Function<? super T, ? extends LongStream> mapper);

DoubleStream flatMapToDouble(Function<? super T, ? extends DoubleStream> mapper);
1
2
3
4
5
6
7

distinct（去除重复，对象需要重写 equals、hashCode）

Stream<T> distinct();
1

sorted（排序）

Stream<T> sorted();

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

peek（生成新的流：流是单向的，例如用于日志打印）

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

limit（取前面 n 个元素）

Stream<T> limit(long maxSize);
1

skip（跳过 n 个元素）

Stream<T> skip(long n);
1

forEach（遍历）

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

void forEachOrdered(Consumer<? super T> action);
1
2
3

toArray（转换成数组）

Object[] toArray();
<A> A[] toArray(IntFunction<A[]> generator);
1
2

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);
1
2
3
4
5
6
7

collect（转换成集合）

<R> R collect(Supplier<R> supplier,
             BiConsumer<R, ? super T> accumulator,
             BiConsumer<R, R> combiner);

<R, A> R collect(Collector<? super T, A, R> collector);
1
2
3
4
5

转list

// 转list
Collectors.toList();

// 转set
Collectors.toSet();

// 转map
List<TestVo> testList = new ArrayList<>(10);

Map<Long, TestVo> data = releaseList.stream()
       .collect(Collectors.toMap(TestVo::getId, x -> x));
1
2
3
4
5
6
7
8
9
10
11

count（计数）

long count();
1

查找

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

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

boolean noneMatch(Predicate<? super T> predicate);
1
2
3
4
5

查找

Optional<T> findFirst();

Optional<T> findAny();
1
2
3

三、最佳实践具体使用案例

点击以下蓝色字体链接查看：

java8中stream流api具体使用案例