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-創建流的幾種方式》