上一篇我們介紹了stream的集中建立方式，《 java8 Stream-建立流的幾種方式》，從這篇開始，我們開始介紹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();

	}
}
 

通過抽象方法的定義，我們可以看到，這個方法，可以分成兩種型別，一種返回型別為介面本身的Stream<T>，另外一種是返回其他物件型別的，返回介面型別的，我們稱這些方法為中間操作，返回其他具體型別的，我們稱為終端操作；

中間操作，是什麼操作? 我們先看下字串操作StringBuilder的append的方法

 @Override
    public StringBuilder append(String str) {
        super.append(str);
        return this;
    }

對，就是這樣，返回物件本身；然後我們就可以像操作StringBuilder的append一樣，可以連線操作；

StringBuilder sb = new StringBuilder();
		sb.append("a").append("b").append("c");

終端操作，是指返回最終的結果，例如我們常用的forEach，內部迭代；

下面附一張具體的分類的圖，這個圖，來自《java8實戰》的第五章，我也就直接拿來使用了，不再去單獨整理

先介紹到這裡，我們下一篇開始，介紹流的中間操作的方法