O IdentidadeHashMap implementos Mapa interface usando Tabela hash usando igualdade de referência no lugar da igualdade de objeto ao comparar chaves (e valores). Esta classe não é uma implementação de mapa de uso geral. Embora esta classe implemente a interface Map, ela viola intencionalmente o contrato geral do Map, que exige o uso do método equals() ao comparar objetos. Esta classe é utilizada quando o usuário requer que os objetos sejam comparados via referência. Pertence a java.util pacote.

Recursos do IdentityHashMap

• Segue a igualdade de referência em vez de usar o método equals(), ele usa o operador ==.
• Não está sincronizado e deve ser sincronizado externamente.
• Iteradores são lançados com falha rápida ConcurrentModificationException na tentativa de modificar durante a iteração.
• Esta classe fornece desempenho em tempo constante para as operações básicas (get e put), assumindo que a função hash de identidade do sistema (System.identityHashCode(Object)) dispersa os elementos adequadamente entre os buckets. IdentityHashMap não usa o método hashCode() em vez disso, usa o método System.identityHashCode(). Esta é uma diferença significativa porque agora você pode usar objetos mutáveis ​​como chave no Mapa cujo código hash provavelmente mudará quando o mapeamento for armazenado dentro do IdentityHashMap.

Declaração:

classe pública IdentityHashMapestende AbstractMapimplementa MapaSerializável Clonável 
 

Aqui K é o tipo de objeto chave e V é o valor Tipo de objeto.

Em Java IdentityHashMap é uma classe que implementa a interface Map. É semelhante à classe HashMap, com a principal diferença sendo que IdentityHashMap usa igualdade de referência em vez de igualdade de objeto ao comparar chaves.

Enquanto HashMap usa o método equals() para comparar as chaves, IdentityHashMap usa o operador == para comparar as chaves. Isso significa que em um IdentityHashMap duas chaves são consideradas iguais se e somente se forem o mesmo objeto, em vez de serem iguais em termos de conteúdo.

como obter pombo de jogo no android

Aqui está um exemplo de como você pode usar um IdentityHashMap em Java:

import java.util.IdentityHashMap; public class Example {  public static void main(String[] args) {  IdentityHashMap<String Integer> identityHashMap = new IdentityHashMap<>();  identityHashMap.put('A' 1);  identityHashMap.put(new String('A') 2);  System.out.println(identityHashMap.size()); // 2  System.out.println(identityHashMap.get('A')); // 1  } } 

saída;

2 

1

A classe IdentityHashMap em Java é uma implementação baseada em tabela hash da interface Map que usa igualdade de referência no lugar da igualdade de objeto ao comparar chaves (e valores).

Vantagens de usar IdentityHashMap em vez de HashMap:

1. Pesquisas mais rápidas: como o IdentityHashMap usa igualdade de referência para comparação, é mais rápido para pesquisas em comparação com o HashMap, que usa igualdade de objetos.
2. Útil para comparar instâncias de objetos: IdentityHashMap é útil em situações em que você deseja comparar instâncias de objetos em vez de valores de objetos.

Desvantagens de usar IdentityHashMap:

1. Usa mais memória: IdentityHashMap usa mais memória em comparação com HashMap, pois precisa armazenar a referência ao objeto.
2. Não é adequado para todos os casos de uso: IdentityHashMap não é adequado para todos os casos de uso e deve ser usado com cautela, pois pode levar a um comportamento inesperado em determinadas situações.

A hierarquia do IdentityHashMap

foreach texto datilografado

Ele implementa Serializável Clonável Mapa interfaces e extensões ResumoMapa aula.

Exemplo:

// Java code to demonstrate IdentityHashMap  import java.util.Map; import java.util.HashMap; import java.util.IdentityHashMap; public class IdentityHashMapExample  {  public static void main(String[] args)   {  // creating an instance of IdentityHashMap  Map<String String> ihm = new IdentityHashMap<>();  // Putting key and value pair  // in a IdentityHashMap Object  ihm.put('ihmkey''ihmvalue');   ihm.put(new String('ihmkey')'ihmvalue1');     // ihm.size() will print 2 since it   // compares the objects by reference  System.out.println('Size of IdentityHashMap--'+ihm.size());    } } 

Size of IdentityHashMap--2 

Construtores de IdentityHashMap

Podemos criar uma instância de IdentidadeHashMap de duas maneiras:

IdentityHashMap ihm = new IdentityHashMap(); (or) Map hm = new IdentityHashMap();

1. IdentidadeHashMap():  Constrói um novo mapa hash de identidade vazio com um tamanho máximo esperado padrão. 

IdentidadeHashMapele = novo IdentityHashMap();

2. IdentidadeHashMap (int esperadoMaxSize):  Constrói um novo mapa vazio com o tamanho máximo esperado especificado. 

IdentidadeHashMapihm = new IdentityHashMap(int esperadoMaxSize);

3. IdentityHashMap (Mapa m):  Constrói um novo mapa hash de identidade contendo os mapeamentos de valores-chave no mapa especificado.

IdentidadeHashMapihm = new IdentityHashMap(Mapa m);

Operações básicas em IdentityHashMap

1. Adicionando Elementos

Para inserir ou adicionar mapeamento em um IdentityHashMap, temos colocar() e colocarTodos() métodos. put() pode inserir uma chave específica e o valor que ela está mapeando em um mapa específico. Se uma chave existente for passada, o valor anterior será substituído pelo novo valor. putAll() copia todos os elementos, ou seja, os mapeamentos de um mapa para outro. 

// Java code to illustrate // adding elements to IdentityHashMap import java.util.*; public class AddingElementsToIdentityHashMap {    public static void main(String[] args)  {  // Creating an empty IdentityHashMap  Map<Integer String> identity_hash  = new IdentityHashMap<Integer String>();  // Mapping string values to int keys  // using put() method  identity_hash.put(10 'Geeks');  identity_hash.put(15 '4');  identity_hash.put(20 'Geeks');  identity_hash.put(25 'Welcomes');  identity_hash.put(30 'You');  // Displaying the IdentityHashMap  System.out.println('Initial Mappings are: '  + identity_hash);  // Inserting existing key along with new value  // previous value gets returned and stored in  // returned_value  String returned_value  = (String)identity_hash.put(20 'All');  // Verifying the returned value  System.out.println('Returned value is: '  + returned_value);  // Displaying the new map  System.out.println('New map is: ' + identity_hash);  // Creating a new Identityhash map and copying  Map<Integer String> new_Identityhash_map  = new IdentityHashMap<Integer String>();  new_Identityhash_map.putAll(identity_hash);  // Displaying the final IdentityHashMap  System.out.println('The new map: '  + new_Identityhash_map);  } } 

Initial Mappings are: {30=You 10=Geeks 15=4 25=Welcomes 20=Geeks} Returned value is: Geeks New map is: {30=You 10=Geeks 15=4 25=Welcomes 20=All} The new map: {30=You 10=Geeks 15=4 25=Welcomes 20=All} 

2. Removendo Elementos
Para remover mapeamentos, usamos remover() um método embutido da classe IdentityHashMap e é usado para remover o mapeamento de qualquer chave específica do mapa.

// Java code to illustrate removing // elements from IdentityHashMap import java.util.*;  public class RemovingMappingsFromIdentityHashMap {   public static void main(String[] args)   {   // Creating an empty IdentityHashMap   Map<Integer String> Identity_hash = new  IdentityHashMap<Integer String>();     // Mapping string values to int keys   Identity_hash.put(10 'Geeks');   Identity_hash.put(15 '4');   Identity_hash.put(20 'Geeks');   Identity_hash.put(25 'Welcomes');   Identity_hash.put(30 'You');   // Displaying the IdentityHashMap   System.out.println('Initial Mappings are: ' +   Identity_hash);   // Removing the existing key mapping   String returned_value =   (String)Identity_hash.remove(20);   // Verifying the returned value   System.out.println('Returned value is: ' +   returned_value);   // Displaying the new map   System.out.println('New map is: ' + Identity_hash);   }  }  

Initial Mappings are: {30=You 10=Geeks 15=4 25=Welcomes 20=Geeks} Returned value is: Geeks New map is: {30=You 10=Geeks 15=4 25=Welcomes} 

3. Acessando os Elementos

Podemos acessar os elementos de um IdentityHashMap usando o pegar() método, o exemplo disso é dado abaixo.

// Java code to illustrate the accessing // elements from IdentityHashMap import java.util.*; public class AccessingElementsFromIdentityHashMap {  public static void main(String[] args)  {  // Creating an empty IdentityHashMap  Map<Integer String> identity_hash  = new IdentityHashMap<Integer String>();  // Mapping string values to int keys  identity_hash.put(10 'Geeks');  identity_hash.put(15 '4');  identity_hash.put(20 'Geeks');  identity_hash.put(25 'Welcomes');  identity_hash.put(30 'You');  // Displaying the IdentityHashMap  System.out.println('Initial Mappings are: '  + identity_hash);  // Getting the value of 25  System.out.println('The Value is: '  + identity_hash.get(25));  // Getting the value of 10  System.out.println('The Value is: '  + identity_hash.get(10));    // Using keySet() to get the set view of keys   System.out.println('The set is: ' + identity_hash.keySet());     // Using entrySet() to get the set view   System.out.println('The set is: ' +   identity_hash.entrySet());   } } 

Initial Mappings are: {30=You 10=Geeks 15=4 25=Welcomes 20=Geeks} The Value is: Welcomes The Value is: Geeks The set is: [30 10 15 25 20] The set is: [30=You 10=Geeks 15=4 25=Welcomes 20=Geeks] 

4. Atravessando
Podemos usar a interface Iterator para percorrer qualquer estrutura do Collection Framework. Como os Iteradores trabalham com um tipo de dados, usamos Entry< ? ? >para resolver os dois tipos separados em um formato compatível. Então, usando o método next(), imprimimos os elementos do IdentityHashMap.

// Java code to illustrate the  // iterating over IdentityHashmap import java.util.*; public class IteratingIdentityHashMap {  public static void main(String[] args)  {  // Creating an empty IdentityHashMap  IdentityHashMap<Integer String> identity_hash  = new IdentityHashMap<Integer String>();  // Mapping string values to int keys  identity_hash.put(10 'Geeks');  identity_hash.put(15 '4');  identity_hash.put(20 'Geeks');  identity_hash.put(25 'Welcomes');  identity_hash.put(30 'You');  // Displaying the IdentityHashMap  System.out.println('Initial Mappings are: '  + identity_hash);  // Create an Iterator over the  // IdentityHashMap  Iterator<IdentityHashMap.Entry<Integer String> >  itr = identity_hash.entrySet().iterator();  // The hasNext() method is used to check if there is  // a next element The next() method is used to  // retrieve the next element  while (itr.hasNext()) {  IdentityHashMap.Entry<Integer String> entry  = itr.next();  System.out.println('Key = ' + entry.getKey()  + ' Value = '  + entry.getValue());  }  } } 

Initial Mappings are: {30=You 10=Geeks 15=4 25=Welcomes 20=Geeks} Key = 30 Value = You Key = 10 Value = Geeks Key = 15 Value = 4 Key = 25 Value = Welcomes Key = 20 Value = Geeks 

IdentidadeHashMap Sincronizada

Se vários threads acessam um mapa hash de identidade simultaneamente e pelo menos um dos threads modifica o mapa estruturalmente, ele deve ser sincronizado externamente. (Uma modificação estrutural é qualquer operação que adiciona ou exclui um ou mais mapeamentos; apenas alterar o valor associado a uma chave que uma instância já contém não é uma modificação estrutural.) Isso normalmente é realizado por meio da sincronização em algum objeto que encapsula naturalmente o mapa. Se tal objeto não existir, o mapa deverá ser 'embrulhado' usando o Collections.synchronizedMap método. É melhor fazer isso no momento da criação para evitar acesso acidental não sincronizado ao mapa. 

Mapa m = Collections.synchronizedMap(new IdentityHashMap(...));

Métodos de IdentityHashMap

K– O tipo das chaves no mapa.V– O tipo de valores mapeados no mapa.

Métodos declarados na classe java.util.AbstractMap

Métodos declarados na interface java.util.Map

IdentidadeHashMap vs.  HashMap

• IdentityHashMap usa o operador de igualdade '==' para comparar chaves e valores, enquanto HashMap usa o método equals para comparar chaves e valores dentro do Map.
• Como IdentityHashMap não usa equals(), é comparativamente mais rápido que HashMap para um objeto com equals() caro.
• IdentityHashMap não exige que as chaves sejam imutáveis, pois não depende de equals().

O programa abaixo ilustra a diferença entre a implementação de IdentityHashMap e HashMap.

// Java code to demonstrate IdentityHashMap and // illustration of how it is different from HashMap  import java.util.Map; import java.util.HashMap; import java.util.IdentityHashMap; public class IdentityHashMapExample  {  public static void main(String[] args)   {  // Creating HashMap and IdentityHashMap objects  Map<String String> hm = new HashMap<>();  Map<String String> ihm = new IdentityHashMap<>();  // Putting key and value in HashMap and IdentityHashMap Object  hm.put('hmkey''hmvalue');  hm.put(new String('hmkey')'hmvalue1');   ihm.put('ihmkey''ihmvalue');   ihm.put(new String('ihmkey')'ihmvalue1');     // Print Size of HashMap and WeakHashMap Object  // hm.size() will print 1 since it compares the objects logically  // and both the keys are same  System.out.println('Size of HashMap is : '+hm.size());    // ihm.size() will print 2 since it compares the objects by reference  System.out.println('Size of IdentityHashMap is : '+ihm.size());    } } 

Size of HashMap is : 1 Size of IdentityHashMap is : 2 

IdentityHashMap é uma classe em Java que implementa a interface Map e usa igualdade de referência para comparar chaves. É semelhante a um HashMap normal, mas usa o operador == para comparar chaves em vez do método equals(). Isso significa que duas chaves com o mesmo conteúdo, mas com referências de objetos diferentes, serão tratadas como chaves distintas em um IdentityHashMap.

Aqui está um exemplo de como usar IdentityHashMap em Java:

import java.util.IdentityHashMap; public class IdentityHashMapExample {  public static void main(String[] args) {  IdentityHashMap<String Integer> map = new IdentityHashMap<>();  // Add key-value pairs to the map  String key1 = new String('key');  String key2 = new String('key');  map.put(key1 1);  map.put(key2 2);  // Get values from the map using the same and different keys  System.out.println(map.get(key1)); // Output: 1  System.out.println(map.get(key2)); // Output: 2  System.out.println(map.get(new String('key'))); // Output: null  } } 

1 2 null 

Neste exemplo, criamos um IdentityHashMap que mapeia chaves String para valores inteiros. Adicionamos dois pares de valores-chave ao mapa usando dois objetos String diferentes que possuem o mesmo conteúdo. Em seguida, recuperamos valores do mapa usando objetos String iguais e diferentes. Descobrimos que podemos recuperar valores do mapa usando duas chaves diferentes que possuem o mesmo conteúdo, mas não podemos recuperar um valor usando um objeto String que possui o mesmo conteúdo, mas é uma referência de objeto diferente.

Observe que IdentityHashMap tem um comportamento ligeiramente diferente de um HashMap normal e geralmente só é útil em certas situações onde a igualdade de referência é importante. Na maioria dos casos, um HashMap regular é suficiente e mais apropriado.

assistente do comissário de polícia