Des collectionneurs.groupingBy n'accepte pas les clés null

Pour la première question, je suis d'accord avec skiwi qu'il ne devrait pas être jeter un NPE. J'espère qu'ils vont changer ça (ou au moins l'ajouter à la javadoc). En attendant, pour répondre à la deuxième question, j'ai décidé d'utiliser Collectors.toMap au lieu de Collectors.groupingBy:

Stream<Class<?>> stream = Stream.of(ArrayList.class);

Map<Class<?>, List<Class<?>>> map = stream.collect(
    Collectors.toMap(
        Class::getSuperclass,
        Collections::singletonList,
        (List<Class<?>> oldList, List<Class<?>> newEl) -> {
        List<Class<?>> newList = new ArrayList<>(oldList.size() + 1);
        newList.addAll(oldList);
        newList.addAll(newEl);
        return newList;
        }));

Ou, encapsulation:

/** Like Collectors.groupingBy, but accepts null keys. */
public static <T, A> Collector<T, ?, Map<A, List<T>>>
groupingBy_WithNullKeys(Function<? super T, ? extends A> classifier) {
    return Collectors.toMap(
        classifier,
        Collections::singletonList,
        (List<T> oldList, List<T> newEl) -> {
            List<T> newList = new ArrayList<>(oldList.size() + 1);
            newList.addAll(oldList);
            newList.addAll(newEl);
            return newList;
            });
    }

Et de l'utiliser comme ceci:

Stream<Class<?>> stream = Stream.of(ArrayList.class);
Map<Class<?>, List<Class<?>>> map = stream.collect(groupingBy_WithNullKeys(Class::getSuperclass));

Veuillez noter rolfl a donné un autre, de plus en plus compliqué de répondre, ce qui vous permet d'avoir votre propre Carte et de la Liste des fournisseurs. Je n'ai pas testé.

À votre 1ère question, à partir de la documentation:

Il n'y a pas de garanties sur le type, la mutabilité, serializability, ou le fil de sécurité de la Carte ou de la Liste des objets retournés.

Parce que pas tous les Carte implémentations permettent clés null ils ont probablement ajoutée à réduire le plus commun admissible définition d'un plan pour obtenir un maximum de flexibilité lors du choix d'un type.

À votre 2ème question, vous avez juste besoin d'un fournisseur, ne serait pas un lambda de travail? Je suis encore à se familiariser avec Java 8, peut-être une personne plus intelligente pouvez ajouter une meilleure réponse.

J'ai pensé que je voudrais prendre un moment et essayer de digérer cette question que vous avez. J'ai mis en place un SSCE pour ce que je m'attends si je l'ai fait manuellement, et ce que le groupingBy mise en œuvre dans la réalité.

Je ne pense pas que c'est une réponse, mais c'est une merveille pourquoi c'est un problème " de la chose. Aussi, si vous voulez, n'hésitez pas à pirater ce code pour avoir un null-friendly collector.

Modifier: générique-friendly de mise en œuvre:

/** groupingByNF - NullFriendly - allows you to specify your own Map and List supplier. */
private static final <T,K> Collector<T,?,Map<K,List<T>>> groupingByNF (
final Supplier<Map<K,List<T>>> mapsupplier,
final Supplier<List<T>> listsupplier,
final Function<? super T,? extends K> classifier) {
BiConsumer<Map<K,List<T>>, T> combiner = (m, v) -> {
K key = classifier.apply(v);
List<T> store = m.get(key);
if (store == null) {
store = listsupplier.get();
m.put(key, store);
}
store.add(v);
};
BinaryOperator<Map<K, List<T>>> finalizer = (left, right) -> {
for (Map.Entry<K, List<T>> me : right.entrySet()) {
List<T> target = left.get(me.getKey());
if (target == null) {
left.put(me.getKey(), me.getValue());
} else {
target.addAll(me.getValue());
}
}
return left;
};
return Collector.of(mapsupplier, combiner, finalizer);
}
/** groupingByNF - NullFriendly - otherwise similar to Java8 Collections.groupingBy */
private static final <T,K> Collector<T,?,Map<K,List<T>>> groupingByNF (Function<? super T,? extends K> classifier) {
return groupingByNF(HashMap::new, ArrayList::new, classifier);
}

Considérer ce code (le code groupes de valeurs de Chaîne en fonction de la Chaîne.longueur(), (ou null si la Chaîne d'entrée est null)):

public static void main(String[] args) {
String[] input = {"a", "a", "", null, "b", "ab"};
//How we group the Strings
final Function<String, Integer> classifier = (a) -> {return a != null ? Integer.valueOf(a.length()) : null;};
//Manual implementation of a combiner that accumulates a string value based on the classifier.
//no special handling of null key values.
BiConsumer<Map<Integer,List<String>>, String> combiner = (m, v) -> {
Integer key = classifier.apply(v);
List<String> store = m.get(key);
if (store == null) {
store = new ArrayList<String>();
m.put(key, store);
}
store.add(v);
};
//The finalizer merges two maps together (right into left)
//no special handling of null key values.
BinaryOperator<Map<Integer, List<String>>> finalizer = (left, right) -> {
for (Map.Entry<Integer, List<String>> me : right.entrySet()) {
List<String> target = left.get(me.getKey());
if (target == null) {
left.put(me.getKey(), me.getValue());
} else {
target.addAll(me.getValue());
}
}
return left;
};
//Using a manual collector
Map<Integer, List<String>> manual = Arrays.stream(input).collect(Collector.of(HashMap::new, combiner, finalizer));
System.out.println(manual);
//using the groupingBy collector.        
Collector<String, ?, Map<Integer, List<String>>> collector = Collectors.groupingBy(classifier);
Map<Integer, List<String>> result = Arrays.stream(input).collect(collector);
System.out.println(result);
}

Le code ci-dessus génère la sortie:

{0=[], null=[null], 1=[a, a, b], 2=[ab]}
Exception in thread "main" java.lang.NullPointerException: element cannot be mapped to a null key
at java.util.Objects.requireNonNull(Objects.java:228)
at java.util.stream.Collectors.lambda$groupingBy$135(Collectors.java:907)
at java.util.stream.Collectors$$Lambda$10/258952499.accept(Unknown Source)
at java.util.stream.ReduceOps$3ReducingSink.accept(ReduceOps.java:169)
at java.util.Spliterators$ArraySpliterator.forEachRemaining(Spliterators.java:948)
at java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:512)
at java.util.stream.AbstractPipeline.wrapAndCopyInto(AbstractPipeline.java:502)
at java.util.stream.ReduceOps$ReduceOp.evaluateSequential(ReduceOps.java:708)
at java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:234)
at java.util.stream.ReferencePipeline.collect(ReferencePipeline.java:499)
at CollectGroupByNull.main(CollectGroupByNull.java:49)