Controllo dell'esistenza chiave in HashMap

Il controllo dell'esistenza delle chiavi in ​​HashMap è sempre necessario?

Ho una HashMap con diciamo 1000 voci e sto cercando di migliorare l'efficienza. Se si accede a HashMap molto frequentemente, il controllo dell'esistenza della chiave ad ogni accesso comporterà un notevole sovraccarico. Invece se la chiave non è presente e quindi si verifica un'eccezione, posso rilevare l'eccezione. (quando so che questo accadrà raramente). Ciò ridurrà della metà gli accessi a HashMap.

Questa potrebbe non essere una buona pratica di programmazione, ma mi aiuterà a ridurre il numero di accessi. O mi sto perdendo qualcosa qui?

[ Aggiornamento ] Non ho valori nulli in HashMap.

Memorizzi mai un valore nullo? In caso contrario, puoi semplicemente fare:

Foo value = map.get(key);
if (value != null) {
    ...
} else {
    // No such key
}

In caso contrario, si potrebbe basta controllare per l'esistenza, se si ottiene un valore nullo restituito:

Foo value = map.get(key);
if (value != null) {
    ...
} else {
    // Key might be present...
    if (map.containsKey(key)) {
       // Okay, there's a key but the value is null
    } else {
       // Definitely no such key
    }
}

Non otterrai nulla controllando che la chiave esista. Questo è il codice di HashMap:

@Override
public boolean containsKey(Object key) {
    Entry<K, V> m = getEntry(key);
    return m != null;
}

@Override
public V get(Object key) {
    Entry<K, V> m = getEntry(key);
    if (m != null) {
        return m.value;
    }
    return null;
}

Controlla se il valore di ritorno get()è diverso da null.

Questo è il codice sorgente di HashMap.

Risorse:

• Codice sorgente HashMap cattivo
• Codice sorgente HashMap Buono

Il modo migliore è usare il containsKeymetodo di HashMap. Domani qualcuno aggiungerà null alla Mappa. È necessario distinguere tra presenza chiave e chiave con valore nullo.

Vuoi dire che hai un codice simile

if(map.containsKey(key)) doSomethingWith(map.get(key))

dappertutto? Quindi dovresti semplicemente controllare se map.get(key)restituito null e basta. A proposito, HashMap non genera eccezioni per le chiavi mancanti, ma restituisce null. L'unico caso in cui containsKeyè necessario è quando si memorizzano valori null, per distinguere tra un valore null e un valore mancante, ma questo è generalmente considerato una cattiva pratica.

Usa solo containsKey()per chiarezza. È veloce e mantiene il codice pulito e leggibile. Il punto centrale di HashMaps è che la ricerca dei tasti è veloce, assicurati solo che hashCode()e equals()siano implementati correttamente.

if(map.get(key) != null || (map.get(key) == null && map.containsKey(key)))

Puoi anche usare il computeIfAbsent()metodo nella HashMapclasse.

Nel seguente esempio, mapmemorizza un elenco di transazioni (numeri interi) che vengono applicati alla chiave (il nome del conto bancario). Per aggiungere 2 transazioni di 100e 200per checking_accountte puoi scrivere:

HashMap<String, ArrayList<Integer>> map = new HashMap<>();
map.computeIfAbsent("checking_account", key -> new ArrayList<>())
   .add(100)
   .add(200);

In questo modo non è necessario verificare se la chiave checking_accountesiste o meno.

• Se non esiste, ne verrà creato uno e restituito dall'espressione lambda.
• Se esiste, verrà restituito il valore per la chiave computeIfAbsent().

Davvero elegante! 👍

Di solito uso il linguaggio

Object value = map.get(key);
if (value == null) {
    value = createValue(key);
    map.put(key, value);
}

Ciò significa che colpisci la mappa solo due volte se manca la chiave

1. Se la classe chiave è tua, assicurati che siano implementati i metodi hashCode () e equals ().
2. Fondamentalmente l'accesso a HashMap dovrebbe essere O (1) ma con un'implementazione errata del metodo hashCode è diventato O (n), perché il valore con la stessa chiave hash verrà archiviato come Elenco collegato.

La risposta di Jon Skeet affronta bene i due scenari (mappa con nullvalore e non nullvalore) in modo efficiente.

Per quanto riguarda le voci numeriche e il problema dell'efficienza, vorrei aggiungere qualcosa.

Ho una HashMap con diciamo 1.000 voci e sto cercando di migliorare l'efficienza. Se si accede a HashMap molto frequentemente, la verifica dell'esistenza della chiave ad ogni accesso comporterà un notevole sovraccarico.

Una mappa con 1.000 voci non è una mappa enorme.
Oltre a una mappa con 5.000 o 10.000 voci.
Mapsono progettati per un rapido recupero con tali dimensioni.

Ora, si presume che hashCode()delle chiavi della mappa fornisca una buona distribuzione.

Se puoi usare un Integertipo di chiave, fallo.
Il suo hashCode()metodo è molto efficiente poiché le collisioni non sono possibili per intvalori univoci :

public final class Integer extends Number implements Comparable<Integer> {
    ...
    @Override
    public int hashCode() {
        return Integer.hashCode(value);
    }

    public static int hashCode(int value) {
        return value;
    }
    ...
}

Se per la chiave, è necessario utilizzare un altro tipo incorporato come Stringad esempio in cui viene spesso utilizzato Map, è possibile che si verifichino delle collisioni, ma da 1 000 a alcune migliaia di oggetti nel Map, si dovrebbe avere pochissimi come String.hashCode()metodo fornisce una buona distribuzione.

Se si utilizza un tipo personalizzato, eseguire l'override hashCode()e equals()correttamente e assicurarsi nel complesso che hashCode()fornisca una distribuzione equa.
È possibile fare riferimento all'articolo 9 di Java Effectiveesso si riferisce.
Ecco un post che descrive in modo dettagliato.