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

לולאת for הקלאסית בת שלושת החלקים

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

public class Main {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            System.out.println("i = " + i);
        }
    }
}

שלושת החלקים רצים בקצב קבוע:

1. אתחול (int i = 0): רץ פעם אחת, לפני כל דבר אחר.
2. תנאי (i < 5): נבדק לפני כל סיבוב; הלולאה נעצרת כשהוא false.
3. עדכון (i++): רץ אחרי כל סיבוב, לפני שהתנאי נבדק שוב.

לכן הקוד מדפיס מ-i = 0 עד i = 4. המונה i מוגבל לתחום הלולאה: הוא לא קיים אחרי הסוגר המסולסל הסוגר.

ספירה למעלה, למטה ובקפיצות

שלושת החלקים נותנים לכם שליטה מלאה במונה:

public class Main {
    public static void main(String[] args) {
        for (int i = 10; i > 0; i--) {       // ספירה לאחור
            System.out.print(i + " ");
        }
        System.out.println();

        for (int i = 0; i <= 20; i += 5) {   // קפיצות של 5
            System.out.print(i + " ");
        }
    }
}

i-- מפחית ב-1, i += 5 קופץ בצעדים של חמש: שניהם אופרטורים אריתמטיים שמבצעים את החשבון של המונה. התנאי קובע מתי לעצור בהתאם לכיוון: השתמשו ב-> כשסופרים לאחור, וב-< או <= כשסופרים קדימה.

מעבר על מערך

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

public class Main {
    public static void main(String[] args) {
        String[] colors = {"red", "green", "blue"};

        for (int i = 0; i < colors.length; i++) {
            System.out.println(i + ": " + colors[i]);
        }
    }
}

שימו לב ש-colors.length הוא שדה בלי סוגריים: מערכים מיוחדים בעניין הזה. List, לעומת זאת, משתמשת ב-list.size(). התנאי i < colors.length נכון: האינדקסים נעים מ-0 עד length - 1, ולכן שימוש ב-< (ולא <=) מונע שגיאה של חריגה מהטווח.

לולאת for-each המשופרת

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

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> colors = List.of("red", "green", "blue");

        for (String color : colors) {
            System.out.println(color.toUpperCase());
        }
    }
}

קראו את for (String color : colors) כ-"לכל color ב-colors". היא עובדת על מערכים ועל כל דבר שאפשר לעבור עליו. המחיר: אין לכם אינדקס, ואי אפשר להוסיף לאוסף או להסיר ממנו בזמן המעבר (זה זורק חריגת זמן ריצה, ConcurrentModificationException). בחרו בלולאה עם מונה כשצריך אחד מהשניים.

לולאות מקוננות

לולאה בתוך לולאה, שימושית לטבלאות, רשתות וצירופים. הלולאה הפנימית רצה במלואה בכל סיבוב של החיצונית:

public class Main {
    public static void main(String[] args) {
        for (int row = 1; row <= 3; row++) {
            for (int col = 1; col <= 3; col++) {
                System.out.print(row * col + "\t");
            }
            System.out.println();
        }
    }
}

זה מדפיס טבלת כפל של 3x3. כשהקינון מעמיק, תנו למונים שמות משמעותיים (row, col) במקום i, j: זה חוסך בלבול בין המונים.

break ו-continue

break יוצא מהלולאה מיד. continue מדלג על שאר הסיבוב הנוכחי וקופץ לשלב העדכון:

public class Main {
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            if (i % 2 == 0) continue;   // מדלגים על מספרים זוגיים
            if (i > 7) break;           // עוצרים אחרי 7
            System.out.println(i);
        }
    }
}

זה מדפיס 1 3 5 7. continue מדלג על הזוגיים; break מסיים את הלולאה ברגע ש-i היה עובר את 7. בלולאות מקוננות, שניהם משפיעים רק על הלולאה הפנימית ביותר, אלא אם משתמשים ב-break עם תווית.

היזהרו מלולאות אינסופיות

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

for (int i = 0; i < 5; i--) {   // i רק קטן -> אף פעם לא מגיע ל-5
    System.out.println(i);
}

לולאה אינסופית מכוונת משמיטה את כל שלושת החלקים, for (;;) { ... }, ומסתמכת על break בפנים כדי לעצור. השתמשו בזה במשורה; while (true) בדרך כלל ברור יותר.

הבא בתור: לולאות while

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