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