在 Java 8 中创建嵌套的父子列表

Question

我是 Java 8 的新手，需要解决以下问题。

我有两个类如下：

class Person {
    String name;
    int age;
    List<Address> address;
}

class Address {
    String street;
    String city;
    String country;
}

现在我有一个来自数据库的列表，如下所示：

List<Person> findPerson;

adam
26
<123, xyz, yyy>

adam
26
<456, rrr, kkk>

bill
31
<666, uuu, hhh>

现在我需要将相同的人对象与不同的地址对象合并为一个，如下所示？

List<Person> findPerson;

adam
26
<123, xyz, 456>
<456, rrr, 123>

bill
31
<666, uuu, 999>

如何在 Java 8 流中做到这一点？

Answer 1

我建议你在 Person 类中实现 equals 和 hashcode。

例子：

@Override
public boolean equals(Object o) {
       if (this == o) return true;
       if (o == null || getClass() != o.getClass()) return false;

       Person person = (Person) o;

       if (age != person.age) return false;
       return name != null ? name.equals(person.name) : person.name == null;
}

@Override
public int hashCode() {
       int result = name != null ? name.hashCode() : 0;
       result = 31 * result + age;
       return result;
}

然后您可以将Map<Person, List<Address>> 作为结果集的接收者类型。

Map<Person, List<Address>> resultSet = findPerson.stream()
    .collect(
        Collectors.groupingBy(
            Function.identity(),
            Collectors.flatMapping(
                p -> p.getAddress().stream(), 
                Collectors.toList()
            )
        )
    )
;

这个解决方案使用了 flatMapping 收集器，它只在 Java-9 中可用。

如果您仍在使用 Java-8，那么您可以这样做：

Map<Person, List<Address>> resultSet = findPerson.stream()
    .collect(
        Collectors.groupingBy(
            Function.identity(),
            Collectors.collectingAndThen(
                Collectors.mapping(
                    Person::getAddress, 
                    Collectors.toList()
                ),
                lists -> lists.stream()
                    .flatMap(List::stream)
                    .collect( Collectors.toList() )
            )
        )
    )   
;

note - 目前，我假设两个或更多人被认为是平等的基于 name 和 age，但是，如果它仅基于 name 或仅基于 @ 987654332@ 那么你需要稍微调整一下equals / hashcode 方法。

Answer 2

假设Person 始终如一地实现hashCode 和equals，您可以收集到Map：

Map<Person, Person> map = findPerson.stream()
    .collect(Collectors.toMap(
        p -> p,
        p -> p,
        (oldPerson, newPerson) -> { 
            oldPerson.getAddress().addAll(newPerson.getAddress()); 
            return oldPerson; 
        }));

这使用Collectors.toMap，它通过合并一个新人与一个已经在地图中的老人，合并意味着添加地址。

现在，在地图的值中，你有合并的人：

Collection<Person> result = map.values();

如果需要返回列表：

List<Person> result = new ArrayList<>(map.values());

---

编辑：

这假定每个人的List<Address> 是可变的（因此addAll 有效）。情况并非总是如此，尤其是如果您不想破坏封装，则不应让您的Person 对象的地址被外部修改。

在这种情况下，您可以在Person 中提供一个方法，负责在不破坏封装的情况下合并地址：

public Person merge(Person another) {
    this.address.addAll(another.address);
    return this;
}

或者如果地址列表是不可变的：

public Person merge(Person another) {
    List<Address> merged = new ArrayList<>(this.address);
    merged.addAll(another.address);
    this.address = merged;
    return this;
}

现在收集器中的代码可以重构为：

Map<Person, Person> map = findPerson.stream()
    .collect(Collectors.toMap(
        p -> p, 
        p -> p,
        Person::merge));

Answer 3

另一种方法，不需要覆盖 equals 和 hashCode：

List<Person> merged = findPerson.stream()
    .collect( 
        Collectors.collectingAndThen(
            Collectors.toMap( 
                (p) -> new AbstractMap.SimpleEntry<>( p.getName(), p.getAge() ), 
                Function.identity(), 
                (left, right) -> { 
                    left.getAddress().addAll( right.getAddress() ); 
                    return left; 
                }
            ),        
            ps -> new ArrayList<>( ps.values() ) 
        ) 
    )
;

Answer 4

此答案与最近删除的答案非常相似：

findPerson = findPerson.stream()
                       .collect(Collectors.groupingBy(Person::getName,
                                Collectors.reducing((p1, p2) -> {
                                    p1.getAddress().addAll(p2.address);
                                    return p1;
                       }))).values().stream()
                           .filter(Optional::isPresent)
                           .map(Optional::get)
                           .collect(Collectors.toList());

在 Java 9 中，底部的两行可以替换为对 Optional::stream 的一次调用。

使用你的例子，结果如下：

[Person[bill, 31, [Address[666, uuu, hhh]]], Person[adam, 26, [Address[123, xyz, yyy], Address[456, rrr, kkk]]]]

注意：记得为Person 适当地覆盖equals 和hashCode。