JAVA 8 Stream

1. Stream简介

Stream流可以让我们以一种声明的方式处理数据，强调“做什么而非怎么做”，Stream具有如下三个特征：

• Stream不存储数据；
• Stream不改变源数据；
• 延迟执行；

注意：Stream的操作分为中间操作和终结操作，中间操作返回流对象本身，多个中间操作可以串联成管道；终结操作是将流约简为可以在程序中使用的非流值，一个流只能有一次终结操作，已进行终结操作的流不可以再继续使用了。

2. 流的创建

java.util.stream.Stream
	//产生一个元素为给定值的流。
    static <T> Stream<T> of(T ... values)
    
    //产生一个不包含任何元素的流。
    static <T> Stream<T> empty()
    
    //产生一个无限流，他的值是通过反复调用函数s而构建的。
    static <T> Stream<T> generate(Supplier<T> s)
    
    //产生一个无限流，它的元素包含种子、在种子上调用f产生的值、在前一个元素上调用f产生的值。 
    static <T> Stream<T> iterate(T seed, UnaryOperator<T> f)
    
java.util.Arrays
	//产生一个流，它的元素是由数组中指定范围内的元素构成的。
    static <T> Stream<T> stream(T[] array, int startInclusive, int endExclusive)
        
java.util.regex.Pattern
	//产生一个流，它的元素是输入中由该模式界定的部分。
    Stream<String> splitAsStream(CharSequence input)
        
java.nio.file.Files
	//产生一个流，它的元素是指定文件中的行，该文件的字符集为UTF-8，或者为指定的字符集。
    static Stream<String> lines(Path path)
    static Stream<String> lines(Path path, Charset cs)

java.util.stream.Stream
	//产生一个流，它包含当前流中所有满足断言条件的元素。
    Stream<T> filter(Predicate<? super T> predicate)
    
    //使用一个断言作为参数，返回给定Stream的子集直到断言语句第一次返回false。如果第一个值不满足断言条件，将返回一个空的 Stream。此方法和filter的区别在于当断言返回false后将不再过滤，即使后面还以符合条件的元素也全部丢弃。注意：此方法只在JAVA 9 及更高版本才有。
    Stream<T> takeWhile(Predicate<? super T> predicate)
    
    //和上面的takeWhile正好相反，此方法只在JAVA 9 及更高版本才有。
    Stream<T> dropWhile(Predicate<? super T> predicate)
    
    //产生一个流，它包含将mapper应用于当前流中所有元素所产生的结果。
    <R> Stream<R> map(Function<? super T, ? extends R> mapper)
    
    //产生一个流，它是通过将mapper应用于当前流中所有元素所产生的结果连接到一起而获得的。
    <R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper)

3. 流的转换

java.util.stream.Stream
	//产生一个流，在maxSize个元素之后结束，如果当前流长度不足，则在当前流结束时结束。
    Stream<T> limit(long maxSize)
    
    //产生一个流，它的元素是当前流中除了前n个元素之外的所有元素。
    Stream<T> skip(long n)
    
    //将两个流a和b连接起来。注意：第一个流不应该是无限流，否则第二个流永远都不会被宠幸。
    static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)
    
    //去重。
    Stream<T> distinct()
    
    //排序。
    Stream<T> sorted()
    
    //排序。
    Stream<T> sorted(Comparator<? super T> comparator)
    
    //产生一个流，它与当前流中的元素相同，在获取其中每个元素时，会将其传递给action。
    Stream<T> peek(Consumer<? super T> action)

4. 流的终结操作

java.util.stream.Stream
	//获取当前流的最大元素并包装成Optional，如果当前流为空，则返回空Optional。
    Optional<T> max(Comparator<? super T> comparator)
        
    //获取当前流的最小元素并包装成Optional，如果当前流为空，则返回空Optional。
    Optional<T> min(Comparator<? super T> comparator)
    
    //获取当前流的第一个元素并包装成Optional，如果当前流为空，则返回空Optional。
    Optional<T> findFirst()
    
    //获取当前流的任意一个元素并包装成Optional，如果当前流为空，则返回空Optional，注意：此方法返回的元素并非流中的随机元素，在特定的流中，返回的结果永远都是那一个固定元素。
    Optional<T> findAny()
    
    //任意元素匹配指定断言则返回true。
    boolean anyMatch(Predicate<? super T> predicate)
    
    //所有元素匹配指定断言则返回true。
    boolean allMatch(Predicate<? super T> predicate)
    
    //没有元素匹配指定断言则返回true。
    boolean noneMatch(Predicate<? super T> predicate)

5. 收集结果

java.util.stream.BaseStream
	//获取当前流中各个元素的迭代器。
    Iterator<T> iterator()
        
java.util.stream.Stream
	//在当前流的每个元素上调用指定Consumer。
    void forEach(Consumer<? super T> action)
    
    //生成当前流元素的对象数组。 
    Object[] toArray()
    
    //产生一个指定类型的对象数组。
    <A> A[] toArray(IntFunction<A[]> generator)
   
    //使用给定的收集器来收集当前流中的元素。Collectors类有用于多种收集器的工厂方法。
    <R, A> R collect(Collector<? super T, A, R> collector)
        
java.util.stream.Collectors
	//产生一个将元素收集到List的集合器。
    static <T> Collector<T, ?, List<T>> toList()
    
    //产生一个将元素收集到Set的集合器。
    static <T> Collector<T, ?, Set<T>> toSet()
    
    //产生一个将元素收集到任意集合中的收集器。
    static <T, C extends Collection<T>> Collector<T, ?, C> toCollection(Supplier<C> collectionFactory)
    
    //产生一个连接字符串的收集器，分隔符会置于字符串之间，可以有前缀和后缀。
    static Collector<CharSequence, ?, String> joining()
    static Collector<CharSequence, ?, String> joining(CharSequence delimiter)
    static Collector<CharSequence, ?, String> joining(CharSequence delimiter, CharSequence prefix, CharSequence suffix)
    
    static <T> Collector<T, ?, IntSummaryStatistics> summarizingInt(ToIntFunction<? super T> mapper)
    static <T> Collector<T, ?, LongSummaryStatistics> summarizingLong(ToLongFunction<? super T> mapper)
    static <T> Collector<T, ?, DoubleSummaryStatistics> summarizingDouble(ToDoubleFunction<? super T> mapper)
    
IntSummaryStatistics
    long getCount()
    int getSum()
    double getAverage()
    int getMax()
    int getMin()
    
LongSummaryStatistics
    long getCount()
    long getSum()
    double getAverage()
    long getMax()
    long getMin()
    
DoubleSummaryStatistics
    long getCount()
    double getSum()
    double getAverage()
    double getMax()
    double getMin()

6. 收集到映射表

java.util.Stream.Collectors
    static <T, K, U> Collector<T, ?, Map<K, U>> toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper)
    static <T, K, U> Collector<T, ? Map<K, U>> toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper, BinaryOperator<U> mergeFunction)
    static <T, K, U, M extends Map<K, U>> Collector<T, ?, M> toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper, BinaryOperator<U> mergeFunction, Supplier<M> mapSupplier)
    static <T, K, U> Collector<T, ?, ConcurrentMap<K, U>> toConcurrentMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper)
    static <T, K, U> Collector<T, ? ConcurrentMap<K, U>> toConcurrentMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper, BinaryOperator<U> mergeFunction)
    static <T, K, U, M extends ConcurrentMap<K, U>> Collector<T, ?, M> toConcurrentMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper, BinaryOperator<U> mergeFunction, Supplier<M> mapSupplier)

7. 群组和区分

java.util.stream.Collectors
    static <T, K> Collector<T, ?, Map<K, List<T>>> groupingBy(Function<? super T, ? extends K> classifier)
    static <T, K, A, D> groupingBy(Function<? super T, ? extends K> classifier, Collector<? super T, A, D> downStream)
    static <T, K, D, A, M extends Map<K, D>> groupingBy(Function<? super T, ? extends k> classifier, Supplier<M> mapFactory, Collector<? super T, A, D> downStream)
    static <T, K> Collector<T, ?, ConcurrentMap<K, List<T>>> groupingByConcurrent(Function<? super T, ? extends K> classifier)
    
	//产生一个收集器，它会产生一个映射表，其键是true/false，而值是由满足/不满足断言的元素构成的列表。
    static <T> Collector<T, >, Map<Boolean, List<T>>> partitioningBy(Predicate<? super t> prediate)

8. 待续