A interface Java Map faz parte da estrutura Java Collection, mas não é um subtipo da interface Collection. Portanto, ele se comporta de maneira diferente em comparação com, digamos, Listas ou outros Objetos de coleção. Cada elemento de Map<Key, Value> representa um par chave-valor. Ambos Key e value são alguns objetos. Todas as chaves em um determinado mapa são exclusivas, enquanto os valores não são, portanto, podem ser duplicados. Você pode pensar no Map em Java como uma espécie de dicionário ou catálogo de loja online, onde você pode encontrar qualquer item usando seu índice exclusivo. A chave é um identificador exclusivo do valor em um mapa. Por exemplo em Map<String, Item> String é um ID de algum Item da loja online. De acordo com as documentações, o Map possui as seguintes subinterfaces:
Encadernações ;
ConcurrentMap<K,V> ;
ConcurrentNavigableMap<K,V> ;
LogicalMessageContext ;
MessageContext ;
MapaNavegável<K,V> ;
SOAPMessageContext ;
SortedMap<K,V> .
E Implementa Classes:
ResumoMapa
Atributos
AuthProvider
ConcurrentHashMap
ConcurrentSkipListMap
EnumMap
HashMap
Hashtable
IdentityHashMap
LinkedHashMap
Estado da ImpressoraRazões
Propriedades
Fornecedor
Dicas de renderização
SimpleBindings
TabularDataSupport
TreeMap
UIDfaults
WeakHashMap
Java AbstractMap é uma classe abstrata que implementa a maior parte da interface Map.
Java HashMap é uma estrutura de dados para armazenar pares chave-valor usando uma tabela hash.
Java TreeMap é uma estrutura de dados para usar uma árvore, ou seja, exibição com chaves classificadas.
WeakHashMap para usar uma tabela hash com chaves fracas, display com valores que podem ser apagados pelo coletor de lixo caso não sejam mais utilizados.
LinkedHashMap é um mapa com a ordem de adição de elementos, permite iteração na ordem de inserção.
EnumMap estende a classe AbstractMap para uso com chaves enum.
IdentityHashMap usa verificação de equivalência referencial ao comparar documentos, mapeando com chaves comparadas usando
== operação em vez do método
equals ()
Aqui estamos interessados nas implementações mais populares de Map Interface: HashMap, TreeMap e LinkedHashMap. A propósito, a ordem dos elementos do mapa depende de implementações específicas. Digamos que TreeMap e LinkedHashMap tenham ordem previsível dos elementos, enquanto HashMap não.
métodos de mapa
As principais operações de qualquer Map são inserção, remoção e busca de elementos.
public Object put(Object key, Object value) insere um elemento no mapa.
public void putAll(Map map) insere o mapa especificado dentro do mapa.
public Object remove(Object key) exclui uma entrada de acordo com a chave especificada.
public Object get(Object key) retorna o valor para a chave especificada.
public boolean containsKey(Object key) pesquisa a chave especificada neste mapa
public Set keySet() retorna uma visualização Set que contém todas as chaves
public Set entrySet() retorna uma visualização Set com todas as chaves e valores.
O que é HashMap
O que é HashMap? É a implementação mais popular da interface Map<Key,Value>. Essa estrutura de dados é baseada no princípio de hashing.
O princípio principal do trabalho do HashMap: hashing
Para entender o que é um hashmap e como ele funciona, vamos falar primeiro sobre hashing e funções hash. Uma função hash é apenas uma função em um sentido matemático. Portanto, há algum valor de entrada (um objeto, um dado) e a função o converte usando uma regra adequada em valor de saída - um hash. Muitas vezes, o hash é um número hexadecimal de comprimento adequado. As regras dos processos de conversão podem ser diferentes, mas estão sujeitas aos seguintes princípios:
Uma entrada específica (objeto) possui um código hash específico.
Se dois objetos forem iguais, seus códigos hash também serão iguais. O contrário não é verdade.
Se os códigos hash forem diferentes, os objetos definitivamente não são iguais.
Às vezes, objetos diferentes podem ter o mesmo código hash. É um evento muito improvável, denominado “colisão” e uma função hash de boa qualidade deve minimizar a probabilidade de colisões.
Em Java, cada objeto tem um código hash. É calculado pelo método hashCode da classe Object, classe parental de todos os objetos Java. Normalmente, os desenvolvedores substituem esse método por suas próprias classes, bem como pelos métodos equals associados a ele.
HashMap: como funciona
Portanto, a classe HashMap<K,V> como toda implementação de mapa consiste em chaves e valores. Ele armazena chaves usando princípios de hash. Dentro do HashMap, os pares chave-valor são armazenados em "buckets", esses buckets juntos constroem uma "tabela", um array interno de listas encadeadas e seu tamanho inicial é 16. O HashMap em Java usa o hashcode da chave para determinar um balde onde o par chave/valor deve mapear: O recurso complicado do HashMap é que cada célula (bucket) da tabela [] mantém não apenas um par, mas vários. Eles não são armazenados como um objeto explícito (como LinkedList), mas como uma cadeia implícita. A cadeia é criada devido ao fato de que cada par armazena um link para o próximo par. Ou seja, todos os pares de HashMap estão espalhados por 16 cadeias. Quando você coloca um novo par na tabela, o hash da chave é considerado. Esse hash não é uma função hashcode incorporada ao objeto-chave. É considerado na faixa de 0-15. O par é adicionado à cadeia de pares armazenados no balde com o índice de hash. Essa abordagem nos dá aceleração de busca. Ao procurar um par por chave, não há necessidade de percorrer toda a tabela. O hash da chave é considerado e apenas a cadeia que está armazenada na célula com o índice de hash é verificada. Se houver muitos pares no HashMap, as cadeias ficarão muito longas. Em seguida, o tamanho da matriz aumenta, o hash de todos os objetos armazenados é recalculado e eles são espalhados por novas cadeias.
Declaração do HashMap
Se você for ao código HashMap da classe, encontrará a seguinte declaração:
public class HashMap extends AbstractMap implements Map, Cloneable, Serializable
Onde K é o tipo de chaves mantidas por este mapa e V - o tipo de valores mapeados. Este é um exemplo de declaração HashMap com chave Integer e valor String em seu código:
HashMap<Integer, String> myHashMap = new HashMap<Integer, String>();
métodos HashMap
Aqui está a lista de métodos HashMap.
Object get(Object key) retorna o valor para a chave especificada;
O objeto put(Chave k, Valor v) insere o mapeamento de valor-chave no mapa;
Object remove(Object key) remove o mapeamento para a chave especificada deste mapa, se presente;
void clear() remove todos os pares chave-valor do HashMap;
Object clone() retorna uma cópia rasa desta instância HashMap sem clonar as chaves e valores;
boolean containsKey(Object key) retorna true se a chave especificada for encontrada no mapa, false se não for;
boolean containsValue(Object Value) retorna true se a chave especificada for encontrada no mapa, false se não for;
boolean isEmpty() retorna true se o mapa estiver vazio, false se não estiver;
Set keySet() retorna o Set das chaves buscadas no mapa;
int size() retorna a quantidade de mapeamento de valor-chave;
Collection values() retorna uma coleção dos valores do mapa;
Object remove(Object key) remove o par chave-valor da chave especificada;
void putAll(Map m) copia todos os elementos do mapa para o outro mapa.
Java HashMap Exemplo
Vamos criar um programa com Java HashMap Example para demonstrar como funciona:
import java.util.HashMap;
import java.util.Map;
import java.util.Iterator;
import java.util.Set;
public class HashMap {
public static void main(String[] args) {
{
// HashMap declaration
HashMap<Integer, String> myHashMap = new HashMap<Integer, String>();
//Adding elements into HashMap
myHashMap.put(7, "Johnny");
myHashMap.put(8, "Ivy");
myHashMap.put(1, "Rick");
myHashMap.put(4, "Stan");
myHashMap.put(3, "Kyle");
//print out the map content using Iterator
Set set = myHashMap.entrySet();
Iterator iterator = set.iterator();
while (iterator.hasNext()) {
Map.Entry mapEntry = (Map.Entry) iterator.next();
System.out.print("key: " + mapEntry.getKey() + " value: ");
System.out.println(mapEntry.getValue());
}
System.out.println("get an element from myHashMap via key and print the value out:");
System.out.println(myHashMap.get(8));
//print out hashMap on standard way:
System.out.println(myHashMap);
// Get values based on key
String var = myHashMap.get(2);
//here we'll get null, we don't have such a key
System.out.println("Value with key 2: " + var);
var = myHashMap.get(7);
System.out.println("Value with key 7: " + var);
// Remove values based on key
myHashMap.remove(4);
System.out.println("myHashMap after removing element:");
System.out.println(myHashMap);
myHashMap.clear();
System.out.println("myHashMap after total clearing:");
System.out.println(myHashMap);
}
}
}
O resultado da execução do programa:
key: 1 value: Rick
key: 3 value: Kyle
key: 4 value: Stan
key: 7 value: Johnny
key: 8 value: Ivy
get an element from myHashMap via key and print the value out:
Ivy
{1=Rick, 3=Kyle, 4=Stan, 7=Johnny, 8=Ivy}
Value with key 2: null
Value with key 7: Johnny
myHashMap after removing element:
{1=Rick, 3=Kyle, 7=Johnny, 8=Ivy}
myHashMap after total clearing:
{}
TreeMap
O TreeMap em Java também implementa a interface Map<Key,Value>, mas é baseado na estrutura de dados da árvore Red-Black. Uma Árvore consiste em "nós" e linhas que conectam nós - ramos". O nó "raiz" está no topo da árvore. Da raiz, pode haver ramos e nós. É uma estrutura hierárquica, você pode pensar em esses nós como "filhos" da raiz. O nó filho pode ter seus próprios filhos - nós inferiores. Os nós sem filhos são chamados de "nós finais" ou "folhas". Uma árvore binária é uma árvore, onde cada nó tem zero, um , ou dois filhos.A árvore de busca binária é uma estrutura, onde cada nó interno armazena uma chave, e às vezes um valor associado, e possui duas sub-árvores distintas ("esquerda" e "direita"). Uma árvore de busca binária autobalanceada é uma árvore de busca binária baseada em nós que automaticamente mantém sua altura (número máximo de níveis abaixo da raiz) pequena diante de inserções e exclusões arbitrárias de itens. Uma árvore rubro-negra é uma árvore binária balanceada com as propriedades:
Cada nó é vermelho ou preto
A raiz é sempre preta
Cada folha é um nó NIL (tipo de vazio, nulo) e é preto
Se um nó é vermelho, seus filhos são definitivamente pretos.
Cada caminho simples de um nó para uma folha descendente contém o mesmo número de nós pretos.
Recursos do TreeMap
Um TreeMap usa uma estrutura de dados de árvore para armazenar as chaves como os nós e classifica as chaves usando o algoritmo Red-Black Tree. Assim, o TreeMap mantém suas entradas classificadas de acordo com a ordem natural de suas chaves. Para números, natural é a ordem crescente, para strings - ordem alfabética. Você pode usar um comparador se precisar alterar a lógica do pedido. Classificar objetos de forma natural é uma grande vantagem do TreeMap, assim como encontrar alguns objetos usando diferentes filtros e condições.
Métodos TreeMap
Object get(Object key) retorna o valor da chave correspondente;
Object put(Object key, Object value) insere um mapeamento em um mapa;
Object remove(Object key) remove o mapeamento para esta chave se o TreeMap contiver;
boolean containsKey(Object key) retorna true se este mapa contiver um mapeamento para a chave especificada;
boolean containsValue(Object value) retorna true se o TreeMap mapeia uma ou mais chaves para o valor especificado;
Object firstKey() retorna a primeira chave atualmente no mapa classificado;
O objeto lastKey() retorna a última chave atualmente no mapa classificado;
void putAll(Map map) copia todos os mapeamentos do mapa especificado para o mapa;
Set entrySet() retorna uma visão definida dos mapeamentos
int size() retorna a quantidade de mapeamentos de valor-chave
Collection values() retorna uma visão de coleção dos valores
Object clone() retorna uma cópia rasa do TreeMap
void clear() remove todos os mapeamentos do TreeMap
SortedMap headMap(Object key_value) retorna uma visualização da parte do mapa menor que o parâmetro key_value
Set keySet() retorna uma visualização Set das chaves contidas no treemap
SortedMap subMap(K fromKey, K toKey) retorna uma visualização da parte deste mapa cujas chaves variam de fromKey, inclusive, a toKey, exclusivo
Object firstKey() retorna a primeira chave do TreeMap.
Exemplo de TreeMap
import java.util.TreeMap;
import java.util.Set;
import java.util.Iterator;
import java.util.Map;
public class TreeMapExample {
public static void main(String args[]) {
//TreeMap declaration
TreeMap<Integer, String> myTreeMap = new TreeMap<Integer, String>();
//put elements to TreeMap
myTreeMap.put(1, "Stuart");
myTreeMap.put(23, "Michael");
myTreeMap.put(7, "Johnny");
myTreeMap.put(5, "Ivy");
myTreeMap.put(2, "Alex");
//Display and print out myTreeMap using Iterator
Set set = myTreeMap.entrySet();
Iterator iterator = set.iterator();
while (iterator.hasNext()) {
Map.Entry myEntry = (Map.Entry) iterator.next();
System.out.print("key: " + myEntry.getKey() + " value: ");
System.out.println(myEntry.getValue());
}
//TreeMap printed in classical way
System.out.println(myTreeMap);
//removing an element with the key =2
myTreeMap.remove(2);
//myTreeMap after removing:
System.out.println(myTreeMap);
}
}
O resultado da execução do programa:
key: 1 value: Stuart
key: 2 value: Alex
key: 5 value: Ivy
key: 7 value: Johnny
key: 23 value: Michael
{1=Stuart, 2=Alex, 5=Ivy, 7=Johnny, 23=Michael}
{1=Stuart, 5=Ivy, 7=Johnny, 23=Michael}
LinkedHashMap
LinkedHashMap é uma estrutura de dados que combina listas vinculadas e mapas de hash. De fato, LinkedHashMap estende a classe HashMap e implementa a interface Map, mas o que há com as listas encadeadas? A declaração de LinkedHashMap:
Map <Integer, String> linkedHashMap = new LinkedHashMap <Integer, String>();
Este novo linkedHashMap herda as propriedades do HashMap (como table, loadFactor, threshold, size, entrySet), também recebe duas propriedades especiais:
header é o cabeçalho de uma lista duplamente encadeada. Durante a inicialização, ele se indica
accessOrder indica como obter acesso aos elementos usando iterator. Se verdadeiro, na ordem do último acesso. Se false, o acesso será na ordem em que os elementos foram inseridos.
Essa lista encadeada define a ordem da iteração. Normalmente, é a ordem de inserção das chaves no mapa.
Métodos LinkedHashMap
Object get(Object key) retorna o valor para o qual a chave especificada é mapeada ou nulo se este mapa não contiver mapeamento para a chave
void clear() remove todos os mapeamentos do mapa.
boolean containsKey(Object key) retorna verdadeiro se o elemento especificado for mapeado por uma ou mais chaves
boolean removeEldestEntry(Map.Entry mais antigo) retorna verdadeiro se o mapa remover sua entrada mais antiga do mapa
Set<Map.Entry<K,V>> entrySet() retorna uma visualização Set dos mapeamentos contidos neste mapa
void forEach(BiConsumer<? super K,? super V> action) executa a ação dada para cada entrada neste mapa até que todas as entradas tenham sido processadas ou a ação gere uma exceção.
Object getOrDefault(Object key, V defaultValue) retorna o valor para o qual a chave especificada é mapeada. Se o mapa não contiver um mapeamento para a chave, retornará defaultValue.
Set<K> keySet() retorna uma visualização Set das chaves contidas no mapa
boolean removeEldestEntry(Map.Entry<K,V> mais antigo) retorna verdadeiro se este mapa deve remover sua entrada mais antiga
void replaceAll(BiFunction<? super K,? super V,? extends V> function) substitui cada valor de entrada pelo resultado da invocação da função fornecida nessa entrada até que todas as entradas tenham sido processadas ou a função lance uma exceção.
Collection<v>values() retorna uma visualização Collection dos valores contidos no mapa
Exemplo de LinkedHashMap
import java.util.LinkedHashMap;
import java.util.Set;
import java.util.Iterator;
import java.util.Map;
public class HashLinkedListExample {
public static void main(String args[]) {
// LinkedHashMap Declaration
LinkedHashMap<Integer, String> myLinkedHashMap =
new LinkedHashMap<Integer, String>();
//Adding elements into LinkedHashMap
myLinkedHashMap.put(7, "Johnny");
myLinkedHashMap.put(12, "Rick");
myLinkedHashMap.put(1, "Kyle");
myLinkedHashMap.put(5, "Percy");
myLinkedHashMap.put(85, "Sebastian");
// Generate a Set of entries
Set set = myLinkedHashMap.entrySet();
// Display and print out the nodes of LinkedHashMap
Iterator iterator = set.iterator();
while(iterator.hasNext()) {
Map.Entry me = (Map.Entry)iterator.next();
System.out.print("key: "+ me.getKey() +
" value: "+me.getValue()+"\n");
}
//print out HashLinkedMap on standard way:
System.out.println(myLinkedHashMap);
myLinkedHashMap.put(21, "Ivy");
System.out.println(myLinkedHashMap);
myLinkedHashMap.remove(12);
System.out.println(myLinkedHashMap);
myLinkedHashMap.put(12, "Ronny");
System.out.println(myLinkedHashMap);
myLinkedHashMap.put(1, "Stan");
System.out.println(myLinkedHashMap);
}
}
Aqui criamos um novo LinkedHashMap, adicionando cinco elementos, e então o imprimimos usando o iterador e de maneira clássica. Como você pode ver, LinkedHashMap mantém a ordem de inserção. Depois disso, excluímos um elemento do nosso mapa, adicionamos o novo e depois - mais um elemento com a chave, que já está no mapa. Ele substitui o valor antigo mapeado para esta chave. O resultado da execução do programa:
HashMap, TreeMap e LinkedHashMap são as implementações de interfaces Map. HashMap e LinkedHashMap são estruturas de dados com chaves de hashes. TreeMap usa a ordem natural de suas chaves para organizar uma árvore de busca. Ordem:
O HashMap não mantém nenhuma ordem.
TreeMap classifica as entradas em ordem crescente de chaves.
LinkedHashMap mantém a ordem de inserção.
Chaves nulas:
HashMap e LinkedHashMap permitem ter uma chave nula.
LinkedHashMap não permite chaves nulas caso as chaves usem ordenação natural ou o Comparator não suporta comparação em regras nulas.
Vejamos um exemplo de mapa Java que inclui todas as três implementações analisadas neste artigo:
Como podemos ver, a ordem dos elementos no HashMap não é óbvia, no treeMap depende das chaves, no LinkedHashMap é sobre a ordem de inserção. Se tentarmos colocar uma chave nula em linkedHashMap, obteremos NullPointerException, mas em linkedHashMap1, onde as chaves são String, podemos fazer isso. Um mapa de hash é a melhor implementação de mapa de uso geral. Ele fornece velocidade máxima de pesquisa, armazenamento rápido e operações de recuperação, mas você deve se lembrar de sua ordem caótica. Um mapa de hash vinculado herda as vantagens do HashMap e obtém uma ordem para as chaves. No entanto, ele contém linkedList, que é relativamente caro em termos de memória. é mais lento que o HashMap na pesquisa e um pouco mais lento para adicionar/remover devido à manutenção da lista vinculada. Um mapa de árvore armazena as chaves classificadas em ordem crescente. No entanto, Para reforçar o que você aprendeu, sugerimos que você assista a uma vídeo aula do nosso Curso de Java
GO TO FULL VERSION