Java 8 List<V> in Map<K, V> umwandeln

Question

Ich möchte eine Liste von Objekten in eine Map mit Java 8 Streams und Lambdas übersetzen.

So würde ich es in Java 7 und darunter schreiben.

private Map nameMap(List choices) {
        final Map hashMap = new HashMap<>();
        for (final Choice choice : choices) {
            hashMap.put(choice.getName(), choice);
        }
        return hashMap;
}

Das kann ich einfach mit Java 8 und Guava erreichen, aber ich möchte wissen, wie man dies ohne Guava machen kann.

In Guava:

private Map nameMap(List choices) {
    return Maps.uniqueIndex(choices, new Function() {

        @Override
        public String apply(final Choice input) {
            return input.getName();
        }
    });
}

Und Guava mit Java 8 Lambdas.

private Map nameMap(List choices) {
    return Maps.uniqueIndex(choices, Choice::getName);
}

Answer 1

Ich werde schreiben, wie man eine Liste in eine Map mit Generics und Inversion of Control umwandelt. Einfach Universalmethode!

Vielleicht haben wir eine Liste von Ganzzahlen oder Objekten. Die Frage ist also: Was soll der Schlüssel der Map sein?

Erstelle Interface

public interface KeyFinder {
    K getKey(E e);
}

Jetzt mithilfe der Inversion of Control:

  static  Map listToMap(List list, KeyFinder finder) {
        return  list.stream().collect(Collectors.toMap(e -> finder.getKey(e) , e -> e));
    }

Zum Beispiel, wenn wir Objekte vom Typ Buch haben, ist diese Klasse dafür zuständig, den Schlüssel für die Map auszuwählen

public class BookKeyFinder implements KeyFinder {
    @Override
    public Long getKey(Book e) {
        return e.getPrice()
    }
}

Answer 2

Another possibility only present in comments yet:

Map result =
choices.stream().collect(Collectors.toMap(c -> c.getName(), c -> c)));

Useful if you want to use a parameter of a sub-object as Key:

Map result =
choices.stream().collect(Collectors.toMap(c -> c.getUser().getName(), c -> c)));

Answer 3

Ich verwende diese Syntax

Map> choiceMap = 
choices.stream().collect(Collectors.groupingBy(choice -> choice.getName()));

Answer 4

Es ist möglich, Streams zu verwenden, um dies zu tun. Um die Notwendigkeit, explizit Collectors zu verwenden, zu entfernen, ist es möglich, toMap statisch zu importieren (wie von Effective Java, dritte Ausgabe empfohlen).

import static java.util.stream.Collectors.toMap;

private static Map nameMap(List choices) {
    return choices.stream().collect(toMap(Choice::getName, it -> it));
}

Answer 5

Dies kann auf 2 Arten gemacht werden. Lassen Sie Person die Klasse sein, die wir verwenden werden, um es zu demonstrieren.

public class Person {

    private String name;
    private int age;

    public String getAge() {
        return age;
    }
}

Lassen Sie persons die Liste von Personen sein, die in die Map konvertiert werden sollen

1. Mit einer einfachen Schleife und einem Lambda-Ausdruck in der Liste

Map> mapPersons = new HashMap<>();
persons.forEach(p->mapPersons.put(p.getAge(),p));

2. Mit Collectors auf einem Stream, der auf der gegebenen Liste definiert ist

Map> mapPersons = 
           persons.stream().collect(Collectors.groupingBy(Person::getAge));