java8 Stream接口简介

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

流是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-创建流的几种方式》

《JAVA8 stream接口 中间操作和终端操作》

《JAVA8 Stream接口，map操作，filter操作，flatMap操作》

《JAVA8 stream接口 distinct，sorted，peek，limit，skip》

《java8 stream接口 终端操作 forEachOrdered和forEach》

《java8 stream接口 终端操作 toArray操作》

《java8 stream接口 终端操作 min，max，findFirst，findAny操作》

《java8 stream接口终端操作 count，anyMatch，allMatch，noneMatch》

《java8 srteam接口终端操作reduce操作》

《java8 stream接口 终端操作 collect操作》

4.其他部分

《java8 Optional静态类简介，以及用法》