How to use Map.computeIfAbsent() in a stream?

Question

I have a fun puzzler. Say I have a list of String values:

["A", "B", "C"]

Then I have to query another system for a Map<User, Long> of users with an attribute that corresponds to those values in the list with a count:

{name="Annie", key="A"} -> 23
{name="Paul", key="C"} -> 16

I need to return a new List<UserCount> with a count of each key. So I expect:

 {key="A", count=23},
 {key="B", count=0},
 {key="C", count=16}

But I'm having a hard time computing when one of my User objects has no corresponding count in the map.

I know that map.computeIfAbsent() does what I need, but how can I apply it based on what's on the contents of the original list?

I think I need to stream the over the original list, then apply compute? So I have:

valuesList.stream()
 .map(it -> valuesMap.computeIfAbsent(it.getKey(), k-> OL))
 ...

But here's where I get stuck. Can anyone provide any insight as to how I accomplish what I need?

Answer 1

You can create an auxiliary Map<String, Long> which will associate each string key with the count and then generate a list of UserCount based on it.

Example:

public record User(String name, String key) {}
public record UserCount(String key, long count) {}

public static void main(String[] args) {
    List<String> keys = List.of("A", "B", "C");
    
    Map<User, Long> countByUser =
        Map.of(new User("Annie", "A"), 23L,
               new User("Paul", "C"), 16L));
    
    Map<String, Long> countByKey = countByUser.entrySet().stream()
        .collect(Collectors.groupingBy(entry -> entry.getKey().key(), 
            Collectors.summingLong(Map.Entry::getValue)));

    List<UserCount> userCounts = keys.stream()
        .map(key -> new UserCount(key, countByKey.getOrDefault(key, 0L)))
        .collect(Collectors.toList());

    System.out.println(userCounts);
}

Output

[UserCount[key=A, count=23], UserCount[key=B, count=0], UserCount[key=C, count=16]]

Regarding the idea of utilizing computeIfAbsent() with stream - this approach is wrong and discouraged by the documentation of the Stream API.

Sure, you can use computeIfAbsent() to solve this problem, but not in conjunction with streams. It's not a good idea to create a stream that operates via side effects (at least without compelling reason).

And I guess you even don't need Java 8 computeIfAbsent(), plain and simple putIfAbsent() will be sufficient.

The following code will produce the same result:

Map<String, Long> countByKey = new HashMap<>();

countByUser.forEach((k, v) -> countByKey.merge(k.key(), v, Long::sum));
keys.forEach(k -> countByKey.putIfAbsent(k, 0L));

List<UserCount> userCounts = keys.stream()
            .map(key -> new UserCount(key, countByKey.getOrDefault(key, 0L)))
            .collect(Collectors.toList());

And instead of applying forEach() on a map and list, you can create two enhanced for loops if this options looks convoluted.

Answer 2

To get a List<UserCount> from your Map<User, Long> with a List<String>, you could stream the List<String> as you were doing and then map each key to a UserCount.

Basically, for every list's key, you could check if this is present within the map's keyset by returning the user with the corresponding key. To return the User from the map, you could simply stream the keyset, filter it by the current key and use the terminal operation findFirst() to get an Optional containing the only User with that key or nothing (orElse(null) will return a User if contained or null). After retrieving the user, you can now create a new UserCount with the current key you're mapping and 0L if the user is null or its corresponding long value if this is not null.

List<UserCount> listRes = listKeys.stream()
        .map(key -> {
            //Retrieving the user whose key is equal to the current one we're mapping, if no user has been found we return null
            User user = mapUsers.keySet().stream().filter(u -> u.getKey().equals(key)).findFirst().orElse(null);

            //Returning a UserCount with key equals to the one we're mapping and with count equals to its corresponding value (if the user is not null) or 0 (if the user is null)
            return new UserCount(key, user != null ? mapUsers.get(user) : 0L);
        })
        .collect(Collectors.toList());

Here there is also a sample

https://ideone.com/FNm9XS

Answer 3

Another educational and parallel friendly version would be to gather the logic in one place and build your own custom accumulator and combiner for the Collector

public static void main(String[] args) {

    Map<User, Long> countByUser =
            Map.of(new User("Alice", "A"), 23L,
                    new User("Bob", "C"), 16L);

    List<String> keys = List.of("A", "B", "C");

    UserCountAggregator userCountAggregator =
            countByUser.entrySet()
                    .parallelStream()
                    .collect(UserCountAggregator::new,
                            UserCountAggregator::accumulator,
                            UserCountAggregator::combiner);

    List<UserCount> userCounts = userCountAggregator.getUserCounts(keys);
    System.out.println(userCounts);
}

Output

[UserCount(key=A, count=23), UserCount(key=B, count=0), UserCount(key=C, count=16)]

User and UserCount classes with Lombok's @Value

@Value
class User {
    private String name;
    private String key;
}

@Value
class UserCount {
    private String key;
    private long count;
}

And the UserCountAggregator which contains your custom accumulator and combiner

class UserCountAggregator {
    private Map<String, Long> keyCounts = new HashMap<>();

    public void accumulator(Map.Entry<User, Long> userLongEntry) {
        keyCounts.put(userLongEntry.getKey().getKey(),
                keyCounts.getOrDefault(userLongEntry.getKey().getKey(), 0L) 
                        + userLongEntry.getValue());
    }

    public void combiner(UserCountAggregator other) {
        other.keyCounts
                .forEach((key, value) -> keyCounts.merge(key, value, Long::sum));
    }

    public List<UserCount> getUserCounts(List<String> keys) {
        return keys.stream()
                .map(key -> new UserCount(key, keyCounts.getOrDefault(key, 0L)))
                .collect(Collectors.toList());
    }
}

Answer 4

final Map<User,Long> valuesMap = ...

// First, map keys to counts (assuming keys are unique for each user) 
final Map<String,Long> keyToCountMap = valuesMap.entrySet().stream()
    .collect(Collectors.toMap(e -> e.getKey().key, e -> e.getValue()));

final List<UserCount> list = valuesList.stream()
  .map(key -> new UserCount (key, keyToCountMap.getOrDefault(key, 0L)))
  .collect(Collectors.toList());