上一篇我們介紹了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實戰》的第五章，我也就直接拿來使用了，不再去單獨整理
先介紹到這裏，我們下一篇開始，介紹流的中間操作的方法
1.lambda表達式
《java8 Lambda表達式簡介》
《java8 lambda表達式，方法的引用以及構造器的引用》
2.函數式接口
《java8 函數式接口簡介》
3.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 stream接口 終端操作 collect操作》
4.其他部分
