Add Lists.partitionBy to split a list into a list of lists

Sometimes you wish to iterate over a list of items in a grouped fashion:

List<Project> trending = Arrays.asList(new Project("guava", "java"),
        new Project("spring", "java"), new Project("node", "js"));

Project current = null;
for (Project p : trending) {
    if (current == null) {
        current = p;
    } else if (!current.getLang().equals(p.getLang())) {
        System.out.println("---");
        current = p;
    }
    System.out.println(p.getName());
}

There already is Lists.partition, but in this case the sub lists might have different sizes (and we don’t know these sizes).

It would be nice to have a standard way to split the list, with only needing to specify the difference between the items:

List<List<Project>> grouped = Lists.partitionBy(trending,
        (p1, p2) -> p1.getLang().equals(p2.getLang()));
for (int i = 0; i < grouped.size(); i++) {
    if (i > 0) {
        System.out.println("---");
    }
    for (Project p : grouped.get(i)) {
        System.out.println(p.getName());
    }
}

Naming

There already is Lists.partition and as that also returns List<List<T>>, I would suggest a similar name. Possible alternatives would be splitBy or groupBy. My suggestion would be partitionBy.

Related

• Lists.partition, but assumes that each sub list has the same size
• java.util.stream.Collectors.groupingBy (and very similar Collectors.partitioningBy) only expect a predicate (not a BiPredicate), so the caller cannot compare two items directly. They also return a Map, which is not desired in some cases.

Summary

Add new method List<List<T>> Lists.partitionBy(List<T>, BiPredicate<T, T>).

I would be happy to implement it and if there is agreement on this, I can create a PR. Thanks for reading, and if you have any questions, please ask!

[pascalgn]

Thanks for the pointer, I have not considered that! However, Multimaps.index returns a map, so it’s very similar to Collectors.groupingBy:

var result = Multimaps.index(Arrays.asList("Inky", "Blinky", "Pinky", "Pinky", "Clyde"),
        String::length);
System.out.println(result);  // {4=[Inky], 6=[Blinky], 5=[Pinky, Pinky, Clyde]}

Sometimes it might be easier to determine where a list should be split (“no, these two items are different!”) than to assign a suitable key to each item. Additionally, the proposed solution would support cases where you would not want items matched to an “old” group when there are groups in between:

List<List<String>> grouped = Lists.partitionBy(
        Arrays.asList("Pinky", "Blinky", "Pinky", "Pinky"),
        (a, b) -> a.length() == b.length());
System.out.println(grouped);  // [[Pinky], [Blinky], [Pinky, Clyde]]

[pascalgn]

I received some cautious 👍and no 👎, so I created a PR for it. If you have some time, please have a look (it’s small!) and tell me what you think!