java8 Stream接口简介

原創

2020-02-21 23:13

首先我们先来认识下一个的接口的意思，流是什么？

流是java API中的新的成员，它可以让你用声明式的方式处理集合，简单点说，可以看成遍历数据的一个高级点的迭代器，也可以看做一个工厂，数据处理的工厂，当然，流还天然的支持并行操作；也就不用去写复杂的多线程的代码，下面我先来看下stream的接口定义

public interface Stream<T> extends BaseStream<T, Stream<T>> {
 
    Stream<T> filter(Predicate<? super T> predicate);
 
    <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);
 
    <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);
 
    Stream<T> distinct();
 
    Stream<T> sorted();
 
    Stream<T> sorted(Comparator<? super T> comparator);
 
    Stream<T> peek(Consumer<? super T> action);
 
    Stream<T> limit(long maxSize);
 
    Stream<T> skip(long n);
 
    void forEach(Consumer<? super T> action);
 
    void forEachOrdered(Consumer<? super T> action);
 
    Object[] toArray();
 
    <A> A[] toArray(IntFunction<A[]> generator);
 
    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);
 
    <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);
 
    Optional<T> min(Comparator<? super T> comparator);
 
    Optional<T> max(Comparator<? super T> comparator);
 
    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();
 
    public static <T> Builder<T> builder() {
        return new Streams.StreamBuilderImpl<>();
    }
 
    public static <T> Stream<T> empty() {
        return StreamSupport.stream(Spliterators.<T> emptySpliterator(), false);
    }
 
    public static <T> Stream<T> of(T t) {
        return StreamSupport.stream(new Streams.StreamBuilderImpl<>(t), false);
    }
 
    @SafeVarargs
    @SuppressWarnings("varargs") // Creating a stream from an array is safe
    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);
    }
 
    public static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b) {
        Objects.requireNonNull(a);
        Objects.requireNonNull(b);
 
        @SuppressWarnings("unchecked")
        Spliterator<T> split = new Streams.ConcatSpliterator.OfRef<>((Spliterator<T>) a.spliterator(),
                (Spliterator<T>) b.spliterator());
        Stream<T> stream = StreamSupport.stream(split, a.isParallel() || b.isParallel());
        return stream.onClose(Streams.composedClose(a, b));
    }
 
    public interface Builder<T> extends Consumer<T> {
        @Override
        void accept(T t);
 
        default Builder<T> add(T t) {
            accept(t);
            return this;
        }
 
        Stream<T> build();
 
    }
}

通过接口定义，可以看到，抽象方法，有30多个，里面还有一些其他的接口；后续，我会慢慢给大家介绍，每个抽象方法的作用，以及用法

1.lambda表达式
《java8 Lambda表达式简介》

《java8 lambda表达式，方法的引用以及构造器的引用》

2.函数式接口
《java8 函数式接口简介》

《JAVA8 Function接口以及同类型的特化的接口》

《JAVA8 Consumer接口》

《JAVA8 Supplier接口》

《JAVA8 UnaryOperator接口》

《JAVA8 BiConsumer 接口》

3.stream接口操作

《java8 Stream接口简介》

《 java8 Stream-创建流的几种方式》