Thực đơn
trang chủSự liên quan

Android java thoát khỏi vòng lặp. Vòng lặp trong Java - cách tạo và ngắt chúng

Khi bạn cần thực hiện cùng một hành động nhiều lần hoặc cho đến khi đáp ứng một điều kiện nhất định, vòng lặp sẽ hỗ trợ chúng tôi.

TRONG ngôn ngữ Java Có một số cách để tạo vòng lặp. Như bạn có thể đoán, chúng tôi sẽ xem xét tất cả.

Cách đầu tiên để khai báo một vòng lặp là sử dụng cấu trúc sau: for (điều kiện bắt đầu vòng lặp; điều kiện kết thúc; bước mà vòng lặp sẽ đi) (thân vòng lặp)

Hãy chuyển thẳng sang các ví dụ. Giả sử chúng ta có nhiệm vụ hiển thị cụm từ “hello world” 10 lần. Nếu bạn không sử dụng vòng lặp, bạn chỉ cần viết System.out.println("Hello world"); mười lần và chúng tôi sẽ giải quyết được vấn đề. Hãy sử dụng các vòng lặp cho mục đích này. Tạo nên lớp mới và gọi nó là CuclesInJava chẳng hạn. Bây giờ hãy khai báo điều kiện vòng lặp (đặt là 0), điều kiện kết thúc - 10 và bước. Chúng ta sẽ đi theo từng bước một. Trong phần thân vòng lặp, đặt dòng System.out.println("Hello world");

Đây là một ví dụ mã:

Kết quả của đoạn mã này sẽ là 10 dòng liên tiếp có cụm từ “Xin chào thế giới!”

Làm thế nào về việc viết một cái gì đó phức tạp hơn. Chúng ta đã học được những điều cơ bản rồi. Hãy sử dụng chúng.

Hãy viết một ứng dụng đơn giản sẽ hiển thị dòng cảnh báo mỗi khi thực hiện một bước + một số biến bằng 5. Tôi rất kém về trí tưởng tượng))

Đầu tiên, hãy viết một đoạn mã sẽ chấp nhận một biến được nhập từ bảng điều khiển làm đầu vào. Trong bài viết trước, tôi đã đưa ra một ví dụ về mã này và chúng tôi đã đồng ý rằng sau đó tôi sẽ giải thích cách thức hoạt động và nguồn gốc của nó. Và bây giờ chúng ta sẽ chỉ sử dụng nó:

Tiếp theo, bạn cần viết một vòng lặp bắt đầu từ 0 và đếm đến 10 (như trong ví dụ trước). Trong thân vòng lặp chúng ta viết điều hành có điều kiện, nó sẽ kiểm tra xem biến này có bằng 5 hay không và nếu có thì chúng ta sẽ xuất ra dòng “OK”. Đây là những gì tôi có:

    nhập java.util.Scanner;

  1. lớp công khai CuclesInJava(

    biến int = scanner.nextInt(); // chúng ta sẽ giải quyết vấn đề này dần dần và sau đó sẽ rõ cách thức hoạt động của nó

  2. vì (int i = 1; tôi< 10 ; i++ ) {

    int newVariable = i + biến;

    if (newVariable== 5) (

Nó không trở nên phức tạp lắm. Với ví dụ này, tôi muốn chỉ ra cách bạn có thể sử dụng các vòng lặp kết hợp với các nhánh.

Cách tiếp theo để khai báo vòng lặp là sử dụng cấu trúc: while(điều kiện là đúng)(khối mã sẽ được thực thi). Thiết kế này có dạng khác:

do(khối mã sẽ được thực thi)while(điều kiện đúng). Sự khác biệt giữa vòng lặp thứ nhất và vòng lặp thứ hai là vòng lặp thứ hai thực hiện một vòng lặp bất kể điều kiện có đúng hay không. Bạn có thể tự suy nghĩ: đầu tiên chúng tôi thực thi mã và sau đó chúng tôi kiểm tra điều kiện. Và ngay cả khi điều kiện không đúng, mã vẫn sẽ được thực thi một lần, tại thời điểm ở kiểu xây dựng đầu tiên, điều kiện được kiểm tra lần đầu và cho đến khi nó đúng, mã sẽ không được thực thi.

Mã phải trực quan. Tôi nghĩ điều đáng nói là với cấu trúc while và do-while bạn có thể "vòng" chương trình nếu điều kiện thoát khỏi vòng lặp không được chỉ định hoặc chỉ định không chính xác. Hãy nhìn vào ví dụ trên và nghĩ điều gì sẽ xảy ra nếu tôi viết không phải i—, mà là i++; hoặc thay vì i>0, i<0. Моя программа никогда не вышла бы из цикла и продолжала бы выводить строку Hello world! до тех пор, пока не завис компьютер. Поэтому, будьте очень осторожными с циклами и всегда следите, чтобы из них Ваша программа могла выйти или закончить работу.

Vâng, một ví dụ với do-while:

Về vấn đề này, tôi nghĩ chúng ta có thể kết thúc bài viết về vòng lặp trong Java. Như bạn có thể thấy, các thiết kế không phức tạp lắm nhưng rất hữu ích. Chúng sẽ đặc biệt hữu ích khi chúng ta làm quen với mảng và chuỗi.

vòng lặp for

Kể từ JDK 5, có hai dạng trong Java vòng lặp for. Đầu tiên là hình thức truyền thống, được sử dụng từ nguyên bản Phiên bản Java. Thứ hai - hình thức mới"cho mỗi". Chúng ta sẽ xem xét cả hai loại vòng lặp for, bắt đầu với dạng truyền thống.

Dạng tổng quát của câu lệnh for truyền thống như sau:

for(khởi tạo; điều kiện; lặp lại)
( // thân hình
}

Nếu chỉ có một câu lệnh được lặp lại trong một vòng lặp, bạn có thể bỏ qua dấu ngoặc nhọn.

Vòng lặp for hoạt động như sau. Khi vòng lặp được khởi chạy lần đầu tiên, chương trình sẽ thực hiện phần khởi tạo của vòng lặp. TRONG trường hợp chung là một biểu thức đặt giá trị của biến điều khiển vòng lặp, hoạt động như một bộ đếm điều khiển vòng lặp. Điều quan trọng là phải hiểu rằng biểu thức khởi tạo chỉ được thực hiện một lần. Sau đó, chương trình sẽ đánh giá điều kiện, điều kiện này phải là biểu thức Boolean. Thông thường, biểu thức so sánh giá trị của biến điều khiển với giá trị của mục tiêu. Nếu giá trị này đúng, chương trình sẽ thực thi phần thân vòng lặp. Nếu sai thì việc thực hiện vòng lặp sẽ bị hủy bỏ. Chương trình sau đó thực hiện phần lặp lại của vòng lặp. Thông thường đây là biểu thức làm tăng hoặc giảm giá trị của biến điều khiển. Sau đó, chương trình lặp lại vòng lặp, mỗi lần nó đi qua bằng cách đánh giá biểu thức điều kiện trước tiên, sau đó thực thi phần thân vòng lặp và thực hiện biểu thức lặp lại. Quá trình được lặp lại cho đến khi biểu thức lặp lại có giá trị sai.

Dưới đây là phiên bản của chương trình đếm đồng hồ sử dụng vòng lặp for.

// Minh họa cách sử dụng vòng lặp for.
lớp ForTick (

int n;
vì(n=10; n>0; n-)

}
}

Khai báo các biến điều khiển vòng lặp bên trong vòng lặp for

Thông thường, biến điều khiển vòng lặp for chỉ cần thiết cho vòng lặp đó và không được sử dụng ở bất kỳ nơi nào khác. Trong trường hợp này, biến có thể được khai báo bên trong phần khởi tạo của câu lệnh for. Ví dụ: chương trình trước có thể được viết lại bằng cách khai báo một biến điều khiển kiểu int bên trong vòng lặp for:

// Khai báo một biến điều khiển vòng lặp bên trong vòng lặp for.
lớp ForTick (public static void main(String args) (
//V trong trường hợp này biến n được khai báo bên trong vòng lặp for
for(int n=10; n>0; n-)
System.out.println("beat " + n);
}
}

Khi khai báo một biến bên trong vòng lặp for, bạn phải nhớ trường hợp quan trọng sau: phạm vi và thời gian tồn tại của biến này hoàn toàn giống với phạm vi và thời gian tồn tại của câu lệnh for. (Nghĩa là, phạm vi của biến bị giới hạn bởi vòng lặp for.) Bên ngoài vòng lặp cho biến sẽ không còn tồn tại. Nếu một biến điều khiển vòng lặp cần được sử dụng trong các phần khác của chương trình thì nó không thể được khai báo bên trong vòng lặp for.

Trong trường hợp biến điều khiển vòng lặp không cần thiết ở bất kỳ nơi nào khác, hầu hết Lập trình viên Java thích khai báo nó bên trong câu lệnh for hơn. Để làm ví dụ, hãy cho một chương trình đơn giản, để kiểm tra xem số đã nhập có phải là số nguyên tố hay không. Lưu ý rằng biến điều khiển vòng lặp i được khai báo bên trong vòng lặp for vì nó không cần thiết ở bất kỳ nơi nào khác.

Các biến thể của vòng lặp for

Vòng lặp for có nhiều biến thể giúp tăng khả năng và khả năng ứng dụng của nó. Tính linh hoạt của vòng lặp này là do ba phần của nó: khởi tạo, kiểm tra điều kiện và lặp lại không chỉ được sử dụng cho mục đích đã định trước của chúng. Trên thực tế, mỗi phần của câu lệnh for có thể được sử dụng cho bất kỳ mục đích nào. Hãy xem xét một vài ví dụ.

Một trong những biến thể phổ biến nhất liên quan đến việc sử dụng biểu thức điều kiện. Đặc biệt, biểu thức này không cần so sánh biến điều khiển của vòng lặp với bất kỳ giá trị đích nào. Trong thực tế, điều kiện điều khiển vòng lặp for có thể là bất kỳ biểu thức Boolean nào. Ví dụ: hãy xem xét đoạn mã sau:

boolean xong = sai;
for(int i=1; !done; i++) (
// ...
if(interrupted()) done = true;
}

Trong ví dụ này, vòng lặp for tiếp tục cho đến khi done được đặt thành true. Trong vòng lặp này, giá trị của biến điều khiển vòng lặp i không được kiểm tra.

Đây là một biến thể khác của vòng lặp for. Bằng cách để trống cả ba phần của câu lệnh, bạn có thể cố ý tạo một vòng lặp vô hạn (vòng lặp không bao giờ kết thúc). Ví dụ:

vì(; ;) (
// ...
}

Vòng lặp này có thể chạy vô thời hạn vì không có điều kiện nào khiến nó bị gián đoạn. Mặc dù một số chương trình như bộ xử lý lệnh hệ điều hành, yêu cầu một vòng lặp vô hạn, hầu hết "vòng lặp vô hạn" thực sự chỉ là các vòng lặp với điều kiện đặc biệt ngắt quãng. Như bạn sẽ sớm thấy, có một cách để phá vỡ vòng lặp - thậm chí là vòng lặp vô hạn như ví dụ này - mà không yêu cầu sử dụng điều kiện vòng lặp thông thường.

Phiên bản "cho mỗi" của vòng lặp for

Bắt đầu với JDK 5, Java cho phép bạn sử dụng dạng thứ hai của vòng lặp for, dạng này triển khai vòng lặp kiểu "cho mỗi". Như bạn có thể biết, khái niệm vòng lặp "cho mỗi" ngày càng trở nên phổ biến trong lý thuyết ngôn ngữ lập trình hiện đại và nhanh chóng trở thành tiêu chuẩn. chức năng bằng nhiều ngôn ngữ. Vòng lặp kiểu for-each được thiết kế để thực hiện các hành động lặp lại trên một tập hợp các đối tượng, chẳng hạn như một mảng, theo cách tuần tự nghiêm ngặt. Không giống như một số ngôn ngữ như C#, sử dụng vòng lặp "for-each" để triển khai từ khóa foreach, trong Java, khả năng sử dụng vòng lặp for-each được triển khai bằng cách cải thiện vòng lặp for. Ưu điểm của phương pháp này là không cần thêm từ khóa nào để triển khai và không có mã tồn tại trước đó bị hỏng. Vòng lặp for kiểu for còn được gọi là vòng lặp for nâng cao. Dạng chung của phiên bản "for-each" của vòng lặp for là lượt xem tiếp theo:

for (gõ iter-per: bộ sưu tập)
toán tử khối

Ở đây type cho biết loại và iter-per là tên của biến lặp sẽ tuần tự lấy các giá trị từ bộ sưu tập, từ đầu đến cuối. Phần tử bộ sưu tập chỉ định bộ sưu tập cần lặp lại. Với vòng lặp for bạn có thể sử dụng Nhiều loại khác nhau các bộ sưu tập, nhưng trong chương này chúng ta sẽ chỉ sử dụng mảng. (Các loại bộ sưu tập khác có thể được sử dụng với vòng lặp for, chẳng hạn như các bộ sưu tập được xác định trong Khung sưu tập, sẽ được thảo luận trong các chương sau của cuốn sách.) Tại mỗi lần lặp của vòng lặp, chương trình sẽ truy xuất phần tử tiếp theo của bộ sưu tập và lưu trữ nó trong biến iter. Vòng lặp chạy cho đến khi tất cả các phần tử của bộ sưu tập được lấy ra.

Bởi vì một biến lặp nhận các giá trị từ một bộ sưu tập nên loại này phải khớp (hoặc tương thích với) loại của các phần tử được lưu trữ trong bộ sưu tập. Vì vậy, khi lặp qua mảng, kiểu đó phải tương thích với kiểu cơ bản của mảng.

Kiểu vòng lặp for cho phép bạn tự động hóa quá trình này. Đặc biệt, việc sử dụng vòng lặp như vậy giúp không thể thiết lập giá trị của bộ đếm vòng lặp bằng cách chỉ định giá trị ban đầu và giá trị cuối cùng và loại bỏ nhu cầu lập chỉ mục mảng theo cách thủ công. Thay vào đó, chương trình sẽ tự động lặp qua toàn bộ mảng, lấy các giá trị của từng phần tử trong mảng một cách tuần tự, từ phần tử đầu tiên đến phần tử cuối cùng. Ví dụ: với phiên bản "for-each" của vòng lặp for, đoạn trước đó có thể được viết lại như sau:

int nums = ( 1, 2, 3, 4, 5, b, 7, 8, 9, 10 );
int sum = 0;
for(int x: nums) sum += x;

Mỗi lần vòng lặp đi qua biến x sẽ tự động được gán một giá trị bằng phần tử tiếp theo số mảng. Do đó, ở lần lặp đầu tiên x chứa 1, ở lần lặp thứ hai - 2, v.v. Điều này không chỉ đơn giản hóa cú pháp chương trình mà còn loại bỏ khả năng xảy ra lỗi ngoài giới hạn của mảng.

Dưới đây là một ví dụ chương trình đầy đủ, minh họa việc sử dụng phiên bản "for-each" được mô tả của vòng lặp for.

// Sử dụng vòng lặp for theo kiểu for-each.
lớp ForEach(
public static void main(String args) (

int sum = 0;
// sử dụng kiểu for-each để hiển thị và tính tổng các giá trị
for(int x: nums) (

tổng += x;
}
System.out.println("Tổng là: " + sum);
}
}

Giá trị là: 1
Giá trị là: 2
Giá trị là: 3
Giá trị là: 4
Giá trị là: 5
Giá trị là: 6
Giá trị là: 7
Giá trị là: 8
Giá trị là: 9
Giá trị là: 10
Số tiền là: 55

Như bạn có thể thấy từ kết quả đầu ra này, kiểu câu lệnh "for-each" tự động lặp qua các phần tử mảng, từ chỉ mục thấp nhất đến chỉ mục cao nhất.

Mặc dù kiểu vòng lặp for lặp lại cho đến khi tất cả các phần tử của mảng được xử lý, vòng lặp có thể bị gián đoạn trước đó bằng cách sử dụng câu lệnh break. Ví dụ, chương trình tiếp theo tính tổng các giá trị của năm phần tử đầu tiên của mảng nums.

// Cách sử dụng toán tử ngắt trong một vòng lặp for theo kiểu for-each.
lớp ForEach2 (
public static void main(String args) (
int sum = 0;
int số = ( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 );
// sử dụng vòng lặp for để hiển thị và tính tổng các giá trị
for(int x: nums) (
System.out.println("Giá trị là: " + x);
tổng += x; v if (x == 5) phá vỡ; // kết thúc vòng lặp sau khi nhận được 5 giá trị
}
System.out.println("Tổng của 5 phần tử đầu tiên là: " + sum);
}
}

Chương trình tạo ra đầu ra sau:

Giá trị là: 1
Giá trị là: 2
Giá trị là: 3
Giá trị là: 4
Giá trị là: 5
Tổng của 5 phần tử đầu tiên là: 15

Như bạn có thể thấy, vòng lặp dừng thực thi sau khi nhận được giá trị của phần tử thứ năm. Câu lệnh break cũng có thể được sử dụng với các lệnh khác Vòng lặp Java. Toán tử này sẽ được thảo luận chi tiết hơn trong các phần tiếp theo của chương này.

Khi sử dụng vòng lặp for-each, có một điều quan trọng cần lưu ý: Biến lặp của nó là biến chỉ đọc vì nó chỉ được liên kết với mảng ban đầu. Hoạt động gán giá trị cho một biến lặp không ảnh hưởng đến mảng ban đầu. Nói cách khác, nội dung của mảng không thể thay đổi bằng cách gán giá trị mới cho biến lặp. Ví dụ, hãy xem xét chương trình sau:

// Biến vòng lặp for-each chỉ đọc.
lớp NoChange (
public static void main(String args) (
int số = ( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 );
for(int x: nums) (
System.out.print(x + " ");
x=x*10; // toán tử này không có tác dụng gì với mảng nums
}
System.out.println();
cho(int x: số)
System.out.print(x + " ");
System.out.println();
}
}

Vòng lặp for đầu tiên tăng giá trị của biến lặp lên 10. Tuy nhiên, thao tác gán này không ảnh hưởng đến mảng nums ban đầu, như có thể thấy từ kết quả của câu lệnh for thứ hai. Đầu ra do chương trình tạo ra xác nhận điều này:

1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9 10

Lặp lại trong mảng đa chiều

Một phiên bản cải tiến của vòng lặp for cũng áp dụng cho mảng đa chiều. Tuy nhiên, cần nhớ rằng trong Java đa chiều mảng bao gồm các mảng của mảng. (Ví dụ: mảng hai chiều là mảng gồm các mảng một chiều.) Điều này rất quan trọng khi lặp trong mảng đa chiều, vì kết quả của mỗi lần lặp là mảng tiếp theo chứ không phải một phần tử. Hơn nữa, kiểu của biến lặp vòng lặp for phải tương thích với kiểu của mảng kết quả. Ví dụ, trong trường hợp mảng hai chiều biến lặp phải là một tham chiếu đến mảng một chiều. Nói chung, khi bạn sử dụng vòng lặp for-each để duyệt qua một mảng có kích thước N, đối tượng thu được sẽ là các mảng có kích thước N-1. Để hiểu điều gì xảy ra sau đó, hãy xem xét chương trình sau. Nó sử dụng các vòng lặp for lồng nhau để thu được các phần tử được sắp xếp theo hàng của mảng hai chiều.

// Sử dụng vòng lặp for kiểu for trên mảng hai chiều.
lớp ForEach3 (
public static void main(String args) (
int sum = 0;
int nums = int mới;
// gán giá trị cho các phần tử của mảng nums
for (int i = 0; i nums[i] [j] = (i+l)*(j+l) ; // sử dụng vòng lặp for kiểu for-each để hiển thị
// và tính tổng các giá trị
cho (int x : số) (
for(int y: x) (
System.out.println("Giá trị là: " + y);
tổng += y;
}
}
System.out.println("Tổng: " + tổng);
}

Chương trình này tạo ra đầu ra sau:

Giá trị là: 1
Giá trị là: 2
Giá trị là: 3
Giá trị là: 4
Giá trị là: 5
Giá trị là: 2
Giá trị là: 4
Giá trị là: 6
Giá trị là: 8
Giá trị là: 10
Giá trị là: 3
Giá trị là: 6
Giá trị là: 9
Giá trị là: 12
Giá trị là: 15
Số tiền: 9 0

Dòng sau đây của chương trình này đáng được quan tâm đặc biệt:

cho (int x : số) (

Hãy chú ý đến cách khai báo biến x. Biến này là tham chiếu đến mảng một chiều chứa các giá trị nguyên. Điều này là cần thiết vì kết quả của mỗi lần lặp của vòng lặp for là mảng tiếp theo trong mảng nums, bắt đầu bằng mảng được chỉ định bởi phần tử nums. Sau đó, vòng lặp for bên trong sẽ lặp qua từng mảng này, hiển thị các giá trị của từng phần tử.

Sử dụng vòng lặp For cải tiến

Vì mỗi kiểu câu lệnh for-each chỉ có thể lặp qua các phần tử của một mảng một cách tuần tự, bắt đầu từ phần tử đầu tiên và kết thúc ở phần tử cuối cùng, nên nó có vẻ như bị hạn chế sử dụng. Tuy nhiên, nó không phải vậy. Nhiều thuật toán yêu cầu sử dụng cơ chế đặc biệt này. Một trong những thuật toán được sử dụng phổ biến nhất là tìm kiếm. Ví dụ: chương trình sau sử dụng vòng lặp for để tìm kiếm một giá trị trong một mảng không có thứ tự. Việc tìm kiếm dừng lại khi tìm thấy giá trị tìm kiếm.

// Tìm kiếm mảng bằng cách sử dụng kiểu vòng lặp for-each.
Tìm kiếm lớp (
public static void main(String args) (
int nums = ( 6, 8, 3, 7, 5, 6, 1, 4 );
int giá trị =5;
tìm thấy boolean = sai;
// sử dụng vòng lặp for theo kiểu for-each
cho (int x: số) (
nếu (x == val) (
tìm thấy = đúng;
phá vỡ;
}
}
Nếu được tìm thấy)
System.out.println("Tìm thấy giá trị!");)

Trong trường hợp này, việc chọn kiểu "cho mỗi" cho vòng lặp for là hoàn toàn hợp lý, vì việc tìm kiếm trong một mảng không có thứ tự bao gồm việc xem xét từng phần tử một cách tuần tự. (Tất nhiên, nếu mảng được sắp xếp theo thứ tự, thì có thể sử dụng tìm kiếm nhị phân, việc này sẽ yêu cầu một kiểu vòng lặp khác để triển khai.) Các loại ứng dụng khác được hưởng lợi từ vòng lặp for-each bao gồm tính trung bình, tìm giá trị tối thiểu hoặc tối đa trong một tập hợp, tìm kiếm các bản sao, v.v.



Kể từ JDK 5, có hai dạng vòng lặp for trong Java. Đầu tiên là hình thức truyền thống, được sử dụng từ phiên bản gốc Java. Thứ hai là hình thức “cho mỗi” mới. Chúng ta sẽ xem xét cả hai loại vòng lặp for, bắt đầu với dạng truyền thống.

Dạng tổng quát của toán tử truyền thống vì như sau:

Nếu chỉ có một câu lệnh được lặp lại trong một vòng lặp, bạn có thể bỏ qua dấu ngoặc nhọn.

Xe đạp vì hoạt động như sau. Khi vòng lặp được bắt đầu lần đầu tiên, chương trình sẽ thực thi khởi tạo một phần của chu kỳ. Nói chung, đây là biểu thức đặt giá trị của biến điều khiển vòng lặp, hoạt động như một bộ đếm điều khiển vòng lặp. Điều quan trọng là phải hiểu rằng biểu thức khởi tạo chỉ được thực hiện một lần. Sau đó chương trình sẽ tính toán tình trạng cần được boolean sự biểu lộ. Thông thường, biểu thức điều kiện so sánh giá trị của biến điều khiển với giá trị đích. Nếu giá trị này đúng thì chương trình sẽ thực thi thân hình xe đạp. Nếu sai thì việc thực hiện vòng lặp sẽ bị hủy bỏ.. Chương trình sau đó thực hiện thân hình vòng lặp và chỉ sau đó phần đó được thực thi sự lặp lại xe đạp. Sự lặp lại nó thường là biểu thức tăng hoặc giảm giá trị của biến điều khiển. Chương trình sau đó lặp lại vòng lặp, mỗi lần nó trôi qua, đầu tiên tính toán có điều kiện biểu hiện, sau đó làm thân hình vòng lặp và thực hiện biểu thức sự lặp lại . Quá trình được lặp lại cho đến khi giá trị của biểu thức điều kiện sẽ không trở thành sai.

Vì hầu hết các vòng lặp chỉ sử dụng các biến của chúng trong vòng lặp, nên vòng lặp vì cho phép biểu thức khởi tạo là một khai báo biến hoàn chỉnh. Do đó, biến được giới hạn trong phần thân của vòng lặp và không thể nhìn thấy được từ bên ngoài..

Dưới đây là một vài ví dụ giải thích tất cả những điều trên:

Trong ví dụ này biến Tôiđược khai báo bên ngoài vòng lặp (dòng 7), do đó nó cũng có sẵn sau khi hoàn thành (dòng 12).

Từ đầu ra của chương trình này có thể thấy rằng biểu thức sự lặp lại chu kỳ, cụ thể là tăng tiền tố ( ++tôi) Biến đổi Tôiđược thực thi sau khi phần thân vòng lặp được thực thi, tức là sau khi dòng 10 được thực thi, dòng này in ra lời chào.

Điểm này rất quan trọng cần phải hiểu để có sự hiểu biết chính xác về cách thức hoạt động của chu trình. vì.

Bây giờ hãy xem đầu ra của chương trình này có và không có đối số dòng lệnh:

Như có thể thấy từ đầu ra của chương trình này, mức tăng của biến Tôi xảy ra sau khi lệnh cuối cùng trong vòng lặp được thực thi, lệnh này in ra lời chào (dòng 10).

Bây giờ hãy khai báo một biến bên trong vòng lặp (câu lệnh for):

Như bạn có thể thấy, Eclipse ngay lập tức chỉ ra cho chúng ta lỗi mà biến j, được khai báo ở dòng 15, không hiển thị bên ngoài vòng lặp vì phạm vi hoặc phạm vi của nó chỉ mở rộng đến phần thân của vòng lặp mà nó được khai báo.

Để chương trình hoạt động, bạn cần chú thích dòng 19.

Đầu ra của mã này tương tự như đầu ra của mã chúng ta vừa xem, ngoại trừ việc thay vì “Xin chào”, nó sẽ xuất ra “Xin chào”. Chà, sau vòng lặp, không thể hiển thị giá trị của một biến j.

Khi khai báo một biến trong vòng lặp vì Cần nhớ một tình huống quan trọng sau: diện tích và thời gian tồn tại của biến này hoàn toàn trùng khớp với diện tích và thời gian tồn tại của toán tử vì .

Cú pháp vòng lặp vì không bị giới hạn ở các vòng lặp với một biến duy nhất. Như trong biểu thức khởi tạo , và trong biểu thức sự lặp lại có thể được sử dụng dấu phẩyđể tách nhiều biểu thức khởi tạo Và sự lặp lại .

Ví dụ:

Trong ví dụ này ở khởi tạo các phần của chu trình chúng tôi thiết lập giá trị ban đầu cả hai biến kiểm soát Một Và b. Cả hai câu lệnh được phân tách bằng dấu phẩy trong lặp đi lặp lại các phần được thực hiện mỗi khi vòng lặp được lặp lại.

Mã này tạo ra đầu ra sau:

Xe đạp vì hỗ trợ một số hương vị làm tăng khả năng và khả năng ứng dụng của nó. Tính linh hoạt của chu trình này là do nó có ba phần: khởi tạo , kiểm tra điều kiện Và lặp đi lặp lại không nhất thiết phải được sử dụng chỉ cho mục đích dự định của nó. Trên thực tế, mỗi phần của tuyên bố vì có thể được sử dụng cho bất kỳ mục đích nào. Ví dụ:

Tất nhiên, ví dụ này hơi khó hiểu nhưng về bản chất thì nó rất đơn giản. Phần đầu tiên của câu lệnh khởi tạo biến b, cái thứ hai sẽ kiểm tra nó và cái thứ ba sẽ hiển thị một thông báo trên bảng điều khiển.

Về cơ bản, chương trình này thực hiện điều tương tự với các đối số chào hỏi nếu có. Nếu chúng không có ở đó thì nó sẽ không xuất ra bất cứ thứ gì. Hãy để tôi đưa ra ngay một ví dụ về đầu ra của nó:

Như có thể thấy từ đầu ra của chương trình này, phần lặp được thực thi, như đã đề cập, sau khi phần thân vòng lặp được thực thi. Trong trường hợp này nó là người vận hành in ở dòng 9. Câu lệnh for trong mã này trải dài trên hai dòng 9 và 10 vì nó khá dài. Tôi làm điều này để chứng minh rằng mọi phần của câu lệnh for đều có thể được sử dụng trong cho các mục đích khác nhau. Cũng cần lưu ý rằng mức tăng của biến Tôi xảy ra ở dòng 12 và cũng đặt điều kiện để tiếp tục hoặc thoát khỏi vòng lặp, được kiểm tra ở dòng 9.

Một ví dụ tương tự khác, vòng lặp for có thể được sử dụng để lặp qua các phần tử của danh sách liên kết:

Điều đáng lưu ý là bất kỳ phần nào của chu kỳ vì (khởi tạo, tình trạng Và lặp đi lặp lại) hoặc thậm chí bạn có thể bỏ qua mọi thứ. Ví dụ: bạn có thể tạo một vòng lặp vô hạn theo cách này:

( ;; ){
//chu kỳ vô tận
}

Một biểu thức khởi tạo hoặc lặp lại hoặc cả hai có thể bị thiếu:

Trong ví dụ này khởi tạo Và lặp đi lặp lại biểu thức được di chuyển ra ngoài định nghĩa của toán tử vì. Kết quả là, các phần tương ứng của tuyên bố vì trống.

Để trình tự thực hiện các phần của toán tử for rõ ràng hơn, tôi sẽ đưa ra ví dụ nhỏ. Mặc dù chúng tôi chưa nghiên cứu các phương pháp nhưng tôi hy vọng bạn sẽ hiểu được ý tưởng của chương trình này. Mục đích của nó là trình bày rõ ràng trình tự thực hiện của tất cả các phần của câu lệnh for.

Từ đầu ra của chương trình, rõ ràng rằng khởi tạo một phần của chương trình ( phương thức initTest()) chỉ được thực hiện một lần.

Sau đó việc kiểm tra được thực hiện điều kiện , được biểu diễn bằng phương pháp condTest().

Sau khi kiểm tra điều kiện , thực hiện thân hình xe đạp.

Và sau đó phần được thực thi sự lặp lại , được biểu diễn bằng phương pháp recTest().

Phương thức condTest() kiểm tra điều kiện tiếp tục vòng lặp. Trong trường hợp này, biến i được so sánh với 4 và miễn là biến i nhỏ hơn 4 thì phần thân vòng lặp sẽ được thực thi.

Phần thân của vòng lặp được thực thi bốn lần kể từ khi biến i được khởi tạo bằng 0 theo mặc định.

Nhà điều hành cho mỗi

Bắt đầu với JDK 5, Java có thể sử dụng dạng thứ hai của vòng lặp for, thực hiện một vòng lặp theo kiểu cho mỗi ("cho mỗi"). Chu kỳ theo phong cách cho mỗi được thiết kế để thực hiện tuần tự nghiêm ngặt các hành động lặp đi lặp lại liên quan đến tập hợp các đối tượng, chẳng hạn như mảng. Trong Java, khả năng sử dụng vòng lặp cho mỗi được thực hiện bằng cách cải thiện chu trình vì. Mẫu phiên bản chung cho mỗi xe đạp vì có dạng sau:

for (loại biến lặp: bộ sưu tập) các câu lệnh khối

Kiểu đây là loại biến, biến lặp — tên của một biến lặp sẽ tuần tự lấy các giá trị từ bộ sưu tập , từ đầu đến cuối. Phần tử bộ sưu tập chỉ định bộ sưu tập cần lặp lại. Với vòng lặp vì Bạn có thể sử dụng các loại bộ sưu tập khác nhau, nhưng hiện tại chúng tôi sẽ chỉ sử dụng mảng mà chúng tôi chưa thử, nhưng ít nhất đã có nhiều ví dụ với lời chào từ một chuỗi chuỗi, trong đó các đối số dòng lệnh đi.

Trên một lưu ý: nhà điều hành cho mỗi áp dụng cho các mảng và lớp triển khai giao diện java.lang.Iterable.

Tại mỗi lần lặp của vòng lặp, chương trình sẽ lấy phần tử tiếp theo của tập hợp và lưu nó vào một biến lặp. Vòng lặp chạy cho đến khi tất cả các phần tử của bộ sưu tập được lấy ra.

Mặc dù chu kỳ lặp đi lặp lại vì trong phong cách cho mỗi được thực thi cho đến khi tất cả các phần tử của mảng (bộ sưu tập) đã được xử lý; vòng lặp có thể bị gián đoạn trước đó bằng cách sử dụng toán tử; phá vỡ.

Bởi vì một biến lặp nhận các giá trị từ một bộ sưu tập nên loại của nó phải khớp (hoặc tương thích với) loại của các phần tử được lưu trữ trong bộ sưu tập. Vì vậy, khi lặp qua mảng, kiểu đó phải tương thích với kiểu cơ bản của mảng.

Để hiểu động cơ sử dụng vòng lặp theo phong cách cho mỗi , xét loại chu trình vì, mà phong cách này nhằm thay thế.

Hãy lấy lại ví dụ của chúng ta về các đối số chào mừng từ dòng lệnh:

Chẳng phải nó thanh lịch hơn nhiều so với việc sử dụng các toán tử vòng lặp khác cho mục đích này sao?

Trên thực tế, chương trình này có một đầu ra đơn giản:

Chúng tôi đã nhìn thấy anh ấy nhiều lần trong các lựa chọn khác nhau, nhưng sự lặp lại là mẹ của việc học.

Để rõ ràng hơn, chúng ta hãy xem thêm một vài ví dụ.

Mỗi lần vòng lặp trôi qua, biến x sẽ tự động được gán một giá trị bằng giá trị của phần tử tiếp theo trong mảng nums. Do đó, ở lần lặp đầu tiên x chứa 1, ở lần lặp thứ hai - 2, v.v. Điều này giúp đơn giản hóa cú pháp chương trình và loại bỏ khả năng vượt ra ngoài mảng.

Đầu ra của phần này của chương trình là:

Mặc dù chu kỳ lặp đi lặp lại vì trong phong cách cho mỗi được thực thi cho đến khi tất cả các phần tử của mảng được xử lý xong; vòng lặp có thể bị gián đoạn trước đó bằng cách sử dụng toán tử; phá vỡ. Ví dụ:

TRONG trong ví dụ này vòng lặp sẽ chỉ chạy ba lần lặp, sau đó vòng lặp sẽ thoát theo điều kiện của toán tử nếu như, điều này sẽ kích hoạt toán tử phá vỡ.

Điều quan trọng là phải hiểu rằng biến lặp nhận các giá trị từ tập hợp (mảng) tại mỗi lần lặp, do đó, ngay cả khi giá trị của nó bị thay đổi trong phần thân vòng lặp, thì ở lần lặp tiếp theo, nó sẽ lại lấy giá trị tiếp theo. giá trị từ bộ sưu tập. Hơn nữa, những thay đổi của nó không ảnh hưởng đến giá trị của bộ sưu tập (các phần tử mảng trong ví dụ này).

Mã này sẽ xuất ra như sau:

Bất kỳ phương thức nào trả về một mảng đều có thể được sử dụng với cho mỗi . Ví dụ chuỗi lớp chứa phương thức toCharArray trả về một mảng char. Ví dụ:

Mã này sẽ chỉ in ra chuỗi Hello World!

Đây là nơi chúng ta có thể kết thúc với các toán tử này. Điều đáng nói duy nhất là ở phần khởi tạo bạn chỉ có thể khai báo các biến cùng kiểu, hoặc khởi tạo biến các loại khác nhau, nhưng như vậy có thể rút gọn thành một loại chung theo quy tắc truyền kiểu mà chúng ta đã xem xét trước đó.

Cuối cùng, tôi sẽ đưa ra thêm một vài ví dụ về toán tử nâng cao vì. Qua nhìn chung, đây chỉ là mã được cấu trúc lại của ví dụ mà tôi đã đưa ra.

Chẳng phải mã này đã trở nên dễ đọc và dễ hiểu hơn mã tôi đã cung cấp sao? Hay là nó không rõ ràng? Vậy thì, hãy xem một ví dụ khác về mã thực hiện điều tương tự.

Lại không rõ ràng sao?

Cả hai mã này đều tạo ra cùng một đầu ra:

Tất nhiên, với điều kiện là các lập luận trong dòng lệnh có Vasya và Petya.

Về điều này với cho nhà điều hành và hãy kết thúc với foreach bóng của nó.

Vòng lặp là một khối lệnh được thực hiện lặp đi lặp lại miễn là đáp ứng một điều kiện nhất định. Đoạn mã được lặp lại được gọi là "phần thân vòng lặp". Một lần thực hiện phần thân vòng lặp được gọi là lần lặp.

Trong Java, bạn có thể làm việc với một số loại vòng lặp - để làm điều này, có các toán tử sau:

trong khi– chu kỳ với điều kiện tiên quyết– đầu tiên chúng ta kiểm tra điều kiện, sau đó thực hiện phần thân vòng lặp;

làm trong khi– chu kỳ với hậu điều kiện– đầu tiên chúng ta thực hiện phần thân vòng lặp một lần, sau đó chúng ta kiểm tra điều kiện và nếu nó đáp ứng thì chúng ta tiếp tục;

vì– vòng lặp với bộ đếm – chạy và cập nhật bộ đếm ở mỗi lần lặp miễn là đáp ứng điều kiện trong khai báo vòng lặp (tức là kiểm tra điều kiện trả về đúng);

viết tắt cho(được gọi là foreach trong các ngôn ngữ khác) – lặp qua mảng từ phần tử đầu tiên đến phần tử cuối cùng và thực thi phần thân của vòng lặp ở mỗi lần lặp.

Bản chất của điều kiện vòng lặp là kiểm tra một biểu thức có một hoặc nhiều biến: “Trong khi một<11, в каждой итерации выполняем тело цикла и увеличиваем "а" на 1». Но чему равно «а» при первом выполнении цикла?

Nếu chúng ta sử dụng cấu trúc với while, giá trị phải được chỉ định trước khi bắt đầu vòng lặp:

int a = 1;

trong khi một< 11) {

System.out.println(a);

một++; // tăng từng cái một

}

Nếu biến hoạt động như một bộ đếm vòng lặp và không được sử dụng bên ngoài nó thì biến đó sẽ được khởi tạo trực tiếp trong điều kiện. Và sau đó họ viết phải làm gì với nó vào cuối mỗi lần lặp. Tất cả điều này - trong một dòng - sử dụng cho:

với (a=1, a<11, i++) {

System.out.println(a);

}

Chúng tôi nhận được kết quả tương tự. Danh sách có thể bắt đầu từ 0 hoặc từ một giá trị âm - chúng tôi tự xác định phạm vi.

Phiên bản rút gọn của vòng lặp for không có dấu hiệu nào về số lần lặp lại hoặc hành động ở cuối bước. Vòng lặp foreach được sử dụng để lặp qua các mảng. Bạn cần di chuyển từ phần tử đầu tiên sang phần tử tiếp theo cho đến khi mảng kết thúc.

int ms = (1, 2, 3, 4); // tạo một mảng

int s = 0;

for(int i: ms) ( // chỉ định nội dung cần lặp lại

s *= tôi; // nhân các phần tử một cách nhất quán

}

System.out.println(s);

Vòng lặp lồng nhau trong Java

Các vòng lặp có thể được lồng vào nhau. Trong trường hợp này, số lần lặp lại của vòng lặp bên ngoài và vòng lặp lồng nhau sẽ được nhân lên. Nếu vòng lặp bên ngoài được thực thi 5 lần và vòng lặp bên trong 5 lần thì vòng lặp sẽ được thực hiện tổng cộng 25 lần.

Hãy hiển thị bảng nhân bằng hai mảng:

int a, b, kết quả = 0;

với (a = 2; a< 10; a++) {

với (b = 2; b< 10; b++) {

kết quả = a*b;

System.out.println(a+"x"+b+" = "+result);

}

}

Tạo đối tượng trong vòng lặp Java

Vòng lặp rất hữu ích khi bạn cần tạo và đánh số nhiều đối tượng. Số lượng của chúng đôi khi không được biết trước: các đối tượng có thể được tạo theo yêu cầu của người dùng. Vì vậy, chúng tôi hỏi cần bao nhiêu thứ và viết số đó vào biến n. Bây giờ hãy tạo các đối tượng với số lượng yêu cầu:

Mảng gì đó = Something mới[n]; //tạo một mảng kiểu “thứ gì đó” gồm n phần tử

for(int i = 0; i< n; i++){

mảng[i] = Cái gì đó mới(); // tạo “thứ gì đó” và đặt nó vào một mảng

}

Cách thoát khỏi vòng lặp Java

Để thoát khỏi vòng lặp, có các từ khóa break - “ngắt”, tiếp tục - “tiếp tục” và quay lại - “trở lại”. Lệnh break chuyển chương trình sang thực thi các câu lệnh sau vòng lặp. Các điều kiện gián đoạn vòng lặp trong Java được chính thức hóa thông qua phân nhánh if. Điều chính là việc kiểm tra được thực hiện trước phần chính của thân vòng lặp.

// sau khi tạo mảng m ta viết:

cho (a: m) (

nếu (a==5) phá vỡ;

System.out.println(a);

}

Các toán tử nhánh và vòng lặp trong Java thường làm việc cùng nhau: chúng ta bắt đầu một vòng lặp và bên trong nó, chúng ta kiểm tra xem liệu điều kiện nào chưa được đáp ứng hay không, theo đó chúng ta cần ngắt vòng lặp hoặc làm điều gì khác.

Nếu bạn sử dụng break trong một vòng lặp lồng nhau thì chỉ vòng lặp đó bị gián đoạn, còn vòng lặp bên ngoài sẽ tiếp tục thực thi.

Để kết thúc sớm vòng lặp for trong Java, tiếp tục được sử dụng. Khi chương trình đạt đến nó, nó sẽ bỏ qua phần chưa hoàn thành của lần lặp, cập nhật bộ đếm và chuyển sang lần lặp tiếp theo.

Trong các cấu trúc while, cùng một continue hoạt động khác nhau: nó trả về cho chúng ta việc kiểm tra điều kiện để tiếp tục vòng lặp. Một lệnh khác, return, trả chương trình về vị trí mà phương thức chứa vòng lặp được gọi.

Cả tiếp tục và ngắt đều có thể được sử dụng với nhãn - để chuyển đến phần mã mong muốn - tương tự như goto:

breakMark1; // với điều kiện Mark1 ở đâu đó phía trên:

Vòng lặp vô hạn Java

Tạo một vòng lặp vô hạn thật dễ dàng - chỉ cần không chỉ định bất kỳ tham số nào trong for:

vì (; ;) ()

Khó hơn để tận dụng nó. Thông thường, vòng lặp vô hạn là một lỗi nghiêm trọng khiến chương trình không thể thực thi. Do đó, mỗi vòng lặp cần được kiểm tra khả năng kết thúc chính xác vào đúng thời điểm. Để làm điều này bạn cần:

  • chỉ ra các điều kiện ngắt trong thân vòng lặp,
  • đảm bảo rằng biến trong điều kiện ngắt có thể nhận giá trị tại đó vòng lặp sẽ dừng lại.

Chu trình là một đoạn của chương trình được lặp lại nhiều lần.

Có hai loại vòng lặp trong java: loại "while" và loại "n-time".

Loại “while” đầu tiên được thiết kế để lặp lại một số hành động cho đến khi đáp ứng một số điều kiện. Ví dụ: tăng một số lên 5 cho đến khi số đó có ba chữ số.

Loại thứ hai “n-time” nhằm mục đích lặp lại một số hành động với số lần xác định trước. Ví dụ: nhân một số với chính nó 4 lần.

Vòng lặp while (các câu lệnh while và do...while)

Câu lệnh while lặp lại các hành động đã chỉ định miễn là tham số của nó là đúng.

Ví dụ: một vòng lặp như vậy sẽ được thực hiện 4 lần và “1 2 3 4” sẽ được hiển thị trên màn hình:

Int tôi = 1; trong khi tôi< 5) { System.out.print(i + " "); i++; }

Vòng lặp như vậy sẽ không được thực hiện dù chỉ một lần và sẽ không có gì hiển thị trên màn hình:

Int tôi = 1; trong khi tôi< 0) { System.out.print(i + " "); i++; }

Vòng lặp này sẽ chạy vô tận và màn hình sẽ hiển thị “1 2 3 4 5 6 7…”:

Int tôi = 1; while (true) ( ​​​​System.out.print(i + " "); i++; )

Điều kiện xác định xem vòng lặp có được lặp lại hay không được kiểm tra trước mỗi bước của vòng lặp, kể cả bước đầu tiên. Họ nói chuyện gì đang xảy ra kiểm tra trướcđiều kiện.

Có một chu kỳ giống như “tạm biệt” với kiểm tra sauđiều kiện. Để viết nó, một cấu trúc của câu lệnh do...while được sử dụng.

Vòng lặp này sẽ được thực hiện 4 lần và “2 3 4 5” sẽ được hiển thị trên màn hình:

< 5);

Vòng lặp này sẽ được thực hiện 1 lần và số “2” sẽ hiển thị trên màn hình:

Int tôi = 1; làm ( i++; System.out.print(i + " "); ) while (i< 0);

Phần thân của vòng lặp do...while được thực thi ít nhất một lần. Toán tử này thuận tiện sử dụng khi một số hành động trong chương trình cần được thực hiện ít nhất một lần, nhưng trong một số điều kiện nhất định, nó sẽ phải lặp lại nhiều lần.

Hãy xem chương trình sau (nó đoán một số nguyên ngẫu nhiên từ một phân đoạn và yêu cầu người dùng đoán số đó bằng cách nhập các tùy chọn từ bàn phím, cho đến khi người dùng đoán được số đó, chương trình sẽ nhắc anh ta, cho anh ta biết số đoán được nhiều hơn hay ít hơn những gì người dùng đã nhập):

Nhập java.util.Scanner; public class Main ( public static void main(String args) ( // prog - một số được tạo bởi chương trình // người dùng - một số được người dùng nhập vào int prog, user; // Tạo một số nguyên ngẫu nhiên từ 1 đến 10 prog = (int)(Math. Random() * 10) + 1; System.out.println("Tôi đoán một số từ 1 đến 10, đoán xem."); System.out.print("Nhập số của bạn: ") ; System.in); // Kiểm tra xem có số nguyên trong luồng đầu vào hay không if(input.hasNextInt()) ( do ( // Đọc một số nguyên từ luồng đầu vào user = input.nextInt(); if(user = = prog) ( System.out.println("Bạn đoán rồi!"); ) else ( // Kiểm tra xem số có được đưa vào phân đoạn hay không if (user > 0 && user<= 10) { System.out.print("Вы не угадали! "); // Если число загаданное программой меньше... if(prog < user) { System.out.println("Моё число меньше."); } else { System.out.println("Моё число больше."); } } else { System.out.println("Ваше число вообще не из нужного отрезка!"); } } } while(user != prog); } else { System.out.println("Ошибка. Вы не ввели целое число!"); } System.out.println("До свиданья!"); } }

Thực hiện các sửa đổi sau đây cho chương trình:

    Chương trình sẽ nghĩ ra một số không phải từ phân đoạn , mà là một số nguyên từ phân đoạn từ [−10;10], ngoại trừ số 0. Đồng thời, cố gắng đảm bảo rằng sự phân bố các số ngẫu nhiên do chương trình tạo ra là đồng nhất (nghĩa là nếu số 0 bị mất, nó không thể được thay thế bằng một số khác, ví dụ: bằng 1, vì khi đó 1 sẽ là giảm với xác suất gấp đôi các số còn lại).

    Chương trình sẽ nhắc người dùng rằng họ đã mắc lỗi về dấu nếu chương trình đoán số dương và người dùng nhập số âm. Và ngược lại.

Vòng lặp N-thời gian (cho câu lệnh)

Câu lệnh for chứa ba tham số. Đầu tiên được gọi là khởi tạo, thứ hai được gọi là điều kiện lặp lại và thứ ba được gọi là lặp lại.

For (khởi tạo; điều kiện; lặp lại) ( // phần thân vòng lặp, tức là các hành động được lặp lại theo chu kỳ)

Trong tham số đầu tiên, bạn thường chọn một số biến sẽ được sử dụng để đếm số lần lặp lại của vòng lặp. Nó được gọi là bộ đếm. Bộ đếm được cung cấp một số giá trị ban đầu (chúng cho biết nó sẽ thay đổi từ giá trị nào).

Tham số thứ hai cho biết một số giới hạn trên bộ đếm (cho biết giá trị nào nó sẽ thay đổi).

Tham số thứ ba chỉ định một biểu thức thay đổi bộ đếm sau mỗi bước vòng lặp. Thông thường đây là mức tăng hoặc giảm, nhưng bạn có thể sử dụng bất kỳ biểu thức nào mà bộ đếm sẽ được gán một số giá trị mới.

Trước bước đầu tiên của vòng lặp, bộ đếm được gán một giá trị ban đầu (việc khởi tạo được thực hiện). Điều này chỉ xảy ra một lần.

Trước mỗi bước của vòng lặp (nhưng sau khi khởi tạo), điều kiện lặp lại được kiểm tra; nếu nó đúng thì phần thân của vòng lặp sẽ được thực hiện lại. Đồng thời, phần thân của vòng lặp có thể không được thực thi dù chỉ một lần nếu điều kiện sai ở lần kiểm tra đầu tiên.

Sau khi hoàn thành mỗi bước của vòng lặp và trước khi bắt đầu bước tiếp theo (và do đó trước khi kiểm tra điều kiện lặp lại), việc lặp lại được thực hiện.

Chương trình sau hiển thị các số từ 1 đến 100:

Với (int i = 1; i<= 100; i++) { System.out.print(i + " "); }

Chương trình sau hiển thị các số từ 10 đến −10:

For (int s = 10; s > -11; s--) ( System.out.print(s + " "); )

Chương trình trình bày hiển thị các số lẻ từ 1 đến 33:

Với (int i = 1; i<= 33; i = i + 2) { System.out.print(i + " "); }

Chương trình được trình bày sẽ tính tổng các phần tử của một đoạn của dãy 2, 4, 6, 8,... 98, 100. Vậy:

Tổng số nguyên = 0; // Ta sẽ tích lũy kết quả ở đây cho (int j = 2; j

Chương trình được trình bày sẽ đưa ra một số từ một biến Mộtđến mức độ tự nhiên từ biến N:

Nhân đôi a = 2; int n = 10; độ phân giải gấp đôi = 1; // Chúng ta sẽ tích lũy kết quả ở đây cho (int i = 1; i<= n; i++) { res = res * a; } System.out.println(res);

Chương trình được trình bày sẽ hiển thị 10 phần tử đầu tiên của dãy 2n+2, trong đó n=1, 2, 3…:

Với (int i = 1; i< 11; i++) { System.out.print(2*i + 2 + " "); }

Chương trình được trình bày sẽ hiển thị 10 phần tử đầu tiên của dãy 2a n−1 +3, trong đó a 1 =3:

Int a = 3; với (i=1; tôi<=10;i++) { System.out.print(a + " "); a = 2*a + 3; }

Trong một chu kỳ, bạn có thể đặt nhiều bộ đếm cùng một lúc. Trong trường hợp này, một số biểu thức lặp và khởi tạo được phân tách bằng dấu phẩy. Chỉ có thể chỉ định một điều kiện lặp lại, nhưng nó có thể là một biểu thức chứa nhiều bộ đếm cùng một lúc.

Chương trình được trình bày sẽ hiển thị 10 phần tử đầu tiên của dãy 2a n−1 -2, trong đó a 1 =3:

Với (int a=3, i=1; i<=10; a=2*a-2, i++) { System.out.print(a + " "); }

Chương trình được trình bày sẽ hiển thị chuỗi sau “0 -1 -4 -9 -16 -25”:

Với (int a=0, b=0; a-b<=10; a++, b--) { System.out.print(a*b + " "); }

Kết thúc vòng lặp sớm (câu lệnh break)

Cả vòng lặp kiểu “while” và vòng lặp kiểu “n-time” đều có thể bị kết thúc sớm nếu bạn gọi toán tử bên trong thân vòng lặp phá vỡ. Trong trường hợp này, vòng lặp sẽ thoát ngay lập tức; ngay cả bước hiện tại cũng sẽ không được hoàn thành (nghĩa là nếu có bất kỳ câu lệnh nào khác sau khi ngắt, chúng sẽ không được thực thi).

Theo kết quả của ví dụ sau, chỉ có các số “1 2 3 4 End” được hiển thị trên màn hình:

Với (int a=1; a

Khi chương trình thực hiện vòng lặp lần thứ năm (nhập một vòng lặp có bộ đếm bằng 5), điều kiện mà câu lệnh break sẽ được thực thi sẽ ngay lập tức được kiểm tra và cho thấy là đúng. Phần còn lại của thân vòng lặp (xuất ra màn hình) sẽ không được tạo ra: chương trình sẽ ngay lập tức tiến hành thực hiện các thao tác được chỉ định sau vòng lặp và hơn thế nữa.

Sử dụng câu lệnh break, bạn có thể ngắt một vòng lặp rõ ràng là vô hạn. Ví dụ (màn hình sẽ hiển thị “100 50 25 12 6 3 1 0” và sau đó vòng lặp sẽ dừng):

Int s = 100; while (true) ( ​​​​System.out.print(s + " "); s = s / 2; if(s == 0) ( break; ) )

Sẽ hợp lý hơn nếu chỉ gọi toán tử ngắt khi một số điều kiện xảy ra, nếu không vòng lặp sẽ được hoàn thành trước thời hạn ở bước đầu tiên.

Int một; for (a=25; a>0; a--) ( break; System.out.print(a + " "); ) System.out.print("a=" + a);

Trong ví dụ trên, việc xuất ra màn hình theo vòng lặp sẽ không xảy ra dù chỉ một lần và khi biến Mộtđược hiển thị trên màn hình sau vòng lặp, hóa ra giá trị của nó không bao giờ thay đổi, tức là “a=25” sẽ được hiển thị (và không có gì khác).

Cũng lưu ý rằng biến đã được khai báo trước khi vòng lặp bắt đầu. Khi một biến được khai báo trong các tham số của vòng lặp, nó sẽ không thể truy cập được bên ngoài nó, nhưng trong trường hợp này cần phải có một thứ khác - để tìm ra giá trị nào mà bộ đếm sẽ có sau khi vòng lặp kết thúc.

Nhiệm vụ

    Viết chương trình hiển thị tất cả các số có bốn chữ số trong dãy 1000 1003 1006 1009 1012 1015….

    Viết chương trình hiển thị 55 phần tử đầu tiên của dãy 1 3 5 7 9 11 13 15 17 ….

    Viết chương trình hiển thị tất cả các phần tử không âm của dãy 90 85 80 75 70 65 60….

    Viết chương trình hiển thị 20 phần tử đầu tiên của dãy 2 4 8 16 32 64 128 ….

    Hiển thị tất cả các số hạng của dãy 2a n-1 -1, trong đó a 1 = 2, nhỏ hơn 10000.

    Hiển thị tất cả các số hạng có hai chữ số của dãy 2a n-1 +200, trong đó a 1 = -166.

    Viết chương trình tính giai thừa của số tự nhiên n mà người dùng nhập từ bàn phím.

    Hiển thị tất cả các ước dương của một số tự nhiên được người dùng nhập từ bàn phím.

    Kiểm tra xem số tự nhiên người dùng nhập từ bàn phím có phải là số nguyên tố hay không. Cố gắng không thực hiện các hành động không cần thiết (ví dụ: sau khi bạn đã tìm thấy ít nhất một ước số không tầm thường, rõ ràng số đó là hợp số và không cần phải tiếp tục kiểm tra). Cũng lưu ý rằng ước số nhỏ nhất của số tự nhiên n, nếu nó tồn tại, phải nằm trong phân số.

    Viết chương trình hiển thị 12 phần tử đầu tiên của dãy 2a n-2 -2, trong đó a 1 = 3 và a 2 = 2.

    Hiển thị 11 số hạng đầu tiên của dãy Fibonacci. Chúng tôi xin nhắc bạn rằng số hạng thứ nhất và thứ hai của dãy bằng nhau và mỗi số hạng tiếp theo là tổng của hai số hạng trước đó.

    Đối với một số tự nhiên được người dùng nhập từ bàn phím, hãy tính tổng của tất cả các chữ số của nó (không biết trước số đó sẽ có bao nhiêu chữ số).

    Tại thành phố N, việc di chuyển bằng xe điện được thực hiện bằng vé xé giấy. Hàng tuần, kho xe điện đặt mua một cuộn vé từ nhà in địa phương với các số từ 000001 đến 999999. Một tấm vé được coi là “may mắn” nếu tổng của ba chữ số đầu bằng tổng của ba chữ số cuối các chữ số, chẳng hạn như trong các vé có số 003102 hoặc 567576. Tổng kho xe điện đã quyết định tặng một món quà lưu niệm cho người chiến thắng mỗi chiếc vé may mắn và hiện đang tự hỏi sẽ cần bao nhiêu món quà lưu niệm. Dùng chương trình đếm xem một lần có bao nhiêu vé may mắn?

    Ở thành phố N có một nhà kho lớn chứa 50.000 kệ khác nhau. Để thuận tiện cho công nhân, ban quản lý kho quyết định đặt mua một tấm có số từ 00001 đến 50000 cho mỗi kệ từ một nhà in ở địa phương, nhưng khi in xong thì hóa ra máy in do trục trặc, không in số 2, vì vậy tất cả các tấm có số chứa một hoặc nhiều hai (ví dụ: 00002 hoặc 20202) - bạn cần gõ lại. Viết chương trình đếm xem có bao nhiêu tấm bị lỗi trong lô bị lỗi.

    Đồng hồ điện tử hiển thị thời gian theo định dạng từ 00:00 đến 23:59. Đếm xem có bao nhiêu lần mỗi ngày xảy ra sự kết hợp đối xứng được hiển thị ở bên trái dấu hai chấm và một ở bên phải dấu hai chấm (ví dụ: 02:20, 11:11 hoặc 15:51).

    Trong quân đội Mỹ, số 13 được coi là không may mắn, còn ở Nhật Bản - 4. Trước các cuộc tập trận quốc tế, bộ chỉ huy quân đội Nga đã quyết định loại trừ các số thiết bị quân sự có chứa số 4 hoặc 13 (ví dụ: 40123, 13313, 12345 hoặc 13040) để không gây nhầm lẫn cho đồng nghiệp nước ngoài. Nếu quân đội có 100 nghìn đơn vị thiết bị quân sự tùy ý sử dụng và mỗi phương tiện chiến đấu có một số từ 00001 đến 99999 thì sẽ phải loại ra bao nhiêu số?

2010, Alexey Nikolaevich Kostin. Khoa TIDM, Khoa Toán, Đại học Sư phạm quốc gia Moscow.