Java: Cómo convertir Lista a Mapa

Recientemente tuve una conversación con un colega sobre cuál sería la forma óptima de convertir Lista MapJava y si hay algún beneficio específico de hacerlo.

Quiero conocer el enfoque de conversión óptimo y realmente agradecería si alguien me puede guiar.

¿Es este un buen enfoque?

List<Object[]> results;
Map<Integer, String> resultsMap = new HashMap<Integer, String>();
for (Object[] o : results) {
    resultsMap.put((Integer) o[0], (String) o[1]);
}

List<Item> list;
Map<Key,Item> map = new HashMap<Key,Item>();
for (Item i : list) map.put(i.getKey(),i);

Suponiendo, por supuesto, que cada elemento tiene un getKey()método que devuelve una clave del tipo adecuado.

Con java-8, podrás hacer esto en una línea usando streams y la Collectorsclase.

Map<String, Item> map = 
    list.stream().collect(Collectors.toMap(Item::getKey, item -> item));

Demo breve:

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class Test{
    public static void main (String [] args){
        List<Item> list = IntStream.rangeClosed(1, 4)
                                   .mapToObj(Item::new)
                                   .collect(Collectors.toList()); //[Item [i=1], Item [i=2], Item [i=3], Item [i=4]]

        Map<String, Item> map = 
            list.stream().collect(Collectors.toMap(Item::getKey, item -> item));

        map.forEach((k, v) -> System.out.println(k + " => " + v));
    }
}
class Item {

    private final int i;

    public Item(int i){
        this.i = i;
    }

    public String getKey(){
        return "Key-"+i;
    }

    @Override
    public String toString() {
        return "Item [i=" + i + "]";
    }
}

Salida:

Key-1 => Item [i=1]
Key-2 => Item [i=2]
Key-3 => Item [i=3]
Key-4 => Item [i=4]

Como se señaló en los comentarios, puede usar en Function.identity()lugar de item -> item, aunque me parece i -> ibastante explícito.

Y para ser completo, tenga en cuenta que puede usar un operador binario si su función no es biyectiva. Por ejemplo, consideremos esto Listy la función de mapeo que para un valor int, calcule el resultado del módulo 3:

List<Integer> intList = Arrays.asList(1, 2, 3, 4, 5, 6);
Map<String, Integer> map = 
    intList.stream().collect(toMap(i -> String.valueOf(i % 3), i -> i));

Al ejecutar este código, recibirá un error que dice java.lang.IllegalStateException: Duplicate key 1 . Esto se debe a que 1% 3 es igual a 4% 3 y, por lo tanto, tiene el mismo valor de clave dada la función de asignación de teclas. En este caso, puede proporcionar un operador de fusión.

Aquí hay uno que suma los valores; (i1, i2) -> i1 + i2;eso se puede reemplazar con la referencia del método Integer::sum.

Map<String, Integer> map = 
    intList.stream().collect(toMap(i -> String.valueOf(i % 3), 
                                   i -> i, 
                                   Integer::sum));

que ahora produce:

0 => 9 (i.e 3 + 6)
1 => 5 (i.e 1 + 4)
2 => 7 (i.e 2 + 5)

¡Espero eso ayude! :)

En caso de que esta pregunta no se cierre como un duplicado, la respuesta correcta es usar Google Collections :

Map<String,Role> mappedRoles = Maps.uniqueIndex(yourList, new Function<Role,String>() {
  public String apply(Role from) {
    return from.getName(); // or something else
  }});

Usando Java 8 puedes hacer lo siguiente:

Map<Key, Value> result= results
                       .stream()
                       .collect(Collectors.toMap(Value::getName,Function.identity()));

Value puede ser cualquier objeto que uses.

Desde Java 8, la respuesta de @ZouZou usando el Collectors.toMaprecopilador es ciertamente la forma idiomática de resolver este problema.

Y como esta es una tarea tan común, podemos convertirla en una utilidad estática.

De esa manera, la solución realmente se convierte en una línea.

/**
 * Returns a map where each entry is an item of {@code list} mapped by the
 * key produced by applying {@code mapper} to the item.
 *
 * @param list the list to map
 * @param mapper the function to produce the key from a list item
 * @return the resulting map
 * @throws IllegalStateException on duplicate key
 */
public static <K, T> Map<K, T> toMapBy(List<T> list,
        Function<? super T, ? extends K> mapper) {
    return list.stream().collect(Collectors.toMap(mapper, Function.identity()));
}

Y así es como lo usarías en un List<Student>:

Map<Long, Student> studentsById = toMapBy(students, Student::getId);

A Listy Mapson conceptualmente diferentes. A Listes una colección ordenada de artículos. Los elementos pueden contener duplicados, y un elemento puede no tener ningún concepto de un identificador único (clave). A Maptiene valores asignados a claves. Cada clave solo puede apuntar a un valor.

Por lo tanto, dependiendo de Listlos elementos de su, puede o no ser posible convertirlo en a Map. ¿ ListSus artículos no tienen duplicados? ¿Cada elemento tiene una clave única? Si es así, entonces es posible ponerlos en a Map.

Alexis ya ha publicado una respuesta en Java 8 utilizando el método toMap(keyMapper, valueMapper). Según el documento para la implementación de este método:

No hay garantías sobre el tipo, mutabilidad, serialización o seguridad de subprocesos del Mapa devuelto.

Entonces, en caso de que estemos interesados ​​en una implementación específica de la Mapinterfaz, por ejemplo HashMap, podemos usar el formulario sobrecargado como:

Map<String, Item> map2 =
                itemList.stream().collect(Collectors.toMap(Item::getKey, //key for map
                        Function.identity(),    // value for map
                        (o,n) -> o,             // merge function in case of conflict with keys
                        HashMap::new));         // map factory - we want HashMap and not any Map implementation

Aunque usar cualquiera Function.identity()o i->iestá bien, pero parece que en Function.identity()lugar de i -> ipodría ahorrar algo de memoria según esta respuesta relacionada .

También hay una manera simple de hacerlo usando Maps.uniqueIndex (...) de Googleguayaba bibliotecas

Método universal

public static <K, V> Map<K, V> listAsMap(Collection<V> sourceList, ListToMapConverter<K, V> converter) {
    Map<K, V> newMap = new HashMap<K, V>();
    for (V item : sourceList) {
        newMap.put( converter.getKey(item), item );
    }
    return newMap;
}

public static interface ListToMapConverter<K, V> {
    public K getKey(V item);
}

Sin java-8, podrá hacer esto en colecciones de una línea de Commons, y en la clase de Cierre

List<Item> list;
@SuppressWarnings("unchecked")
Map<Key, Item> map  = new HashMap<Key, Item>>(){{
    CollectionUtils.forAllDo(list, new Closure() {
        @Override
        public void execute(Object input) {
            Item item = (Item) input;
            put(i.getKey(), item);
        }
    });
}};

Se te ocurren muchas soluciones, dependiendo de lo que quieras lograr:

Cada elemento de la lista es clave y valor

for( Object o : list ) {
    map.put(o,o);
}

Los elementos de la lista tienen algo para buscarlos, tal vez un nombre:

for( MyObject o : list ) {
    map.put(o.name,o);
}

Los elementos de la lista tienen algo para buscarlos, y no hay garantía de que sean únicos: use Google MultiMaps

for( MyObject o : list ) {
    multimap.put(o.name,o);
}

Dando a todos los elementos la posición como clave:

for( int i=0; i<list.size; i++ ) {
    map.put(i,list.get(i));
}

...

Realmente depende de lo que quieras lograr.

Como puede ver en los ejemplos, un Mapa es un mapeo de una clave a un valor, mientras que una lista es solo una serie de elementos que tienen una posición cada uno. Por lo tanto, simplemente no son convertibles automáticamente.

Aquí hay un pequeño método que escribí exactamente para este propósito. Utiliza Validar de Apache Commons.

Sientase libre de usarlo.

/**
 * Converts a <code>List</code> to a map. One of the methods of the list is called to retrive
 * the value of the key to be used and the object itself from the list entry is used as the
 * objct. An empty <code>Map</code> is returned upon null input.
 * Reflection is used to retrieve the key from the object instance and method name passed in.
 *
 * @param <K> The type of the key to be used in the map
 * @param <V> The type of value to be used in the map and the type of the elements in the
 *            collection
 * @param coll The collection to be converted.
 * @param keyType The class of key
 * @param valueType The class of the value
 * @param keyMethodName The method name to call on each instance in the collection to retrieve
 *            the key
 * @return A map of key to value instances
 * @throws IllegalArgumentException if any of the other paremeters are invalid.
 */
public static <K, V> Map<K, V> asMap(final java.util.Collection<V> coll,
        final Class<K> keyType,
        final Class<V> valueType,
        final String keyMethodName) {

    final HashMap<K, V> map = new HashMap<K, V>();
    Method method = null;

    if (isEmpty(coll)) return map;
    notNull(keyType, Messages.getString(KEY_TYPE_NOT_NULL));
    notNull(valueType, Messages.getString(VALUE_TYPE_NOT_NULL));
    notEmpty(keyMethodName, Messages.getString(KEY_METHOD_NAME_NOT_NULL));

    try {
        // return the Method to invoke to get the key for the map
        method = valueType.getMethod(keyMethodName);
    }
    catch (final NoSuchMethodException e) {
        final String message =
            String.format(
                    Messages.getString(METHOD_NOT_FOUND),
                    keyMethodName,
                    valueType);
        e.fillInStackTrace();
        logger.error(message, e);
        throw new IllegalArgumentException(message, e);
    }
    try {
        for (final V value : coll) {

            Object object;
            object = method.invoke(value);
            @SuppressWarnings("unchecked")
            final K key = (K) object;
            map.put(key, value);
        }
    }
    catch (final Exception e) {
        final String message =
            String.format(
                    Messages.getString(METHOD_CALL_FAILED),
                    method,
                    valueType);
        e.fillInStackTrace();
        logger.error(message, e);
        throw new IllegalArgumentException(message, e);
    }
    return map;
}

Puede aprovechar la API de secuencias de Java 8.

public class ListToMap {

  public static void main(String[] args) {
    List<User> items = Arrays.asList(new User("One"), new User("Two"), new User("Three"));

    Map<String, User> map = createHashMap(items);
    for(String key : map.keySet()) {
      System.out.println(key +" : "+map.get(key));
    }
  }

  public static Map<String, User> createHashMap(List<User> items) {
    Map<String, User> map = items.stream().collect(Collectors.toMap(User::getId, Function.identity()));
    return map;
  }
}

Para más detalles visite: http://codecramp.com/java-8-streams-api-convert-list-map/

Un ejemplo de Java 8 para convertir un List<?>objeto en un Map<k, v>:

List<Hosting> list = new ArrayList<>();
list.add(new Hosting(1, "liquidweb.com", new Date()));
list.add(new Hosting(2, "linode.com", new Date()));
list.add(new Hosting(3, "digitalocean.com", new Date()));

//example 1
Map<Integer, String> result1 = list.stream().collect(
    Collectors.toMap(Hosting::getId, Hosting::getName));

System.out.println("Result 1 : " + result1);

//example 2
Map<Integer, String> result2 = list.stream().collect(
    Collectors.toMap(x -> x.getId(), x -> x.getName()));

Código copiado de:
https://www.mkyong.com/java8/java-8-convert-list-to-map/

como ya se dijo, en java-8 tenemos la solución concisa de Collectors:

  list.stream().collect(
         groupingBy(Item::getKey)
        )

y también, puede anidar varios grupos pasando un otro método groupingBy como segundo parámetro:

  list.stream().collect(
         groupingBy(Item::getKey, groupingBy(Item::getOtherKey))
        )

De esta manera, tendremos un mapa multinivel, como este: Map<key, Map<key, List<Item>>>

Usando flujos java-8

results.stream().collect(Collectors.toMap(e->((Integer)e[0]), e->(String)e[1]));

Me gusta la respuesta de Kango_V, pero creo que es demasiado compleja. Creo que esto es más simple, tal vez demasiado simple. Si está inclinado, puede reemplazar String con un marcador genérico y hacer que funcione para cualquier tipo de clave.

public static <E> Map<String, E> convertListToMap(Collection<E> sourceList, ListToMapConverterInterface<E> converterInterface) {
    Map<String, E> newMap = new HashMap<String, E>();
    for( E item : sourceList ) {
        newMap.put( converterInterface.getKeyForItem( item ), item );
    }
    return newMap;
}

public interface ListToMapConverterInterface<E> {
    public String getKeyForItem(E item);
}

Usado así:

        Map<String, PricingPlanAttribute> pricingPlanAttributeMap = convertListToMap( pricingPlanAttributeList,
                new ListToMapConverterInterface<PricingPlanAttribute>() {

                    @Override
                    public String getKeyForItem(PricingPlanAttribute item) {
                        return item.getFullName();
                    }
                } );

Apache Commons MapUtils.populateMap

Si no usa Java 8 y no desea usar un bucle explícito por alguna razón, intente MapUtils.populateMapdesde Apache Commons.

MapUtils.populateMap

Digamos que tiene una lista de Pairs.

List<ImmutablePair<String, String>> pairs = ImmutableList.of(
    new ImmutablePair<>("A", "aaa"),
    new ImmutablePair<>("B", "bbb")
);

Y ahora desea un Mapa de la Pairclave del Pairobjeto.

Map<String, Pair<String, String>> map = new HashMap<>();
MapUtils.populateMap(map, pairs, new Transformer<Pair<String, String>, String>() {

  @Override
  public String transform(Pair<String, String> input) {
    return input.getKey();
  }
});

System.out.println(map);

da salida:

{A=(A,aaa), B=(B,bbb)}

Dicho esto, un forbucle es quizás más fácil de entender. (Esto a continuación da el mismo resultado):

Map<String, Pair<String, String>> map = new HashMap<>();
for (Pair<String, String> pair : pairs) {
  map.put(pair.getKey(), pair);
}
System.out.println(map);