מעבר על Collections ב-Java: for-each, Iterator, forEach

משימה אחת, כמה כלים

אספתם נתונים, ב-ArrayList, ב-HashSet או ב-HashMap, ועכשיו אתם רוצים לעבור על כל איבר. Java נותנת כמה דרכים לעשות את זה, והבחירה תלויה בשאלה אם צריך את האינדקס, אם צריך למחוק פריטים באמצע הלולאה, והאם אתם מעדיפים תחביר של מתודה או של לולאה.

החדשות הטובות: כל Collection (רשימה, קבוצה, תור) תומך באותה לולאת for משופרת, כך שברגע שלומדים אותה אפשר לעבור על כולם באותה צורה.

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> langs = List.of("Java", "Python", "Go");

        for (String lang : langs) {
            System.out.println(lang);
        }
    }
}

קראו את הנקודתיים כ"בתוך": "לכל lang בתוך langs". אתם לא נוגעים באינדקס בכלל, אז אין פה מה לפספס.

לולאת for-each

לולאת for המשופרת היא הבחירה הרגילה כשרק רוצים "לעשות משהו עם כל איבר". היא קריאה ועובדת בדיוק אותו דבר בכל סוגי האוספים. הנה היא על HashSet, שאין לו אינדקסים בכלל:

import java.util.HashSet;
import java.util.Set;

public class Main {
    public static void main(String[] args) {
        Set<String> tags = new HashSet<>();
        tags.add("urgent");
        tags.add("review");
        tags.add("urgent");   // Set מתעלם מהכפילות

        for (String tag : tags) {
            System.out.println(tag);
        }
    }
}

דבר אחד שכדאי לזכור לגבי HashSet: אין לו סדר מוגדר, אז האיברים יכולים להודפס בכל סדר שהוא. לולאת for-each עוברת על כולם בדיוק פעם אחת בכל מקרה.

כשצריך את האינדקס

לולאת for-each נותנת את האיבר אבל לא את המיקום שלו. אם באמת צריך את האינדקס, כדי למספר שורות או להסתכל על איברים שכנים, השתמשו בלולאה עם מונה, size() ו-get(i). זה עובד על List, שמבוסס על מיקומים. לקבוצות ולמפות אין אינדקס, אז הסגנון הזה לא מתאים להן.

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> langs = List.of("Java", "Python", "Go");

        for (int i = 0; i < langs.size(); i++) {
            System.out.println((i + 1) + ". " + langs.get(i));
        }
    }
}

אל תבחרו בזה רק מתוך הרגל. אם אתם לא משתמשים ב-i לשום דבר מעבר ל-get(i), גרסת ה-for-each קצרה יותר וקשה יותר לטעות בה.

מעבר על Map

Map הוא לא Collection, ולכן אי אפשר להפעיל עליו for-each ישירות. במקום זה עוברים על אחת משלוש התצוגות שלו. הנפוצה ביותר היא 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", 28);

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

אם צריך רק את המפתחות, עברו על ages.keySet(). אם צריך רק את הערכים, עברו על ages.values(). כשצריך את שניהם העדיפו את entrySet(): מעבר על המפתחות וקריאה ל-ages.get(key) בתוך הלולאה מבצע חיפוש נוסף בכל איטרציה בלי שום סיבה.

ה-Iterator

לולאת for-each היא בעצם קיצור תחבירי מעל Iterator: אובייקט שעובר על אוסף איבר אחרי איבר בעזרת hasNext() ו-next(). כמעט אף פעם לא כותבים את הלולאה הזו ידנית, עם חריג חשוב אחד: זו הדרך הבטוחה למחוק איברים תוך כדי מעבר.

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = new ArrayList<>(List.of(1, 2, 3, 4, 5, 6));

        Iterator<Integer> it = nums.iterator();
        while (it.hasNext()) {
            int n = it.next();
            if (n % 2 == 0) {
                it.remove();   // בטוח: מוחק את האיבר שהוחזר זה עתה
            }
        }

        System.out.println(nums);
    }
}

it.remove() מוחק את האיבר ש-next() החזיר לאחרונה, וה-iterator נשאר תקין. זו הדרך המאושרת היחידה לשנות אוסף במהלך לולאה ידנית.

המלכודת: ConcurrentModificationException

אם קוראים ל-add או ל-remove על האוסף עצמו בתוך לולאת for-each, מקבלים ConcurrentModificationException: ה-iterator שם לב שהאוסף השתנה מתחתיו ומסרב להמשיך. זו אחת השגיאות הנפוצות ביותר אצל מתחילים, וכמו כל חריגת זמן ריצה היא עוצרת את המתודה, אלא אם נמנעים מלגרום לה מלכתחילה.

List<Integer> nums = new ArrayList<>(List.of(1, 2, 3, 4));
for (int n : nums) {
    if (n % 2 == 0) {
        nums.remove(Integer.valueOf(n));   // throws ConcurrentModificationException
    }
}

הפתרון הוא כמעט תמיד removeIf, שמבטא את הכוונה בשורה אחת ומטפל במעבר בשבילכם:

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = new ArrayList<>(List.of(1, 2, 3, 4, 5, 6));
        nums.removeIf(n -> n % 2 == 0);   // מסננים החוצה את המספרים הזוגיים
        System.out.println(nums);
    }
}

removeIf עובד על כל Collection, כך שאותה קריאה מנקה גם HashSet.

המתודה forEach

לכל אוסף יש גם מתודה forEach שמקבלת lambda ומריצה אותה על כל איבר. זו חלופה פונקציונלית יותר, בסגנון של ביטוי, ללולאה, ונוחה לשורות קצרות:

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

public class Main {
    public static void main(String[] args) {
        List<String> langs = List.of("Java", "Python", "Go");
        langs.forEach(lang -> System.out.println(lang));

        Map<String, Integer> ages = new HashMap<>();
        ages.put("Ada", 36);
        ages.put("Boris", 28);
        ages.forEach((name, age) -> System.out.println(name + ": " + age));
    }
}

שימו לב ש-Map.forEach מקבלת ישירות lambda עם שני ארגומנטים (key, value), בלי צורך ב-entrySet(). השתמשו ב-forEach לפעולות צד מהירות, וחזרו ללולאת for הרגילה כשהגוף גדל או כשצריך לצאת מוקדם עם break, דבר ש-lambda לא יכולה לעשות.

הבא בתור: מתודות

ארזתם נתונים באוספים ועברתם עליהם בכל דרך ש-Java מציעה. השלב הבא הוא לארוז התנהגות: לכתוב מתודות משלכם, כדי לתת שם לגוש של לוגיקה, להעביר לו קלט ולהשתמש בו שוב. זה העמוד הבא.