Java: Construire une carte à partir d'une seule expression?

Question

Je me demande pourquoi il n'y a aucun moyen de construire une carte avec des valeurs dans une seule expression. Ou est-ce? Je m'attendrais

new HashMap().add(key, value).add(key, value)...; 

Je ne peux pas trouver quelque chose comme ça même dans Commons Collections.

Est-ce que j'ai manqué quelque chose dans JDK ou Commons?

Answer 1

Goyave a qu'avec son ImmutableMap:

final Map<Foo, Bar> map = ImmutableMap.of(foo1, bar1, foo2, bar2, etc, etc); 

Bonus: le nom de ImmutableMap n'est pas un mensonge;)

Notez que Il existe 5 versions de la méthode .of(), donc jusqu'à 5 paires clé/valeur. Une façon plus générique est d'utiliser un constructeur:

final Map<Foo, Bar> map = ImmutableMap.<Foo, Bar>builder() 
    .put(foo1, bar1) 
    .put(foo2, bar2) 
    .put(foo3, bar3) 
    .put(etc, etc) 
    .build(); 

Notez, cependant: cette carte ne accepte les clés nulles ou des valeurs.

Alternativement, voici une version pauvre de ImmutableMap. Il utilise un modèle de générateur classique. Notez qu'il ne vérifie pas les valeurs NULL:

public final class MapBuilder<K, V> 
{ 
    private final Map<K, V> map = new HashMap<K, V>(); 

    public MapBuilder<K, V> put(final K key, final V value) 
    { 
     map.put(key, value); 
     return this; 
    } 

    public Map<K, V> build() 
    { 
     // Return a mutable copy, so that the builder can be reused 
     return new HashMap<K, V>(map); 
    } 

    public Map<K, V> immutable() 
    { 
     // Return a copy wrapped into Collections.unmodifiableMap() 
     return Collections.unmodifiableMap(build()); 
    } 
} 

vous pouvez utiliser:

final Map<K, V> map = new MapBuilder<K, V>().put(...).put(...).immutable(); 

Answer 2

Essayez cette ..

Map<String, Integer> map = new HashMap<String, Integer>() 
{{ 
    put("One", 1); 
    put("Two", 2); 
    put("Three", 3); 
}}; 

Answer 3

Il n'y a rien dans la Chambre des communes ou des collections dans le JDK. Mais vous pouvez également utiliser Guava et le code suivant:

Map<String, String> mapInstance = ImmutableMap.<String, String> builder().put("key1", "value1").put("key2", "value2").build(); 

Answer 4

• Si vos clés et Vales sont du même type ayant alors cette méthode:

  <K> Map<K, K> init(Map<K, K> map, K... args) { 
      K k = null; 
      for(K arg : args) { 
       if(k != null) { 
        map.put(k, arg); 
        k = null; 
       } else { 
        k = arg; 
       } 
      } 
      return map; 
  } 
  

  Vous pouvez initialiser votre carte avec:

  init(new HashMap<String, String>(), "k1", "v1", "k2", "v2"); 
  

• Si vos clés et Vales sont d'un type différent ayant alors cette méthode:

  <K, V> Map<K, V> init(Map<K, V> map, List<K> keys, List<V> values) { 
      for(int i = 0; i < keys.size(); i++) { 
       map.put(keys.get(i), values.get(i)); 
      } 
      return map; 
  } 
  

  Vous pouvez initialiser votre carte avec:

  init(new HashMap<String, Integer>(), 
      Arrays.asList("k1", "k2"), 
      Arrays.asList(1, 2));