Java 8 Stream Collectors - 使用多个存储桶中的对象创建 Map 的收集器

以下代码有效且可读，但在我看来，我认为不需要中间操作。我编写了这个简化版本，因为实际代码是一个更大过程的一部分。

我有一个 Collection 的 Widget ，每个都有一个名称和多种类型(由 WidgetType 枚举的常量表示)。这些多种类型可以作为 Stream<WidgetType> 获取，但如有必要，我可以将它们作为其他类型返回。 (出于各种原因，强烈希望将它们作为 Stream<WidgetType> 返回，因为这些小部件稍后在实际代码中是如何使用的。)

这些小部件被添加到 EnumMap<WidgetType, List<Widget>> 中，稍后将其转换为 EnumMap<WidgetType, Widget[]> 。

如果每个 Widget 只有一个 WidgetType ，这将是一个微不足道的解决方案，但是，由于任何 Widget 都可能有 1 个或多个类型，因此我会被 Collectors.groupingBy() 方法(及其重载)的语法绊倒。

这是代码示例，再次，功能齐全，并为我提供了我需要的确切结果。

class StackOverFlowExample {

    private final Map<WidgetType, Widget[]> widgetMap = new EnumMap<>(WidgetType.class);

    public static void main(String[] args) { new StackOverFlowExample(); }

    StackOverFlowExample() {
        Collection<Widget> widgetList = getWidgetsFromWhereverWidgetsComeFrom();

        {
            final Map<WidgetType, List<Widget>> intermediateMap = new EnumMap<>(WidgetType.class);
            widgetList.forEach(w ->
                    w.getWidgetTypes().forEach(wt -> {
                        intermediateMap.putIfAbsent(wt, new ArrayList<>());
                        intermediateMap.get(wt).add(w);
                    })
            );
            intermediateMap.entrySet().forEach(e -> widgetMap.put(e.getKey(), e.getValue().toArray(new Widget[0])));
        }

        Arrays.stream(WidgetType.values()).forEach(wt -> System.out.println(wt + ": " + Arrays.toString(widgetMap.get(wt))));
    }

    private Collection<Widget> getWidgetsFromWhereverWidgetsComeFrom() {
        return Arrays.asList(
                new Widget("1st", WidgetType.TYPE_A, WidgetType.TYPE_B),
                new Widget("2nd", WidgetType.TYPE_A, WidgetType.TYPE_C),
                new Widget("3rd", WidgetType.TYPE_A, WidgetType.TYPE_D),
                new Widget("4th", WidgetType.TYPE_C, WidgetType.TYPE_D)
        );
    }

}

这输出:

TYPE_A: [1st, 2nd, 3rd]
TYPE_B: [1st]
TYPE_C: [2nd, 4th]
TYPE_D: [3rd, 4th]

为了完整起见，这里是 Widget 类和 WidgetType 枚举:

class Widget {

    private final String       name;
    private final WidgetType[] widgetTypes;

    Widget(String n, WidgetType ... wt) { name = n; widgetTypes = wt; }

    public String getName() { return name; }
    public Stream<WidgetType> getWidgetTypes() { return Arrays.stream(widgetTypes).distinct(); }

    @Override public String toString() { return name; }
}

enum WidgetType { TYPE_A, TYPE_B, TYPE_C, TYPE_D }

欢迎任何有关执行此逻辑的更好方法的想法。谢谢!

最佳答案

恕我直言，关键是将 Widget 实例转换为 Stream<Pair<WidgetType, Widget>> 实例。一旦我们有了它，我们就可以对一个小部件流进行 flatMap 并收集结果流。当然我们在Java中没有Pair，所以必须使用AbstractMap.SimpleEntry来代替。

widgets.stream()
       // Convert a stream of widgets to a stream of (type, widget)
       .flatMap(w -> w.getTypes().map(t->new AbstractMap.SimpleEntry<>(t, w)))
       // Grouping by the key, and do additional mapping to get the widget
       .collect(groupingBy(e->e.getKey(),
                mapping(e->e.getValue,
                        collectingAndThen(toList(), l->l.toArray(new Widget[0])))));

附言在这种情况下，IntelliJ 的建议不会使用方法引用缩短 lambda。

关于Java 8 Stream Collectors - 使用多个存储桶中的对象创建 Map 的收集器，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/41668001/