Mesclar Java HashMap ()

O método Java HashMap merge () insere o mapeamento de chave / valor especificado no hashmap se a chave especificada já não estiver presente.

Se a chave especificada já estiver associada a um valor, o método substitui o valor antigo pelo resultado da função especificada.

A sintaxe do merge()método é:

 hashmap.merge(key, value, remappingFunction)

Aqui, hashmap é um objeto da HashMapclasse.

Parâmetros merge ()

O merge()método leva 3 parâmetros:

  • chave - chave com a qual o valor especificado deve ser associado
  • valor - valor a ser associado à chave, se a chave já estiver associada a algum valor
  • remappingFunction - resultado a ser associado à chave se a chave já estiver associada a um valor

valor de retorno merge ()

  • retorna o novo valor associado à chave
  • retorna nullse nenhum valor associado à chave

Nota : Se remappingFunction resultar null, então o mapeamento para a chave especificada é removido.

Exemplo 1: HashMap merge () para inserir uma nova entrada

 import java.util.HashMap; class Main ( public static void main(String() args) ( // create an HashMap HashMap prices = new HashMap(); // insert entries to the HashMap prices.put("Shoes", 200); prices.put("Bag", 300); prices.put("Pant", 150); System.out.println("HashMap: " + prices); int returnedValue = prices.merge("Shirt", 100, (oldValue, newValue) -> oldValue + newValue); System.out.println("Price of Shirt: " + returnedValue); // print updated HashMap System.out.println("Updated HashMap: " + prices); ) )

Resultado

 HashMap: (Calça = 150, Bolsa = 300, Sapatos = 200) Preço da camisa: 100 HashMap atualizado: (Calça = 150, Camisa = 100, Bolsa = 300, Sapatos = 200)

No exemplo acima, criamos um hashmap denominado preços. Observe a expressão,

 prices.merge("Shirt", 100, (oldValue, newValue) -> oldValue + newValue)

Aqui, usamos a expressão lambda, (oldValue, newValue) -> oldValue + newValue)como a função de remapeamento. Para saber mais sobre a expressão lambda, visite Java Lambda Expressions.

Como a chave Shirt não está presente nos preços, o merge()método insere o mapeamento Shirt=100. E, o resultado da função de remapeamento é ignorado.

Exemplo 2: HashMap merge () para inserir a entrada com chave duplicada

 import java.util.HashMap; class Main ( public static void main(String() args) ( // create an HashMap HashMap countries = new HashMap(); // insert entries to the HashMap countries.put("Washington", "America"); countries.put("Canberra", "Australia"); countries.put("Madrid", "Spain"); System.out.println("HashMap: " + countries); // merge mapping for key Washington String returnedValue = countries.merge("Washington", "USA", (oldValue, newValue) -> oldValue + "/" + newValue); System.out.println("Washington: " + returnedValue); // print updated HashMap System.out.println("Updated HashMap: " + countries); ) )

Resultado

 HashMap: (Madrid = Espanha, Canberra = Austrália, Washington = América) Washington: América / EUA HashMap atualizado: (Madrid = Espanha, Canberra = Austrália, Washington = América / EUA),

No exemplo acima, criamos um hashmap chamado países. Observe a expressão,

 countries.merge("Washington", "USA", (oldValue, newValue) -> oldValue + "/" + newValue)

Aqui, usamos a expressão lambda, (oldValue, newValue) -> oldValue + "/" + newValue)como a função de remapeamento.

Como a chave Washington já está presente nos países, o valor antigo é substituído pelo valor retornado pela função de remapeamento. Portanto, o mapeamento para Washington inclui o valor América / EUA.

Exemplo 3: HashMap merge () para mesclar dois HashMaps

 import java.util.HashMap; class Main ( public static void main(String() args) ( // create an HashMap HashMap prices1 = new HashMap(); // insert entries to the HashMap prices1.put("Pant", 230); prices1.put("Shoes", 350); System.out.println("HashMap 1: " + prices1); // create another hashmap HashMap prices2 = new HashMap(); //insert entries to the HashMap prices2.put("Shirt", 150); prices2.put("Shoes", 320); System.out.println("HashMap 2: " + prices2); // forEach() access each entries of prices2 // merge() inserts each entry from prices2 to prices1 prices2.forEach((key, value) -> prices1.merge(key, value, (oldValue, newValue) -> ( // return the smaller value if (oldValue < newValue) ( return oldValue; ) else ( return newValue; ) ))); System.out.println("Merged HashMap: " + prices1); ) )

Resultado

 HashMap 1: (Calça = 230, Sapatos = 350) HashMap 2: (Camisa = 150, Sapatos = 320) HashMap mesclado: (Calça = 230, Camisa = 150, Sapatos = 320)

No exemplo acima, criamos dois hashmaps chamados prices1 e prices2. Observe o código,

  prices2.forEach((key, value) -> prices1.merge(key, value, (oldValue, newValue) -> ( if (oldValue < newValue) ( return oldValue; ) else ( return newValue; ) )));

Aqui, o método HashMap forEach () acessa cada entrada dos preços do hashmap2 e as mescla com os preços do hashmap1. Usamos duas expressões lambda:

  • (chave, valor) -> prices.merge (…) - Acessa cada entrada de prices1 e passa para o merge()método.
  • (oldValue, newValue) -> (…) - É uma função de remapeamento. Ele compara dois valores e retorna o valor menor.

Como a chave Shoes está presente em ambos os hashmap, o valor de Shoes é substituído pelo resultado da função de remapeamento.

Java HashMap merge () vs. Ponha tudo

Também podemos usar o putAll()método para mesclar dois hashmaps. No entanto, se uma chave estiver presente em ambos os hashmaps, o valor antigo é substituído pelo novo valor.

Ao contrário do merge(), o putAll()método não fornece a função de remapeamento. Portanto, não podemos decidir qual valor armazenar para chaves duplicadas.

Para saber mais sobre o putAll()método, visite Java HashMap putAll ().

Artigos interessantes...