Lambda_12 函数表达式 Stream Collector集合数据流转换|8月更文挑战

这是我参与8月更文挑战的第27天，活动详情查看：8月更文挑战

@[TOC](Stream Collector集合数据流转换)

1. Collector集合转换
2. Collector数据流转换

代码示例：

public class Lambda13 {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("L", "A", "M", "B", "D", "A");
        //将list集合转换为字符串，使用特殊字符分割
        String str = list.stream().collect(Collectors.joining(","));
        System.out.println(str);

        //List ==转换为==> LinkedList
        System.out.println("匿名内部类方式 实现 List ==转换为==> LinkedList");
        LinkedList<String> linkedList = list.stream().collect(Collectors.toCollection(new Supplier<LinkedList<String>>() {
            @Override
            public LinkedList<String> get() {
                return new LinkedList<String>();
            }
        }));
        linkedList.forEach(x-> System.out.println(x));

        System.out.println("Lambda实现方式 List ==转换为==> LinkedList");
        LinkedList<String> linkedListLambda = list.stream().collect(Collectors.toCollection(LinkedList::new));
        linkedListLambda.forEach(x-> System.out.println(x));

        System.out.println("Lambda实现方式 List ==转换为==> TreeSet");
        TreeSet treeSet = list.stream().collect(Collectors.toCollection(TreeSet::new));
        treeSet.forEach(x-> System.out.println(x));
        System.out.println("TreeSet具有去重复的功能，可以看到打印输出中已经将重复的值省去了。");
    }
}

输出：

L,A,M,B,D,A
匿名内部类方式 实现 List ==转换为==> LinkedList
L
A
M
B
D
A
Lambda实现方式 List ==转换为==> LinkedList
L
A
M
B
D
A
Lambda实现方式 List ==转换为==> TreeSet
A
B
D
L
M
TreeSet具有去重复的功能，可以看到打印输出中

Collector接口的定义

public interface Collector<T, A, R> {
    /**
     * 用来创建并且返回一个可变结果容器
     */
    Supplier<A> supplier();

    /**
     * 将一个值叠进一个可变结果容器
     */
    BiConsumer<A, T> accumulator();

    /**
     * 接受两个部分结果并将它们合并。可能是把一个参数叠进另一个参数并且返回另一个参数，
     * 也有可能返回一个新的结果容器，多线程处理时会用到
     */
    BinaryOperator<A> combiner();

    /**
     * 将中间类型执行最终的转换，转换成最终结果类型
     * 如果属性 IDENTITY_TRANSFORM 被设置，该方法会假定中间结果类型可以强制转成最终结果
     * 类型
     */
    Function<A, R> finisher();

    /**
     * 收集器的属性集合
     */
    Set<Characteristics> characteristics();

    public static<T, R> Collector<T, R, R> of(Supplier<R> supplier,
                                              BiConsumer<R, T> accumulator,
                                              BinaryOperator<R> combiner,
                                              Characteristics... characteristics) {
        Objects.requireNonNull(supplier);
        Objects.requireNonNull(accumulator);
        Objects.requireNonNull(combiner);
        Objects.requireNonNull(characteristics);
        Set<Characteristics> cs = (characteristics.length == 0)
                                  ? Collectors.CH_ID
                                  : Collections.unmodifiableSet(EnumSet.of(Collector.Characteristics.IDENTITY_FINISH,
                                                                           characteristics));
        return new Collectors.CollectorImpl<>(supplier, accumulator, combiner, cs);
    }

    public static<T, A, R> Collector<T, A, R> of(Supplier<A> supplier,
                                                 BiConsumer<A, T> accumulator,
                                                 BinaryOperator<A> combiner,
                                                 Function<A, R> finisher,
                                                 Characteristics... characteristics) {
        Objects.requireNonNull(supplier);
        Objects.requireNonNull(accumulator);
        Objects.requireNonNull(combiner);
        Objects.requireNonNull(finisher);
        Objects.requireNonNull(characteristics);
        Set<Characteristics> cs = Collectors.CH_NOID;
        if (characteristics.length > 0) {
            cs = EnumSet.noneOf(Characteristics.class);
            Collections.addAll(cs, characteristics);
            cs = Collections.unmodifiableSet(cs);
        }
        return new Collectors.CollectorImpl<>(supplier, accumulator, combiner, finisher, cs);
    }

    enum Characteristics {

        CONCURRENT,


        UNORDERED,


        IDENTITY_FINISH
    }