Stream - Stream（一） - 《Java 语言基础》

Stream 关于流
Stream API

Stream 关于流

什么是流？

流是Java8引入的全新概念，它用来处理集合中的数据，暂且可以把它理解为一种高级集合。

众所周知，集合操作非常麻烦，若要对集合进行筛选、投影，需要写大量的代码，而流是以声明的形式操作集合，它就像SQL语句，我们只需告诉流需要对集合进行什么操作，它就会自动进行操作，并将执行结果交给你，无需我们自己手写代码。

因此，流的集合操作对我们来说是透明的，我们只需向流下达命令，它就会自动把我们想要的结果给我们。由于操作过程完全由Java处理，因此它可以根据当前硬件环境选择最优的方法处理，我们也无需编写复杂又容易出错的多线程代码了。

流的特点

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

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

流的操作过程
使用流一共需要三步：
准备一个数据源
执行中间操作中间操作可以有多个，它们可以串连起来形成流水线。
执行终端操作执行终端操作后本次流结束，你将获得一个执行结果。

Stream API

List 转 Stream

// 转stream
list.stream()
// 并发处理
list.parallelStream()

filter（过滤）

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

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

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

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

Stream<T> distinct();

sorted（排序）

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

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

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

limit（取前面 n 个元素）

Stream<T> limit(long maxSize);

skip（跳过 n 个元素）

Stream<T> skip(long n);

forEach（遍历）

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

toArray（转换成数组）

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

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> R collect(Supplier<R> supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R, R> combiner);
<R, A> R collect(Collector<? super T, A, R> collector);

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

count（计数）

long count();

查找

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

查找

Optional<T> findFirst();
Optional<T> findAny();

Stream（一）