JavaRush /Blog Java /Random-VI /Vòng lặp while trong Java

Vòng lặp while trong Java

Xuất bản trong nhóm

Giới thiệu

Chương trình đầu tiên của chúng tôi là một chuỗi các lệnh được thực hiện lần lượt. Không có nĩa. Đây là HelloWorld, đưa ra cụm từ chào hỏi và các phép tính số học tới bảng điều khiển. Sau các chương trình đầu tiên, chúng ta đã học cách phân nhánh, tức là chương trình thực hiện một số hành động nhất định tùy theo điều kiện. Đây là cách bạn có thể mã hóa máy điều hòa để bật để sưởi ấm và làm mát:
if (tempRoom>tempComfort)
    airConditionerOn();
if (tempRoom<tempComfort
    heaterOn();
Hãy thực hiện bước tiếp theo. Trong cuộc sống hàng ngày, chúng ta thường thực hiện những hành động đơn điệu, lặp đi lặp lại, chẳng hạn như gọt táo để làm bánh. Quá trình hấp dẫn này có thể được mô tả như sau:
  1. Nếu có táo trong chậu, hãy làm theo các bước từ 1.1 đến 1.4:

    1. 1.1. Lấy một quả táo
    2. 1.2. Làm sạch và cắt thành lát
    3. 1.3. Đặt trên đế bánh ngọt vào chảo rán
    4. 1.4. Hãy quay lại bước 1.
Toán tử while - 2
Giả sử bạn có 10 quả táo, 2 bàn tay và một con dao. Trong cuộc sống, bạn luôn làm sạch toàn bộ mười, được hướng dẫn bởi cùng một thuật toán. Làm thế nào bạn có thể khiến chương trình thực hiện một hành động lặp lại với mỗi quả táo?
  • Chúng ta hãy tự ràng buộc mình với số lượng táo, nhưng nếu chúng ta có ít táo, một số lệnh sẽ được thực thi vô ích nếu không có "trọng tải" (và có lẽ, chúng ta sẽ tự cắt mình khi gọt một quả táo không tồn tại).
  • Nếu có nhiều táo hơn nhóm chế biến của chúng tôi thì một số sản phẩm sẽ không được xử lý.
  • “Mã” như vậy rất khó đọc, chứa nhiều sự lặp lại và khó sửa đổi.

Vòng lặp là các toán tử để thực hiện các hành động nhiều lần.

Vòng lặp while Java (vòng lặp vile) hoạt động tốt trong trường hợp của chúng tôi. Thiết kế này tổ chức nhiều hành động thành một cấu trúc ngắn gọn và dễ hiểu. Một thuật toán cắt táo để làm bánh trong Java có thể trông như thế này:
while(числоЯблокВТазике>0) {
    яблоко = тазик.взятьОчередноеЯблоко();
    положитьВПирог(яблоко.чистить().нарезать());
    числоЯблокВТазике--;//-- this is a decrement, reduces the number of apples by one
}
System.out.println('Apples for the pie are processed.');

Cú pháp lệnh

Cách đầu tiên để mô tả câu lệnh while như sau:
while(Логическое выражение) {
	// Loop body - periodically executed statement(s)
}
Việc này được thực hiện như sau (từng bước một):
  1. Chúng tôi đánh giá điều kiện Boolean theo sau dấu ngoặc đơn.
  2. Nếu điều kiện logic đúng thì các toán tử trong thân vòng lặp được thực thi, sau khi thực hiện toán tử cuối cùng trong thân vòng lặp thì chuyển sang bước 1
  3. Nếu điều kiện logic là sai thì chúng ta chuyển sang câu lệnh đầu tiên bên ngoài vòng lặp while.

Vòng lặp với điều kiện tiên quyết

Vì trước khi thực hiện phần thân vòng lặp, chúng ta luôn tính toán trước một biểu thức logic (điều kiện để vào vòng lặp) nên kiểu while này thường được gọi là vòng lặp có điều kiện tiên quyết. Hãy xây dựng một bảng gồm mười số nguyên đầu tiên, lũy thừa dương của một số:
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++;
    }
}
Kết quả đầu ra của bàn điều khiển:
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

Vòng lặp với hậu điều kiện

Loại chu kỳ thứ hai:
do {
    // Loop body - periodically executed statement(s)
}while (Логическое выражение);
Thực hiện như sau (các bước):
  1. Phần thân vòng lặp được thực thi (ngay sau từ khóa do).
  2. Chúng tôi đánh giá điều kiện Boolean theo sau dấu ngoặc đơn.
  3. Nếu điều kiện logic đúng thì chuyển sang bước 1
  4. Nếu điều kiện logic là sai thì chúng ta chuyển sang câu lệnh đầu tiên bên ngoài vòng lặp while.
Hai điểm khác biệt chính so với loại vòng lặp trước đó: phần thân vòng lặp được thực thi ít nhất một lần và điều kiện logic được kiểm tra sau khi phần thân vòng lặp được thực thi. Vì vậy, loại vòng lặp while này được gọi là vòng lặp hậu điều kiện. Lần này chúng ta sẽ hiển thị một bảng lũy ​​thừa của một số không vượt quá 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
Kết quả đầu ra của bàn điều khiển:
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
Hãy chú ý đến những thay đổi trong mã, so sánh nó với phiên bản của vòng lặp có điều kiện tiên quyết.

Sự thật thú vị về cách làm việc với vòng lặp

Các lệnh điều khiển trong thân vòng lặp

Có hai lệnh ảnh hưởng đến tiến trình của vòng lặp: break, các tính năng mà chúng tôi sẽ trình bày trong chương tiếp theo, và Tiếp tục.
  • continue – dừng thực thi phần thân của vòng lặp hiện tại và chuyển sang biểu thức logic của toán tử while. Nếu biểu thức được tính toán là đúng thì việc thực hiện vòng lặp sẽ tiếp tục.
  • break – ngay lập tức dừng việc thực thi vòng lặp hiện tại và chuyển sang lệnh đầu tiên bên ngoài nó. Do đó, việc thực hiện vòng lặp hiện tại bị gián đoạn. Chúng ta sẽ xem xét nó chi tiết hơn trong chủ đề tiếp theo.
Hãy nhớ lại ví dụ về trái cây của chúng ta. Nếu không chắc chắn về chất lượng của táo được cung cấp, chúng ta có thể thay đổi mã bằng lệnh 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
    }
    положитьВПирог(яблоко.чистить().нарезать());
}
Cấu trúc này continuethường được sử dụng khi trong thân vòng lặp cần thực thi các lệnh khi một điều kiện nhất định xảy ra, chẳng hạn như thực hiện các hành động khi cảm biến trong thiết bị được kích hoạt (nếu không thì chỉ cần tiếp tục chu trình đọc các chỉ báo của nó) hoặc để tính toán một biểu thức chỉ ở các bước nhất định của chu trình. Một ví dụ cho trường hợp cuối cùng là phép tính trong vòng lặp while tổng các lập phương của các số tự nhiên có bình phương nhỏ hơn số của chúng:
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
}

Chu kỳ vô tận

Các lệnh điều khiển này thường được sử dụng trong vòng lặp vô hạn. Nó được gọi như vậy vì điều kiện thoát logic không bao giờ được thỏa mãn. Trong mã nó trông giống như sau:
while(true) {
    // Loop body
}
breakTrong trường hợp này, việc sử dụng lệnh để tổ chức thoát khỏi nó sẽ hữu ích . Loại vòng lặp này xảy ra khi chờ đợi các điều kiện bên ngoài được hình thành bên ngoài logic của thân vòng lặp. Ví dụ: trong các trò chơi mô phỏng thế giới ảo xung quanh anh hùng (thoát khỏi vòng lặp = thoát khỏi trò chơi), hệ điều hành. Hoặc khi sử dụng thuật toán, có thể cải thiện kết quả với mỗi lệnh gọi tiếp theo trong vòng lặp nhưng giới hạn chúng theo thời gian hoặc sự xuất hiện của một sự kiện bên ngoài (cờ caro, cờ vua hoặc dự báo thời tiết). Cần nhớ rằng trong điều kiện bình thường, các vòng lặp vô tận là một trong những vấn đề gây mất ổn định chương trình. Để chứng minh, chúng ta hãy quay trở lại lũy thừa của các con số:
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
    }
}
Kết quả đầu ra của bàn điều khiển:
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

Vòng lồng nhau

Ở đây chúng ta đến chủ đề cuối cùng về chu kỳ của chúng ta. Hãy nghĩ về chiếc bánh táo (hy vọng lúc này bạn không đói) và "vòng lặp" của chúng ta:
  1. Nếu có táo trong chậu, hãy làm theo các bước từ 1.1 đến 1.4:

    1. 1.1. Lấy một quả táo
    2. 1.2. Làm sạch và cắt thành lát
    3. 1.3. Đặt trên đế bánh ngọt vào chảo rán
    4. 1.4. Hãy quay lại bước 1.
Hãy để chúng tôi mô tả chi tiết hơn quá trình cắt thành lát:
  1. Số lát = 0
  2. Trong khi số lát < 12, hãy làm theo các bước 2.1 đến 2.3

    1. 2.1. Cắt một lát táo khác
    2. 2.2. Số lát ++
    3. 2.3. Quay lại bước 2
Và chèn nó vào thuật toán bánh kẹo của chúng tôi:
  1. Nếu có táo trong chậu, hãy làm theo các bước từ 1.1 đến 1.6:

    1. 1.1. Lấy một quả táo
    2. 1.2. Bóc nó ra
    3. 1.3. Số lát = 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-х видели на обложках тетрадей в младших классах.
Toán tử trong khi - 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, вы изучите все их разнообразие, разберёте тонкости функционирования и получите практические навыки их применения.
Bình luận
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION