Java8-Stream collect

原创 2016年08月31日 16:35:59
package lambda;

import java.util.Arrays;
import java.util.List;
import java.util.SortedSet;
import java.util.TreeSet;
import java.util.stream.Collectors;

public class StreamCollectExam {
    public static void collectExam1() {
        List<String> numbers = Arrays.asList("1", "2", "3", "4", "1", "2", "7", "8");

        // [1, 2, 3, 4, 7, 8]
        SortedSet<String> uniqueSortedNumbers = numbers.stream().collect(Collectors.toCollection(TreeSet::new));
        System.out.println(uniqueSortedNumbers);

        // [1, 2, 3, 4, 1, 2, 7, 8]
        List<String> listNumbers = numbers.stream().collect(Collectors.toList());
        System.out.println(listNumbers);
    }

    /**
     * The combiner is used only in a parallel stream.
     */
    public static void collectExam2() {
        List<String> numbers = Arrays.asList("1", "2", "3", "4", "5", "6", "7", "8");
        /**
         * print result:
         in supplier, create a StringBuilder
         in peek,param=1
         in accumulator,param=1,result[before]=,result[after]=1
         in peek,param=2
         in accumulator,param=2,result[before]=1,result[after]=12
         in peek,param=3
         in accumulator,param=3,result[before]=12,result[after]=123
         in peek,param=4
         in accumulator,param=4,result[before]=123,result[after]=1234
         in peek,param=5
         in accumulator,param=5,result[before]=1234,result[after]=12345
         in peek,param=6
         in accumulator,param=6,result[before]=12345,result[after]=123456
         in peek,param=7
         in accumulator,param=7,result[before]=123456,result[after]=1234567
         in peek,param=8
         in accumulator,param=8,result[before]=1234567,result[after]=12345678
         streamNumbers=12345678
         */
        StringBuilder streamNumbers = numbers.stream().peek(StreamCollectExam::peek)
                .collect(StreamCollectExam::supplier, StreamCollectExam::accumulator, StreamCollectExam::combiner);
        System.out.println("streamNumbers=" + streamNumbers);
        System.out.println("-------------------------");

        /**
         * print result:
         in supplier, create a StringBuilder
         in peek,param=5
         in accumulator,param=5,result[before]=,result[after]=5
         in peek,param=6
         in accumulator,param=6,result[before]=5,result[after]=56
         in supplier, create a StringBuilder
         in peek,param=7
         in accumulator,param=7,result[before]=,result[after]=7
         in peek,param=8
         in accumulator,param=8,result[before]=7,result[after]=78
         in combiner,additional=78,result[before]=56,result[after]=5678
         in supplier, create a StringBuilder
         in peek,param=3
         in accumulator,param=3,result[before]=,result[after]=3
         in peek,param=4
         in accumulator,param=4,result[before]=3,result[after]=34
         in supplier, create a StringBuilder
         in peek,param=1
         in accumulator,param=1,result[before]=,result[after]=1
         in peek,param=2
         in accumulator,param=2,result[before]=1,result[after]=12
         in combiner,additional=34,result[before]=12,result[after]=1234
         in combiner,additional=5678,result[before]=1234,result[after]=12345678
         parallelStreamNumbers=12345678
         */
        /**
         *   <R> R collect(Supplier<R> supplier, BiConsumer<R,? super T> accumulator, BiConsumer<R,R> combiner)
         *      A supplier that supplies a mutable container to store the results.For a
         *                 parallel execution, this function may be called
         *                 multiple times and must return a fresh value each time
         *      An accumulator that accumulates the results into the mutable container.
         *      A combiner that combines the partial results when used in parallel.
         *
         *   First, create a supplier which returns an StringBuilder
         *   Second, create an accumulator that receives two arguments which is the container
         *          returned from the supplier(StringBuilder in this case). and the element of the stream.
         *   Finally, a combiner combines the results into one StringBuilder
         */
        StringBuilder parallelStreamNumbers = numbers.parallelStream().peek(StreamCollectExam::peek)
                .collect(StreamCollectExam::supplier, StreamCollectExam::accumulator, StreamCollectExam::combiner);
        System.out.println("parallelStreamNumbers=" + parallelStreamNumbers);

    }

    public static void peek(String param) {
        System.out.println("in peek,param=" + param);
    }

    private static StringBuilder supplier() {
        System.out.println("in supplier, create a StringBuilder");
        return new StringBuilder();
    }

    public static void accumulator(StringBuilder result, String param) {
        System.out.print("in accumulator,param=" + param + ",result[before]=" + result);
        result.append(param);
        System.out.println(",result[after]=" + result);
    }

    public static void combiner(StringBuilder result, StringBuilder additional) {
        System.out.print("in combiner,additional=" + additional + ",result[before]=" + result);
        result.append(additional);
        System.out.println(",result[after]=" + result);
    }

    public static void main(String[] args) {
        collectExam1();
        collectExam2();
    }
}

JAVA8之collect总结(给自己)

一,collect是一个终端操作,它接收的参数是将流中的元素累积到汇总结果的各种方式(称为收集器) 二,预定义收集器包括将流元素归约和汇总到一个值.如下 工厂方法 返回类型 用于 ...

java8 汇聚操作之reduce、collect用法

java8 汇聚操作之reduce、collect用法。
  • KKKoko
  • KKKoko
  • 2017年03月14日 15:24
  • 217

JAVA8之collect总结

一,collect是一个终端操作,它接收的参数是将流中的元素累积到汇总结果的各种方式(称为收集器) 二,预定义收集器包括将流元素归约和汇总到一个值.如下 工厂方法 ...

Java8中聚合操作collect、reduce方法参数作用

T reduce(T identity, BinaryOperator accumulator)    identity:它允许用户提供一个循环计算的初始值。accumulator:计算的累加器,其方...

Java8函数式编程之七:Stream(流)的各种操作

上篇博客对流的基础知识进行了介绍,本篇博客将着重介绍关于流的各种操作,使用很多的实例代码,你只需要将其放进你的main函数中就能运行。—————————————— 创建流:public class ...

Java8 Stream流操作在用户系统中的妙用

本文主要介绍了Java8 新api Stream的使用案例。实现排序,去重,对比,筛选,分组,收集,聚集等等功能。主要包含sort()函数,distinct()函数,map()函数,collect()...

详解Java8特性之Stream API并行流

在详解Java8特性之Stream API中,我用的例子使用的都是顺序流,即单线程执行的,其实Stream API还提供了并行流,即多线程执行操作。java.util.Collection新添加了两个...

[Java 8] (7) 利用Stream类型的"懒"操作

利用懒操作 代码中的很多操作都是Eager的,比如在发生方法调用的时候,参数会立即被求值。总体而言,使用Eager方式让编码本身更加简单,然而使用Lazy的方式通常而言,即意味着更好的效率。 本篇...

Java8新特性Stream API与Lambda表达式详解(1)

简单说,对 Stream 的使用就是实现一个 filter-map-reduce 过程,产生一个最终结果,或者导致一个副作用(side effect)。 当我们使用一个流的时候,通常包括三个基本步骤:...
  • chs0113
  • chs0113
  • 2016年05月02日 22:16
  • 5728
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Java8-Stream collect
举报原因:
原因补充:

(最多只允许输入30个字)