Inicializar um HashMap em Java

1. Visão geral

Neste tutorial, aprenderemos sobre várias maneiras de inicializar um JavaHashMap in.

Usaremos Java 8, bem como Java 9.

Leitura adicional:

Comparando dois HashMaps em Java

Aprenda como comparar dois HashMaps em Java e encontre as diferenças entre eles

Trabalhando com mapas usando fluxos

Aprenda a combinar Java Maps e Streams

2. O inicializador estático para umHashMap estático

Podemos inicializar umHashMap using um bloco de códigostatic:

public static Map articleMapOne;
static {
    articleMapOne = new HashMap<>();
    articleMapOne.put("ar01", "Intro to Map");
    articleMapOne.put("ar02", "Some article");
}

A vantagem desse tipo de inicialização é que o mapa é mutável, mas funcionará apenas para estático. As inscrições podem ser adicionadas e removidas como e quando necessário.

Vamos testar:

@Test
public void givenStaticMap_whenUpdated_thenCorrect() {

    MapInitializer.articleMapOne.put(
      "NewArticle1", "Convert array to List");

    assertEquals(
      MapInitializer.articleMapOne.get("NewArticle1"),
      "Convert array to List");
}

Também podemos inicializar o mapa usando a sintaxe de chave dupla:

Map doubleBraceMap  = new HashMap() {{
    put("key1", "value1");
    put("key2", "value2");
}};

Observe que,we must try to avoid this initialization technique as it creates an anonymous extra class at every usage, and also holds hidden references to the enclosing objecte pode causar problemas de vazamento de memória.

3. Usando coleções Java

Se precisarmos criar um mapa único e imutável, com uma única entrada,Collections.singletonMap() se torna muito útil:

public static Map createSingletonMap() {
    return Collections.singletonMap("username1", "password1");
}

Observe que o mapa aqui é imutável, se tentarmos adicionar mais entradas, ele lançarájava.lang.UnsupportedOperationException.

Também podemos criar um mapa vazio imutável usandoCollections.emptyMap():

Map emptyMap = Collections.emptyMap();

4. O caminho do Java 8

Aqui, nesta seção, vamos dar uma olhada nas maneiras de inicializar um mapa usando Java 8Stream API.

4.1. UsandoCollectors.toMap()

Vamos usar umStream de uma matriz bidimensionalString e coletá-los em um mapa:

Map map = Stream.of(new String[][] {
  { "Hello", "World" },
  { "John", "Doe" },
}).collect(Collectors.toMap(data -> data[0], data -> data[1]));

Observe aqui que o tipo de dados da chave e o valor deMap são os mesmos.

Para torná-lo mais genérico, vamos pegar a matriz deObjects e executar a mesma operação:

 Map map = Stream.of(new Object[][] {
     { "data1", 1 },
     { "data2", 2 },
 }).collect(Collectors.toMap(data -> (String) data[0], data -> (Integer) data[1]));

Aqui, criamos um mapa da chave comoStringe valor comoInteger.

4.2. Usando um fluxo deMap.Entry

Aqui, usaremos as instâncias deMap.Entry. . Esta é outra abordagem em que temos diferentes tipos de chave e valor.

Primeiro, vamos usar a simplificação deSimpleEntry da sinterfaceEntry :

Map map = Stream.of(
  new AbstractMap.SimpleEntry<>("idea", 1),
  new AbstractMap.SimpleEntry<>("mobile", 2))
  .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

Agora, vamos criar o mapa usando a simplificaçãoSimpleImmutableEntry :

Map map = Stream.of(
  new AbstractMap.SimpleImmutableEntry<>("idea", 1),
  new AbstractMap.SimpleImmutableEntry<>("mobile", 2))
  .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

4.3. Inicializando um mapa imutável

Em certos casos de uso, precisamos inicializar um mapa imutável. Isso pode ser feito envolvendo oCollectors.toMap() dentro deCollectors.collectingAndThen():

Map map = Stream.of(new String[][] {
    { "Hello", "World" },
    { "John", "Doe" },
}).collect(Collectors.collectingAndThen(
    Collectors.toMap(data -> data[0], data -> data[1]),
    Collections:: unmodifiableMap));

Observe que devemos evitar usar essa inicialização usandoStreams, , pois ela pode causar uma grande sobrecarga de desempenho e muitos objetos de lixo são criados apenas para inicializar o mapa.

5. O caminho do Java 9

Java 9 vem com vários métodos de fábrica na interfaceMap, que simplifica a criação e inicialização de mapas imutáveis.

Vamos examinar esses métodos de fábrica.

5.1. Map.of()

Este método de fábrica não usa argumentos, um único argumento e argumentos variáveis:

Map emptyMap = Map.of();
Map singletonMap = Map.of("key1", "value");
Map map = Map.of("key1","value1", "key2", "value2");

Observe que este método suporta apenas um máximo de 10 pares de valores-chave.

5.2. Map.ofEntries()

É semelhante aMap.of() , mas não tem limitações quanto ao número de pares de valores-chave:

Map map = Map.ofEntries(
  new AbstractMap.SimpleEntry("name", "John"),
  new AbstractMap.SimpleEntry("city", "budapest"),
  new AbstractMap.SimpleEntry("zip", "000000"),
  new AbstractMap.SimpleEntry("home", "1231231231")
);

Observe que os métodos de fábrica produzem mapas imutáveis, portanto, qualquer mutação resultará em umUnsupportedOperationException.

Além disso, eles não permitem chaves nulas nem chaves duplicadas.

Agora, se precisarmos de um mapa mutável ou crescente após a inicialização, podemos criar qualquer uma das implementações da interfaceMap e passar esses mapas imutáveis no construtor:

Map map = new HashMap (
  Map.of("key1","value1", "key2", "value2"));
Map map2 = new HashMap (
  Map.ofEntries(
    new AbstractMap.SimpleEntry("name", "John"),
    new AbstractMap.SimpleEntry("city", "budapest")));

6. Usando goiaba

Agora que examinamos as maneiras de usar o Java principal, vamos seguir em frente e inicializar um mapa usando o Apache Guava:

Map articles
  = ImmutableMap.of("Title", "My New Article", "Title2", "Second Article");

Isso criaria um mapa imutável e criar um mapa mutável:

Map articles
  = Maps.newHashMap(ImmutableMap.of("Title", "My New Article", "Title2", "Second Article"));

O métodoImmutableMap.of() coloca var-args no formato chave1, valor1, chave2, valor2 e assim por diante:

ImmutableMap.of("key1", "value1", "key2", "value2");

7. Conclusão

Neste artigo, examinamos as várias maneiras de inicializar aMap, particularmente para criar mapas vazios, singleton, imutáveis e mutáveis. As you can see, there’s a huge improvement in this field since Java 9.

Como sempre, o código-fonte de amostra está localizado emGithub project. Os exemplos de Java 9 estão localizados emheree amostra de Guavahere.

TOC

Inicializar um HashMap em Java