Using stream to merge two list with updated values

Is there a more elegant way to merge two lists in a 3rd one which take values from one and take values from second if the value is updated ?

To be clearer, let's consider I have 2 lists of users:

List<User> users = Arrays.asList(
        User.builder()
            .id(1).surname("john").build(),
        User.builder()
            .id(2).surname("paul").build(),
        User.builder()
            .id(3).surname("george").build(),
        User.builder()
            .id(4).surname("walter").build());


List<User> updatedUsers = Arrays.asList(
        User.builder()
            .id(1).surname("john").email("myEmail@email.com").build(),
        User.builder()
            .id(2).surname("paul").email("myEmail@email.com").build());

I'm expecting to get a list containing all users and common users replaced by the updated values.

I used the following code to implement the expected output:

Map<Integer, User> usersMap = users.stream()
        .collect(Collectors.toMap(User::getId, Function.identity()));
Map<Integer, User> updatedUsersMap = updatedUsers.stream()
        .collect(Collectors.toMap(User::getId, Function.identity()));


usersMap.putAll(updatedUsersMap);
List<User> output = usersMap.values().stream().toList();

I do have the expected result and I just wonder if there's another way to do it using stream, more efficient and elegant.
Thanks !

Your solution seems efficient enough to me, what is elegant might be matter of subject. Developers often use List when Set is more suitable collection (do you really want to access users by index?).

If the collections were Sets, User.equals() method was based only on the id field, and you want to emphasize the data of updatedUsers override the base data, you could describe result using set operations (yes, these are not part of standard Java - I borrow them from Guava or you can use any other implementation).

Set<Users> usersSet = new HashSet<>(users);
Set<Users> updatedUsersSet = new HashSet<>(updatedUsers);
Set<Users> output = Sets.union(updatedUsersSet, Sets.difference(usersSet, updatedUsersSet));

The problem is shifted to higher level of abstraction which I admit not everyone must like.

You can do it in one go without creating intermediate maps if you concat the stream of users and updated users and collecting the second value if you encounter a duplicate key:

List<User> result = new ArrayList<>(
        Stream.concat(users.stream(), updatedUsers.stream())
              .collect(Collectors.toMap(User::getId, 
                                        Function.identity(),
                                        (first,second) -> second)).values());

Streams are very useful in many circumstances. But they also incur quite a bit of overhead. Just use a little imperative programming to do the same thing.

You are creating a new user and placing it in a list. The busy work is done. Since the updated user has been created and there is no way to tell if the user is a new user or an updated user, just add it to the map normally. It will either be added as a new user or replace an existing one.

Map<Integer, User> userMap = new HashMap<>();
 
for(User user : users) {
    userMap.put(user.getId(), user);
}
       
for(User user : updatedUsers) {
    userMap.put(user.getId(), user);
}

Now you can get the updated map entries by user id.

Note: You many want to institute some syntax/invariant checking when creating the User instance. For example:

• user id out of range
• email syntax error

You can always retrieve the users as a list as follows.

List<User> userList = new ArrayList<>(userMap.values());

If for some reason, you need to verify that a user is in the map before taking action, you can see if the user's id is already there.

if (userMap.containsKey(userId)) {
  ...
}

</details>



# 答案4
**得分**: 0

你可以通过`import`静态导入来使其看起来更整洁。此外，不必迭代每个集合以添加到组合的`Map`，你可以将组合的`Map`用作`Supplier`：

```java
Map<Integer, User> updatedUsersMap = updatedUsers.stream()
    .collect(Collectors.toMap(
        User::getId,
        Function.identity(),
        (k, v) -> v,
        () -> usersMap));

Map<Integer, User> updatedUsersMap = updatedUsers.stream().
    collect(toMap(
                User::getId,
                identity(),
                (k, v) ->v,
                ()-> { return usersMap; }));