Java Stream: get latest version of user records

Question

I have a list of User objects, defined as follows:

public class User {
    private String userId; // Unique identifier
    private String name;
    private String surname;
    private String otherPersonalInfo;
    private int versionNumber;
    }
    public User(String userId, String name, String surname, String otherPersonalInfo, int version) {
      super();
      this.name = name;
      this.surname = surname;
      this.otherPersonalInfo = otherPersonalInfo;
      this.version = version;
    }
}

Example list:

List<User> users = Arrays.asList(
  new User("JOHNSMITH", "John", "Smith", "Some info",     1),
  new User("JOHNSMITH", "John", "Smith", "Updated info",  2),
  new User("JOHNSMITH", "John", "Smith", "Latest info",   3),
  new User("BOBDOE",    "Bob",  "Doe",   "Personal info", 1),
  new User("BOBDOE",    "Bob",  "Doe",   "Latest info",   2)
);

I need a way to filter this list such that I get only the latest version for each user, i.e:

{"JOHNSMITH", "John", "Smith", "Latest info", 3},
{"BOBDOE", "Bob", "Doe", "Latest info", 2}

What's the best way to achieve this by using Java8 Stream API?

Have you tried using a `Comparator` that sorts the list by `version` ? — Anand Undavia, Mar 08 '17 at 12:14

score 8 · Answer 1 · edited May 23 '17 at 12:26

8

With a little assistance from this answer:

    Collection<User> latestVersions = users.stream()
            .collect(Collectors.groupingBy(User::getUserId,
                    Collectors.collectingAndThen(Collectors.maxBy(Comparator.comparing(User::getVersionNumber)), Optional::get)))
                    .values();

I am assuming the usual getters. Result:

[John Smith Latest info 3, Bob Doe Latest info 2]

edited May 23 '17 at 12:26

Community

1
1

answered Mar 08 '17 at 12:42

Ole V.V.

81,772
15
137
161

I've added an unique userId to replace the fullName here. Same concept though. – Nick Melis Mar 08 '17 at 12:49
Running your code into a JUnit test gives me an error though: java.lang.NullPointerException: element cannot be mapped to a null key – Nick Melis Mar 08 '17 at 12:50
2

@Nick Melis: well, the exception message already says it. `null` keys are not allowed, so the `fullName`, resp. `userId` property must not be `null`. – Holger Mar 08 '17 at 12:53
@Holger yes sorry that was just me being dumb :) – Nick Melis Mar 08 '17 at 12:57

score 1 · Answer 2 · edited May 23 '17 at 11:47

I sorted first by version to ensure the newst entry is first in the list. Afterwards I filtered on a distinct key to ensure only one object matching this key is part of the result. For the filtering I needed a predicate which stores a state to filter on things already seen.

The predicate looks like this:

    private static <T> Predicate<T> distinctByKey( Function<? super T, ?> key ) {
    Map<Object, Boolean> seen = new ConcurrentHashMap<>();
    return t -> seen.putIfAbsent( key.apply( t ), Boolean.TRUE ) == null;
}

And then I can use the following Stream:

users.stream().sorted( ( u1, u2 ) -> u2.versionNumber - u1.versionNumber )
              .filter( distinctByKey( u -> u.name + u.surname ) )
              .collect( Collectors.toList() );

There are some other nice solutions to do a distinct base on a key which can be found at Java 8 Distinct by property.

score 1 · Accepted Answer · answered Mar 09 '17 at 20:20

HashMap<String, User> map = users.stream().collect(Collectors.toMap(User::getUserId, 
            e -> e, 
            (left, right) -> {return left.getVersion() > right.getVersion() ? left : right;}, 
            HashMap::new));
System.out.println(map.values());

Above code prints:

[User [userId=BOBDOE, name=Bob, surname=Doe, otherPersonalInfo=Latest info, version=2], User [userId=JOHNSMITH, name=John, surname=Smith, otherPersonalInfo=Latest info, version=3]]

Explanation: toMap method takes 4 arguments:

keyMapper a mapping function to produce keys
valueMapper a mapping function to produce values
mergeFunction a merge function, used to resolve collisions between values associated with the same key, as supplied to Map.merge(Object, Object, BiFunction)
mapSupplier a function which returns a new, empty Map into which the results will be inserted

First arg is User::getUserId() to get key.
Second arg is a function that returns the User object as it is.
Third arg is a function which solves collision by comparing and keeping the User with latest version.
Fourth arg is the "new" method of HashMap.

Sean Patrick Floyd · Answer 4 · 2017-03-08T13:07:56.387

This will be painful, but it can be done with some aggregation, in the Java 8 Streams framework:

// create a Map from user name to users, sorted by version
Map<String, NavigableSet<User>> grouped =
        users.stream()
             .collect(
                     Collectors.groupingBy(
                             u -> u.name + "," + u.surname,
                             HashMap::new,
                             Collectors.toCollection(
                                     () -> new TreeSet<>(
                                             Comparator.comparing(
                                                   User::getVersionNumber)))));

// retrieve the latest versions from the Map
List<User> latestVersions = grouped.entrySet()
                                   .stream()
                                   .map(e -> e.getValue().last())
                                   .collect(Collectors.toList());

Given how verbose this is, I'd probably settle for an imperative solution though.

Keep a Map<String, User>
For every User, check whether the Map already contains the User's string representation
If it doesn't, or the User mapped to it has a lower version number, store the User in the Map.

Would it be useful if the User class had an ID field (rather than having to group by name + surname) ? — Nick Melis, Mar 08 '17 at 12:42
@NickMelis yes, definitely. That would eliminate false positives (the John Smith case) — Sean Patrick Floyd, Mar 08 '17 at 12:43
You can just use `Collector.toCollection(() -> new TreeSet<>( Comparator.comparing( User::getVersionNumber))` instead of `Collector.>of( () -> new TreeSet<>(Comparator.comparing(User::getVersionNumber)), Set::add, (left, right) -> { left.addAll(right); return left; })` — Holger, Mar 08 '17 at 12:58

score 0 · Answer 5 · answered Mar 08 '17 at 12:40

In java 8 you can create a comparator in the form of a lambda expression.

call users.stream().sorted passing in the comparator.

Example:

 Comparator<User > byVersionNumber = (u1, u2) -> Integer.compare(
            u1.getversionNumber(), u2.getversionNumber());

    users.stream().sorted(byVersionNumber)
            .forEach(u -> System.out.println(u));

Please check for syntax its rough

score 0 · Answer 6 · answered Aug 09 '17 at 15:27

 List<User> users = Arrays.asList(
                new User("JOHNSMITH", "John", "Smith", "Some info", 1),
                new User("JOHNSMITH", "John", "Smith", "Updated info", 2),
                new User("JOHNSMITH", "John", "Smith", "Latest info", 3),
                new User("BOBDOE", "Bob", "Doe", "Personal info", 1),
                new User("BOBDOE", "Bob", "Doe", "Latest info", 2)
        ).stream()
                .collect(Collectors.collectingAndThen(
                        Collectors.toMap(
                                User::getUserId,     //The user's unique property
                                Function.identity(), //Function<User, User>
                                BinaryOperator.maxBy(Comparator.comparing(User::getVersionNumber))

                        ),
                        map -> (List)map.values() 
                ));

Java Stream: get latest version of user records

6 Answers6

Linked