Рассмотрим 2 цикла: do-while и for.

Скачать исходники для статьи можно ниже

Цикл do-while

Цикл do-while всегда выполняет свое тело по крайней мере один раз, потому что его условное выражение размещается в конце цикла. Общая форма цикла:

do {
      // тело цикла
} while (condition);

Каждая итерация цикла do-while сначала выполняет тело цикла, а затем оценивает условное выражение. Если это выражение — true, цикл повторится. Иначе цикл заканчивается. Как и у всех Java-циклов, condition должно быть булевским выражением.
Ниже показана программы с “тиками”, которая демонстрирует цикл do-while.

// Демонстрирует do-while цикл.
public class DoWhile {
    public static void main(String[] args) {
        int n = 10;
        do {
           System.out.println("тик " + n);
           n - -;
        } while (n > 0);
    }
}

Вывод программы:
тик 10
тик 9
тик 8
тик 7
тик 6
тик 5
тик 4
тик 3
тик 2
тик 1

Цикл, for

Общая форма цикла for:

for (initialization; condition; iteration) statement;

Если повторяется только один оператор, фигурные скобки не нужны.
Цикл for работает следующим образом. В начале работы цикла выполняется выражение initialization. В общем случае это выражение устанавливает значение переменной управления циклом, которая действует как счетчик. Важно понять, что выражение инициализации выполняется только один раз. Затем оценивается condition. Оно должно быть булевским выражением и обычно сравнивает переменную управления циклом с некоторым граничным значением. Если это выражение — true, то отрабатывают операторы из тела цикла, если — false, цикл заканчивается. Далее выполняется часть цикла iteration. Обычно это выражение, которое осуществляет инкрементные или декрементные операции с переменной управления циклом. Затем цикл реализовывает итерации. В каждом проходе цикла — сначала оценивается условное выражение, потом выполняется тело цикла и затем — выражение iteration. Этот процесс повторяется до тех пор, пока управляющее выражение не станет false.

Ниже приводится программа вывода “тиков”, которая использует цикл for:

// Демонстрирует for-цикл.
 public class ForTick {
    public static void main(String[] args) {
        int n;
        for (n = 10; n > 0; n - -) {
            System.out.println("тик " + n);
        }
    }
}

Вывод программы:
тик 10
тик 9
тик 8
тик 7
тик 6
тик 5
тик 4
тик 3
тик 2
тик 1

Объявление переменных управления внутри цикла for.
Часто переменная, которая управляет циклом for, необходима только для целей цикла и не используется в другом месте. Когда дело обстоит так, можно объявить переменную внутри инициализационной части for. Например, предшествующая программа перекодирована так, чтобы переменная управления циклом n объявлялась типом int внутри заголовка for:

// Определение переменной управления циклом внутри for. 
public class ForTick {
    public static void main(String[] args) {
        // здесь n объявлена внутри заголовка for-цикла 
        for (int n = 10; n > 0; n - -) {
            System.out.println("тик " + n);
        }
    }
}

Когда переменная объявляется внутри заголовка for-цикла, важно помнить, что область ее действия заканчивается там же, где и у for-оператора (т. е. область действия переменной ограничена циклом for). Вне цикла for переменная прекратит существование. Если нужно использовать управляющую переменную цикла в другом месте программы, ее не следует объявлять внутри цикла for.
Когда управляющая переменная цикла не нужна где-то в другом месте, большинство Java-программистов объявляет ее внутри for-заголовка. Ниже показана небольшая программа, которая проверяет, является ли число простым (Простым называется число, которое делится только на собственное значение и на 1 (например, простыми являются числа 1, 2, 3, 5, 7, 11, 13 и т. д.). Обратите внимание, что управляющая переменная цикла i объявлена внутри for-заголовка, т. к. она нигде больше не нужна.

// Проверка на принадлежность к категории простых чисел.
public class FindPrim {
    public static void main(String[] args) {
        {
            int num;
            boolean isPrime = true;
            num = 14;
            for (int i = 2; i < num / 2; i++) {
                if ((num % i) == 0) {
                    isPrime = false;
                    break;
                }
            }
            if (isPrime) {
                System.out.println("Простое число");
            } else {
                System.out.println("Число не является простым");
            }
        }
    }
}

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

public class Sample {
    public static void main(String[] args) {
        int a, b;
        b = 4;
        for (a = 1; a < b; a++) {
            System.out.println("a = " + a);
            System.out.println("b = " + b);
            b - -;
        }
    }
}

He трудно заметить, что цикл зависит от взаимодействия двух переменных. Так как цикл управляется двумя переменными, было бы полезно включить их непосредственно в заголовок оператора for вместо того, чтобы обрабатывать переменную вручную. К счастью, в Java обеспечена такая возможность. Чтобы позволить двум или большему числу переменных управлять циклом for, Java разрешает вам включать множественные операторы как в инициализационную, так и в итерационную части for-заголовка. Каждый оператор отделяется от следующего запятой.
Используя запятую, предыдущий цикл for можно закодировать более эффективно:

// Использование запятой.
public class Comma {
    public static void main(String[] args) {
        int a, b;
        for (a = 1, b = 4; a < b; a++, b - -) {
            System.out.println("а = " + a);
            System.out.println("b = " + b);
        }
    }
}

В этом примере инициализационная часть устанавливает значения как для а, так и для b. Два разделенных запятыми оператора в итерационной части выполняются каждый раз, когда цикл повторяется. Программа генерирует следующий вывод:
а = 1
b = 4
а = 2
b = 3

Замечание. В Java запятая — это разделитель, который применяется только в цикле for.

Подобно всем другим языкам программирования Java допускает вложение циклов. То есть один цикл может быть внутри другого. Например, следующая программа вкладывает for-циклы:

// Циклы могут быть вложенными.
public class Nested {
    public static void main(String[] args) {
        int i, j;
        for (i = 0; i < 5; i++) {
            for (j = i; j < 5; j++) {
               System.out.print(".");
            }
            System.out.println();
        }
    }
}

Вывод этой программы:
…..
….
…
..
.

Приведем более внятный пример этой программы:

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

Вывод этой программы
i = 0,j = 0
i = 0,j = 1
i = 0,j = 2
i = 0,j = 3
i = 0,j = 4
i = 1,j = 1
i = 1,j = 2
i = 1,j = 3
i = 1,j = 4
i = 2,j = 2
i = 2,j = 3
i = 2,j = 4
i = 3,j = 3
i = 3,j = 4
i = 4,j = 4

В этом примере более наглядно видно, что на каждый вывод i, приходится 5 выводов j.