Основные конструкции языка
Установка пакетов и первый запуск программы
Структура программы, переменные, константы, оператор присваивания
Консольный ввод/вывод, импорт пакетов
Арифметические операции
Условные операторы if и switch
Операторы циклов while, for, do while
Обучающие курсы
Python Python ООП Структуры данных Django C/C++
Телеграм-каналы
Канал selfedu_rus Python Django Машинное обучение Java и С++
Наш канал

Главная
Основы Java
Основные конструкции языка

Операторы циклов while, for, do while

Ни одна, сколь-нибудь серьезная программа не обходится без циклов. Что это такое? Представьте, что вам необходимо вычислить вот такую сумму:

Писать тысячу слагаемых не очень то приятное занятие. А что если их будет 10 000? В таких задачах без циклов не обойтись. Представим эту задачу в виде блок-схемы.

Видите, вот эта часть алгоритма постоянно повторяется, пока n<=1000 и в цикле происходит суммирование слагаемых 1/n. Сначала это будет 1/1, потом 1/2, затем, 1/3 и так далее до 1/1000. Когда n=1001 условие цикла становится ложным и программа завершается.

Оператор цикла while

По сути на этой блок-схеме приведена работа оператора цикла языка Java while, который имеет следующий синтаксис:

while(<условие цикла>) {
[тело цикла]
}

Здесь тело цикла – это набор операторов или функций, которые выполняются внутри цикла. Давайте запишем нашу задачу вычисления суммы на языке Java.

double S = 0;
int n = 1;
 
while (n <= 1000) {
    S += 1.0 / n;
    n++;
}
 
System.out.println(S);

Смотрите, здесь мы задаем вещественную переменную S (так как сумма будет содержать дробные значения) и сразу присваиваем ей 0 – начальное значение суммы. Далее, задаем целочисленную переменную n (так как это счетчик и он будет содержать целые значения) и присваиваем ему начальное значение 1. Затем, идет оператор цикла while, то есть, все что стоит внутри его фигурных скобок будет повторяться до тех пор, пока n<=1000, то есть, пока истинно условие. Внутри цикла while мы прибавляем слагаемые к сумме S и увеличиваем счетчик n на 1 на каждой итерации цикла. Когда n становится равным 1001, цикл завершается и на экран выводится значение суммы S. Вот так работает цикл while.

А теперь давайте рассмотрим такой пример. Будем вычислять сумму S введенных с клавиатуры чисел, пока S < 100 или пока пользователь не введет число 0. Такая программа выглядит так:

double S = 0;
int n = 1;
 
Scanner in = new Scanner(System.in);
 
while (S < 100 && n != 0) {
    System.out.print("Введите целое число: ");
    n = in.nextInt();
 
    S += n;
}
 
System.out.println(S);
in.close();

Обратите внимание на условие цикла while – оно составное и будет истинно, пока S<100 и n !=0, то есть, если хотя бы одно из этих условие окажется ложным, то будет ложно все условие и цикл завершит свою работу. Посмотрим как это работает.

То есть, в условии циклов можно писать все те же самые условия, что и в условном операторе if, о котором мы говорили на предыдущем занятии.

И последний пример с циклом while. Напишем программу, которая будет вычислять сумму пока . Эту программу можно записать в краткой форме вот так:

int S = 0;
int i = 1;
 
while ((S += ++i) < 50);
 
System.out.println(S);

Смотрите, здесь подсчет суммы записан сразу в операторе while вместе с проверкой меньше 50, а тело цикла вовсе отсутствует, стоит точка с запятой. Такие конструкции тоже можно делать, используя операторы циклов. Запустим эту программу и посмотрим на результат ее работы.

Оператор цикла for

Наверное, самый часто используемый оператор цикла – это оператор for. Он имеет следующий синтаксис:

for(<инициализация счетчика>;<условие>;<изменение значения счетчика>)
{
[тело цикла]
}

Давайте перепишем пример с подсчетом суммы ряда

используя оператор цикла for.

double S = 0;
for (int n = 1; n <= 1000; ++n) S += 1.0 / n;
 
System.out.println(S);

Смотрите, здесь весь цикл записан буквально в одну строчку, а тело цикла состоит из одного оператора подсчета суммы (именно поэтому здесь не стоят фигурные скобки – для одного оператора они необязательны). Такая запись гораздо короче и нагляднее, поэтому цикл for и является самым популярным.

Цикл for можно задавать и с вещественными счетчиками. Предположим, нам нужно вывести значения линейной функции на экран монитора при значениях , а параметры k, b пользователь вводит с клавиатуры. Такая программа будет выглядеть так:

double f, k, b;
 
Scanner in = new Scanner(System.in);
System.out.print("Введите k и b: ");
k = in.nextDouble();
b = in.nextDouble();
 
for (double x = 0; x <= 1; x += 0.1) {
    f = k * x + b;
    System.out.print(f+" ");
}
 
in.close();

Здесь уже в теле цикла стоят два оператора, поэтому используются фигурные скобки.

И последнее. Заметим, что оператор цикла for можно записать и в таком виде:

double x = 0;
for (; x <= 1; x += 0.1) {
    f = k * x + b;
    System.out.print(f+" ");
}

или так:

double x = 0;
for (; x <= 1; ) {
    f = k * x + b;
    System.out.print(f+" ");
    x += 0.1;
}

или, даже так:

double x = 0;
for (; ; ) {
    if (x > 1) break;
    f = k * x + b;
    System.out.print(f+" ");
    x += 0.1;
}

Обратите внимание, здесь внутри цикла стоит проверка условия x>1 и когда оно будет истинно, то выполнится оператор break, прерывающий работу цикла. Забегая вперед скажу, что оператор break прерывает работу всех циклов языка Java. Если бы этого условия не было бы, то цикл for работал бы, как говорится, «вечно».

Оператор цикла do while

Последний оператор цикла, который мы рассмотрим – это цикл do while. Он имеет следующий синтаксис:

do {
[тело цикла]
}
while(<условие цикла>);

Отличие этого цикла от двух предыдущих в том, что он сначала выполняет тело цикла, и только потом проверяет условие цикла. Когда используется такая реализация? Например, мы вводим с клавиатуры некий код и будем продолжать выполнение программы только после того, как пользователь введет верный код. Своего рода проверка пароля. Запишем эту программу.

final int secret_code = 13;
int code_ent;
 
Scanner in = new Scanner(System.in);
 
do {
    System.out.print("Введите секретный код : ");
    code_ent = in.nextInt();
} while (code_ent != secret_code);
 
 
System.out.println("Вы ввели верный код!");
in.close();

Здесь вначале задается константа в виде целочисленной переменной со значением 13. Это тот код, который и должен ввести пользователь. Затем, выполняется тело цикла, в котором пользователю предлагается ввести код. Если введенный код не будет равен заданному, то условие цикла do while будет истинным и он продолжится, то есть, пользователю будет предложено снова ввести код. Это будет продолжаться до тех пор, пока пользователь не введет число 13. Тогда условие цикла окажется ложным и программа перейдет к следующему оператору. Вот так работает этот цикл.

Вложенные циклы

Итак, мы с вами рассмотрели три цикла:

while, for и do .. while

Все эти циклы можно комбинировать друг с другом, создавая вложенные циклы. Например, нам необходимо вычислить сумму вот такого ряда:

Вычислим ее, используя два оператора for:

int N = 5, M = 7, S=0;
 
for (int i = 0; i < N; ++i)
    for (int j = 0; j < M; ++j)
        S += i * j;
 
System.out.println(S);

Обратите внимание, здесь внутри первого оператора цикла for находится второй такой же оператор цикла. Наглядно работу такого вложенного цикла можно представить следующим образом.

Здесь счетчики i, j пробегают все вот эти значения, указанные в клетках. По программе вычисляется их произведение и сумма. Вот так можно интерпретировать вложенный цикл. Соответственно, если мы вложим еще один цикл, то получим куб, ну а дальше, четырехмерную фигуру, пятимерную и так далее.

Операторы break и continue

В заключение этого занятия рассмотрим два оператора break и continue, с помощью которых можно управлять работой циклов.

О первом операторе break мы уже упоминали. Он позволяет прервать выполнение цикла и передать управление следующему оператору или функции в программе.

Второй оператор continue пропускает тело цикла, стоящее после него и цикл переходит к следующей итерации. Продемонстрируем его работу на примере вычисления суммы пяти положительных чисел, которые пользователь вводит с клавиатуры.

float x, S=0;
int n = 0;
 
Scanner in = new Scanner(System.in);
 
do {
    System.out.print("Введите число: ");
    x = in.nextFloat();
 
    if (x < 0) continue;
 
    n++;
    S += x;
    System.out.println("Текущая сумма: " + S);
} while (n < 5);

Смотрите, когда пользователь вводит с клавиатуры отрицательное число, то срабатывает оператор continue и все последующие строчки в теле цикла пропускаются. В результате это отрицательное число не участвует в сумме и счетчик положительных чисел n остается неизменным. Если же вводится неотрицательное число, то счетчик увеличивается на 1, а число прибавляется к сумме. Кроме того, на экран выводится значение текущей суммы. Вот так работает оператор continue.