java8 Stream接口简介

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

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

public interface Stream extends BaseStream> {

	Stream filter(Predicate predicate);

	 Stream map(Function mapper);

	IntStream mapToInt(ToIntFunction mapper);

	LongStream mapToLong(ToLongFunction mapper);

	DoubleStream mapToDouble(ToDoubleFunction mapper);

	 Stream flatMap(Function> mapper);

	IntStream flatMapToInt(Function mapper);

	LongStream flatMapToLong(Function mapper);

	DoubleStream flatMapToDouble(Function mapper);

	Stream distinct();

	Stream sorted();

	Stream sorted(Comparator comparator);

	Stream peek(Consumer action);

	Stream limit(long maxSize);

	Stream skip(long n);

	void forEach(Consumer action);

	void forEachOrdered(Consumer action);

	Object[] toArray();

	 A[] toArray(IntFunction generator);

	T reduce(T identity, BinaryOperator accumulator);

	Optional reduce(BinaryOperator accumulator);

	 U reduce(U identity, BiFunction accumulator, BinaryOperator combiner);

	 R collect(Supplier supplier, BiConsumer accumulator, BiConsumer combiner);

	 R collect(Collector collector);

	Optional min(Comparator comparator);

	Optional max(Comparator comparator);

	long count();

	boolean anyMatch(Predicate predicate);

	boolean allMatch(Predicate predicate);

	boolean noneMatch(Predicate predicate);

	Optional findFirst();

	Optional findAny();

	public static  Builder builder() {
		return new Streams.StreamBuilderImpl<>();
	}

	public static  Stream empty() {
		return StreamSupport.stream(Spliterators. emptySpliterator(), false);
	}

	public static  Stream of(T t) {
		return StreamSupport.stream(new Streams.StreamBuilderImpl<>(t), false);
	}

	@SafeVarargs
	@SuppressWarnings("varargs") // Creating a stream from an array is safe
	public static  Stream of(T... values) {
		return Arrays.stream(values);
	}

	public static  Stream iterate(final T seed, final UnaryOperator f) {
		Objects.requireNonNull(f);
		final Iterator iterator = new Iterator() {
			@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  Stream generate(Supplier s) {
		Objects.requireNonNull(s);
		return StreamSupport.stream(new StreamSpliterators.InfiniteSupplyingSpliterator.OfRef<>(Long.MAX_VALUE, s),
				false);
	}

	public static  Stream concat(Stream a, Stream b) {
		Objects.requireNonNull(a);
		Objects.requireNonNull(b);

		@SuppressWarnings("unchecked")
		Spliterator split = new Streams.ConcatSpliterator.OfRef<>((Spliterator) a.spliterator(),
				(Spliterator) b.spliterator());
		Stream stream = StreamSupport.stream(split, a.isParallel() || b.isParallel());
		return stream.onClose(Streams.composedClose(a, b));
	}

	public interface Builder extends Consumer {
		@Override
		void accept(T t);

		default Builder add(T t) {
			accept(t);
			return this;
		}

		Stream 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静态类简介，以及用法》