Regrouper des éléments d'une liste en sous-listes (peut-être en utilisant la goyave)

bien sûr, il est possible, et encore plus facile avec la goyave :) utiliser Multimaps.index(Iterable, Function) :

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

Si vous donnez cas concret d'utilisation, il serait plus facile de le montrer en action.

exemple tiré de docs:

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);

imprime

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

dans votre cas si GroupFunction est défini comme:

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

alors il traduirait à:

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

ce qui est possible stringLengthFunction implémentation utilisée dans L'exemple de Guava.

---

enfin, en Java 8, tout l'extrait pourrait être encore plus simple, comme lambas et les références de méthode sont assez concises pour être inligné:

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

Par pure Java 8 (pas de Goyave) exemple d'utilisation de Collector.groupingBy voir Jeffrey Bosboom la réponse de , bien qu'il n'y peu de différences dans cette approche:

• il n'a pas de retour ImmutableListMultimap mais plutôt Map avec Collection valeurs",

• Il n'y a pas de garanties sur le type, la mutabilité, serializability, ou le fil de sécurité de la Carte retournée ( source ),

• c'est un peu plus verbeux que la méthode Goyave + référence.

---

modifier : si vous ne vous souciez pas des clés indexées, vous pouvez récupérer des valeurs groupées:

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);

ce que vous offre Lists<List<E>> afficher le contenu peut être facilement copié ArrayList ou tout simplement utilisé comme il est, comme vous le souhaitiez, en premier lieu. Notez également que indexed.get(key) est 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());

EDIT 2 : As Petr Gladkikh mentionne dans le commentaire ci-dessous , si Collection<List<E>> est suffisant, l'exemple ci-dessus pourrait être plus simple:

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