En Java Quelle est la différence entre IdentityHashMap et HashMap + Comparaison des performances

Publié: 2021-10-19
différence-entre-identityhashmap-et-hashmap-performance-comparaison

Il y a quelque temps, j'ai un cas particulier dans lequel je dois comparer Map's Key en fonction de equality operator (==) . L'opérateur d'égalité (==) compare les références (adresses en mémoire) des deux clés comme deux nombres différents.

D'autre part, HashMap est le composant Java Collection Framework le plus utilisé qui compare l'unicité de la clé à l'aide de la méthode equals() .

De plus, IdentityHashMap n'utilise pas le hachage de object.hashCode() mais utilise System.identityHashCode(object) . Nous pourrions utiliser IdentityHashMap pour les objets mutables dont le code de hachage change pendant l'exécution.

Si vous voulez en savoir plus sur equals() et == qui s'appliquent on String Object , suivez ce tutoriel : https://crunchify.com/how-to-override-equals-and-hashcode-method-in-java/.

Test de base qui démontre le comportement ci-dessus equals() et == :

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 ( ) ) ;
}
}

Résultat:

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

Faisons des tests de performances sur les deux cartes :

  1. Créer une classe Java : CrunchifyIdentityHashMapVsHashMapPerformance .java
  2. startCrunchifyTest()
    • Génère une taille de carte aléatoire en millions
    • Instanciez et initialisez crunchifyString[] String Array avec le numéro aléatoire généré ci-dessus avec du texte : This is Crunchify's Test # number
  3. crunchifyCompareIdentityHashMapVsHashMap(String[] crunchifyString , Map<String, Integer> crunchifyMap , String name )
    • Passez tous les paramètres requis à cette méthode
    • crunchifyMap aura pour valeur IdentityHashMap / HashMap
    • Itérer à travers crunchifyString[] et mettre des valeurs dans Map - cette opération prend un certain temps
    • Itérer à travers crunchifyString[] et obtenir les valeurs de Map — cette opération prend un certain temps
    • Nous découvrirons le temps d'exécution pour les deux opérations ci-dessus afin de pouvoir comparer laquelle est la meilleure pour les opérations ci-dessus ? IdentityHashMap OR HashMap
    • Imprimer le résultat ci-dessus
  4. Effectuez les tâches 2 et 3 ci-dessus 8 fois au total.
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 ( ) ;
}
 
}

Résultat:

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

Observation:

Comme vous pouvez le voir ici dans le résultat, pour les grandes cartes, IdentityHashMap fonctionne beaucoup mieux. Pourquoi? IdentityHashMap doesn't use equals() and hashcode() methods , considérées comme très coûteuses.

Juste FYI:

Les opérations ci-dessus que nous effectuons pour mettre et obtenir des valeurs depuis et vers Map sont très gourmandes en CPU.

Test IdentityHashMap vs HashMap - Utilisation du processeur