עבור Loop ב-Java

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

System.out.println(0);
System.out.println(1);
System.out.println(2);
System.out.println(3);
System.out.println(4);
System.out.println(5);
// And so on

הקוד הזה ייקח 100 שורות! כל כך הרבה. וכך זה ייראה עם לולאה:

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

רק 3 שורות!

מה מיועדות ללולאות?

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

1. הכינו כוס.
2. פתח את המכסה.
3. קבל טיפה אחת.
4. קח 2 טיפות.
...
32. קבל 30 טיפות.
33. סגור את התרופה.
34. קח את המנה שהתקבלה.

ניתן להסביר את האלגוריתם הזה הרבה יותר מהר:

1. הכינו כוס.
2. פתח את מכסה הטפטוף.
3. קח 30 טיפות.
4. סגור את התרופה.
5. קח את המנה שהתקבלה.

אנו משתמשים בלולאת for כמעט כל יום בשיחה עם אנשים אחרים: "...20 צעדים ברחוב...", "...לעשות 10 חזרות ועוד 5 בקצב איטי יותר פי 2...", ".. לעשות 5 רכישות בקטגוריות שונות ולקבל פרס..." יכולתי להמשיך עוד הרבה זמן, אבל המשמעות ברורה. ב-Java, לולאת for חיונית כדי לשמור על הקוד שלך קצר ותמציתי.

איך לולאת for עובדת

לולאת for משמשת כך:

for(<начальная точка>; <condition выхода>; <операторы счетчика>) {
	// Loop body
}
Пример перебора цифр от 0 до 5 и вывод каждой в консоль:
for(int i = 0; i < 5; i++) {
   System.out.println(i);
}

סיכום:

0
1
2
3
4

אם נתרגם את הערך הזה לשפה אנושית, נקבל את הדבר הבא: " צור משתנה i עם ערך התחלתי של 0, עד שהוא מגיע ל-5, הוסף לו 1 ובכל שלב כתוב את הערך של i לקונסולה ." לולאת for ב-Java מבוססת על שלושה שלבים, אותם ניתן לייצג באמצעות הדיאגרמה הבאה: התנאי ליציאה מהלולאה הוא ביטוי בוליאני. אם הוא שקר, הלולאה תסתיים. בדוגמה למעלה, המשתנה iמוגדל ב-1. אם הערך שלו קטן מ-5, הלולאה ממשיכה. אבל ברגע iשהוא יהיה גדול או שווה ל-5, המחזור ייפסק. האופרטור מונה הוא ביטוי שמבצע המרה על משתנה מונה. בדוגמה למעלה, המשתנה iגדל ב-1. כלומר, הלולאה תתבצע בדיוק 5 פעמים. אם אופרטור המונה מוסיף 2 למשתנה i, התוצאה תהיה שונה:

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

סיכום:

0
2
4

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

for(int i = 0; true; i++) {
   if(i % 1000000 == 0) System.out.println(i);
}
System.out.println("Loop ended");

אז הקוד שאחרי הלולאה יסומן בשגיאה unreachable statement, מכיוון שהוא לעולם לא יבוצע. אתגר לכושר ההמצאה: האם כתוצאה מהפעלת הקוד שלהלן, " Loop ended" ייצא לקונסולה או האם הלולאה תפעל ללא סוף?

for(int i = 0; i > -1; i++) {
   if(i % 1000000 == 0) System.out.println(i);
}
System.out.println("Loop ended");

תשובה: יהיה. המשתנה i יגיע במוקדם או במאוחר לערכו המקסימלי, ועלייה נוספת תהפוך אותו לערך שלילי מקסימלי, וכתוצאה מכך יתקיים תנאי היציאה (i < = -1).

עבור כל לולאה

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

public void printAllElements(String[] stringArray) {
   for(int i = 0; i < stringArray.length; i++) {
       System.out.println(stringArray[i]);
   }
}

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

for(<Тип element> <Name переменной, куда будет записан очередной элемент> : <Название массива>) {
	// Loop body
}

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

public void printAllElements(String[] stringArray) {
   for(String s : stringArray) {
       System.out.println(s);
   }
}

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

איך עבור לולאות משמשים

כעת נסתכל על כמה דוגמאות לשימוש בלולאת for ב-Java כדי לפתור בעיות שונות.

מחזור הפוך (מגדול לקטן יותר)

for(int i = 5; i > 0; i--) {
   System.out.println(i);
}

סיכום:

5
4
3
2
1

מספר משתנים והגדלת המונה בגוף הלולאה

אתה יכול להשתמש במספר משתנים בלולאת for, למשל ניתן להמיר אותם במשפט נגד:

int a = 0;
for(int i = 5; i > 0; i--, a++) {
   System.out.print("Step: " + a + " Meaning: ");
   System.out.println(i);
}

סיכום:

Шаг: 0 Значение: 5
Шаг: 1 Значение: 4
Шаг: 2 Значение: 3
Шаг: 3 Значение: 2
Шаг: 4 Значение: 1

או להכריז על שני משתנים ולולאה עד שהם יהיו שווים זה לזה:

for(int i = 5, j = 11; i != j; i++, j--) {
   System.out.println("i: " + i + " j: " + j);
}

סיכום:

i: 5 j: 11
i: 6 j: 10
i: 7 j: 9

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

for(int i = 0; i < 5; i++) {
   System.out.print(i + " | ");
   for(int j = 0; j < 5; j++) {
       System.out.print(j + " ");
   }
   System.out.print('\n');
}

סיכום:

0 | 0 1 2 3 4 
1 | 0 1 2 3 4 
2 | 0 1 2 3 4 
3 | 0 1 2 3 4 
4 | 0 1 2 3 4

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

int[][] array = { {0, 1, 2, 3, 4 },
                       {1, 2, 3, 4, 5},
                       {2, 3, 4, 5, 6},
                       {3, 4, 5, 6, 7}};

for(int i = 0; i < array.length; i++) {
   for(int j = 0; j < array[i].length; j++) {
       System.out.print(array[i][j] + " ");
   }
   System.out.print('\n');
}

סיכום:

0 1 2 3 4 
1 2 3 4 5 
2 3 4 5 6 
3 4 5 6 7 

סיום מוקדם של המחזור

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

public void getFirstPosition(String[] stringArray, String element) {
   for (int i = 0; i < stringArray.length; i++) {
       if(stringArray[i].equals(element)) {
           System.out.println(i);
           break;
       }
   }
}

השיטה תדפיס את מיקומו של הרכיב הראשון שמחפש במערך:

String[] array = {"one", "two", "three", "Jeronimo"};
getFirstPosition(array, "two");

סיכום:

1

מחזור אינסופי

דרך נוספת ליצור לולאה אינסופית היא להשאיר את אזור הצהרת הנגד, תנאי היציאה והצהרת הנגד ריקים:

for (;;) {
}

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