Guava way of sorting List according to another lis

问题:

I have List<Integer> consisting Ids of my Users. And after a database query, I am retrieving List<User>. I would like to order this list according to first Id list. List<User> may not include some of the Ids. What is the Guava way for sorting this list?

回答1:

The fully "functional" way, using Guava, would combine Ordering#explicit() with Ordering#onResultOf()

public class UserService {

    @Inject private UserDao userDao;

    public List<User> getUsersWithIds(List<Integer> userIds) {
        List<User> users = userDao.loadUsersWithIds(userIds);
        Ordering<User> orderById = Ordering.explicit(userIds).onResultOf(UserFunctions.getId());
        return orderById.immutableSortedCopy(users);
    }

}

You could declare an anonymous function inline, but I like to declare my functions as static factory methods in a separate class, for a cleaner code (the verbosity of Java's function declarations is hidden in the utility class):

/**
 * Static factory methods to create {@link Function}s for {@link User}s.
 */
public final class UserFunctions {
    private UserFunctions() { /* prevents instantiation */ }

    /**
     * @return a {@link Function} that returns an {@link User}'s id.
     */
    public static Function<User, Integer> getId() {
        return GetIdFunction.INSTANCE;
    }

    // enum singleton pattern
    private enum GetIdFunction implements Function<User, Integer> {
        INSTANCE;

        public Integer apply(User user) {
            return user.getId();
        }
    }

}

---

As mentioned by @Arne in a comment, this can be simplified in Java 8, using a method reference instead of the UserFunctions class:

public class UserService {

    @Inject private UserDao userDao;

    public List<User> getUsersWithIds(List<Integer> userIds) {
        List<User> users = userDao.loadUsersWithIds(userIds);
        Ordering<User> orderById = Ordering.explicit(userIds).onResultOf(User::getId);
        return orderById.immutableSortedCopy(immutableSortedCopy(users));
    }

}

回答2:

I don't think Guava has anything specific to do this. But it's just a matter of writing this comparator:

Collections.sort(userList, new Comparator<User>() {
    @Override
    public int compare(User u1, User u2) {
         int i1 = idList.indexOf(u1.getId());
         int i2 = idList.indexOf(u2.getId());
         return Ints.compare(i1, i2);
    }
}

Now that I think about it, it can also be implemented this way:

final Ordering<Integer> idOrdering = Ordering.explicit(idList);
Collections.sort(userList, new Comparator<User>() {
    @Override
    public int compare(User u1, User u2) {
         return idOrdering.compare(u1.getId(), u2.getId());
    }
}

which is probably more efficient.

回答3:

Others have already answered your question using Guava. Here is a Functional Java answer.

Please note that you'll have to use immutable data structures from the library in order to avail of all the goodness.

F<User, Integer> indexInIdList = new F<User, Integer>() {
  public Integer f(User u) {
    return idList.elementIndex(Equal.intEqual, u.getId()).toNull();
  }
};
userList.sort(Ord.intOrd.comap(indexInIdList));   

回答4:

Simpler answer using Google Guava

class Form {
  public Integer index; // for simplicity, no setter/getter included
}

List<Form> forms = ... // list instances, each of each with values for index

// ordering of forms by the ui sort index.
private static final Ordering<Form> sorter = Ordering.natural().onResultOf(new Function<Form, Integer>() {

    @Override
    public Integer apply(Form form) {
       return form.index;
    }
});

private List<Form> sortForms(List<Form> forms) {
    return sorter.sortedCopy(forms);
}

回答5:

Here's how to do this with Java 8 lambdas.

List<Integer> ids = ...; List<User> users = ...;
//map ids to their list indices, to avoid repeated indexOf calls
Map<Integer, Integer> rankMap = IntStream.range(0, ids.size()).boxed()
    .collect(Collectors.toMap(ids::get, Function.identity()));
//sort on the id's position in the list
users.sort(Comparator.comparing(u -> rankMap.get(u.id())));