Java 8 Java8中按问题分组

我有一个名为“父”的java类，它的列表属性（字符串）为子。构建一个：

Map

很容易，其中的键是所有父亲的名字和他所有儿子的值

我想知道如何做相反的操作：

Map

，其中他们的键与每个儿子相关，值是他父亲的列表。考虑到一个儿子可能属于一个或两个父亲（父亲和母亲）

我有以下代码：

结果是：

我希望得到的结果是，例如： 儿子：玛丽亚-父亲：[玛丽亚·尤金尼亚，恩里克·阿尔贝托]

---

儿子：阿古斯丁-父亲：[玛丽亚·尤金尼亚，恩里克·阿尔贝托]

因此，一种方法是将其视为两步手术。第一步是构建一个

对流，然后使用groupingBy将该流缩减为

映射

静态类父类{
字符串名；
列出儿子；
公共父项（最终字符串名称、最终列表子项）{
this.name=名称；
这个。儿子=儿子；
}
@凌驾
公共字符串toString（）{
返回MoreObjects.toStringHelper（此）
.添加（“名称”，名称）
.加上（“儿子”，儿子）
.toString（）；
}
}
静态类子{
公共子项（最终字符串名）{
this.name=名称；
}
字符串名；
@凌驾
公共字符串toString（）{
返回MoreObjects.toStringHelper（此）
.添加（“名称”，名称）
.toString（）；
}
}
静态空位{
子女c1=新子女（“aa”）；
子女c2=新子女（“bb”）；
List parents=ImmutableList.of(
新的父项（“P1”，不可变列表（c1）），
新父代（“P2”，不可变列表（c1，c2）），
新的父母（“P3”，不可变的（c2））；
Map childToParents=parents.stream（）
.flatMap（p->p.sons.stream（）
.collect（Collectors.toMap（Function.identity（），s->p））
.entrySet（）
.stream（））
.collect（收集器.groupingBy(
Map.Entry:：getKey，
映射（Map.Entry:：getValue，toList（））；
System.out.println（儿童家长）；
}
因此，一种方法是将其视为两步操作。第一步是构建一个
对流，然后使用groupingBy将该流缩减为
映射

静态类父类{
字符串名；
列出儿子；
公共父项（最终字符串名称、最终列表子项）{
this.name=名称；
这个。儿子=儿子；
}
@凌驾
公共字符串toString（）{
返回MoreObjects.toStringHelper（此）
.添加（“名称”，名称）
.加上（“儿子”，儿子）
.toString（）；
}
}
静态类子{
公共子项（最终字符串名）{
this.name=名称；
}
字符串名；
@凌驾
公共字符串toString（）{
返回MoreObjects.toStringHelper（此）
.添加（“名称”，名称）
.toString（）；
}
}
静态空位{
子女c1=新子女（“aa”）；
子女c2=新子女（“bb”）；
List parents=ImmutableList.of(
新的父项（“P1”，不可变列表（c1）），
新父代（“P2”，不可变列表（c1，c2）），
新的父母（“P3”，不可变的（c2））；
Map childToParents=parents.stream（）
.flatMap（p->p.sons.stream（）
.collect（Collectors.toMap（Function.identity（），s->p））
.entrySet（）
.stream（））
.collect（收集器.groupingBy(
Map.Entry:：getKey，
映射（Map.Entry:：getValue，toList（））；
System.out.println（儿童家长）；
}
将代码作为文本而不是图像发布。将代码作为文本而不是图像发布。Gene Taylor！。你太棒了！。。。谢谢你的帮助。。。想深入了解Java8流。。。下次我将以文本而不是图像的形式发布代码。。。谢谢你。。。我现在将进一步分析它……您不需要将子列表收集到一个映射，只需要获得一个
map.Entry
s流。您可以简单地说
.flatMap（p->p.sons.stream（）.map（s->new AbstractMap.SimpleImmutableEntry（s，p））
是的，因为我们只在这对（子，父）之后。我决定使用一个中间图来明确转换是如何发生的。（如果标准库中有一个对，这样我们就可以避免使用像SimpleImmutableEntry这样的笨拙的构造）而Java 9仍然没有对/元组类型，那么就会有方便的
Map.entry（s，p）
替换
新的AbstractMap.SimpleImmutableEntry（s，p）
.Gene Taylor！。你太棒了！。。。谢谢你的帮助。。。想深入了解Java8流。。。下次我将以文本而不是图像的形式发布代码。。。谢谢你。。。我现在将进一步分析它……您不需要将子列表收集到一个映射，只需要获得一个
map.Entry
s流。您可以简单地说
.flatMap（p->p.sons.stream（）.map（s->new AbstractMap.SimpleImmutableEntry（s，p））
是的，因为我们只在这对（子，父）之后。我决定使用一个中间图来明确转换是如何发生的。（如果标准库中只有一对，这样我们就可以避免使用像SimpleImmutableEntry这样的笨拙构造）虽然Java 9仍然没有对/元组类型，但是会有方便的
Map.entry（s，p）
替换
新的AbstractMap.SimpleImmutableEntry（s，p）
。
static class Parent{
    String name;
    List<Child> sons;

    public Parent(final String name, final List<Child> sons) {
        this.name = name;
        this.sons = sons;
    }

    @Override
    public String toString() {
        return MoreObjects.toStringHelper(this)
                .add("name", name)
                .add("sons", sons)
                .toString();
    }
}

static class Child{
    public Child(final String name) {
        this.name = name;
    }

    String name;


    @Override
    public String toString() {
        return MoreObjects.toStringHelper(this)
                .add("name", name)
                .toString();
    }
}

static void SonsToFathers(){
    Child c1 = new Child("aa");
    Child c2 = new Child("bb");

    List<Parent> parents = ImmutableList.of(
            new Parent("P1", ImmutableList.of(c1)),
            new Parent("P2", ImmutableList.of(c1,c2)),
            new Parent("P3", ImmutableList.of(c2)));


    Map<Child,List<Parent>> childToParents = parents.stream()
            .flatMap(p -> p.sons.stream()
                    .collect(Collectors.toMap(Function.identity(), s -> p))
                    .entrySet()
                    .stream())
            .collect(Collectors.groupingBy(
                    Map.Entry::getKey, 
                    mapping(Map.Entry::getValue, toList())));


    System.out.println(childToParents);
}