java8 Stream接口简介

ゝ一纸荒年。 2021-09-26 21:18 250阅读 0赞

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

流是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]

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

### 2.函数式接口 ###

[《java8 函数式接口简介》][java8]

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

[《JAVA8 Consumer接口》][JAVA8 Consumer]

[《JAVA8 Supplier接口》][JAVA8 Supplier]

[《JAVA8 UnaryOperator接口》][JAVA8 UnaryOperator]

[《JAVA8 BiConsumer 接口》][JAVA8 BiConsumer]

3.stream接口操作

[《java8 Stream接口简介》][java8 Stream]

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

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

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

[《JAVA8 stream接口 distinct，sorted，peek，limit，skip》][JAVA8 stream_ distinct_sorted_peek_limit_skip]

[《java8 stream接口 终端操作 forEachOrdered和forEach》][java8 stream_ _ forEachOrdered_forEach]

[《java8 stream接口 终端操作 toArray操作》][java8 stream_ _ toArray]

[《java8 stream接口 终端操作 min，max，findFirst，findAny操作》][java8 stream_ _ min_max_findFirst_findAny]

[《java8 stream接口终端操作 count，anyMatch，allMatch，noneMatch》][java8 stream_ _ min_max_findFirst_findAny]

[《java8 srteam接口终端操作reduce操作》][java8 srteam_reduce]

[《java8 stream接口 终端操作 collect操作》][java8 stream_ _ collect]

4.其他部分

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

[java8 Lambda]: https://blog.csdn.net/qq_28410283/article/details/80961022
[java8 lambda]: https://blog.csdn.net/qq_28410283/article/details/80963351
[java8]: https://blog.csdn.net/qq_28410283/article/details/80962325
[JAVA8 Function]: https://blog.csdn.net/qq_28410283/article/details/80615629
[JAVA8 Consumer]: https://blog.csdn.net/qq_28410283/article/details/80618456
[JAVA8 Supplier]: https://blog.csdn.net/qq_28410283/article/details/80625482
[JAVA8 UnaryOperator]: https://blog.csdn.net/qq_28410283/article/details/80634319
[JAVA8 BiConsumer]: https://blog.csdn.net/qq_28410283/article/details/80704487
[java8 Stream]: https://blog.csdn.net/qq_28410283/article/details/80633292
[java8 Stream-]: https://blog.csdn.net/qq_28410283/article/details/80633710
[JAVA8 stream_]: https://blog.csdn.net/qq_28410283/article/details/80634725
[JAVA8 Stream_map_filter_flatMap]: https://blog.csdn.net/qq_28410283/article/details/80642786
[JAVA8 stream_ distinct_sorted_peek_limit_skip]: https://blog.csdn.net/qq_28410283/article/details/80643711
[java8 stream_ _ forEachOrdered_forEach]: https://blog.csdn.net/qq_28410283/article/details/80782808
[java8 stream_ _ toArray]: https://blog.csdn.net/qq_28410283/article/details/80783286
[java8 stream_ _ min_max_findFirst_findAny]: https://blog.csdn.net/qq_28410283/article/details/80783946
[java8 srteam_reduce]: https://blog.csdn.net/qq_28410283/article/details/80873910
[java8 stream_ _ collect]: https://blog.csdn.net/qq_28410283/article/details/81052881
[java8 Optional]: https://blog.csdn.net/qq_28410283/article/details/80952768