添加两个自己类型的列表

Question

我有一个简单的User 类，它有一个String 和一个int 属性。

我想以这种方式添加两个用户列表：

• 如果字符串等于，则应添加数字，这将是它的新值。
• 新列表应包含所有具有正确值的用户。

像这样：

List1: { [a:2], [b:3] }
List2: { [b:4], [c:5] }
ResultList: {[a:2], [b:7], [c:5]}

User 定义：

public class User { 
    private String name;
    private int comments;
}

我的方法：

public List<User> addTwoList(List<User> first, List<User> sec) {
    List<User> result = new ArrayList<>();
    for (int i=0; i<first.size(); i++) {
        Boolean bsin = false;
        Boolean isin = false;
        for (int j=0; j<sec.size(); j++) {
            isin = false; 
            if (first.get(i).getName().equals(sec.get(j).getName())) {
                int value= first.get(i).getComments() + sec.get(j).getComments();
                result.add(new User(first.get(i).getName(), value));
                isin = true;
                bsin = true;
            }
            if (!isin) {result.add(sec.get(j));}
        }
        if (!bsin) {result.add(first.get(i));}
    }
    return result;      
}

但它在列表中添加了很多东西。

Answer 1

最好通过toMap 收集器来完成：

 Collection<User> result = Stream
    .concat(first.stream(), second.stream())
    .collect(Collectors.toMap(
        User::getName,
        u -> new User(u.getName(), u.getComments()),
        (l, r) -> {
            l.setComments(l.getComments() + r.getComments());
            return l;
        }))
    .values();

• 首先，通过Stream.concat 将两个列表连接成一个Stream<User>。
• 其次，我们使用toMap 收集器来合并恰好具有相同Name 的用户并返回Collection<User> 的结果。

如果您严格想要List<User>，则将结果传递给ArrayList构造函数，即List<User> resultSet = new ArrayList<>(result);

---

感谢@davidxxx，您可以直接从管道收集到一个列表，并避免使用以下方法创建中间变量：

List<User> result = Stream
    .concat(first.stream(), second.stream())
    .collect(Collectors.toMap(
         User::getName,
         u -> new User(u.getName(), u.getComments()),
         (l, r) -> {
              l.setComments(l.getComments() + r.getComments());
              return l;
         }))
    .values()
    .stream()
    .collect(Collectors.toList());

Answer 2

您必须使用中间映射来合并两个列表中的用户，方法是对他们的年龄求和。

一种方法是使用流，如Aomine's answer 所示。这是另一种方式，没有流：

Map<String, Integer> map = new LinkedHashMap<>();
list1.forEach(u -> map.merge(u.getName(), u.getComments(), Integer::sum));
list2.forEach(u -> map.merge(u.getName(), u.getComments(), Integer::sum));

现在，您可以创建一个用户列表，如下所示：

List<User> result = new ArrayList<>();
map.forEach((name, comments) -> result.add(new User(name, comments)));

这假定User 有一个接受name 和comments 的构造函数。

---

编辑：正如@davidxxx 所建议的，我们可以通过分解第一部分来改进代码：

BiConsumer<List<User>, Map<String, Integer>> action = (list, map) -> 
        list.forEach(u -> map.merge(u.getName(), u.getComments(), Integer::sum));

Map<String, Integer> map = new LinkedHashMap<>();
action.accept(list1, map);
action.accept(list2, map);

此重构将避免 DRY。

Answer 3

使用Collectors.groupingBy 和Collectors.reducing 有一种非常直接的方法，不需要需要设置器，这是最大的优势，因为您可以保持User 不可变 ：

Collection<Optional<User>> d = Stream
    .of(first, second)                    // start with Stream<List<User>> 
    .flatMap(List::stream)                // flatting to the Stream<User>
    .collect(Collectors.groupingBy(       // Collecting to Map<String, List<User>>
        User::getName,                    // by name (the key)
                                          // and reducing the list into a single User

        Collectors.reducing((l, r) -> new User(l.getName(), l.getComments() + r.getComments()))))
    .values();                            // return values from Map<String, List<User>>

不幸的是，结果是Collection<Optional<User>>，因为归约管道返回Optional，因为结果可能根本不存在。您可以流式传输值并使用map() 摆脱Optional 或使用Collectors.collectAndThen*：

Collection<User> d = Stream
    .of(first, second)                    // start with Stream<List<User>> 
    .flatMap(List::stream)                // flatting to the Stream<User>
    .collect(Collectors.groupingBy(       // Collecting to Map<String, List<User>>       
        User::getName,                    // by name (the key)
        Collectors.collectingAndThen(     // reduce the list into a single User

            Collectors.reducing((l, r) -> new User(l.getName(), l.getComments() + r.getComments())), 
            Optional::get)))              // and extract from the Optional
    .values();  

^{* 感谢@Aomine}

Answer 4

作为替代相当直接和高效：

• 流式传输元素
• 将它们收集到Map<String, Integer> 中，以将每个名称与 cmets 的总和相关联 (int)
• 流式传输收集到的地图条目以创建用户列表。

或者，对于第三步，您可以使用 collectingAndThen(groupingBy()..., m -> ... 对 Map 收集器应用完成转换 但我发现它并不总是非常可读，在这里我们可以不用。

它会给：

List<User> users =
        Stream.concat(first.stream(), second.stream())
              .collect(groupingBy(User::getName, summingInt(User::getComments)))
              .entrySet()
              .stream()
              .map(e -> new User(e.getKey(), e.getValue()))
              .collect(toList());