En Java ¿Cuál es la diferencia entre IdentityHashMap y HashMap + Comparación de rendimiento?

Publicado: 2021-10-19
diferencia-entre-identityhashmap-y-hashmap-rendimiento-comparación

Hace algún tiempo, tengo un caso especial en el que tengo que comparar la clave del mapa en función del equality operator (==) . El operador de igualdad (==) compara las referencias (direcciones en la memoria) de las dos Claves como dos números diferentes.

Por otro lado, HashMap es el componente Java Collection Framework más utilizado que compara la singularidad de la clave con la ayuda del método equals() .

Además, IdentityHashMap no usa hash de object.hashCode() sino que usa System.identityHashCode(object) . Podríamos usar IdentityHashMap para objetos mutables cuyo código hash cambia durante el tiempo de ejecución.

Si desea obtener más información sobre equals() y == que se aplica on String Object , siga este tutorial: https://crunchify.com/how-to-override-equals-and-hashcode-method-in-java/.

Prueba básica que demuestra el comportamiento anterior de equals() y ==:

Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
package crunchify . com . tutorials ;
 
import java . util . HashMap ;
import java . util . IdentityHashMap ;
import java . util . Map ;
 
/**
* @author Crunchify.com
*
*/
 
public class CrunchifyIdenityHashMapVsHashMapSample {
 
public static void main ( String [ ] args ) {
Map < String , String > crunchifyIdentityHashMap = new IdentityHashMap < String , String > ( ) ;
Map < String , String > crunchifyHashMap = new HashMap < String , String > ( ) ;
 
// Let's checkout what happens when we put Unique Key to IdentityHashMap
crunchifyIdentityHashMap . put ( "Company" , "Crunchify" ) ;
// this considered different object for == operator
crunchifyIdentityHashMap . put ( new String ( "Company" ) , "Google" ) ;
crunchifyIdentityHashMap . put ( "Company" , "Facebook" ) ;
System . out . println ( "crunchifyIdentityHashMap KeySet Size: " + crunchifyIdentityHashMap . keySet ( ) . size ( ) ) ;
 
// Let's checkout what happens when we put Unique Key to HashMap
crunchifyHashMap . put ( "Company" , "Crunchify" ) ;
// key1.equals(key2) returns true hence it removes the old value
crunchifyHashMap . put ( new String ( "Company" ) , "Google" ) ;
crunchifyHashMap . put ( "Company" , "Facebook" ) ;
System . out . println ( "crunchifyHashMap KeySet Size: " + crunchifyHashMap . keySet ( ) . size ( ) ) ;
}
}

Resultado:

1
2
crunchifyIdentityHashMap KeySet Size : 2
crunchifyHashMap KeySet Size : 1

Hagamos pruebas de rendimiento en ambos mapas:

  1. Crear clase Java: CrunchifyIdentityHashMapVsHashMapPerformance .java
  2. startCrunchifyTest()
    • Genera tamaño de mapa aleatorio en millones
    • Crear una instancia e inicializar el objeto de matriz de cadenas crunchifyString[] con el número aleatorio generado anteriormente con texto: This is Crunchify's Test # number
  3. crunchifyCompareIdentityHashMapVsHashMap(String[] crunchifyString , Map<String, Integer> crunchifyMap , String name )
    • Pase todos los parámetros requeridos a este método
    • crunchifyMap tendrá valor IdentityHashMap / HashMap
    • Iterar a través de crunchifyString[] y poner valores en Map: esta operación lleva algún tiempo
    • Iterar a través de crunchifyString[] y obtener valores de Map: esta operación lleva algún tiempo
    • Descubriremos el tiempo de ejecución de las dos operaciones anteriores para poder comparar cuál es mejor para las operaciones anteriores. IdentityHashMap O HashMap
    • Imprime el resultado anterior
  4. Realice las tareas anteriores 2 y 3 en total 8 veces.
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
package crunchify . com . tutorials ;
 
import java . util . HashMap ;
import java . util . IdentityHashMap ;
import java . util . Map ;
import java . util . Random ;
 
/**
* @author Crunchify.com
*
*/
 
public class CrunchifyIdentityHashMapVsHashMapPerformance {
static Random rand = new Random ( ) ;
 
private static void startCrunchifyTest ( ) {
 
// Let's run test for 5 times
for ( int i = 0 ; i < 15 ; ++ i ) {
 
// Let's create random Map size which we will use in IdentityHashMap and HashMap
int randomMapSize = 1000000 + rand . nextInt ( 9000000 ) ;
String [ ] crunchifyString = new String [ randomMapSize ] ;
for ( int j = 0 ; j < randomMapSize ; ++ j )
// Assign below string to crunchifyString Object
crunchifyString [ j ] = "This is Crunchify's Test #" + j ;
 
System . out . println ( "\nIteration # " + i + " - Creating String with size: " + randomMapSize ) ;
crunchifyCompareIdentityHashMapVsHashMap ( crunchifyString , new HashMap < String , Integer > ( randomMapSize ) , "HashMap" ) ;
 
// Runs the garbage collector
System . gc ( ) ;
crunchifyCompareIdentityHashMapVsHashMap ( crunchifyString , new IdentityHashMap < String , Integer > ( randomMapSize ) ,
"IdentityHashMap" ) ;
 
// Runs the garbage collector
System . gc ( ) ;
}
}
 
/**
* @param crunchifyString
* @param crunchifyMap
*            : IdentityHashMap / HashMap
* @param name
*/
private static void crunchifyCompareIdentityHashMapVsHashMap ( String [ ] crunchifyString , Map < String , Integer > crunchifyMap ,
String name ) {
long start = System . currentTimeMillis ( ) ;
 
// put crunchifyString String[] to map
for ( int put = 0 ; put < crunchifyString . length ; ++ put )
crunchifyMap . put ( crunchifyString [ put ] , put ) ;
 
boolean result = false ;
for ( int get = 0 ; get < crunchifyString . length ; ++ get ) {
if ( crunchifyMap . get ( crunchifyString [ get ] ) ! = get )
result = true ;
}
System . out . println ( name + " time taken : \t" + ( System . currentTimeMillis ( ) - start ) / 1000. + " sec" ) ;
 
// Check for result discrepancy
if ( crunchifyMap . size ( ) ! = crunchifyString . length )
System . out . println ( "Please check size. Test failed" ) ;
if ( result )
System . out . println ( "Result failed.." ) ;
}
 
public static void main ( String [ ] args ) {
System . out . println ( "IdentityHashMap Vs. HashMap comparison Test started..." ) ;
 
// method to compare IdentityHashMap and HashMap
startCrunchifyTest ( ) ;
}
 
}

Resultado:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
IdentityHashMap Vs . HashMap comparison Test started . . .
 
Iteration # 0 - Creating String with size: 6964175
HashMap time taken : 3.155 sec
IdentityHashMap time taken : 1.517 sec
 
Iteration # 1 - Creating String with size: 6556459
HashMap time taken : 3.415 sec
IdentityHashMap time taken : 1.466 sec      < == IdentityHashMap gives better result for large object
 
Iteration # 2 - Creating String with size: 9567664
HashMap time taken : 4.173 sec
IdentityHashMap time taken : 2.339 sec      < == better
 
Iteration # 3 - Creating String with size: 4230755
HashMap time taken : 0.372 sec
IdentityHashMap time taken : 0.911 sec
 
Iteration # 4 - Creating String with size: 7821718
HashMap time taken : 1.096 sec
IdentityHashMap time taken : 0.812 sec
 
Iteration # 5 - Creating String with size: 8125421
HashMap time taken : 4.883 sec
IdentityHashMap time taken : 1.876 sec      < == better
 
Iteration # 6 - Creating String with size: 3166432
HashMap time taken : 0.537 sec
IdentityHashMap time taken : 0.708 sec
 
Iteration # 7 - Creating String with size: 2821415
HashMap time taken : 0.227 sec
IdentityHashMap time taken : 0.621 sec

Observación:

Como puede ver aquí en el resultado, para mapas grandes, IdentityHashMap funciona mucho mejor. ¿Por qué? IdentityHashMap doesn't use equals() and hashcode() methods , que se consideran muy costosos.

Solo para tu información:

Las operaciones anteriores que estamos haciendo para poner y obtener valores desde y hacia Map requieren mucha CPU.

Prueba IdentityHashMap vs HashMap: uso de CPU