IdentityHashMap implementa la interfaz Map usando Hashtable , usando la igualdad de referencia en lugar de la igualdad de objetos al comparar claves (y valores). Esta clase no es una implementación de mapa de propósito general. Si bien esta clase implementa la interfaz Map, viola intencionalmente el contrato general de Map, que exige el uso del método equals() al comparar objetos. Esta clase se utiliza cuando el usuario requiere que los objetos se comparen por referencia. Pertenece al paquete java.util . Más tarde se agregó en Java 1.4
La principal diferencia entre IdentityHashMap y HashMap en Java es que IdentityHashMap es una implementación especial de la interfaz Map que no usa los métodos equals(obj) y hashCode() para comparar objetos a diferencia de otras implementaciones de Map, por ejemplo, HashMap. En cambio, IdentityHashMap usa el operador de igualdad «==» para comparar claves y valores en Java, lo que lo hace más rápido en comparación con HashMap y adecuado donde necesita una verificación de igualdad de referencia en lugar de igualdad lógica.
Las diferencias entre IdentityHashMap y HashMap son las siguientes:
- La principal diferencia entre HashMap y IdentityHashMap es que IdentityHashMap usa el operador de igualdad “==” para comparar claves y valores dentro de Map, mientras que HashMap usa el método equals(obj) para comparar claves y valores.
- Dado que IdentityHashMap no usa equals(obj), es comparativamente más rápido que HashMap para objetos con equals(obj) y hashCode() costosos.
- Una diferencia más entre HashMap e IdentityHashMap es la inmutabilidad de la clave. Uno de los requisitos básicos de seguridad, cuando almacenamos objetos en HashMap, es que las claves deben ser inmutables, IdentityHashMap no requiere que las claves sean inmutables, ya que no depende de equals(obj) y hashCode().
Ejemplo 1:
Java
// Java Program to illustrate IdentityHashMap by
// Differentiating between HashMap and IdentityHashMap
// Importing input output classes
import java.io.*;
// Importing HashMap, IdentityHashMap and Map classes
// from java.util package
import java.util.HashMap;
import java.util.IdentityHashMap;
import java.util.Map;
// Main Class
public class GFG {
// Main driver method
public static void main (String[] args) {
// Creating objects of HashMap and IdentityHashMap objects
// Declaring objects of type String and Integer type
Map<String, Integer> hashMap = new HashMap<String, Integer>();
Map<String, Integer> identityHashMap = new IdentityHashMap<String, Integer>();
// Adding elements to objects of Maps created above
// Elements are of type key-value pairs using put() method
// Custom entries
hashMap.put("Scala", 100);
hashMap.put(new String("Scala"), 101);
hashMap.put("Groovy", 56);
hashMap.put(new String("Groovy"), 57);
identityHashMap.put("Ruby", 25);
identityHashMap.put(new String("Ruby"), 27);
identityHashMap.put("Swift", 12);
identityHashMap.put(new String("Swift"), 13);
// hashMap.size() will print 2 since
// it compares the objects logically and both the keys are same
System.out.println("Size of HashMap is : " + hashMap.size());
// identityHashMap.size() will print 4 since
// it compares the objects by reference
System.out.println("Size of IdentityHashMap is : " + identityHashMap.size());
}
}
Size of HashMap is : 2 Size of IdentityHashMap is : 4
Implementación: HashMap usa hashCode() para encontrar la ubicación del depósito. IdentityHashMap no usa hashCode(), sino System.identityHashCode(object).
Ejemplo 2:
Java
// Java Program to illustrate IdentityHashMap by
// Differentiating between HashMap and IdentityHashMap
// Importing input output classes
import java.io.*;
// Importing Map,HashMap and IdentityHashMap classes
// from java.util package
import java.util.HashMap;
import java.util.IdentityHashMap;
import java.util.Map;
// Class 1
// Helper Class
class ProgrammingLanguage {
// Member variables of this class
private String language;
private Integer value;
// Constructor of this class
public ProgrammingLanguage(String language,
Integer value)
{
// this keyword refers to current object itself
this.language = language;
this.value = value;
}
// Method 1
public String getlanguage()
{
// Returning language
return language;
}
// Method 2
public Integer getValue()
{
// Returning value associated with a language
return value;
}
// Method 3
// Sets a new value for a language
public void setValue(Integer value)
{
this.value = value;
}
// Method 4
// @Override
public int hashCode()
{
final int prime = 31;
int result = 1;
result
= prime * result
+ ((language == null) ? 0 : value.hashCode());
result
= prime * result
+ ((language == null) ? null
: language.hashCode());
return result;
}
// Method 5
// @Override
public boolean equals(Object obj)
{
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
ProgrammingLanguage other
= (ProgrammingLanguage)obj;
if (value == null) {
if (other.value != null)
return false;
}
else if (!value.equals(other.value))
return false;
if (language == null) {
if (other.language != null)
return false;
}
else if (!language.equals(other.language))
return false;
return true;
}
}
// Class 2
// Main Class
public class GFG {
// Main driver method
public static void main(String[] args)
{
ProgrammingLanguage groovy
= new ProgrammingLanguage("Groovy", 1000);
ProgrammingLanguage scala
= new ProgrammingLanguage("Scala", 2000);
ProgrammingLanguage ruby
= new ProgrammingLanguage("Ruby", 3000);
Map<ProgrammingLanguage, Integer> languageValue
= new HashMap<>();
Map<ProgrammingLanguage, Integer>
languageValueIdentity = new IdentityHashMap<>();
// Inserting elements to object of HashMap created
// Custom entries
languageValue.put(groovy, groovy.getValue());
languageValue.put(scala, scala.getValue());
languageValue.put(ruby, ruby.getValue());
// Inserting elements to object of IdentityHashMap
// created Custom entries
languageValueIdentity.put(groovy,
groovy.getValue());
languageValueIdentity.put(scala, scala.getValue());
languageValueIdentity.put(ruby, ruby.getValue());
// Display message only
System.out.println("Before modifying keys : ");
String result = languageValue.get(groovy) != null
? "Yes"
: "No";
// Print commands to Display the result
System.out.println(
"Does Groovy language exists in HashMap? "
+ result);
result = languageValueIdentity.get(groovy) != null
? "Yes"
: "No";
System.out.println(
"Does Groovy language in IdentityHashMap? "
+ result);
// Now, modifying the value object
groovy.setValue(5000);
// Display message only
System.out.println("After modifying keys : ");
// Print commands to Display the result
result = languageValue.get(groovy) != null ? " Yes "
: " No ";
System.out.println(
"Does Groovy language exists in HashMap? "
+ result);
result = languageValueIdentity.get(groovy) != null
? " Yes "
: " No ";
System.out.println(
"Does Groovy language exists in IdentityHashMap? "
+ result);
}
}
Before modifying keys : Does Groovy language exists in HashMap? Yes Does Groovy language in IdentityHashMap? Yes After modifying keys : Does Groovy language exists in HashMap? No Does Groovy language exists in IdentityHashMap? Yes
Explicación de salida:
Está claro a partir de la salida que una vez que se cambia el objeto del lenguaje de programación, que es clave tanto en HashMap como en IdentityHashMap , no podemos recuperar un objeto en el caso de HashMap , pero podemos recuperarlo cuando usa IdentityHashMap porque el primero usa equals( ) que devuelve falso una vez que se cambia el valor y el último usa el operador «==» que devuelve verdadero porque en ambos casos el objeto es el mismo en el montón.
Publicación traducida automáticamente
Artículo escrito por vanshitatwr620 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA