Java HashMap: put, get, מעבר בלולאה ודפוסים נפוצים

Map שומרת זוגות של מפתח וערך

HashMap (מ-java.util) שומרת שיוכים: כל מפתח ממופה לערך אחד, ומחפשים ערכים לפי המפתח שלהם בזמן כמעט קבוע. חשבו על מילון: המילה היא המפתח, וההגדרה היא הערך.

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

שני פרמטרי הטיפוס הם <KeyType, ValueType>. כאן המפתחות הם String והערכים הם Integer. כמו עם ArrayList, בדרך כלל מגדירים את המשתנה כממשק Map ויוצרים HashMap.

put, get ודריסה

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);   // אותו מפתח -> דורס את הערך הקודם

        System.out.println(stock.get("apples"));  // 75
        System.out.println(stock.get("pears"));    // null: המפתח לא קיים
    }
}

שני דברים שכדאי להפנים:

• מפתח הוא ייחודי. put עם מפתח קיים מחליפה את הערך שלו ומחזירה את הישן.
• get על מפתח חסר מחזירה null, לא שגיאה. unboxing אוטומטי של ה-null הזה ל-int זורק NullPointerException, שזה מקור נפוץ לבאגים.

getOrDefault עוקפת את מלכודת ה-null

במקום לבדוק null בכל פעם, בקשו ערך גיבוי:

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

זו הדרך הנקייה ביותר לטפל בחיפושים של "אולי קיים", והיא מובילה ישר לדפוס המפורסם ביותר של HashMap.

ספירת מופעים

ספירה של כמה פעמים כל פריט מופיע היא המשימה הקלאסית של 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);
    }
}

הדפוס map.put(key, map.getOrDefault(key, 0) + 1) נקרא כך: "קחו את הספירה הנוכחית (או אפס), הוסיפו אחד, ושמרו אותה בחזרה". מקבילה מסודרת יותר היא counts.merge(word, 1, Integer::sum).

בדיקה והסרה

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) כותבת רק כשהמפתח חסר: שימושי לאתחול עצל.

מעבר בלולאה על HashMap

הלולאה הנפוצה ביותר עוברת על entrySet() ונותנת לכם כל מפתח וערך יחד:

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

אם צריך רק את המפתחות או רק את הערכים:

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

אפשר גם להשתמש ב-forEach עם lambda: ages.forEach((name, age) -> System.out.println(name + ": " + age));.

HashMap לא שומרת על סדר

HashMap לא מבטיחה שום סדר מעבר: הסדר הוא מה שה-hashing מייצר, והוא יכול להשתנות בין הרצות. אם צריך סדר צפוי:

• LinkedHashMap שומרת על סדר ההכנסה.
• TreeMap שומרת את המפתחות ממוינים לפי הסדר הטבעי (או לפי Comparator שתספקו).

שלושתן מממשות את הממשק Map, כך שהחלפה ביניהן היא שינוי של שורה אחת בבנאי.

מפתחות חייבים לתמוך ב-hashing

HashMap מוצאת רשומות על ידי hashing של המפתח, ולכן hashCode() ו-equals() של מפתח חייבים להסכים ביניהם. טיפוסים מובנים כמו String ו-Integer כבר עושים את זה נכון. אם אתם משתמשים במחלקה משלכם כמפתח, דרסו גם את equals וגם את hashCode, אחרת שני אובייקטים ש"שווים" במשמעות שלהם ינחתו בדליים שונים והחיפושים ייכשלו באופן מסתורי.

הבא בתור: HashSet

HashMap עונה על השאלה "איזה ערך שמור תחת המפתח הזה?". כשרק חשוב לכם אם משהו קיים בכלל, קבוצה של ערכים ייחודיים בלי נתונים משויכים, הכלי הוא HashSet, שמגיע בעמוד הבא.