לדלג לתוכן

Java/לולאות

מתוך ויקיספר, אוסף הספרים והמדריכים החופשי
תנאים Java
לולאות
מערכים

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

for (int i=0; i<50; i++)
	System.out.print("*");

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

לולאת for

[עריכה]

אחת מהלולאות אשר קיימות בשפה, הינה לולאת for, שאותה כבר ראינו לעיל. צורת הכתיבה היא כזו:

for (init; condition; step)

כאשר במקום init נכתב המצב ההתחלתי (כלומר, פקודה שתתבצע בשעה שהתוכנית נכנסת ללולאה לראשונה), במקום condition נכתוב תנאי סיום - הלולאה תמשיך לרוץ כל עוד התנאי מתקיים, ובמקום step נכתוב מה קורה בכל פעם שהתוכנית חוזרת ללולאה. בדוגמה שלנו השתמשנו בכמה תנאים נפוצים ופשוטים מאוד: בתחילת הלולאה אתחלנו משתנה מסוג int בשם i להיות 0, ופקדנו על התוכנית להפעיל את הפקודות שבתוך הלולאה (דהיינו, הפקודה להדפיס "*") כל זמן ש-i קטן מ-50. בכל פעם שמסיימת התוכנית לבצע את הפקודות, i גדל ב-1. אם כך, לאחר 50 פעמים בהן רצה הלולאה, המשתנה i יהיה שווה ל-50 - התנאי לא יתקיים, והלולאה תסתיים.

חשוב לציין כי התנאים האלו אינם הכרחיים. הפקודה for (;;) היא חוקית - לולאה זו תרוץ לנצח. ניתן להשמיט כל אחד מהחלקים, לפי הצורך.

כעת נראה דוגמה שממחישה יתרון גדול של לולאת ה-for - השימוש במשתנה הלולאה.

for (int i=0; i<10; i++) {
	System.out.println(i);
}

שורות קוד אלו יגרמו להדפסת המספרים מ-0 ועד 9 (חשבו: למה לא 1 עד 10?). נראה דוגמה מורכבת יותר:

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

בדוגמה זו השתמשנו בלולאות מקוננות על מנת להדפיס את לוח הכפל. תזכורת: הסימן "\t" משמש ליצירת רווח קבוע (טאב), על מנת שצורת ההדפסה תהייה נעימה יותר לעין. נעבור על אופן הריצה בצורה מפורטת:

  1. בשלב הראשון, נכנס המחשב ללולאה הראשונה - for (int i=1; i<=10; i++). כפי שכבר ראינו, מתבצע כעת איתחול: המשתנה i מוכרז להיות משתנה מטיפוס int, ומקבל את הערך 1.
  2. כעת, ממשיכה התוכנית ומגיעה אל תחילת הלולאה השנייה - for (int j=1;j<=10;j++). גם כאן מתבצע האיתחול. כעת קיימים שני משתנים: i ו-j, שניהם משתנים מטיפוס int, ובשלב זה - שניהם שווים 1.
  3. התוכנית מתקדמת אל השורה הבאה - System.out.print(i*j+"\t");, ומדפיסה את התוצאה הראשונה: 1 (שני המשתנים שווים 1 - לכן גם מכפלתם).
  4. כאן מגיעה התוכנית אל הצומדיים שמסמנים את סוף הקטע אליו מתייחסת הלולאה השנייה (הלולאה של j). התוכנית חוזרת אל הלולאה: j גדל ב-1, והתוכנית בודקת אם הוא עדיין עומד בתנאי. j עומד בתנאי, כיוון ש-2 קטן מ-10, לכן מתבצע תוכן הלולאה פעם נוספת, הפעם - j שווה ל-2 ו-i שווה ל-1. המספר שיודפס הפעם הוא 2 (כי 2*1=2).
  5. הלולאה ממשיכה לחזור על עצמה עד שהתנאי מפסיק להתקיים: בפעם העשירית, j הופך להיות 11, לא עומד בתנאי, והלולאה מסתיימת. בשלב זה מודפסת כבר שורת המספרים הראשונה: 1 2 3 4 5 ... 10
  6. הגענו אל השורה הבאה: System.out.println();. גם שורה זו מיועדת למטרות נוי בלבד - תפקידה לעבור שורה בכל פעם, כדי שכל עשרה מספרים יודפסו בשורה אחת. בלי שורה זו, היו מודפסים כל המספרים בשורה אחת ארוכה.
  7. התוכנית הגיעה אל קצה הלולאה הראשונה (לולאת ה-i). כמו עם ה-j, גם i מתקדם ב-1, עומד בתנאי (כי 2 קטן מ-10), והלולאה מתחילה מחדש, רק שהפעם - i שווה ל-2. פרט לכך, כל השלבים זהים.
  8. לסיכום, בכל מעבר של הלולאה החיצונית - הלולאה של i, מתבצעת ריצה מלאה של הלולאה הפנימית - הלולאה של j. כל ריצה של הלולאה הפנימית מדפיסה שורת מספרים אחת, כל מעבר של הלולאה החיצונית גורם למעבר שורה ולהמשך ההדפסה של השורה הבאה. סך הכל, מתבצעות 100 פקודות הדפסה, ו-10 פקודות מעבר שורה.

לולאות do-while

[עריכה]

פרט ללולאת ה-for, קיים סוג נוסף של לולאה: לולאת while, או do-while. זוהי לולאה ששונה מלולאת ה-for בכך שאין בה שימוש במשתנה ש"רץ" - הלולאה מסתפקת בתנאי יציאה בלבד. לולאה כזו ניתן לכתוב בשתי צורות:

  • צורה ראשונה - while בלבד:
while(condition) {
	// to do
}
  • צורה שנייה - do ו-while בסוף:
do {
	// to do
} while(condition);

בשתי הצורות שהוצגו יבוא הקוד (הפקודות שהלולאה אמורה לבצע) במקום בו כתוב // to do, ותנאי היציאה במקום בו כתוב condition. ההבדל בין הצורות הוא הרגע בו נבדק התנאי: בצורה הראשונה, כאשר משתמשים ב-while בלבד, נבדק התנאי כאשר נכנסים ללולאה לראשונה, ואז - בכל פעם שמסתיימות הפקודות בבלוק הלולאה. אם משתמשים גם ב-do, נבדק התנאי בכל פעם שמסתיימת הלולאה. במקרה כזה, תמיד תתבצע הלולאה לפחות פעם אחת. כמו לולאת for, גם כאן אפשר להשתמש בלולאות מקוננות ובתנאים מורכבים.

אם כך, באיזו לולאה כדאי להשתמש?

[עריכה]

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

לולאת foreach

[עריכה]

החל מגרסת 1.5[1], ניתן להשתמש בסוגה המיוחד של לולאת for, שנקרא foreach. מבנה הלולאה הוא:

for (Class member: collection) {
	//code
}

בתור דוגמה, נתבונן בקוד הבא:

for (int i: arr) {
	System.out.println(i);
}

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

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

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


כדאי לדעת:

החל מגרסה 1.8 ניתן גם להשתמש בשיטה forEach() ובביטוי למבדה:
arr.forEach(i -> {System.out.println(i)});


תנאים Java
לולאות
מערכים
  1. ^ https://www.javatpoint.com/for-each-loop
  2. ^ https://www.javatpoint.com/for-each-loop