Цикл for

Начиная с версии JDK 5, в Java существуют две формы цикла for. Первая — традиционная форма, используемая начиная с исходной версии Java. Вторая — новая форма "for-each". Мы рассмотрим оба типа цикла for, начиная с традиционной формы.

Общая форма традиционного оператора for выглядит следующим образом:

for(инициализация; условие; повторение)
{ // тело
}

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

Цикл for действует следующим образом. При первом запуске цикла программа выполняет инщиализационную часть цикла. В общем случае это выражение, устанавливающее значение управляющей переменной цикла, которая действует в качестве счетчика, управляющего циклом. Важно понимать, что выражение инициализации выполняется только один раз. Затем программа вычисляет условие, которое должно быть булевским выражением. Как правило, выражение сравнивает значение управляющей переменной с целевым значением. Если это значение истинно, программа выполняет тело цикла. Если оно ложно, выполнение цикла прерывается. Затем программа выполняет часть повторение цикла. Обычно это выражение, которое увеличивает или уменьшает значение управляющей переменной. Затем программа повторяет цикл, при каждом прохождении вначале вычисляя условное выражение, затем выполняя тело цикла и выполняя выражение повторения. Процесс повторяется до тех пор, пока значение выражения повторения не станет ложным.

Ниже приведена версия программы подсчета "тактов", в которой использован цикл for.

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

Объявление управляющих переменных цикла внутри цикла for

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

// Объявление управляющей переменной цикла внутри цикла for.
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. В качестве примера приведем простую программу, которая проверяет, является ли введенное число простым. Обратите внимание, что управляющая переменная цикла i объявлена внутри цикла for, поскольку она нигде больше не требуется.

Разновидности цикла for

Цикл for поддерживает несколько разновидностей, которые увеличивают его возможности и повышают применимость. Гибкость этого цикла обусловлена тем, что его три части: инициализацию, проверку условий и итерационную не обязательно использовать только по прямому назначению. Фактически каждый из разделов оператора for можно применять в любых целях. Рассмотрим несколько примеров.

Одна из наиболее часто встречающихся вариаций предполагает использование условного выражения. В частности, это выражение не обязательно должно выполнять сравнение управляющей переменной цикла с каким-либо целевым значением. Фактически условием, управляющим циклом for, может быть любое булевское выражение. Например, рассмотрим следующий фрагмент:

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

В этом примере выполнение цикла for продолжается до тех пор, пока значение переменной done не будет установлено равным true. В этом цикле проверка значения управляющей переменной цикла i не выполняется.

Приведем еще одну разновидность цикла for. Оставляя все три части оператора пустыми, можно умышленно создать бесконечный цикл (цикл, который никогда не завершается). Например:

for( ; ; ) {
// ...
}

Этот цикл может выполняться бесконечно, поскольку условие, по которому он был бы прерван, отсутствует. Хотя некоторые программы, такие как командные процессоры операционной системы, требуют наличия бесконечного цикла, большинство "бесконечных циклов" в действительности представляют собой всего лишь циклы с особыми условиями прерывания. Как вы вскоре убедитесь, существует способ прерывания цикла — даже бесконечного, подобного приведенному примеру — который не требует использования обычного условного выражения цикла.

Версия "for-each" цикла for

Начиная с версии JDK 5 в Java можно использовать вторую форму цикла for, реализующую цикл в стиле "for-each" ("для каждого"). Как вам, возможно, известно, в современной теории языков программирования все большее применение находит концепция циклов "for-each", которые быстро становится стандартными функциональными возможностями во многих языках. Цикл в стиле "for-each" предназначен для строго последовательного выполнения повторяющихся действий по отношению к коллекции объектов, такой как массив. В отличие некоторых языков, подобных С#, в котором для реализации циклов "for-each" используют ключевое слово f oreach, в Java возможность применения цикла "for-each" реализована за счет усовершенствования цикла for. Преимущество этого подхода состоит в том, что для его реализации не требуется дополнительное ключевое слово, и никакой ранее существовавший код не разрушается. Цикл for в стиле "for-each" называют также усовершенствованным циклом for. Общая форма версии "for-each" цикла for имеет следующий вид:

for (тип итер-пер : коллекция)
блок-операторов

Здесь тип указывает тип, а итер-пер — имя итерационной переменной, которая последовательно будет принимать значения из коллекции, от первого до последнего. Элемент коллекция указывает коллекцию, по которой должен выполняться цикл. С циклом for можно применять различные типы коллекций, но в этой главе мы будем использовать только массивы. (Другие типы коллекций, которые можно применять с циклом for, вроде определенных в каркасе коллекций Collection Framework, рассматриваются в последующих главах книги.) На каждой итерации цикла программа извлекает следующий элемент коллекции и сохраняет его в переменной итер-пер. Цикл выполняется до тех пор, пока не будут получены все элементы коллекции.

Поскольку итерационная переменная получает значения из коллекции, тип должен совпадать (или быть совместимым) с типом элементов, хранящихся в коллекции. Таким образом, при выполнении цикла по массивам тип должен быть совместим с базовым типом массива.

Цикл for в стиле "for-each" позволяет автоматизировать этот процесс. В частности, применение такого цикла позволяет не устанавливать значение счетчика цикла за счет указания его начального и конечного значений, и исключает необходимость индексации массива вручную. Вместо этого программа автоматически выполняет цикл по всему массиву, последовательно получая значения каждого из его элементов, от первого до последнего. Например, с учетом версии "for-each" цикла for предыдущий фрагмент можно переписать следующим образом:

int nums[] = { 1, 2, 3, 4, 5, б, 7, 8, 9, 10 };
int sum = 0;
for(int x: nums) sum += x;

При каждом прохождении цикла переменной х автоматически присваивается значение, равное значению следующего элемента массива nums. Таким образом, на первой итерации х содержит 1, на второй — 2 и т.д. При этом не только упрощается синтаксис программы, но и исключается возможность ошибок выхода за пределы массива.

Ниже показан пример полной программы, иллюстрирующей применение описанной версии "for-each" цикла for.

// Использование цикла for в стиле for-each.
class ForEach {
public static void main(String args[]) {
int nums[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int sum = 0;
// использование стиля for-each для отображения и суммирования значений
for(int х : nums) {
System.out.println("Значение равно: " + x) ;
sum += x;
}
System.out.println ("Сумма равна: " + sum) ;
}
}

Эта программа генерирует следующий вывод:

Значение равно: 1
Значение равно: 2
Значение равно: 3
Значение равно: 4
Значение равно: 5
Значение равно: 6
Значение равно: 7
Значение равно: 8
Значение равно: 9
Значение равно: 10
Сумма равна: 55

Как видно из этого вывода, оператор for в стиле "for-each" автоматически выполняет цикл по элементам массива, от наименьшего индекса к наибольшему.

Хотя повторение цикла for в стиле "for-each" выполняется до тех пор, пока не будут обработаны все элементы массива, цикл можно прервать и раньше, используя оператор break. Например, следующая программа суммирует значения пяти первых элементов массива nums.

// Использование оператора break в цикле for в стиле for-each.
class ForEach2 {
public static void main(String args[]) {
int sum = 0;
int nums[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
// использование цикла for для отображения и суммирования значений
for(int х : nums) {
System.out.println("Значение равно: " + x) ;
sum += x; v if (x == 5) break; // прекращение цикла после получения 5 значений
}
System.out.println("Сумма пяти первых элементов равна: " + sum);
}
}

Программа генерирует следующий вывод:

Значение равно: 1
Значение равно: 2
Значение равно: 3
Значение равно: 4
Значение равно: 5
Сумма пяти первых элементов равна: 15

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

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

// Переменная цикла for-each доступна только для чтения.
class NoChange {
public static void main(String args[]) {
int nums[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
for(int х : nums) {
System.out.print (х + " ");
x=x*10; // этот оператор не оказывает никакого влияния на массив nums
}
System.out.println();
for(int x : nums)
System.out.print (x + " ");
System.out.println ();
}
}

Первый цикл for увеличивает значение итерационной переменной на 10. Однако эта операция присваивания не оказывает никакого влияния на исходный массив nums, как видно из результата выполнения второго оператора for. Генерируемый программой вывод подтверждает сказанное:

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

Итерация в многомерных массивах

Усовершенствованная версия цикла for применима также и к многомерным массивам. Однако следует помнить, что в Java многомерные массивы состоят из массивов массивов. (Например, двумерный массив — это массив одномерных массивов.) Это важно при выполнении итерации в многомерном массиве, поскольку результат каждой итерации — следующий массив, а не отдельный элемент. Более того, тип итерационной переменной цикла for должен быть совместим с типом получаемого массива. Например, в случае двумерного массива итерационная переменная должна быть ссылкой на одномерный массив. В общем случае при использовании цикла "for-each" для выполнения итерации в массиве размерности N получаемые объекты будут массивами размерности N-1. Дабы понять, что из этого следует, рассмотрим следующую программу. В ней вложенные циклы for служат для получения упорядоченных по строкам элементов двумерного массива.

// Использование цикла for в стиле for-each применительно к двумерному массиву.
class ForEach3 {
public static void main(String args[]) {
int sum = 0;
int nums[] [] = new int [3] [5] ;
// присвоение значений элементам массива nums
for (int i = 0; i < 3; i++) for(int j=0; j < 5; j++)
nums[i] [j] = (i+l)*(j+l) ; // использование цикла for в стиле for-each для отображения
// и суммирования значений
for (int х[] : nums) {
for(int у : х) {
System.out.println("Значение равно: " + у);
sum += у;
}
}
System.out.println("Сумма: " + sum);
}

Эта программа генерирует следующий вывод:

Значение равно: 1
Значение равно: 2
Значение равно: 3
Значение равно: 4
Значение равно: 5
Значение равно: 2
Значение равно: 4
Значение равно: 6
Значение равно: 8
Значение равно: 10
Значение равно: 3
Значение равно: 6
Значение равно: 9
Значение равно: 12
Значение равно: 15
Сумма: 9 0

Следующая строка этой программы заслуживает особого внимания:

for (int х[] : nums) {

Обратите внимание на способ объявления переменной х. Эта переменная — ссылка на одномерный массив целочисленных значений. Это необходимо потому, что результат выполнения каждой итерации цикла for — следующий массив в массиве nums, начиная с массива, указанного элементом nums [0]. Затем внутренний цикл for выполняет итерацию по каждому из этих массивов, отображая значения каждого из элементов.

Использование усовершенствованного цикла for

Поскольку каждый оператор for в стиле "for-each" может выполнять цикл по элементам массива только последовательно, начиная с первого и заканчивая последним, может показаться, что его применение ограничено. Однако это не так. Множество алгоритмов требуют использования именно этого механизма. Одним из наиболее часто используемых алгоритмов является поиск. Например, следующая программа использует цикл for для поиска значения в неупорядоченном массиве. Поиск прекращается после обнаружения искомого значения.

// Поиск в массиве с применением цикла for в стиле for-each.
class Search {
public static void main(String args[]) {
int nums[] = { 6, 8, 3, 7, 5, 6, 1, 4 };
int val =5;
boolean found = false;
// использование цикла for в стиле for-each
for (int x : nums) {
if (x == val) {
found = true;
break;
}
}
if(found)
System.out.println("Значение найдено!");}

В данном случае выбор стиля "for-each" для цикла for полностью оправдан, поскольку поиск в неупорядоченном массиве предполагает последовательный просмотр каждого из элементов. (Конечно, если бы массив был упорядоченным, можно было бы использовать бинарный поиск, реализация которого требовала бы применения другого стиля цикла.) К другим типам приложений, которым применение циклов в стиле "for-each" предоставляет преимущества, относятся вычисление среднего значения, отыскание минимального или максимального значения в наборе, поиск дубликатов и т.п.




Rambler's Top100