将列表中的元素分组为子列表（可能使用番石榴）

Question

我想对列表中的元素进行分组。我目前正在这样做：

public static <E> List<List<E>> group(final List<E> list, final GroupFunction<E> groupFunction) {

    List<List<E>> result = Lists.newArrayList();

    for (final E element : list) {

        boolean groupFound = false;
        for (final List<E> group : result) {
            if (groupFunction.sameGroup(element, group.get(0))) {
                group.add(element);
                groupFound = true;
                break;
            }
        }
        if (! groupFound) {

            List<E> newGroup = Lists.newArrayList();
            newGroup.add(element);
            result.add(newGroup);
        }
    }

    return result;
}

public interface GroupFunction<E> {
    public boolean sameGroup(final E element1, final E element2);
}

是否有更好的方法来做到这一点，最好使用番石榴？

Answer 1

当然可以，并且使用Guava甚至更容易:)使用Multimaps.index(Iterable, Function)：

ImmutableListMultimap<E, E> indexed = Multimaps.index(list, groupFunction);

如果给出具体的用例，将更容易展示它的实际作用。

来自文档的示例：

List<String> badGuys =
   Arrays.asList("Inky", "Blinky", "Pinky", "Pinky", "Clyde");
Function<String, Integer> stringLengthFunction = ...;
Multimap<Integer, String> index =
   Multimaps.index(badGuys, stringLengthFunction);
System.out.println(index);

版画

{4=[Inky], 6=[Blinky], 5=[Pinky, Pinky, Clyde]}

在您的情况下，如果GroupFunction定义为：

GroupFunction<String> groupFunction = new GroupFunction<String>() {
  @Override public String sameGroup(final String s1, final String s2) {
    return s1.length().equals(s2.length());
  }
}

那么它将转换为：

Function<String, Integer> stringLengthFunction = new Function<String, Integer>() {
  @Override public Integer apply(final String s) {
    return s.length();
  }
}

这是stringLengthFunctionGuava示例中可能使用的实现。

最后，在Java 8中，整个片段甚至可以变得更加简单，因为lambas和方法引用足够简洁，可以内联：

ImmutableListMultimap<E, E> indexed = Multimaps.index(list, String::length);

对于使用纯Java
8（无Guava）的示例，Collector.groupingBy请参见[JeffreyBosboom的答案]，尽管该方法几乎没有区别：

• 它不会返回ImmutableListMultimap，而是Map带有Collection值，

• 对于返回的Map （源） 的类型，可变性，可序列化性或线程安全性，不做任何保证 ，

• 它比Guava +方法参考更为冗长。

编辑 ：如果您不关心索引键，则可以获取分组值：

List<List<E>> grouped = Lists.transform(indexed.keySet().asList(), new Function<E, List<E>>() {
        @Override public List<E> apply(E key) {
            return indexed.get(key);
        }
});

// or the same view, but with Java 8 lambdas:
List<List<E>> grouped = Lists.transform(indexed.keySet().asList(), indexed::get);

首先，您Lists<List<E>>可以根据需要查看哪些内容可以轻松复制ArrayList或按原样使用。还要注意的indexed.get(key)是ImmutableList。

// bonus: similar as above, but not a view, instead collecting to list using streams:
List<List<E>> grouped = indexed.keySet().stream()
    .map(indexed::get)
    .collect(Collectors.toList());

编辑2 ：正如Petr Gladkikh在下面的评论中提到的，如果Collection<List<E>>足够的话，上面的示例可能会更简单：

Collection<List<E>> grouped = indexed.asMap().values();