Lista de Java 8 <V> en el mapa <K, V>

Quiero traducir una lista de objetos en un mapa utilizando las secuencias y lambdas de Java 8.

Así es como lo escribiría en Java 7 y versiones anteriores.

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

Puedo lograr esto fácilmente usando Java 8 y Guava, pero me gustaría saber cómo hacerlo sin Guava.

En Guayaba:

private Map<String, Choice> nameMap(List<Choice> choices) {
    return Maps.uniqueIndex(choices, new Function<Choice, String>() {

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

Y Guayaba con Java 8 lambdas.

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

Basado en la Collectorsdocumentación , es tan simple como:

Map<String, Choice> result =
    choices.stream().collect(Collectors.toMap(Choice::getName,
                                              Function.identity()));

Si NO se garantiza que su clave sea ​​única para todos los elementos de la lista, debe convertirla en a en Map<String, List<Choice>>lugar de enMap<String, Choice>

Map<String, List<Choice>> result =
 choices.stream().collect(Collectors.groupingBy(Choice::getName));

Úselo getName()como clave y a Choicesí mismo como valor del mapa:

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

Aquí hay otro en caso de que no desee utilizar Collectors.toMap ()

Map<String, Choice> result =
   choices.stream().collect(HashMap<String, Choice>::new, 
                           (m, c) -> m.put(c.getName(), c),
                           (m, u) -> {});

La mayoría de las respuestas enumeradas, omiten un caso cuando la lista tiene elementos duplicados . En ese caso, la respuesta arrojará IllegalStateException. Consulte el siguiente código para manejar también las listas duplicadas :

public Map<String, Choice> convertListToMap(List<Choice> choices) {
    return choices.stream()
        .collect(Collectors.toMap(Choice::getName, choice -> choice,
            (oldValue, newValue) -> newValue));
  }

Una opción más de forma sencilla

Map<String,Choice> map = new HashMap<>();
choices.forEach(e->map.put(e.getName(),e));

Por ejemplo, si desea convertir campos de objetos en mapas:

Objeto de ejemplo:

class Item{
        private String code;
        private String name;

        public Item(String code, String name) {
            this.code = code;
            this.name = name;
        }

        //getters and setters
    }

Y la operación convierte la lista en mapa:

List<Item> list = new ArrayList<>();
list.add(new Item("code1", "name1"));
list.add(new Item("code2", "name2"));

Map<String,String> map = list.stream()
     .collect(Collectors.toMap(Item::getCode, Item::getName));

Si no le importa usar bibliotecas de terceros, la biblioteca cyclops-react de AOL (divulgación, soy un colaborador) tiene extensiones para todos los tipos de colecciones JDK , incluidos List y Map .

ListX<Choices> choices;
Map<String, Choice> map = choices.toMap(c-> c.getName(),c->c);

Puede crear una secuencia de índices utilizando un IntStream y luego convertirlos en un mapa:

Map<Integer,Item> map = 
IntStream.range(0,items.size())
         .boxed()
         .collect(Collectors.toMap (i -> i, i -> items.get(i)));

Estaba tratando de hacer esto y descubrí que, al usar las respuestas anteriores, al usar Functions.identity()la clave del Mapa, tuve problemas con el uso de un método local this::localMethodNameque realmente funciona debido a problemas de escritura.

Functions.identity()en realidad hace algo con la escritura en este caso, por lo que el método solo funcionaría devolviendo Objecty aceptando un parámetro deObject

Para resolver esto, terminé abandonando Functions.identity()y usando en su s->slugar.

Entonces, mi código, en mi caso para enumerar todos los directorios dentro de un directorio, y para cada uno usar el nombre del directorio como clave para el mapa y luego llamar a un método con el nombre del directorio y devolver una colección de elementos, se ve así:

Map<String, Collection<ItemType>> items = Arrays.stream(itemFilesDir.listFiles(File::isDirectory))
.map(File::getName)
.collect(Collectors.toMap(s->s, this::retrieveBrandItems));

Escribiré cómo convertir una lista en un mapa usando genéricos e inversión de control . ¡Solo método universal!

Tal vez tengamos una lista de enteros o una lista de objetos. Entonces la pregunta es la siguiente: ¿cuál debería ser la clave del mapa?

crear interfaz

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

ahora usando inversión de control:

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

Por ejemplo, si tenemos objetos de libro, esta clase es elegir clave para el mapa

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

Yo uso esta sintaxis

Map<Integer, List<Choice>> choiceMap = 
choices.stream().collect(Collectors.groupingBy(choice -> choice.getName()));

Map<String, Set<String>> collect = Arrays.asList(Locale.getAvailableLocales()).stream().collect(Collectors
                .toMap(l -> l.getDisplayCountry(), l -> Collections.singleton(l.getDisplayLanguage())));

Esto se puede hacer de 2 formas. Sea persona la clase que vamos a utilizar para demostrarlo.

public class Person {

    private String name;
    private int age;

    public String getAge() {
        return age;
    }
}

Sea personas la lista de personas que se convertirán al mapa

1.Uso de foreach simple y una expresión Lambda en la lista

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

2. Utilizar recopiladores en Stream definidos en la lista dada.

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

Es posible usar transmisiones para hacer esto. Para eliminar la necesidad de usar explícitamente Collectors, es posible importar toMapestáticamente (como recomienda Effective Java, tercera edición).

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

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

Aquí está la solución de StreamEx

StreamEx.of(choices).toMap(Choice::getName, c -> c);

Map<String,Choice> map=list.stream().collect(Collectors.toMap(Choice::getName, s->s));

Incluso sirve para este propósito para mí,

Map<String,Choice> map=  list1.stream().collect(()-> new HashMap<String,Choice>(), 
            (r,s) -> r.put(s.getString(),s),(r,s) -> r.putAll(s));

Si cada valor nuevo para el mismo nombre de clave debe anularse:

public Map < String, Choice > convertListToMap(List < Choice > choices) {
    return choices.stream()
        .collect(Collectors.toMap(Choice::getName,
            Function.identity(),
            (oldValue, newValue) - > newValue));
}

Si todas las opciones deben agruparse en una lista para un nombre:

public Map < String, Choice > convertListToMap(List < Choice > choices) {
    return choices.stream().collect(Collectors.groupingBy(Choice::getName));
}

List<V> choices; // your list
Map<K,V> result = choices.stream().collect(Collectors.toMap(choice::getKey(),choice));
//assuming class "V" has a method to get the key, this method must handle case of duplicates too and provide a unique key.

Como alternativa a guavauno, puede usar kotlin-stdlib

private Map<String, Choice> nameMap(List<Choice> choices) {
    return CollectionsKt.associateBy(choices, Choice::getName);
}

Otra posibilidad solo presente en los comentarios todavía:

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

Útil si desea utilizar un parámetro de un subobjeto como clave:

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