HashMap w Javie: put, get, iterowanie i popularne wzorce

Mapa przechowuje pary klucz-wartość

HashMap (z java.util) przechowuje powiązania: każdy klucz wskazuje jedną wartość, a wartości wyszukujesz po kluczu w mniej więcej stałym czasie. Pomyśl o słowniku: słowo jest kluczem, a definicja wartością.

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> ages = new HashMap<>();
        ages.put("Ada", 36);
        ages.put("Boris", 29);
        ages.put("Chen", 41);

        System.out.println(ages.get("Boris"));
        System.out.println(ages);
    }
}

Dwa parametry typu to <KeyType, ValueType>. Tutaj klucze to String, a wartości to Integer. Podobnie jak przy ArrayList zmienną zwykle deklaruje się jako interfejs Map, a tworzy HashMap.

put, get i nadpisywanie

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> stock = new HashMap<>();
        stock.put("apples", 50);
        stock.put("apples", 75);   // ten sam klucz -> nadpisuje starą wartość

        System.out.println(stock.get("apples"));  // 75
        System.out.println(stock.get("pears"));    // null: klucza nie ma
    }
}

Dwie rzeczy warto zapamiętać:

• Klucz jest unikalny. put z istniejącym kluczem zastępuje jego wartość i zwraca starą.
• get dla brakującego klucza zwraca null, a nie błąd. Automatyczne rozpakowanie tego null do int rzuca NullPointerException, co jest częstym źródłem błędów.

getOrDefault omija pułapkę null

Zamiast za każdym razem sprawdzać null, poproś o wartość zapasową:

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> stock = new HashMap<>();
        stock.put("apples", 50);

        int apples = stock.getOrDefault("apples", 0);
        int pears = stock.getOrDefault("pears", 0);

        System.out.println(apples + " apples, " + pears + " pears");
    }
}

To najczystszy sposób obsługi wyszukiwań typu „może istnieje” i prowadzi prosto do najsłynniejszego wzorca z HashMap.

Liczenie wystąpień

Liczenie, ile razy pojawia się każdy element, to podręcznikowe zadanie dla HashMap:

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        String text = "the cat the dog the cat";
        Map<String, Integer> counts = new HashMap<>();

        for (String word : text.split(" ")) {
            counts.put(word, counts.getOrDefault(word, 0) + 1);
        }

        System.out.println(counts);
    }
}

Wzorzec map.put(key, map.getOrDefault(key, 0) + 1) czyta się jako „weź bieżącą liczbę (albo zero), dodaj jeden i zapisz z powrotem”. Zgrabniejszy odpowiednik to counts.merge(word, 1, Integer::sum).

Sprawdzanie i usuwanie

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> ages = new HashMap<>();
        ages.put("Ada", 36);
        ages.put("Boris", 29);

        System.out.println(ages.containsKey("Ada"));     // true
        System.out.println(ages.containsValue(29));      // true
        System.out.println(ages.size());                 // 2

        ages.remove("Ada");
        System.out.println(ages.containsKey("Ada"));     // false
    }
}

putIfAbsent(key, value) zapisuje wartość tylko wtedy, gdy klucza brakuje, co przydaje się przy leniwej inicjalizacji.

Pętla po HashMap

Najczęstsza pętla przechodzi po entrySet() i daje każdy klucz razem z wartością:

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> ages = new HashMap<>();
        ages.put("Ada", 36);
        ages.put("Boris", 29);
        ages.put("Chen", 41);

        for (Map.Entry<String, Integer> entry : ages.entrySet()) {
            System.out.println(entry.getKey() + " is " + entry.getValue());
        }
    }
}

Jeśli potrzebujesz tylko kluczy albo tylko wartości:

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> ages = new HashMap<>();
        ages.put("Ada", 36);
        ages.put("Boris", 29);

        for (String name : ages.keySet()) {
            System.out.println(name);
        }
        for (int age : ages.values()) {
            System.out.println(age);
        }
    }
}

Możesz też użyć forEach z lambdą: ages.forEach((name, age) -> System.out.println(name + ": " + age));.

HashMap nie zachowuje kolejności

HashMap nie gwarantuje żadnej kolejności iteracji: wynika ona z haszowania i może się zmieniać między uruchomieniami. Jeśli potrzebujesz przewidywalnej kolejności:

• LinkedHashMap zachowuje kolejność wstawiania.
• TreeMap utrzymuje klucze posortowane według porządku naturalnego (albo podanego przez ciebie Comparator).

Wszystkie trzy implementują interfejs Map, więc zamiana to zmiana jednego wiersza z konstruktorem.

Klucze muszą być haszowalne

HashMap znajduje wpisy przez haszowanie klucza, więc hashCode() i equals() klucza muszą być ze sobą zgodne. Typy wbudowane, takie jak String i Integer, robią to poprawnie. Jeśli jako klucza używasz własnej klasy, nadpisz zarówno equals, jak i hashCode. Inaczej dwa obiekty „równe” znaczeniowo trafią do różnych kubełków, a wyszukiwania będą zagadkowo zawodzić.

Dalej: HashSet

HashMap odpowiada na pytanie „jaka wartość jest zapisana pod tym kluczem?”. Gdy interesuje cię tylko to, czy coś w ogóle występuje, czyli zbiór unikalnych wartości bez powiązanych danych, narzędziem jest HashSet, omówiony na następnej stronie.