לולאת for-each ב-Java: תחביר, דוגמאות ומלכודות

כשהאינדקס רק מפריע

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

לולאת for-each (השם של Java עבורה הוא ה-for המשופר) מוותרת על המונה לגמרי. נותנים שם למשתנה, מכוונים אותו לאוסף, והלולאה מגישה לכם כל איבר בתורו.

תחביר בסיסי

הצורה היא for (Type element : collection). קראו את הנקודתיים כמילה "ב-":

public class Main {
    public static void main(String[] args) {
        int[] scores = {88, 92, 75, 100};

        for (int score : scores) {
            System.out.println("Score: " + score);
        }
    }
}

אין i, אין scores.length, אין scores[i]. בכל סיבוב, score הוא האיבר הבא. הלולאה רצה פעם אחת לכל איבר ונעצרת אוטומטית כשאין עוד איברים: אי אפשר לחרוג מהסוף או להתחיל איבר אחד מוקדם מדי.

מעבר על List

אותה לולאה עובדת על כל דבר שאפשר לעבור עליו, כולל List, Set ושאר סוגי האוספים. טיפוס האיבר בא לפני שם המשתנה:

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 + " has " + lang.length() + " letters");
        }
    }
}

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

var חוסך את שם הטיפוס

אם טיפוס האיבר ארוך או ברור מאליו, var נותן לקומפיילר להסיק אותו כדי שלא תחזרו על עצמכם:

import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> ages = Map.of("Ann", 30, "Bo", 25);

        for (var entry : ages.entrySet()) {
            System.out.println(entry.getKey() + " is " + entry.getValue());
        }
    }
}

בלי var, משתנה הלולאה היה הביטוי הארוך Map.Entry<String, Integer>. var שומר על קריאות, והטיפוס עדיין נבדק במלואו בזמן הקומפילציה: זה לא טיפוס דינמי ורופף.

מלכודת השינוי

הנה הכלל שתופס את כולם: אי אפשר להוסיף לאוסף או להסיר ממנו בזמן שלולאת for-each עוברת עליו. ניסיון כזה זורק ConcurrentModificationException:

List<String> items = new ArrayList<>(List.of("a", "b", "c"));

for (String item : items) {
    if (item.equals("b")) {
        items.remove(item);   // זורק ConcurrentModificationException
    }
}

הלולאה מבחינה שהרשימה השתנתה מתחתיה ומפסיקה, במקום לדלג על איברים או לחזור עליהם בשקט. כדי להסיר בבטחה, רדו רמה ל-Iterator מפורש, שיש לו remove() שהלולאה יודעת עליו:

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

public class Main {
    public static void main(String[] args) {
        List<String> items = new ArrayList<>(List.of("a", "b", "c"));

        Iterator<String> it = items.iterator();
        while (it.hasNext()) {
            if (it.next().equals("b")) {
                it.remove();   // בטוח
            }
        }

        System.out.println(items);   // [a, c]
    }
}

קיצור דרך נפוץ הוא items.removeIf(item -> item.equals("b")), שמשתמש בביטוי lambda כדי לעשות את אותו הדבר בשורה אחת.

קריאה בלבד, בלי השמה מחדש

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

public class Main {
    public static void main(String[] args) {
        int[] nums = {1, 2, 3};

        for (int n : nums) {
            n = n * 10;   // משנה את העותק, לא את המערך
        }

        System.out.println(nums[0]);   // עדיין 1
    }
}

אם צריך לכתוב חזרה למערך, צריך את האינדקס, כלומר את לולאת ה-for הקלאסית עם מונה: for (int i = 0; i < nums.length; i++) nums[i] = nums[i] * 10;. עבור איברים שהם אובייקטים, אפשר לשנות את האובייקט שהמשתנה מצביע עליו (למשל לקרוא ל-setter), אבל אי אפשר להחליף אותו באוסף.

break ו-continue עדיין עובדים

for-each היא לולאה אמיתית, ולכן break ו-continue מתנהגים בדיוק כמו בכל מקום אחר: break יוצא מהלולאה, continue מדלג לאיבר הבא:

public class Main {
    public static void main(String[] args) {
        String[] words = {"keep", "skip", "keep", "stop", "never"};

        for (String w : words) {
            if (w.equals("skip")) continue;   // מתעלמים מהמילה הזו
            if (w.equals("stop")) break;      // יוצאים לגמרי
            System.out.println(w);
        }
    }
}

זה מדפיס keep ואז keep: הקוד מדלג על "skip" ועוצר ב-"stop" לפני שהוא מגיע ל-"never". אז אתם לא חייבים לבקר בכל איבר; אתם רק מוותרים על האינדקס בתמורה לקוד נקי יותר.

הבא בתור: מערכים

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