ST deve ser o LinkedHashmap em Java

Se você já trabalhou na língua Python, deve estar familiarizado com o conceito de dicionários que mantêm os valores em pares de valor-chave. Na programação Java, não temos dicionários como Python, mas temos hashmaps em vez disso. A classe Hashmap de programação Java oferece a oportunidade de criar tabelas de estrutura de mapas de hash, como os pares de valor-chave. A classe Hashmap vinculada de Java fornece uma maneira de organizar seus pares de valor-chave de uma maneira classificada. Assim, discutiremos a criação de hashmaps vinculados em Java usando algumas ilustrações de código Java. Os códigos fornecidos podem ser modificados de acordo com sua ferramenta.

Exemplo 1:

Introdução ao primeiro exemplo deste artigo, discutimos a sintaxe simples de criar um hashmap vinculado na programação Java. Para isso, você precisa seguir uma estrutura básica do programa Java - o nome do pacote ou o nome do arquivo a ser criado, algumas importações de pacotes, classe pública e o método principal. Você também pode colocar outras coisas conforme necessário. Para criar uma estrutura de tabela de mapas de hash vinculada, você precisa importar a classe LinkedHashmap que é estendida da interface hashmap vinculada de Java. Assim, a palavra -chave "importar" junto com o nome do pacote no topo de uma aula pública é suficiente para fazê -lo.

O nome da classe pública, "teste", deve ser o mesmo que o seu nome de arquivo java. A função Main () cria dois hashmaps vinculados usando a classe LinkedHashmap. O primeiro hashmap que é "num1" é criado através da classe LinkedHashmap, declarando a chave do tipo de sequência e o par de valores para o hashmap. A função put () da classe HashMap vinculada adiciona alguns pares de valor-chave no hashMap "num1", adicionando 2 valores. A declaração de função println () é usada após colocar os valores para exibir os pares de valor-chave do hashmap num1.

Depois disso, uma nova estrutura de hash de hash vinculada, "num2", é criada usando da mesma maneira - contendo os pares de valor -chave dos tipos de string. Adicionamos um único par de valores-chave no hashmap "num2" e exibi-lo usando a instrução println (). Agora que este código está completo para execução, podemos copiar, colar e executá -lo na ferramenta Java.

teste de pacote;
importar java.util.LinkedHashmap;
Teste de classe pública
public static void main (string [] args)
LinkedHashmap Num1 = new LinkedHashMap ();
Num1.put ("um", "1");
Num1.put ("dois", "2");
Sistema.fora.println ("LinkedHashmap 01:" + num1);
LinkedHashmap Num2 = new LinkedHashMap ();
Num2.put ("três", "3");
Sistema.fora.println ("LinkedHashmap 02:" + num2);

Após a execução do código Java mencionado anteriormente para hashmaps vinculados, dois hashmaps diferentes são exibidos na mesma ordem em que declaramos seus valores.

Exemplo 2:

Vamos criar outra ilustração para criar os hashmaps vinculados com uma pequena diferença. Nesta ilustração, colocamos os elementos de um hashmap para outro ao mesmo tempo usando a função da classe LinkedHashmap, “Putall”. Para isso, usamos a mesma estrutura do código Java que é usado no exemplo de código anterior. A classe pública “Teste” contém o método principal () enquanto a classe LinkedHashmap do pacote Java é importada antes da declaração de uma classe. Usamos a mesma classe LinkedHashmap para criar dois hashmaps - num1 e num2.

Da mesma forma, como fizemos anteriormente, adicionamos os pares de valor -chave em ambos os hashmaps - 2 valores no valor Num1 e 1 no HashMap num2 usando a função put (). Depois de exibir o primeiro hashmap, não apenas colocamos um único par de valor-chave no hashmap num2, mas também adicionamos todo o hashmap "num1" no Hashmap num2. Para isso, chamamos a função PUTALL () de Java com um hashMap "num2", juntamente com o nome de um hashmap a ser adicionado que é "num1" nos argumentos. Por fim, o hashmap é emitido.

teste de pacote;
importar java.util.LinkedHashmap;
Teste de classe pública
public static void main (string [] args)
LinkedHashmap Num1 = new LinkedHashMap ();
Num1.put ("um", "1");
Num1.put ("dois", "2");
Sistema.fora.println ("LinkedHashmap 01:" + num1);
LinkedHashmap Num2 = new LinkedHashMap ();
Num2.put ("três", "3");
Num2.Putall (num1);
Sistema.fora.println ("LinkedHashmap 02:" + num2);

Após uma longa discussão, é hora de copiar, colar e executar o código anterior. A saída após a execução mostra os dois hashmaps vinculados separadamente. O primeiro contém apenas 2 valores, enquanto o outro tem seu par de valores-chave junto com os que temos no Hashmap num2.

Exemplo 3:

No final, usamos a função putifabsent () da classe LinkedHashmap de java para adicionar um novo valor ao hashmap se ainda não estiver lá. Portanto, atualizamos o código Java um pouco desta vez. Após a declaração de um hashmap num1, adicionamos os dois pares de valor-chave através da chamada para uma função put () através do objeto Hashmap, num1. A declaração de função println () é utilizada aqui para exibir os dois primeiros valores do hashmap num1 vinculado como é.

Depois disso, uma nova chamada de função é feita para a função "putifabsent" do Java para adicionar um par de valores-chave muito novo a um hash "num2" vinculado se ainda não estiver residindo nele. Dessa forma, o valor no hashmap vinculado não é duplicado e será único ao longo do programa. Depois disso, uma nova declaração de função println () é usada para exibir o hashmap recém -atualizado "num1" vinculado no console. Outro hashmap vinculado que é "num2" é criado que contém as teclas inteiras e os valores de string usando a mesma classe LinkedHashmap de Java.

Usando a função put (), adicionamos um total de 2 valores usando a função put (). Depois disso, o uso da função PUTALL () de Java é significativo para copiar e colar o conteúdo do hashmap num1 no hashmap num2. No final, o hashmap "num2" também é apresentado.

teste de pacote;
importar java.util.LinkedHashmap;
Teste de classe pública
public static void main (string [] args)
LinkedHashmap Num1 = new LinkedHashMap ();
Num1.put (3, "três");
Num1.put (5, "cinco");
Sistema.fora.println ("LinkedHashmap 01:" + num1);
Num1.putifabsent (4, "quatro");
Sistema.fora.println ("atualizado LinkedHashMap () 01:" + num1);
LinkedHashmap Num2 = new LinkedHashMap ();
Num2.put (2, "dois");
Num2.put (1, "um");
Num2.Putall (num1);
Sistema.fora.println ("LinkedHashmap 02:" + num2);

O primeiro hashmap vinculado que é "num1" é exibido com 2 valores e sua versão atualizada também é exibida logo após isso. No final, o hashmap num2 é exibido enquanto contém os pares de valor-chave do hashmap num1 no final.

Conclusão

O conceito de hashmaps vinculado tem sido o mesmo que o conceito de dicionários que foi discutido no parágrafo introdutório. Depois disso, discutimos a maneira de criar os hashmaps em Java usando a classe LinkedHashmap de Java por alguns exemplos java. O uso da função put () e putall () é muito importante em todos os exemplos fornecidos.