Bài 21. Cách Sử Dụng Vòng Lặp For Trong Java

Vòng Lặp `for` là gì?

Trong lập trình, vòng lặp (loop) là một kỹ thuật quan trọng giúp bạn lặp đi lặp lại một khối lệnh nhiều lần mà không cần viết lại mã nguồn. Java cung cấp nhiều loại vòng lặp khác nhau, trong đó vòng lặp for là một trong những vòng lặp phổ biến nhất.

Vòng lặp for được sử dụng khi bạn biết trước số lần lặp, giúp mã nguồn trở nên gọn gàng, dễ đọc và dễ bảo trì.

Cú Pháp Của Vòng Lặp `for`

Cú pháp chung của vòng lặp for trong Java như sau:

for (khởi_tạo; điều_kiện; cập_nhật) {
    // Khối lệnh được thực thi
}

Trong đó:

khởi_tạo: Khởi tạo biến điều khiển vòng lặp (chỉ chạy một lần duy nhất trước khi vòng lặp bắt đầu).
điều_kiện: Kiểm tra điều kiện trước mỗi lần lặp, nếu đúng (true), vòng lặp tiếp tục; nếu sai (false), vòng lặp dừng.
cập_nhật: Cập nhật biến điều khiển vòng lặp sau mỗi lần lặp.

Ví dụ đơn giản:

public class VongLapForExample {
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {
            System.out.println("Lần lặp thứ: " + i);
        }
    }
}

Kết quả:

Lần lặp thứ: 1
Lần lặp thứ: 2
Lần lặp thứ: 3
Lần lặp thứ: 4
Lần lặp thứ: 5

Ở ví dụ trên, vòng lặp bắt đầu với i = 1, kiểm tra điều kiện i <= 5, sau mỗi lần lặp, i tăng lên 1 cho đến khi điều kiện sai.

Các Biến Thể Của Vòng Lặp `for`

Dùng Nhiều Biến Điều Khiển

Bạn có thể khai báo nhiều biến điều khiển trong vòng lặp for, miễn là chúng cùng kiểu dữ liệu.

public class MultiVariableForLoop {
    public static void main(String[] args) {
        for (int i = 1, j = 10; i <= 5; i++, j--) {
            System.out.println("i = " + i + ", j = " + j);
        }
    }
}

Kết quả:

i = 1, j = 10
i = 2, j = 9
i = 3, j = 8
i = 4, j = 7
i = 5, j = 6

Vòng Lặp Lồng Nhau (Nested Loop)

Vòng lặp lồng nhau (nested loop) là vòng lặp được đặt bên trong một vòng lặp khác. Trong mỗi lần lặp của vòng lặp ngoài, vòng lặp trong sẽ thực thi toàn bộ số lần lặp của nó.

Ví dụ: In bảng cửu chương bằng vòng lặp for

public class BangCuuChuong {
    public static void main(String[] args) {
        for (int i = 2; i <= 9; i++) { // Vòng lặp ngoài: duyệt qua từng bảng từ 2 đến 9
            System.out.println("Bảng cửu chương " + i + ":");
            for (int j = 1; j <= 10; j++) { // Vòng lặp trong: nhân từ 1 đến 10
                System.out.println(i + " x " + j + " = " + (i * j));
            }
            System.out.println(); // Xuống dòng giữa các bảng
        }
    }
}

Kết quả:

Bảng cửu chương 2:
2 x 1 = 2
2 x 2 = 4
...
2 x 10 = 20

Bảng cửu chương 3:
3 x 1 = 3
3 x 2 = 6
...
3 x 10 = 30

Giải thích:

Vòng lặp ngoài (i) duyệt qua từng bảng từ 2 đến 9.
Vòng lặp trong (j) chạy từ 1 đến 10, thực hiện phép nhân với i.
Kết quả là bảng cửu chương từ 2 đến 9, mỗi bảng cách nhau một dòng trống.

Vòng lặp lồng nhau rất hữu ích khi làm việc với ma trận, bảng số liệu hoặc xử lý dữ liệu nhiều cấp!

Bỏ Qua Một Hoặc Nhiều Thành Phần

Bạn có thể bỏ qua phần khởi tạo, điều kiện hoặc cập nhật trong vòng lặp for.

Bỏ qua phần khởi tạo

Nếu biến điều khiển đã được khai báo từ trước, bạn có thể bỏ qua phần khởi tạo.

public class SkipInitialization {
    public static void main(String[] args) {
        int i = 1;
        for (; i <= 5; i++) {
            System.out.println("i = " + i);
        }
    }
}

Bỏ qua phần cập nhật

Bạn có thể cập nhật biến điều khiển bên trong khối lệnh thay vì trong phần cập_nhật của vòng lặp.

public class SkipUpdate {
    public static void main(String[] args) {
        for (int i = 1; i <= 5;) {
            System.out.println("i = " + i);
            i++; // Cập nhật trong thân vòng lặp
        }
    }
}

Vòng lặp `for` vô tận

Nếu bạn bỏ qua cả điều kiện, vòng lặp sẽ chạy vô tận.

public class InfiniteLoop {
    public static void main(String[] args) {
        for (;;) {
            System.out.println("Vòng lặp vô tận!");
        }
    }
}

Lưu ý: Cần có điều kiện dừng (ví dụ break) để tránh vòng lặp chạy mãi.

Duyệt Mảng Bằng Vòng Lặp `for`

Vòng lặp for được sử dụng phổ biến để duyệt qua các phần tử của mảng.

public class ArrayIteration {
    public static void main(String[] args) {
        int[] numbers = {2, 4, 6, 8, 10};

        for (int i = 0; i < numbers.length; i++) {
            System.out.println("Phần tử thứ " + i + " là: " + numbers[i]);
        }
    }
}

Vòng Lặp `for-each` (Enhanced For Loop)

Java cung cấp vòng lặp for-each để duyệt qua mảng hoặc Collection một cách dễ dàng mà không cần sử dụng biến chỉ số.

Cú pháp của vòng lặp `for-each`

for (Kiểu_dữ_liệu biến : tập_hợp) {
    // Khối lệnh được thực thi
}

Ví dụ:

public class ForEachExample {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};

        for (int num : numbers) {
            System.out.println("Giá trị: " + num);
        }
    }
}

Kết quả:

Giá trị: 1
Giá trị: 2
Giá trị: 3
Giá trị: 4
Giá trị: 5

Ưu điểm của for-each: Gọn gàng, dễ đọc, tránh lỗi chỉ mục.
Nhược điểm: Không thể truy cập chỉ mục của phần tử hiện tại.

Kết Hợp `for` Với `break` và `continue`

Dùng `break` để dừng vòng lặp sớm

public class BreakExample {
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            if (i == 6) {
                break; // Dừng vòng lặp khi i == 6
            }
            System.out.println(i);
        }
    }
}

Kết quả:

Dùng `continue` để bỏ qua lần lặp hiện tại

public class ContinueExample {
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {
            if (i == 3) {
                continue; // Bỏ qua i == 3
            }
            System.out.println(i);
        }
    }
}

Kết quả:

Kết Luận

Vòng lặp for là công cụ mạnh mẽ giúp bạn lặp lại một khối lệnh một cách có kiểm soát. Bạn có thể sử dụng các biến thể khác nhau của for, kết hợp với break và continue để tối ưu chương trình của mình.