Überprüfung der Schlüsselexistenz in HashMap

Ist eine Überprüfung der Schlüsselexistenz in HashMap immer erforderlich?

Ich habe eine HashMap mit beispielsweise 1000 Einträgen und möchte die Effizienz verbessern. Wenn sehr häufig auf die HashMap zugegriffen wird, führt die Überprüfung der Schlüsselexistenz bei jedem Zugriff zu einem hohen Overhead. Wenn der Schlüssel nicht vorhanden ist und daher eine Ausnahme auftritt, kann ich die Ausnahme abfangen. (wenn ich weiß, dass dies selten passieren wird). Dadurch wird der Zugriff auf die HashMap um die Hälfte reduziert.

Dies ist möglicherweise keine gute Programmierpraxis, hilft mir jedoch dabei, die Anzahl der Zugriffe zu verringern. Oder fehlt mir hier etwas?

[ Update ] Ich habe keine Nullwerte in der HashMap.

Speichern Sie jemals einen Nullwert? Wenn nicht, können Sie einfach Folgendes tun:

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

Andernfalls Sie könnten nur die Existenz , wenn Sie einen Nullwert zurück erhalten:

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
    }
}

Sie erhalten nichts, wenn Sie überprüfen, ob der Schlüssel vorhanden ist. Dies ist der Code von 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;
}

Überprüfen Sie einfach, ob sich der Rückgabewert für von get()unterscheidet null.

Dies ist der HashMap-Quellcode.

Ressourcen:

• HashMap-Quellcode Schlechter
• HashMap-Quellcode Gut

Besser ist es zu benutzen containsKey Methode von zu verwenden HashMap. Morgen wird jemand der Karte null hinzufügen. Sie sollten zwischen Schlüsselpräsenz und Schlüssel mit dem Wert Null unterscheiden.

Meinst du, dass du Code wie hast?

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

überall ? Dann sollten Sie einfach prüfen, ob map.get(key)null zurückgegeben wurde und das wars. Übrigens löst HashMap keine Ausnahmen für fehlende Schlüssel aus, sondern gibt stattdessen null zurück. Der einzige Fall, in dem dies containsKeyerforderlich ist, ist das Speichern von Nullwerten, um zwischen einem Nullwert und einem fehlenden Wert zu unterscheiden. Dies wird jedoch normalerweise als schlechte Vorgehensweise angesehen.

Nur containsKey()zur Klarheit verwenden. Es ist schnell und hält den Code sauber und lesbar. Der springende Punkt bei HashMaps ist, dass die Schlüsselsuche schnell ist. Stellen Sie einfach sicher, dass die hashCode()und equals()ordnungsgemäß implementiert sind.

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

Sie können die computeIfAbsent()Methode auch in der HashMapKlasse verwenden.

Im folgenden Beispiel wird mapeine Liste von Transaktionen (Ganzzahlen) gespeichert, die auf den Schlüssel (den Namen des Bankkontos) angewendet werden. Um 2 Transaktionen von 100und 200zu hinzufügen , können checking_accountSie schreiben:

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

Auf diese Weise müssen Sie nicht überprüfen, ob der Schlüssel checking_accountvorhanden ist oder nicht.

• Wenn es nicht existiert, wird einer vom Lambda-Ausdruck erstellt und zurückgegeben.
• Wenn es existiert, wird der Wert für den Schlüssel von zurückgegeben computeIfAbsent().

Wirklich elegant! 👍

Normalerweise benutze ich die Redewendung

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

Dies bedeutet, dass Sie die Karte nur zweimal treffen, wenn der Schlüssel fehlt

1. Wenn Sie eine Schlüsselklasse haben, stellen Sie sicher, dass die Methoden hashCode () und equals () implementiert sind.
2. Grundsätzlich sollte der Zugriff auf HashMap O (1) sein, aber bei falscher Implementierung der HashCode-Methode wird er zu O (n), da der Wert mit demselben Hash-Schlüssel als verknüpfte Liste gespeichert wird.

Die Antwort von Jon Skeet spricht die beiden Szenarien (Karte mit nullWert und nicht nullWert) auf effiziente Weise gut an.

Über die Nummerneinträge und das Effizienzproblem möchte ich noch etwas hinzufügen.

Ich habe eine HashMap mit beispielsweise 1.000 Einträgen und möchte die Effizienz verbessern. Wenn sehr häufig auf die HashMap zugegriffen wird, führt die Überprüfung der Schlüsselexistenz bei jedem Zugriff zu einem hohen Overhead.

Eine Karte mit 1.000 Einträgen ist keine riesige Karte.
Sowie eine Karte mit 5.000 oder 10.000 Einträgen.
Mapsind so konzipiert, dass sie mit solchen Abmessungen schnell abgerufen werden können.

Nun wird davon ausgegangen, dass hashCode()der Kartenschlüssel eine gute Verteilung bietet.

Wenn Sie einen IntegerSchlüsseltyp als verwenden können, tun Sie dies.
Die hashCode()Methode ist sehr effizient, da die Kollisionen für eindeutige intWerte nicht möglich sind:

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;
    }
    ...
}

Wenn Sie für den Schlüssel einen anderen integrierten Typ verwenden müssen, wie Stringer beispielsweise häufig verwendet wird Map, können einige Kollisionen auftreten, aber von 1 Tausend bis zu einigen Tausend Objekten in der Mapsollten Sie nur sehr wenige davon als String.hashCode()Methode verwenden bietet eine gute Verteilung.

Wenn Sie einen benutzerdefinierten Typ verwenden, überschreiben hashCode()und equals()korrigieren Sie ihn und stellen Sie insgesamt sicher, dass hashCode()eine faire Verteilung gewährleistet ist .
Sie können sich auf Punkt 9 Java Effectivebeziehen.
Hier ist ein Beitrag , der den Weg beschreibt.