Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

IdentityHashMap: put, get, containsKey e size

`IdentityHashMap` confronta le chiavi con `==`, non con `equals`. Scopri quando `put` sostituisce una voce, che cosa conta `size` e come distinguere una chiave assente da una associata a `null`.

Versione: Java SE 21

Sintassi

import java.util.IdentityHashMap;

// Instance method signatures on IdentityHashMap<K, V>:
public V put(K key, V value)
public V get(Object key)
public boolean containsKey(Object key)
public int size()

In Java SE 21, java.util.IdentityHashMap<K, V> riconosce una chiave memorizzata se e solo se key == storedKey. Due riferimenti allo stesso oggetto identificano quindi la stessa chiave; due oggetti distinti possono invece essere chiavi separate anche se equals restituisce true. Per trovare una corrispondenza, la mappa non chiama equals né hashCode della chiave: calcola l’hash con System.identityHashCode e stabilisce con == se le chiavi coincidono.

put(K key, V value) aggiunge una voce se la chiave è assente, altrimenti ne sostituisce il valore. Restituisce il valore precedente, oppure null se la chiave era assente o già associata a null. size() restituisce il numero di voci come int: un inserimento lo aumenta di uno, una sostituzione lo lascia invariato.

get(Object key) restituisce il valore associato, oppure null se la chiave è assente. La mappa ammette una chiave null e valori null, quindi get da solo non basta a stabilire se una voce esiste. containsKey(Object key) restituisce true esattamente quando esiste una voce per quella chiave, qualunque sia il valore.

La classe implementa Map, ma si discosta intenzionalmente dal contratto generale di uguaglianza dell’interfaccia, basato su equals. Usala quando conta l’istanza specifica, per esempio per registrare i nodi visitati in un grafo di oggetti. Non usarla al posto di HashMap se le chiavi vanno confrontate per valore.

Esempi

import java.util.IdentityHashMap;

public class Main {
    public static void main(String[] args) {
        String a = new String("node");
        String b = new String("node");
        String alias = a;
        IdentityHashMap<String, String> map = new IdentityHashMap<>();

        System.out.println("a.equals(b): " + a.equals(b));
        System.out.println("a == b: " + (a == b));
        System.out.println("put(a): " + map.put(a, "first"));
        System.out.println("get(alias): " + map.get(alias));
        System.out.println("put(alias): " + map.put(alias, "updated"));
        System.out.println("size after replacement: " + map.size());

        System.out.println("get(b) before insert: " + map.get(b));
        System.out.println("containsKey(b) before insert: " + map.containsKey(b));
        System.out.println("put(b, null): " + map.put(b, null));
        System.out.println("get(b) after insert: " + map.get(b));
        System.out.println("containsKey(b) after insert: " + map.containsKey(b));
        System.out.println("get(a) after insert: " + map.get(a));
        System.out.println("final size: " + map.size());
    }
}

Risultato

a.equals(b): true
a == b: false
put(a): null
get(alias): first
put(alias): first
size after replacement: 1
get(b) before insert: null
containsKey(b) before insert: false
put(b, null): null
get(b) after insert: null
containsKey(b) after insert: true
get(a) after insert: updated
final size: 2

`a` e `b` contengono lo stesso testo, ma sono oggetti distinti. `alias` fa riferimento ad `a`, quindi scrivere tramite `alias` restituisce `first` e lascia la dimensione a `1`. `get(b)` restituisce `null` prima e dopo l’inserimento, ma `containsKey(b)` passa da `false` a `true` e la dimensione sale a `2`.

Lezioni correlate

  • Java · Lezione 17 · Avanzato · Versione: 2

Fonti