《Java8实战》 - 读书笔记 - Stream流操作2：用流收集数据

• 第 6 章 用流收集数据
• • 6.1 收集器简介
  • • 收集 toList
    • 收集 toSet
    • 收集 toMap
    • • 简单版本
      • 配合 Mybatis 使用，遇到了点问题
    • 收集 toCollection
    • 转数组 toArray
  • 6.2 归约和汇总
  • • 6.2.1 查找流中的最大值和最小值
    • • 按最大值 maxBy 查找
      • 按最小值 minBy 查找
    • 6.2.2 汇总
    • • 求合 summingInt、summingLong、summingDouble
      • 平均 averagingInt、averagingLong、averagingDouble
      • 综合统计 summarizingInt、summarizingLong、summarizingDouble
    • 6.2.3 连接字符串 joining
    • 6.2.4 广义的归约汇总 reducing
  • 6.3 分组
  • • 按条件分组 groupingBy
    • 6.3.1 多级分组 groupingBy 嵌套
    • 6.3.2 按子组收集数据
    • • 1. 把收集器的结果转换为另一种类型 collectingAndThen
      • 2. 与groupingBy联合使用的其他收集器的例子 mapping
    • 先分组再各自排序
    • mapping 分组后对值进行映射，再收集
  • 6.4 分区 partitioningBy
  • 6.5 收集器接口
  • • 6.5.1 理解 Collector 接口声明的方法
    • 进行自定义收集而不去实现Collector
  • 6.6 开发你自己的收集器以获得更好的性能
• 小结
• 参考资料

Collectors实用类提供了很多静态工厂方法，可以方便地创建常见收集器的实例，只要拿来用就可以了。最直接和最常用的收集器是toList静态方法，它会把流中所有的元素收集到一个List中：

List transactions = transactionStream.collect(Collectors.toList());

java.util.stream.Collectors.toList()
把流中所有项目收集到一个 List

List scoreList = Hero.getList().stream()
        .map(Hero::getScore)
        .collect(Collectors.toList());
System.out.println(scoreList); // [23, 19, 20, 21, 25, 45]

java.util.stream.Collectors.toSet()
把流中所有项目收集到一个 Set，删除重复项

Set collect = Hero.getList().stream()
        .map(Hero::getScore)
        .collect(Collectors.toSet());
System.out.println(collect); // [19, 20, 21, 23, 25, 45]

java.util.stream.Collectors.toMap()

只指定key和value。这里以Name为key，以对象本身为value。
所以值这里使用了恒等函数java.util.function.Function.identity()

Hero.getList().stream()
			.collect(toMap(Hero::getName, Function.identity()));

这里是配合Mybatis使用，遇到了点问题：key 和 value 能取到，但是直接类型转换报错。
分析：

处理 Key类型转换这里估计与Mybatis的返回值类型处理有关。

• mybatis 返回类型，接口写的是List>，但读取值可以看到实际类型还是List>（与Mybatis查出来的结果一至）。
• id字段在表中类型是int，我试着在resultMap把它定义成了Long。但到了处理key这一步，就报Error: java: 不兼容的类型: java.lang.Integer无法转换为java.lang.Long，怀疑是这个问题，但未深入验证。
• 但collection字段的转换又没问题这个字段是用count算出来的默认返回Long。

Integer与Long没继承关系不能强转，这个我能理解。但intValue()、longValue()也不好使了，我不太明白。。。
以下没有使用resultMap处理，直接使用List>接收（Mybatis返回的实际类型）。
先强转为Number再输出想要的目标类型，问题解决。

collectionsMapper.selectCollection().stream()
	.collect(Collectors.toMap(
        // 处理 key
        m -> ((Number)m.get("id")).longValue(),
        // 处理 value             
        m -> ((Number)m.get("collection")).intValue(),
	    // 处理重复 key 规则 ： 使用新值
	    (oldValue, newValue) -> newvalue,
	    // 想转的目标类型
	    LinkedHashMap::new
     ));

• 关于类型转换，网上看到的其它解决方案：

1. 用Object中转一下再转目标类型

m -> (Long)(Object)m.get("id")

2. 用resultMap把所有字段返回类型都改成String转map时各字段根据需要处理。

m -> Long.parseLong(m.get("id")),

3. 用String中转一下，道理一样。

m -> Long.parseLong(String.valueOf(m.get("id")))

4. 还看到有人是转JSON再转回来这么实现的eeeeeeeeeeee。

把流中所有项目收集到给定的供应源创建的集合

 Hero.getList().stream()
        .collect(toCollection(), ArrayList::new);

利用TreeSet实现去重。

AbstractCollection collect = Hero.getList().stream()
        .collect(toCollection(
                () -> new TreeSet<>(comparing(Hero::getGroupTag))
        ));
System.out.println(JSONObject.toJSONString(collect, SerializerFeature.PrettyFormat));

利用collectingAndThen去重，后再处理（将结果装进ArrayList）

ArrayList collect = Hero.getList().stream().collect(
         collectingAndThen(
                 toCollection(() -> new TreeSet<>(comparing(Hero::getGroupTag))),
                 ArrayList::new
         )
 );
 System.out.println(JSONObject.toJSONString(collect, SerializerFeature.PrettyFormat));

先取出年龄，再toArray装进数组。

 Hero.getList().stream().map(Hero::getAge).toArray(Integer[]::new);

接收一个 Comparator 参数来比较流中的元素。

找到年龄最大的Hero：maxBy接收 Comparator comparator 参数来比较流中的元素。

Comparator heroAgeComparator = Comparator.comparingInt(Hero::getAge);

Optional collect = Hero.getList().stream()
        .collect(maxBy(heroAgeComparator));

Hero hero = collect.get();
System.out.println(hero); // Hero(name=重八, age=60, score=45, group=C)

找到年龄最小的Hero

Optional collect = Hero.getList().stream()
        .collect(minBy(Comparator.comparingInt(Hero::getAge)));
Hero hero = collect.get();
System.out.println(hero); // Hero(name=张三, age=10, score=23, group=A)

接受一个返回int的函数（比如Hero::getScore），并返回一个收集器；该收集器在传递给普通的collect方法后即执行我们需要的汇总操作。
同理。

Collector heroScore = Collectors.summingInt(Hero::getScore);
int total = Hero.getList().stream().collect(heroScore );
System.out.println("分数合计：" + total);// 分数合计：153

• IntStream.sum、LongStream

List list = IntStream.rangeClosed(1,100).boxed().collect(Collectors.toList());
int sum = list.stream().mapToInt(Integer::intValue).sum();
System.out.println(sum); // 5050

List longList = LongStream.rangeClosed(1,100).boxed().collect(Collectors.toList());
long sumLong = longList.stream().mapToLong(Long::longValue).sum();
System.out.println(sumLong); // 5050

• Stream.reduce

List intList = IntStream.rangeClosed(1,100).boxed().collect(Collectors.toList());

Integer sum2 = intList.stream().reduce(0, Integer::sum);
System.out.println(sum2); // 5050

Integer sum1 = intList.stream().reduce(0, (a, b) -> a + b);
System.out.println(sum1); // 5050

参考求合，不再赘述。

一次同时进行总和、平均值、最大值和最小值

 Collector heroScoreCollector = Collectors.summarizingInt(Hero::getScore);
 IntSummaryStatistics collect = Hero.getList().stream()
         .collect(heroScoreCollector);
 System.out.println("合计：" + collect.getSum());       // 合计：153
 System.out.println("平均数：" + collect.getAverage()); // 平均数：25.5
 System.out.println("最大值：" + collect.getMax());     // 最大值：45
 System.out.println("最小值：" + collect.getMin());     // 最小值：19
 System.out.println("计数：" + collect.getCount());     // 计数：6        

String str = Hero.getList().stream()
        .map(Hero::getName)
        .collect(joining("|"));
System.out.println(str); // 张三|李四|王五|赵六|洪七|重八

从一个作为累加器的初始值开始，利用 BinaryOperator 与流中的元素逐个结合，从而将流归约为单个值。

事实上，我们已经讨论的所有收集器，都是一个可以用reducing工厂方法定义的归约过程的特殊情况而已。Collectors.reducing工厂方法是所有这些特殊情况的一般化。可以说，先前讨论的案例仅仅是为了方便程序员而已。（但是，请记得方便程序员和可读性是头等大事！）例如，可以用reducing方法创建的收集器来计算你菜单的总热量，如下所示：

int totalCalories = menu.stream().collect(
		reducing(0, Dish::getCalories, (i, j) -> i + j)
); 

它需要三个参数。

• 第一个参数是归约操作的起始值，也是流中没有元素时的返回值，所以很显然对于数值和而言0是一个合适的值。
• 第二个参数就是你在6.2.2节中使用的函数，将菜肴转换成一个表示其所含热量的int。
• 第三个参数是一个BinaryOperator，将两个项目累积成一个同类型的值。这里它就是对两个int求和。
  同样，你可以使用下面这样单参数形式的reducing来找到热量最高的菜，如下所示：

Optional mostCalorieDish = menu.stream().collect(
 		reducing( (d1, d2) -> d1.getCalories() > d2.getCalories() ? d1 : d2)
);   

你可以把单参数reducing工厂方法创建的收集器看作三参数方法的特殊情况，它把流中的第一个项目作为起点，把恒等函数（即一个函数仅仅是返回其输入参数）作为一个转换函数。这也意味着，要是把单参数reducing收集器传递给空流的collect方法，收集器就没有起点；正如我们在6.2.1节中所解释的，它将因此而返回一个Optional对象。
收集与归约
在上一章和本章中讨论了很多有关归约的内容。你可能想知道，Stream接口的collect和reduce方法有何不同，因为两种方法通常会获得相同的结果。例如，你可以像下面这样使用reduce方法来实现toListCollector所做的工作：

Stream stream = Arrays.asList(1, 2, 3, 4, 5, 6).stream();
List numbers = stream.reduce(
									new ArrayList(),
									(List l, Integer e) -> {	l.add(e); return l; },
									(List l1, List l2) -> { l1.addAll(l2); return l1; }
								 ); 

这个解决方案有两个问题：一个语义问题和一个实际问题。语义问题在于，reduce方法旨在把两个值结合起来生成一个新值，它是一个不可变的归约。与此相反，collect方法的设计就是要改变容器，从而累积要输出的结果。这意味着，上面的代码片段是在滥用reduce方法，因为它在原地改变了作为累加器的List。你在下一章中会更详细地看到，以错误的语义使用reduce方法还会造成一个实际问题：这个归约过程不能并行工作，因为由多个线程并发修改同一个数据结构可能会破坏List本身。在这种情况下，如果你想要线程安全，就需要每次分配一个新的List，而对象分配又会影响性能。这就是collect方法特别适合表达可变容器上的归约的原因，更关键的是它适合并行操作，本章后面会谈到这一点。

groupingBy 根据项目的一个属性的值对流中的项目进行组，并将属性值作为结果 Map 的键。
注意：单参数groupingBy(f)（其中f是分类函数）是groupingBy(f, toList())的简写。

按groupTag分组，结果收集到List。

Map> collect = Hero.getList().stream().collect(
        groupingBy(Hero::getGroupTag, toList())
);
System.out.println(JSONObject.toJSONString(collect, SerializerFeature.PrettyFormat));
//{
//    "A":[
//        { "age":10, "groupTag":"A", "name":"张三", "score":23 },
//        { "age":20, "groupTag":"A", "name":"李四", "score":19 }
//    ],
//    "B":[
//        { "age":30, "groupTag":"B", "name":"王五", "score":20 },
//        { "age":40, "groupTag":"B", "name":"赵六", "score":21 }
//    ],
//    "C":[
//        { "age":50, "groupTag":"C", "name":"洪七", "score":25 },
//        { "age":60, "groupTag":"C", "name":"重八", "score":45 }
//    ]
//}

groupingBy(条件, groupingBy(条件, 收集))。
先按照Age分组，再按照GroupTag分组

Map>> collect = Hero.getList().stream().collect(
        groupingBy(
                h -> h.getAge() > 30 ? "老兵" : "新兵",
                groupingBy(Hero::getGroupTag, toList())
        )
);
System.out.println(JSONObject.toJSONString(collect, SerializerFeature.PrettyFormat));
//{
//    "新兵":{
//        "A":[
//            { "age":10, "groupTag":"A", "name":"张三", "score":23 },
//            { "age":20, "groupTag":"A", "name":"李四", "score":19 }
//        ],
//        "B":[
//            { "age":30, "groupTag":"B", "name":"王五", "score":20 }
//        ]
//    },
//    "老兵":{
//        "B":[
//                { "age":40, "groupTag":"B", "name":"赵六", "score":21 }],
//        "C":[
//                { "age":50, "groupTag":"C", "name":"洪七", "score":25 },
//                { "age":60, "groupTag":"C", "name":"重八", "score":45 }
//            ]
//     }
//}

先按照GroupTag分组，再计数。

Map collect = Hero.getList().stream().collect(
        groupingBy(Hero::getGroupTag, counting())
);
System.out.println(JSONObject.toJSONString(collect, SerializerFeature.PrettyFormat));
// { "A":2, "B":2, "C":2 }

先按照Age分组区分"新兵"， "老兵"，再计数。

Map collect1 = Hero.getList().stream().collect(
        groupingBy(h -> h.getAge() <= 20 ? "新兵" : "老兵", counting())
);
System.out.println(JSONObject.toJSONString(collect1, SerializerFeature.PrettyFormat));
// { "新兵":2, "老兵":4 }

先按照GroupTag分组，再找出年龄最大的Hero。

Map> collect = Hero.getList().stream().collect(
         groupingBy(
                 Hero::getGroupTag,
                 maxBy(comparingInt(Hero::getAge))
         )
 );
 Optional a = collect.get("A");
 Hero hero = a.orElse(new Hero("无名", 9999, 0, "X"));
 System.out.println(hero); // Hero(name=李四, age=20, score=19, groupTag=A)

注意 这个返回Map中的值是Optional (Map)，因为这是maxBy工厂方法生成的收集器的类型，但实际上，如果HeroList中没有某一类型的Hero，那么它根本不会出现在Map的键中。groupingBy收集器只有在应用分组条件后，第一次在流中找到某个键对应的元素时才会把键加入分组Map中。这意味着Optional包装器在这里不是很有用，因为它不会仅仅因为它是归约收集器的返回类型而表达一个最终可能不存在却意外存在的值。
(对原文的引用，但是结合上下文调整了一下)

collectingAndThen 包裹另一个收集器，对其结果应用转换函数。

上面的例子可以看出返回Optional有点多余。那么我们转换一下，最终得到Map吧。

Map collect = Hero.getList().stream().collect(
        groupingBy(
                Hero::getGroupTag,
                collectingAndThen(
                        maxBy(comparingInt(Hero::getAge)),
                        Optional::get
                )
        )
);
System.out.println(JSONObject.toJSONString(collect, SerializerFeature.PrettyFormat));
//{
//    "A":{ "age":20, "groupTag":"A", "name":"李四", "score":19 },
//    "B":{ "age":40, "groupTag":"B", "name":"赵六", "score":21 },
//    "C":{ "age":60, "groupTag":"C", "name":"重八", "score":45 }
//}

public static Collector mapping(Function mapper, Collector downstream)
通过在累加之前对每个输入元素应用映射函数，将一个接受U类型元素的收集器适配为一个接受T类型元素。

Map> collect = Hero.getList().stream().collect(
        groupingBy(
                h -> h.getAge() <= 20 ? "新兵" : "老兵",
                mapping(
                        h -> h.getName()+":"+h.getAge()+"岁",
                        toList()
                )
        )
);
System.out.println(JSONObject.toJSONString(collect, SerializerFeature.PrettyFormat));
//{
//    "新兵":["张三:10岁", "李四:20岁"],
//    "老兵":["王五:30岁", "赵六:40岁", "洪七:50岁", "重八:60岁"]
//}

再看一特殊的例子：（模拟一个toMap）等同于：Hero.getList().stream().collect(toMap(Hero::getName, Hero::getAge))

Map> collect = Hero.getList().stream().collect(
        groupingBy(
                Hero::getName,
                mapping(Hero::getAge, reducing((a, c) -> a.intValue()))
        )
);
System.out.println(JSONObject.toJSONString(collect, SerializerFeature.PrettyFormat));
//{ "李四":20, "张三":10, "洪七":50, "王五":30, "赵六":40, "重八":60 }

这里演示的是“排序”，当然也可以做其它的操作。
并不是在一个流中实现的，分组后先收集了得到一个Map，再取出 Map.Entry 生成流进一步处理的。

// 1. 按年龄分组  age > 20 ? 老兵 : 新兵。
// 2. 新兵按年龄升序，老兵按年龄降序。
// 3. map 返回 Map.Entry>
// 4. 收集器得到结果 HashMap
Map> collect = Hero.getList()
        .stream()
        // 按年龄 >20 分组。收集得到一个 Map
        .collect(groupingBy(h -> h.getAge() > 20 ? KEY1 : KEY2))
        // 获取 Map.Entry
        .entrySet()
        // 获取流
        .stream()    
        // 对分组后的内容各自排序
        .map( entry -> {
            // 判断 Key 默认升序，如果是“老兵”改为降序
            String key = entry.getKey();
            Comparator comparator = Comparator.naturalOrder();
            if(KEY1.equals(key)){                                       
                comparator =  Comparator.reverseOrder();
            }
            // 对当前组的值（List）按年龄排序。
            List list = entry.getValue().stream()
                    .sorted(Comparator.comparing(Hero::getAge, comparator))
                    .collect(Collectors.toList());
            entry.setValue(list);
            // 返回 Map.Entry>
            return entry;
        }).collect(toMap(
                m -> m.getKey(), // 处理 key
                m -> m.getValue() // 处理 value  
        ));

System.out.println(JSONObject.toJSONString(collect, SerializerFeature.PrettyFormat));

mapping通常是配合分组，分区等场景，嵌套使用的。
先按GroupTag分组，然后将结果Hero对象映射为 name 收集进List

Map> collect = Hero.getList().stream().collect(
         groupingBy(
             Hero::getGroupTag,
             mapping(Hero::getName, toList())
         )
 );
 System.out.println(JSONObject.toJSONString(collect, SerializerFeature.PrettyFormat));

partitioningBy 根据对流中每个项目应用谓词的结果来对项目进行分区。

分区是分组的特殊情况：由一个谓词（返回一个布尔值的函数）作为分类函数，它称分区函数。分区函数返回一个布尔值，这意味着得到的分组Map的键类型是Boolean，于是它最多可以分为两组——true是一组，false是一组。

按年龄>20分区：true，false为key。

Map> collect = Hero.getList().stream().collect(
        partitioningBy(h -> h.getAge() > 20)
);
System.out.println(JSONObject.toJSONString(collect, SerializerFeature.PrettyFormat));
//{
//    false:[
//            { "age":10, "groupTag":"A", "name":"张三", "score":23 },
//            { "age":20, "groupTag":"A", "name":"李四", "score":19 }
//		],
//    true:[
//            { "age":30, "groupTag":"B", "name":"王五", "score":20 },
//            { "age":40, "groupTag":"B", "name":"赵六", "score":21 },
//            { "age":50, "groupTag":"C", "name":"洪七", "score":25 },
//            { "age":60, "groupTag":"C", "name":"重八", "score":45 }
//		]
//}

Collector接口包含了一系列方法，为实现具体的归约操作（即收集器）提供了范本。我们已经看过了Collector接口实现的许多收集器，例如toList或groupingBy。这也意味着，你可以为Collector接口提供自己的实现，从而自由地创建自定义归约操作。

public interface Collector { 
	Supplier supplier(); 
	BiConsumer accumulator(); 
	Function finisher(); 
	BinaryOperator combiner(); 
	Set characteristics(); 
}

public Supplier> supplier() { 
	return ArrayList::new; 
}

public BiConsumer, T> accumulator() { 
	return List::add; // (累加器, 当前值) -> 累加器.add(当前值); 
}

public Function, List> finisher() { 
	return Function.identity(); // 最简单的情况就是：直接返回累加器。
}

public BinaryOperator> combiner() { 
	return (list1, list2) -> {
		list1.addAll(list2); 
 		return list1;
 	} 
}

public Set characteristics() { 
	return Collections.unmodifiableSet(EnumSet.of(IDENTITY_FINISH, CONCURRENT));
}

 R collect(Supplier supplier, BiConsumer accumulator, BiConsumer combiner);

// 使用示例：
HashMap collect = Hero.getList().stream()
        .collect(
                HashMap::new,
                (a, c) -> a.put(c.getName(), c.getAge()),
                HashMap::putAll
        );
System.out.println(JSONObject.toJSONString(collect, SerializerFeature.PrettyFormat));
// { "李四":20, "张三":10, "洪七":50, "王五":30, "赵六":40, "重八":60 }

@AllArgsConstructor
public class ToStringCollector implements Collector {
    
    private CharSequence delimiter = ",";
    
    @Override
    public Supplier supplier() {
        return StringBuffer::new;
    }
    
    @Override
    public BiConsumer accumulator() {
        return (sb,h) -> {
            if(sb.length() != 0) sb.append(delimiter);
            sb.append(h);
        };
    }
    
    @Override
    public Function finisher() {
        return sb -> sb.toString();
    }
    
    @Override
    public BinaryOperator combiner() {
        return StringBuffer::append; // (sb, sb2) -> { sb.append(sb2); return sb; };
    }
    
    @Override
    public Set characteristics() {
        return Collections.unmodifiableSet(EnumSet.of(Characteristics.CONCURRENT, Characteristics.UNORDERED));
    }
}

String str = Hero.getList().stream()
        .map(Hero::getName)
        .collect(new ToStringCollector<>("*"));
System.out.println(str); // 张三*李四*王五*赵六*洪七*重八