3-java8 Stream接口简介_ 股票程序化软件自动交易接口

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

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

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();

	}
}