JavaRush /בלוג Java /Random-HE /תוך כדי לולאה בג'אווה

תוך כדי לולאה בג'אווה

פורסם בקבוצה

מבוא

התוכניות הראשונות שלנו היו רצף של הוראות שבוצעו בזו אחר זו. בלי מזלגות. זהו HelloWorld, שמוציא ביטוי ברכה וחישובים אריתמטיים לקונסולה. לאחר התוכניות הראשונות למדנו להסתעף, כלומר התוכנית ביצעה פעולות מסוימות בהתאם לתנאים. כך תוכל לקודד את המזגן להפעלה לחימום וקירור:
if (tempRoom>tempComfort)
    airConditionerOn();
if (tempRoom<tempComfort
    heaterOn();
בואו ניקח את הצעד הבא. בחיי היומיום אנו מבצעים לעתים קרובות פעולות מונוטוניות שחוזרות על עצמן, למשל, קילוף תפוחים לעוגה. ניתן לתאר את התהליך המרתק הזה כך:
  1. אם יש תפוחים באגן, בצע את השלבים 1.1 עד 1.4:

    1. 1.1. קח תפוח
    2. 1.2. מנקים וחותכים אותו לפרוסות
    3. 1.3. מניחים על בסיס פשטידת הבצק במחבת
    4. 1.4. נחזור לשלב 1.
מפעיל בזמן - 2
נניח שיש לך 10 תפוחים, 2 ידיים וסכין אחת. בחיים, אתה מנקה בעקביות את כל העשרה, בהנחיית אותו אלגוריתם. איך אתה יכול לגרום לתוכנית לעשות פעולה חוזרת עם כל תפוח?
  • הבה נקשר את עצמנו למספר התפוחים, אבל אם יש לנו מעט מהם, חלק מהפקודות היו מבוצעות לשווא ללא "מטען" (ואולי, היינו חותכים את עצמנו תוך כדי קילוף תפוח שאינו קיים).
  • אם יש יותר תפוחים מצוותי העיבוד שלנו, חלק מהמוצרים לא יעברו עיבוד.
  • "קוד" כזה קשה לקריאה, מכיל הרבה חזרות וקשה לשינוי.

לולאות הן אופרטורים לביצוע פעולות מספר פעמים.

לולאת ה-Java while (לולאה מרושעת) עובדת היטב במקרה שלנו. עיצוב זה מארגן מספר פעולות למבנה תמציתי ומובן. אלגוריתם של זמן לחתוך תפוחים עבור עוגה ב-Java עשוי להיראות כך:
while(числоЯблокВТазике>0) {
    яблоко = тазик.взятьОчередноеЯблоко();
    положитьВПирог(яблоко.чистить().нарезать());
    числоЯблокВТазике--;//-- this is a decrement, reduces the number of apples by one
}
System.out.println('Apples for the pie are processed.');

תחביר פקודה

הדרך הראשונה לתאר את הצהרת while היא כדלקמן:
while(Логическое выражение) {
	// Loop body - periodically executed statement(s)
}
זה נעשה באופן הבא (שלב אחר שלב):
  1. אנו מעריכים את התנאי הבוליאני שעוקב אחרי ה-while בסוגריים.
  2. אם התנאי הלוגי נכון, אזי האופרטורים בגוף הלולאה מבוצעים, לאחר ביצוע האופרטור האחרון בגוף הלולאה, עבור לשלב 1
  3. אם התנאי הלוגי הוא שקר, אז עבור למשפט הראשון מחוץ ללולאת while.

לולאה עם תנאי מוקדם

מכיוון שלפני ביצוע גוף הלולאה, אנו תמיד מחשבים מראש ביטוי לוגי (התנאי לכניסה ללולאה), סוג זה של while נקרא לרוב לולאה עם תנאי מוקדם. בואו נבנה טבלה של עשרת החזקות השלמות הראשונות, החיוביות של מספר:
public static void main(String[] args) {
    int number = 3; // Number to be raised to a power
    int result = 1; // Result of exponentiation
    int power = 1; // Initial exponent
    while(power <= 10) { // loop entry condition
        result = result * number;
        System.out.println(number + "to the extent" + power + " = " + result);
        power++;
    }
}
תוצאת פלט מסוף:
3 в степени 1 = 3
3 в степени 2 = 9
3 в степени 3 = 27
3 в степени 4 = 81
3 в степени 5 = 243
3 в степени 6 = 729
3 в степени 7 = 2187
3 в степени 8 = 6561
3 в степени 9 = 19683
3 в степени 10 = 59049
Process finished with exit code 0

לולאה עם postcondition

סוג שני של מחזור:
do {
    // Loop body - periodically executed statement(s)
}while (Логическое выражение);
בוצע באופן הבא (שלבים):
  1. גוף הלולאה מבוצע (מיד אחרי מילת המפתח do).
  2. אנו מעריכים את התנאי הבוליאני שעוקב אחרי ה-while בסוגריים.
  3. אם התנאי הלוגי נכון, עבור לשלב 1
  4. אם התנאי הלוגי הוא שקר, אז עבור למשפט הראשון מחוץ ללולאת while.
שני הבדלים עיקריים מהסוג הקודם של הלולאה: גוף הלולאה מבוצע לפחות פעם אחת והמצב הלוגי נבדק לאחר ביצוע גוף הלולאה. לכן, סוג זה של לולאת while נקרא לולאת postcondition. הפעם נציג טבלת חזקות של מספר שלא יעלה על 10000:
public static void main(String[] args) {
    int number = 3;// Number to be raised to a power
    int result = number;// Result of exponentiation
    int power = 1;// Initial exponent
    do {
        System.out.println(number + "to the extent" + power + " = " + result);
        power++;
        result = result * number;
    }while (result < 10000); // loop exit condition
תוצאת פלט מסוף:
3 в степени 1 = 3
3 в степени 2 = 9
3 в степени 3 = 27
3 в степени 4 = 81
3 в степени 5 = 243
3 в степени 6 = 729
3 в степени 7 = 2187
3 в степени 8 = 6561
Process finished with exit code 0
שימו לב לשינויים בקוד, השוו אותו לגרסת הלולאה עם תנאי מוקדם.

עובדות מעניינות על עבודה עם לולאות

פקודות שליטה בגוף הלולאה

ישנן שתי פקודות שמשפיעות על התקדמות הלולאה: break, שאת התכונות שלה נציג בפרק הבא, ו לְהַמשִׁיך.
  • continue – מפסיק את ביצוע הגוף של הלולאה הנוכחית ועובר לביטוי הלוגי של אופרטור while. אם הביטוי המחושב נכון, ביצוע הלולאה ימשיך.
  • break - מפסיק מיד את ביצוע הלולאה הנוכחית וקופץ לפקודה הראשונה מחוצה לה. לפיכך, ביצוע הלולאה הנוכחית מופרע. נסתכל על זה ביתר פירוט בנושא הבא.
בואו נזכור את דוגמה הפירות שלנו. אם איננו בטוחים לגבי איכות התפוחים המוצעים, נוכל לשנות את הקוד באמצעות הפקודה continue:
while(числоЯблокВТазике>0) {
    яблоко = тазик.взятьОчередноеЯблоко();
    числоЯблокВТазике--;//-- this is a decrement, reduces the number of apples by one
    if (яблоко.плохое()) {  // method will return true for rotten, etc. apples
        яблоко.выкинутьВМусор();
        continue; // continue the loop, go to the condition number ofApplesIn the Basin>0
    }
    положитьВПирог(яблоко.чистить().нарезать());
}
הקונסטרוקציה continueמשמשת לעתים קרובות כאשר בגוף הלולאה יש צורך לבצע פקודות כאשר מצב מסוים מתרחש, למשל, לבצע פעולות כאשר חיישן בציוד מופעל (אחרת פשוט להמשיך את מחזור קריאת המחוונים שלו) או לחשב ביטוי רק בשלבים מסוימים של המחזור. דוגמה למקרה האחרון היא החישוב בלולאת while של סכום הקוביות של מספרים טבעיים שהריבוע שלהם קטן ממספרם:
public static void main(String[] args) {
    int sum = 0;    // total amount
    int i = 0;      // starting number of the row
    int count = 20; // amount of numbers
    while(i<=count) {
        i++;        // take the next number, i++ is equivalent to i=i+1
        if (i*i<=count)  // if the square of the number is less
            continue;   // number of numbers - do not count the sum
                        // move on to the next number in the loop
        sum += i*i*i; // otherwise, we calculate the sum of cubes of numbers
    } // sum += i*i*i - notation similar to sum = sum + i*i*i
    System.out.println(sum);// print result
}

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

פקודות בקרה אלו משמשות לרוב בלולאה אינסופית. זה נקרא כך מכיוון שתנאי היציאה הלוגי לא מתקיים אף פעם. בקוד זה נראה משהו כמו:
while(true) {
    // Loop body
}
breakבמקרה זה, שימוש בפקודה לארגון יציאה ממנה יהיה שימושי . סוג זה של לולאה מתרחש כאשר ממתינים לתנאים חיצוניים שנוצרים מחוץ להיגיון של גוף הלולאה. למשל, במשחקים שמחקים את העולם הוירטואלי סביב הגיבור (יציאה מהלולאה = יציאה מהמשחק), מערכות הפעלה. או בעת שימוש באלגוריתמים, אולי שיפור התוצאה עם כל קריאה עוקבת בלולאה, אך הגבלת אותם לפי זמן או התרחשות של אירוע חיצוני (דמקה, שחמט או חיזוי מזג אוויר). יש לזכור שבתנאים רגילים, לולאות אינסופיות הן אחת הבעיות של חוסר יציבות התוכנית. כדי להדגים, נחזור לחזקות המספרים:
public static void main(String[] args) {
    int number = 3; // Number to be raised to a power
    int result = 1; // Result of exponentiation
    int power = 1; // Initial exponent
    while(true) {
        result = result * number;
        System.out.println(number + "to the extent" + power + " = " + result);
        power++;
        if (power>10)
            break; // exit from the loop
    }
}
תוצאת פלט מסוף:
3 в степени 1 = 3
3 в степени 2 = 9
3 в степени 3 = 27
3 в степени 4 = 81
3 в степени 5 = 243
3 в степени 6 = 729
3 в степени 7 = 2187
3 в степени 8 = 6561
3 в степени 9 = 19683
3 в степени 10 = 59049
Process finished with exit code 0

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

כאן אנו מגיעים לנושא האחרון על המחזורים שלנו. בואו נחשוב על פאי תפוחים (מקווה שאתם לא רעבים כרגע) וה"לופ" שלנו:
  1. אם יש תפוחים באגן, בצע את השלבים 1.1 עד 1.4:

    1. 1.1. קח תפוח
    2. 1.2. מנקים וחותכים אותו לפרוסות
    3. 1.3. מניחים על בסיס פשטידת הבצק במחבת
    4. 1.4. נחזור לשלב 1.
נתאר ביתר פירוט את תהליך החיתוך לפרוסות:
  1. מספר פרוסות = 0
  2. בעוד שמספר הפרוסות הוא < 12, בצע את שלבים 2.1 עד 2.3

    1. 2.1. חותכים פרוסה נוספת מתפוח
    2. 2.2. מספר פרוסות ++
    3. 2.3. חזור לשלב 2
והכנס אותו לאלגוריתם הקונדיטוריה שלנו:
  1. אם יש תפוחים באגן, בצע את השלבים 1.1 עד 1.6:

    1. 1.1. קח תפוח
    2. 1.2. תקלף אותו
    3. 1.3. מספר פרוסות = 0
    4. 1.4. Пока число долек < 12, выполнить шаги с 1.4.1 по 1.4.3
      1. 1.4.1. Отрезать очередную дольку от яблока
      2. 1.4.2. Кол-во долек ++
      3. 1.4.3. Возвращаемся на шаг 1.4
    5. 1.5. Помещаем дольки на тестовое основание пирога из теста на сковороде
    6. 1.6. Возвращаемся на шаг 1.
Получor цикл в цикле. Подобные конструкции весьма частые. Для завершающего примера построим таблицу умножения, которые школьники 90-х видели на обложках тетрадей в младших классах.
מפעיל בזמן - 3
public static void main(String[] args) {
    // Display the values ​​of the second multiplier in the line
    System.out.println("    2  3  4  5  6  7  8  9");
    int i = 2;      // first multiplier, assign starting value
    while(i<10) {   // First loop, execute while the first multiplier is less than 10
        System.out.print(i + " | ");// Display the first multiplier at the beginning of the string
        int j = 2;                  // second multiplier, starting value
        while (j<10) { // Second loop, execute while the second multiplier is less than 10
            int mul=i*j; // Calculate the product of factors
            if (mul<10)  // If it contains one digit, print two spaces after it
                System.out.print(mul + "  ");
            else   // otherwise output the product and after it - one space
                System.out.print(mul + " ");
            j++;     // Increase the second multiplier by one,
        }            // Go to the beginning of the second loop (while (j<10 ).... )
        System.out.println(); // Move to the next line of output
        i++;                  // Increase the first multiplier by one,
    }                         // Go to the beginning of the first loop (while ( i<10 ) ....
}
Результат вывода на консоль:
2  3  4  5  6  7  8  9
2 | 4 6 8 10 12 14 16 18
3 | 6 9 12 15 18 21 24 27
4 | 8 12 16 20 24 28 32 36
5 | 10 15 20 25 30 35 40 45
6 | 12 18 24 30 36 42 48 54
7 | 14 21 28 35 42 49 56 63
8 | 16 24 32 40 48 56 64 72
9 | 18 27 36 45 54 63 72 81
Process finished with exit code 0
Циклы (в частности, оператор while) – один из фундаментальных кирпичиков построения программ. Решая задачи на JavaRush, вы изучите все их разнообразие, разберёте тонкости функционирования и получите практические навыки их применения.
הערות
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION