Java

לולאות (for / while / do-while)

מה זו לולאה?

לולאה היא מבנה שמאפשר להריץ את אותו קוד מספר פעמים. ב-Java יש 4 סוגים עיקריים של לולאות.

for - לולאה עם מונה

הלולאה הנפוצה ביותר, כשיודעים כמה פעמים לרוץ:

for (initialization; condition; update) {
    // קוד שחוזר
}

דוגמה קלאסית

for (int i = 0; i < 10; i++) {
    System.out.println("איטרציה " + i);
}

פלט:

איטרציה 0
איטרציה 1
...
איטרציה 9

פירוק

1. אתחול (int i = 0) - רץ פעם אחת בהתחלה
2. תנאי (i < 10) - נבדק לפני כל איטרציה. אם נכון - רץ. אם לא - יוצא.
3. עדכון (i++) - רץ אחרי כל איטרציה

וריאציות

// ספירה לאחור
for (int i = 10; i > 0; i--) {
    System.out.println(i);
}

// קפיצות של 2
for (int i = 0; i < 20; i += 2) {
    System.out.println(i);  // 0, 2, 4, 6, ..., 18
}

// מונה כפול
for (int i = 0, j = 10; i < j; i++, j--) {
    System.out.println(i + " " + j);
}

while - לולאה עם תנאי

כשלא יודעים מראש כמה פעמים:

while (condition) {
    // קוד שחוזר כל עוד התנאי נכון
}

דוגמה:

int n = 100;
while (n > 1) {
    System.out.println(n);
    n = n / 2;
}
// 100, 50, 25, 12, 6, 3

לולאה אינסופית

while (true) {
    // ...
    if (shouldStop) break;
}

do-while - לפחות פעם אחת

בודק את התנאי אחרי האיטרציה, כך שהגוף רץ לפחות פעם אחת:

do {
    // קוד
} while (condition);

דוגמה - קלט מהמשתמש:

Scanner scanner = new Scanner(System.in);
int number;
do {
    System.out.print("הכנס מספר חיובי: ");
    number = scanner.nextInt();
} while (number <= 0);

ההבדל: ב-while, אם התנאי שקרי מההתחלה - הגוף לא רץ אפילו פעם אחת. ב-do-while, הגוף תמיד רץ לפחות פעם אחת.

for-each (enhanced for)

לולאה קצרה לעבור על מערכים ואוספים:

int[] numbers = {1, 2, 3, 4, 5};

for (int n : numbers) {
    System.out.println(n);
}

קוראים את זה: "לכל n בתוך numbers".

זה קצר יותר מ:

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

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

break ו-continue

break - יציאה מהלולאה

for (int i = 0; i < 100; i++) {
    if (i == 10) break;
    System.out.println(i);
}
// מדפיס 0..9

continue - דילוג לאיטרציה הבאה

for (int i = 0; i < 10; i++) {
    if (i % 2 == 0) continue;  // דלג על הזוגיים
    System.out.println(i);
}
// מדפיס 1, 3, 5, 7, 9

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

לולאה בתוך לולאה:

for (int i = 1; i <= 3; i++) {
    for (int j = 1; j <= 3; j++) {
        System.out.print(i * j + " ");
    }
    System.out.println();
}

פלט:

1 2 3
2 4 6
3 6 9

שימושי לציורים

// משולש מכוכביות
for (int i = 1; i <= 5; i++) {
    for (int j = 0; j < i; j++) {
        System.out.print("*");
    }
    System.out.println();
}

פלט:

*
**
***
****
*****

break עם תווית (label)

לצאת מכמה לולאות בבת אחת:

outer:
for (int i = 0; i < 10; i++) {
    for (int j = 0; j < 10; j++) {
        if (i + j > 10) break outer;
        System.out.println(i + " " + j);
    }
}

לא נפוץ, אבל לפעמים חוסך עבודה.

מתי להשתמש בכל לולאה

דוגמה: סכום מספרי פיבונאצ'י

int a = 0, b = 1;
int sum = 0;

while (b < 100) {
    sum += b;
    int temp = b;
    b = a + b;
    a = temp;
}

System.out.println("הסכום: " + sum);