Este artigo demonstra o procedimento para remover e acessar elementos ConcurrentHashMap em Java.
Como remover elementos ConcurrentHashMap em Java?
Os elementos específicos podem ser removidos do “ ConcurrentHashMap ” elementos através do “ remover() ” método. Para remover todos os elementos de uma vez, o botão “ claro() ” método é a melhor opção para escolher.
Existem também duas variações do método “remove()”:
- O ' remover(chave) ” exclui a entidade com o especificado “ chave ” do “ConcurrentHashMap”.
- O ' remove(chave, valor) ” exclui a entidade que especificou “ chave ” ao longo do correspondente “ valor ” do “ConcurrentHashMap”.
Visite o bloco de código abaixo para uma melhor explicação:
importar java.util.concurrent.ConcurrentHashMap ;
aula Raiz
{
público estático vazio principal ( Corda [ ] argumentos ) //criação do método main()
{ // Declaração ConcurrentHashMap
Equipe ConcurrentHashMap = novo ConcurrentHashMap ( ) ;
Equipe. colocar ( 'Thor' , 2 ) ;
Equipe. colocar ( 'Estranho' , 4 ) ;
Equipe. colocar ( 'Gavião' , 6 ) ;
Sistema . fora . println ( 'ConcurrentHashMap: ' + Equipe ) ;
int valor = Equipe. remover ( 'Estranho' ) ;
Sistema . fora . println ( 'O valor que ' + valor + ' é removido' ) ;
Sistema . fora . println ( 'ConcurrentHashMap: ' + Equipe ) ;
boleano resultado = Equipe. remover ( 'Gavião' , 6 ) ;
Sistema . fora . println ( 'A entrada {Hawkeye = 6} foi removida? ' + resultado ) ;
Sistema . fora . println ( 'ConcurrentHashMap atualizado: ' + Equipe ) ;
Equipe. claro ( ) ;
Sistema . fora . println ( 'ConcurrentHashMap atualizado: ' + Equipe ) ;
}
}
Descrição do bloco de código acima:
- Primeiro, o “ConcurrentHashMap” chamado “ Equipe ” é criado e, em seguida, dados fictícios são inseridos dentro dele usando o “ colocar ” método.
- A seguir, o “ remover() ” método é usado e a chave de “ Estranho ” é passado para ele. Este método remove a entidade do mapa com uma chave de “Estranho”.
- Além disso, exiba os elementos restantes do mapa por meio do “ConcurrentHashMap”.
- Agora, passe o “ chave ” e correspondente “ valor ' para o ' remover() ” para excluir uma entidade do “ConcurrentHashMap” que possui uma chave e um valor específicos.
- Depois disso, exiba o “ConcurrentHashMap” para ver visualmente a diferença.
- No final, utilize o “ claro() ” para excluir todos os elementos residentes dentro do “ConcurrentHashMap”. Além disso, exiba o “ConcurrentHashMap” no console no final.
Após o final da fase de compilação:
O instantâneo mostra os elementos que foram removidos do ConcurrentHashMap.
Como acessar elementos ConcurrentHashMap em Java?
Os elementos do “ ConcurrentHashMap ” pode ser acessado usando vários grupos de métodos. O primeiro grupo inclui “ entradaSet() ”, “ conjunto de chaves() ' e ' valores() ' métodos. Eles são utilizados para recuperar todos os elementos de uma só vez. Usando os métodos acima, o programador pode optar por recuperar todos os “ chaves ”, “ valores ' ou ambos ' valor chave ” mapeamento do mapa.
Visite o código abaixo para entender a implementação prática dos métodos acima:
importar java.util.concurrent.ConcurrentHashMap ;aula Principal {
público estático vazio principal ( Corda [ ] argumentos ) //criação do método main()
{ // Declaração ConcurrentHashMap
Equipe ConcurrentHashMap = novo ConcurrentHashMap ( ) ;
Equipe. colocar ( 'Thor' , 2 ) ;
Equipe. colocar ( 'Estranho' , 4 ) ;
Equipe. colocar ( 'Gavião' , 6 ) ;
Equipe. colocar ( 'Pantera negra' , 8 ) ;
Sistema . fora . println ( 'ConcurrentHashMap: ' + Equipe ) ;
Sistema . fora . println ( 'Recuperar chave e valores: ' + Equipe. conjunto de entradas ( ) ) ;
Sistema . fora . println ( 'Recuperar Chaves: ' + Equipe. conjunto de chaves ( ) ) ;
Sistema . fora . println ( 'Recuperar Valores: ' + Equipe. valores ( ) ) ;
}
}
Descrição do bloco de código acima:
- Primeiro, crie um “ConcurrentHashMap” chamado “ Equipe ” e insira vários elementos nele usando o botão “ colocar() ” método.
- Em seguida, exiba o “ConcurrentHashMap” no console usando o “ out.println() ” método.
- Em seguida, use o “ entradaSet() ” para recuperar todos os dados presentes no mapa.
- Depois disso, utilize o “ conjunto de chaves() ” para recuperar apenas as chaves do mapa.
- No final, use o “ valores() ” para recuperar apenas os valores associados a cada chave. Isso retorna apenas valores em sequência.
Após a execução do código acima:
No instantâneo acima, a saída dos métodos usados acima é exibida no console. E limites de cores diferentes são utilizados para criar uma separação visual entre a saída de cada método.
Agora, o segundo grupo inclui o “ pegar() ' e ' getOrDefault() ' métodos. Esses métodos são utilizados para recuperar o “ chaves ' de ' ConcurrentHashMap ”. Por exemplo, visite o bloco de código abaixo:
importar java.util.concurrent.ConcurrentHashMap ;aula Principal {
público estático vazio principal ( Corda [ ] argumentos ) //criação do método main()
{ // Declaração ConcurrentHashMap
Equipe ConcurrentHashMap = novo ConcurrentHashMap ( ) ;
Equipe. colocar ( 'Thor' , 2 ) ;
Equipe. colocar ( 'Estranho' , 4 ) ;
Equipe. colocar ( 'Gavião' , 6 ) ;
Equipe. colocar ( 'Pantera negra' , 8 ) ;
Sistema . fora . println ( 'Usando getOrDefault(): ' + valor2 ) ;
int valor1 = Equipe. pegar ( 'Gavião' ) ;
Sistema . fora . println ( 'A chave recuperada para o valor especificado é: ' + valor1 ) ;
int valor2 = Equipe. getOrDefault ( 'Romanoff' , 10 ) ;
Sistema . fora . println ( 'ConcurrentHashMap: ' + Equipe ) ;
}
}
Explicação do código acima:
- Utilize o mesmo “ ConcurrentHashMap ” que é criado no bloco de código acima.
- Além disso, aplique o “ pegar() ” e passe o valor cuja chave será recuperada entre parênteses.
- Além disso, utilizando o “ getOrDefault() ” que usa dois parâmetros/valores, o valor e a chave padrão. Se o objeto especificado for encontrado dentro do mapa, a chave correspondente será recuperada. E se o valor especificado não for encontrado, a chave padrão será usada.
- Depois disso, armazene os resultados de ambos os métodos em variáveis e exiba-os no console para fins de visualização.
Após a execução do bloco de código acima:
O instantâneo acima exibe as chaves relativas aos valores recuperados e impressos no console.
Conclusão
Para remover/excluir elementos específicos do “ ConcurrentHashMap ' o ' remover() ” pode ser usado. Ao usá-lo, o programador pode deletar um elemento que tenha um “ chave ” ou correspondente “ valor ”. Com o uso do “ claro() ” método, todos os elementos residentes no mapa são excluídos de uma só vez. Para acesso, o “ entradaSet() ”, “ conjunto de chaves() ' e ' valores() ” métodos são usados. Eles podem recuperar todos os “ chaves/valores ”, “ chaves ', e ' valores ' de ' ConcurrentHashMap ' de uma vez só. Para recuperar apenas chaves específicas, o “ pegar ' e ' getOrDefault ” métodos são usados.