Телевизор 

Программы с циклами в java. Циклы Java: While и Do-While

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

Java: описание и примеры

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

while(условие) {

//тело цикла

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

Если в теле цикла заключен всего один оператор, то фигурные скобки можно не ставить, однако считается хорошим тоном, если они стоят всегда. На рисунке выше представлена блок-схема работы данного оператора.

Для наглядности давайте разберем пример, представленный на рисунке ниже:

Объявленная переменная count изначально имеет значение 1. Далее мы видим логическое выражение, заключенное в скобки после названия оператора. Оно будет истинным, т.е. возвращать значение true, до тех пор, пока значение переменной count будет меньше или равно 10. В теле цикла с каждым проходом (итерацией) значение переменной увеличивается на 1 и выводится на консольный экран. Обратите внимание на то, что когда значение переменной достигло 11, цикл прекратил работу.

Если бы значение переменной count изначально равнялось 11, то условие цикла было бы ложным, и программа даже не зашла бы в его тело.

Стоит отметить, что синтаксис Java позволяет использовать оператор while без тела. Приведем пример. Допустим, у нас есть две переменные i = 100 и j = 200, перед нами стоит задача программно вычислить их среднее арифметическое - для этого можно использовать «пустотелый» while:

while(++i < --j);

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

Цикл do-while

В предыдущих примерах если условное выражение изначально возвращало значение false, то выполнение программы проигнорировало бы тело цикла и пошло дальше. Однако часто возникают ситуации, в которых выполнение кода, содержащегося в теле цикла, обязательно хотя бы единожды независимо от истинности условного выражения. Иными словами бывает так, что проверять истинность условного выражения требуется не в начале, а в конце цикла. Такую функциональность может обеспечить разновидность цикла while под названием do-while. Он имеет следующую форму:

do {
//тело цикла

} while(условие);

Как мы видим, сначала на выполнение идет тело цикла, и лишь потом проверяется истинность условия - и так каждую итерацию.

Код, приведенный выше, отработает примерно так же, как в случае с обычным while. Однако если бы мы присвоили переменной count значение 11, тело цикла все равно выполнилось бы один раз, перед тем как оператор смог проверить истинность выражения.

Описание и примеры for - Java цикл

Представляет собой универсальную и эффективную языковую форму в Java. До пятой версии Java SDK была только одна традиционная форма оператора for, а после появилась новая - for each. В данном разделе мы ознакомимся с традиционной формой оператора. for Java цикл имеет следующий вид:

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

Для лучшего понимания приведем пример того, как работает for Java цикл:

Мы видим, что в качестве счетчика используется переменная loopVal. После каждой итерации цикла ее значение будет прирастать на 1, и это будет происходить до тех пор, пока оно не достигнет 11. Обратите внимание, что управляющую переменную можно объявлять и за пределами оператора for, но если вы не собираетесь использовать эту переменную нигде кроме как в цикле, рекомендуется объявлять ее непосредственно в операторе. Имейте в виду, что объявленная в самом операторе переменная имеет область видимости в пределах этого самого цикла.

Бывают ситуации, когда требуется объявить несколько управляющих циклом переменных. For Java цикл позволяет указывать две и более переменные через запятую, причем делать это как при их инициализации, так и при итерации. Такой оператор будет иметь следующий вид:

for(int i = 1, int j = 10; i < j; ++i, --j) {}

При каждой итерации значение переменной i будет увеличиваться на 1, а значение переменной j уменьшаться на 1. Итерации будут выполняться до тех пор, пока i не станет больше или равно j.

Особенности применения оператора for

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

boolean exit = false;

for (int i = 0; !exit; ++i) {

На примере выше мы можем наблюдать, как работа цикла абсолютно не зависит от управляющей переменной i и количество итераций зависит исключительно от того, в какой момент переменная exit примет значение true. Более того управляющую переменную можно и вовсе убрать из цикла и это никак не отразится на его работе: for(; !exit;) {}. Хотя это и не самый разумный способ программирования, иногда это может быть полезным. Главное - предусмотреть ситуацию, в которой переменная примет нужное для выхода из цикла значение, чтобы не превратить его в бесконечный.

For Java цикл может быть объявлен и таким способом: for(; ;) {}. Это типичный пример бесконечного цикла с особыми условиями прерывания. О том, каким же образом прерывать такого рода циклы, мы поговорим немного позже.

Цикл в стиле for each

Цикл foreach Java всегда применяется для последовательного перебора элементов массива или какой-либо и выполнения над ними определенных повторяющихся операций. Пример данной формы оператора for представлен ниже:

В качестве итерационной переменной объявляется name, а объявленный ранее массив строк names выступает вторым аргументом оператора. Переменная name будет поочередно принимать значения каждого элемента массива, пока все его элементы не будут извлечены. Следует отметить, что тип переменной должен быть совместимым с типом элементов, которые хранятся в массиве. Также переменная name доступна исключительно для чтения и попытка ее изменения не приведет к изменению самого элемента в массиве.

Операторы прерывания цикла

Существует три оператора прерывания цикла: break, return и continue. Первые два способны полностью прервать работу цикла, а continue прерывает лишь работу текущей итерации. Если вы используете в своем коде умышленно бесконечный цикл Java, данные операторы обязательно должны в нем присутствовать. Рассмотрим простой пример использования break:

Хотя в данном операторе for предусмотрено 11 итераций, выполнится только 8, поскольку, когда счетчик i будет равен 7, сработает условие, в теле которого имеется оператор break.

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

Использование break в качестве goto

Следует иметь в виду, что break прерывает работу только того цикла, в теле которого он непосредственно находится, т.е. если вы используете его во вложенном цикле, то внешний цикл не прекратит своей работы. Для этого оператор break можно использовать в качестве цивилизованной формы goto.

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

В коде объявлено три блока с именами меток One, Two и Three соответственно. Оператор break с меткой Two вложен во все три блока, но при его срабатывании программа выйдет из блоков Three и Two и продолжит выполнение в блоке One. Т.е. в консоли мы увидим два сообщения: Three и One.

Заключение

Мы ознакомились с понятием циклов в Java, главными операторами while и for, а также их формами do-while и for each соответственно. Для лучшего понимания рекомендуем проделать упражнения с применением данных операторов в различных формах, а также различных способов их прерывания и перехода из одного блока в другой.

Цикл for

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

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

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

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

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

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

// Демонстрация использования цикла for.
class ForTick {

int n;
for(n=10; n>0; 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 sum = 0;
// использование стиля for-each для отображения и суммирования значений
for(int х: nums) {

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 ;
// присвоение значений элементам массива nums
for (int i = 0; i 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 . Затем внутренний цикл 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" предоставляет преимущества, относятся вычисление среднего значения, отыскание минимального или максимального значения в наборе, поиск дубликатов и т.п.



Цикл — это многократно повторяющийся фрагмент программы.

В java существует два типа циклов: типа «пока» и типа «n-раз».

Первый тип «пока» предназначен для повторения какого-то действия до тех пор, пока выполняется некоторое условие. Пример: увеличивать число на 5 до тех пор, пока оно не станет трёхзначным.

Второй тип «n-раз» предназначен для повторения каких-то действий заранее известное количество раз. Пример: умножить число само на себя 4 раза.

Цикл типа «пока» (операторы while и do…while)

Оператор while повторяет указанные действия до тех пор, пока его параметр имеет истинное значение.

Например, такой цикл выполнится 4 раза, а на экран будет выведено «1 2 3 4 »:

Int i = 1; while (i < 5) { System.out.print(i + " "); i++; }

Такой цикл не выполнится ни разу и на экран ничего не выведется:

Int i = 1; while (i < 0) { System.out.print(i + " "); i++; }

Такой цикл будет выполняться бесконечно, а на экран выведется «1 2 3 4 5 6 7 …»:

Int i = 1; while (true) { System.out.print(i + " "); i++; }

Условие, определяющее будет ли цикл повторятся снова, проверяется перед каждым шагом цикла, в том числе перед самым первым. Говорят, что происходит предпроверка условия.

Бывает цикл типа «пока» с постпроверкой условия. Для его записи используется конструкция из операторов do…while.

Такой цикл выполнится 4 раза, а на экран будет выведено «2 3 4 5 »:

< 5);

Такой цикл выполнится 1 раз, а на экран будет выведено «2 »:

Int i = 1; do { i++; System.out.print(i + " "); } while (i < 0);

Тело цикла do…while выполняется по крайней мере один раз. Этот оператор удобно использовать, когда некоторое действие в программе нужно выполнить по крайней мере единожды, но при некоторых условиях придётся повторять его многократно.

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

Import java.util.Scanner; public class Main { public static void main(String args) { // prog - число созданное программой // user - число введённое пользователем int prog, user; // Генерируем случайное целое число от 1 до 10 prog = (int)(Math.random() * 10) + 1; System.out.println("Я загадала число от 1 до 10, отгадайте его."); System.out.print("Вводите ваше число: "); Scanner input = new Scanner(System.in); // Проверяем, есть ли в потоке ввода целое число if(input.hasNextInt()) { do { // Читаем с потока ввода целое число user = input.nextInt(); if(user == prog) { System.out.println("Вы угадали!"); } else { // Проверяем, входит ли число в отрезок 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("До свиданья!"); } }

Внесите в программу следующие доработки:

    Программа должна загадывать число не из отрезка , а целое число из отрезка от [−10;10], исключая ноль. При этом, постарайтесь, чтобы распределение случайных чисел генерируемых программой было равномерных (т. е. в случае выпадения нуля его нельзя просто заменить на какое-то другое число, например, на 1, ведь тогда 1 будет выпадать с вдвое большей вероятностью, чем остальные числа).

    Программа должна подсказывать пользователю, что он ошибся в знаке, если программа загадала положительное число, а пользователь ввёл отрицательное. И наоборот.

Цикл типа «n-раз» (оператор for)

Оператор for содержит три параметра. Первый называется инициализацией, второй — условием повторения, третий — итерацией.

For (инициализация; условие; итерация) { //тело цикла, т. е. действия повторяемые циклично }

В первом параметре обычно выбирают какую-то переменную, с помощью которой будет подсчитываться количество повторений цикла. Её называют счетчиком. Счётчику задают некоторое начальное значение (указывают, начиная с какого значения он будет изменяться).

Во втором параметре указывают некоторое ограничение на счётчик (указывают, до какого значения он будет изменяться).

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

Перед первым шагом цикла счётчику присваивается начальное значение (выполняется инициализация). Это происходит лишь однажды.

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

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

Представленная программа выводит на экран числа от 1 до 100:

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

Представленная программа выводит на экран числа от 10 до −10:

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

Представленная программа выводит на экран нечётные числа от 1 до 33:

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

Представленная программа вычислит сумму элемнтов фрагмента последовательности 2, 4, 6, 8,… 98, 100. Итак:

Int sum = 0; // Сюда будем накапливать результат for (int j = 2; j

Представленная программа будет возводить число из переменной a в натуральную степень из переменной n :

Double a = 2; int n = 10; double res = 1; // Сюда будем накапливать результат for (int i = 1; i <= n; i++) { res = res * a; } System.out.println(res);

Представленная программа выведет на экран 10 первых элементов последовательности 2n+2, где n=1, 2, 3…:

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

Представленная программа выведет на экран 10 первых элементов последовательности 2a n−1 +3, где a 1 =3:

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

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

Представленная программа выведет на экран 10 первых элементов последовательности 2a n−1 -2, где a 1 =3:

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

Представленная программа выведет на экран такую последовательность «0 -1 -4 -9 -16 -25»:

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

Досрочное завершение цикла (оператор break)

Как цикл типа «пока» так и цикл типа «n-раз» можно завершить досрочно, если внутри тела цикла вызвать оператор break . При этом произойдёт моментальный выход из цикла, не будет закончен даже текущий шаг (т. е. если после break присутствовали какие-то ещё операторы, то они не выполнятся).

В результате работы следующего примера на экран будут выведены только числа «1 2 3 4 Конец»:

For (int a=1; a

Когда программа будет выполнять цикл в пятый раз(войдёт в цикл с счётчиком равным 5), сразу же будет проверено и окажется истинным условие при котором выполнится оператор break. Оставшаяся часть тела цикла (вывод на экран) уже производится не будет: программа сразу перейдёт к выполнению операций указанных после цикла и далее.

C помощью оператор break можно прервать заведомо бесконечный цикл. Пример (на экран выведется «100 50 25 12 6 3 1 0 » и после этого цикл остановится):

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

Оператор break имеет смысл вызывать только при наступлении какого-то условия, иначе цикл будет завершен досрочно на первом же своём шаге.

Int a; for (a=25; a>0; a--) { break; System.out.print(a + " "); } System.out.print("a=" + a);

В представленном выше примере вывода в цикле на экран не произойдёт ни разу, а когда переменная a выведется на экран после цикла, то окажется, что её значение ни разу не менялось, т. е. выведено будет «a=25» (и ничего больше).

Обратите внимание также на то, что переменная была объявлена до начала цикла. Когда переменная объявляется в параметрах цикла, то она оказывается недоступной за его приделами, а в данном случае требовалось иное — узнать какое значение будет у счётчика после завершенияцикла.

Задачи

    Создайте программу, выводящую на экран все четырёхзначные числа последовательности 1000 1003 1006 1009 1012 1015 ….

    Создайте программу, выводящую на экран первые 55 элементов последовательности 1 3 5 7 9 11 13 15 17 ….

    Создайте программу, выводящую на экран все неотрицательные элементы последовательности 90 85 80 75 70 65 60 ….

    Создайте программу, выводящую на экран первые 20 элементов последовательности 2 4 8 16 32 64 128 ….

    Выведите на экран все члены последовательности 2a n-1 -1, где a 1 =2, которые меньше 10000.

    Выведите на экран все двузначные члены последовательности 2a n-1 +200, где a 1 = -166.

    Создайте программу, вычисляющую факториал натурального числа n, которое пользователь введёт с клавиатуры.

    Выведите на экран все положительные делители натурального числа, введённого пользователем с клавиатуры.

    Проверьте, является ли введённое пользователем с клавиатуры натуральное число — простым. Постарайтесь не выполнять лишних действий (например, после того, как вы нашли хотя бы один нетривиальный делитель уже ясно, что число составное и проверку продолжать не нужно). Также учтите, что наименьший делитель натурального числа n, если он вообще имеется, обязательно располагается в отрезке .

    Создайте программу, выводящую на экран 12 первых элементов последовательности 2a n-2 -2, где a 1 =3 и a 2 =2.

    Выведите на экран первые 11 членов последовательности Фибоначчи. Напоминаем, что первый и второй члены последовательности равны единицам, а каждый следующий — сумме двух предыдущих.

    Для введённого пользователем с клавиатуры натурального числа посчитайте сумму всех его цифр (заранее не известно сколько цифр будет в числе).

    В городе N проезд в трамвае осуществляется по бумажным отрывным билетам. Каждую неделю трамвайное депо заказывает в местной типографии рулон билетов с номерами от 000001 до 999999. «Счастливым» считается билетик у которого сумма первых трёх цифр номера равна сумме последних трёх цифр, как, например, в билетах с номерами 003102 или 567576. Трамвайное депо решило подарить сувенир обладателю каждого счастливого билета и теперь раздумывает, как много сувениров потребуется. С помощью программы подсчитайте сколько счастливых билетов в одном рулоне?

    В городе N есть большой склад на котором существует 50000 различных полок. Для удобства работников руководство склада решило заказать для каждой полки табличку с номером от 00001 до 50000 в местной типографии, но когда таблички напечатали, оказалось что печатный станок из-за неисправности не печатал цифру 2, поэтому все таблички, в номерах которых содержалась одна или более двойка (например, 00002 или 20202) — надо перепечатывать. Напишите программу, которая подсчитает сколько всего таких ошибочных табличек оказалось в бракованной партии.

    Электронные часы показывают время в формате от 00:00 до 23:59. Подсчитать сколько раз за сутки случается так, что слева от двоеточия показывается симметричная комбинация для той, что справа от двоеточия (например, 02:20, 11:11 или 15:51).

    В американской армии считается несчастливым число 13, а в японской — 4. Перед международными учениями штаб российской армии решил исключить номера боевой техники, содержащие числа 4 или 13 (например, 40123, 13313, 12345 или 13040), чтобы не смущать иностранных коллег. Если в распоряжении армии имеется 100 тыс. единиц боевой техники и каждая боевая машина имеет номер от 00001 до 99999, то сколько всего номеров придётся исключить?

2010, Алексей Николаевич Костин. Кафедра ТИДМ математического факультета МПГУ.

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

Цикл – это последовательное выполнение повторяющихся действий на основе заданного предусловия. Например, нужно переставить сто ящиков из одного угла в другой. Если это каким-то образом записать на языке Java (к сожалению, переставить за вас ящики Java не сможет), то получится запись в сто строк:

1. взять ящик №1 и поставить в другой угол;
2. взять ящик №2 и поставить в другой угол;
3. взять ящик №3 и поставить в другой угол;
…
100. взять ящик №100 и поставить в другой угол;

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

Существует три оператора представляющих циклы в языке Java – это while, do/white и for. Каждый из операторов необходим в своей ситуации, но все же чаще всего используется оператор for. Рассмотрим по порядку каждый из операторов.

Оператор while

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

While(условие) { // действия }

Так же имеет место выполнение определенного предусловия, но в отличие от оператора if/else, данная конструкция построена на циклах проверки условия. Когда программа доходит до оператора while, если предложенное условие истинно, происходит выполнение всех действий в блоке из фигурных скобок {…}. После выполнения этих действий, программа снова делает очередную проверку условия после оператора while и если условие опять истинно, происходит повторное выполнение действий в блоке. Действия в блоке выполняются до тех пор, пока условие не станет ложным и только тогда происходит выход из цикла while.
Для выхода из циклов чаще всего используются так называемые счетчики. Рассмотрим не большой пример:

Int i = 0; while (i < 10) { // действия i++; }

Сначала переменной i присваивается значение 0, далее происходит проверка условия i0)

{ // действия i--; }

Те же действия, но уже в обратную сторону. Дополнительно в цикле while (да и вовсе других циклах) имеется возможность использования булевых переменных, содержащих значения false или true. В этом случае происходит проверка определенного предусловия.

Boolean i = true; while (i) { // действия }

Переменная i истинна, ей присвоено значение true, поэтому происходит выполнение цикла while, до тех пор пока переменной i не будет присвоено значение false. Поэтому необходимо позаботиться о выходе из такого цикла, иначе цикл while будет выполняться бесконечно и такие циклы носят названия бесконечных циклов.

Напоследок хочу еще обратить ваше внимание на оператор равно ==. Если записать цикл таким образом:

Int i = 0 while (i == 5) { // действия i++; }

То получится вполне работоспособный цикл, а вот если вы ошибетесь или по привычке воспользуетесь классическим вариантом оператора равно =, использующимся в математике, то у вас будет проблема в виде бесконечного цикла.

Int i = 0 while (i = 5) { // действия i++; }

В предусловии происходит присвоение переменной i значения 5, а это действие не запрещено и что мы имеем в итоге? Начнется выполнение этого блока цикла в конце которого значение i увеличится на один, но в предусловии после оператора while, переменной i новь будет присвоено значение пять и цикл продолжит свою работу до бесконечности. Это пример простого бесконечного цикла и как следствие, классическая ошибка, случающаяся очень часто с начинающими программистами.

Цикл do/while

Только что рассмотренный нами цикл while, при определенных условиях может и не заработать. Например, если условие будет изначально ложно, то цикл не выполнится ни разу. Программа, дойдя до строки кода с оператором while, проверит условие и если оно будет равно false, проигнорирует весь цикл и перейдет к коду, следующему сразу за циклом while. Но иногда возникает необходимость в выполнении цикла по крайней мере один раз. Для этих целей в Java существует цикл do/while. Запись и создание цикла do/while осуществляется следующим образом:

Do { // действия }while (условие)

Между операторами do и while существует тело цикла, которое будет выполняться до тех пор, пока постусловие, следующее за оператором while, не будет ложно. Тело цикла выполнится, по меньшей мере, один раз, после чего будет произведена проверка условия. Цикл do/while используется не часто, но порой оказывается незаменим.

Цикл for

Это самый распространенный цикл в программировании. Работа цикла for основан на управлении счетчиком. Смысл работы этого цикла схож с рассмотренными выше циклами while и do/while. Посмотрите как выглядит синтаксическая запись цикла for:

For (int i = 0; i < 10; i++) { // действие }

После ключевого слова for, следует условие выполнения цикла. Само же условие объединяет в себе три этапа. Сначала следует инициализация счетчика i = 0, затем проверка условия i < 10 и в конце увеличение переменной i на единицу.

Работает цикл for следующим образом. Когда программа доходит до цикла, то происходит инициализация счетчика i = 0 и проверяется условие i < 10. Далее программа переходит в тело цикла. По окончанию всех действий в цикле for, происходит обращение к третьему этапу цикла: i++, увеличивая счетчик на единицу. После чего сразу же происходит переход ко второму этапу – проверке переменной i < 10 и повторный выход в тело цикла. Весь цикл продолжается до тех пор, пока условие i < 10 не станет ложным. Цикл for используется постоянно при инициализации массива данных, где без него очень сложно, а порой и не возможно обойтись. Так же как и в цикле while возможно использование оператора декремента, например.

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

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

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

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

Поскольку большинство циклов применяют свои переменные только внутри цикла, цикл for допускает, чтобы выражение инициализации было полным объявлением переменной. Таким образом, переменная ограничена телом цикла и невидима извне .

Приведем пару примеров поясняющих все вышесказанное:

В этом примере переменная i объявлена вне цикла (строка 7), поэтому она так же доступна после его завершения (строка 12).

Из вывода выполнения данной программы видно, что выражение повторения цикла, а именно префиксный инкремент (++i ) переменной i выполняется после выполнения тела цикла, то есть после выполнения строки 10, которая выводит приветствие.

Этот момент очень важно понимать, чтобы иметь правильное представление о работе цикла for .

Теперь посмотрим на вывод этой программы с аргументами командной строки и без них:

Как видно из вывода данной программы приращение переменной i происходит после выполнения последней команды цикла, которая выводит приветствие (строка 10).

А теперь объявим переменную внутри цикла (оператора for):

Как видно Eclipse нам сразу же указал на ошибку, что переменная j , объявленная в строке 15, не видна вне цикла, так как ее область действия или область видимости распространяется только на тело цикла, в котором она была объявлена.

Чтобы программа заработала необходимо закомментировать строку 19.

Вывод этого кода, аналогичен выводу, кода который мы только что рассмотрели, за исключением того, что вместо “Привет” выводится “Hello”. Ну и то что после цикла не возможно вывести значение переменной j .

При объявлении переменной внутри цикла for необходимо помнить о следующем важном обстоятельстве: область и время существования этой переменной полностью совпадают с областью и временем существования оператора for .

Синтаксис цикла for не ограничивается циклами с единственной переменной. Как в выражении инициализации , так и в выражении повторения можно использовать запятую для разделения нескольких выражений инициализации и повторения .

Например:

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

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

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

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

По существу эта программа делает то же приветствие аргументов, если они есть. Если их нет, то ни чего не выводит. Сразу же приведу пример ее вывода:

Как видно из вывода этой программы, итерационная часть выполняется, как уже и говорилось, после выполнения тела цикла. В данном случае это оператор println в строке 9. Оператор for в данном коде растянулся на две строки 9 и 10, поскольку он достаточно длинный. Я это сделал для демонстрации того, что каждая часть оператора for может быть применена в разных целях. Стоит еще заметить, что приращение переменной i происходит в строке 12 и там же задается условие для продолжения или выхода из цикла, которое проверяется в строке 9.

Еще один подобный пример, цикл for можно задействовать для прохождения по элементам связного списка:

Стоит, так же, отметить, что любую из частей цикла for (инициализацию , условие и итерационную ) или даже все можно пропустить . Например, можно создать таким образом бесконечный цикл:

( ;; ){
//бесконечный цикл
}

Инициализационное или итерационное выражения либо они оба могут отсутствовать:

В этом примере инициализационное и итерационное выражения вынесены за пределы определения оператора for . В результате соответствующие части оператора for пусты.

Чтобы последовательность выполнения частей оператора for стала более наглядный я приведу небольшой пример. Хотя методы мы еще не изучали, но я надеюсь идея этой программы будет вам понята. Смысл ее в том, чтобы наглядно показать последовательность выполнения всех частей оператора for.

Из вывода программы видно, что инициализационная часть программы (метод initTest() ) выполняется только один раз.

Затем выполняется проверка условия , представленная методом condTest() .

После проверки условия , выполняется тело цикла.

И уже после этого выполняется часть повторение , представленная методом recTest() .

В методе condTest() выполняется проверка условия продолжения цикла. В данном случае переменная i сравнивается c 4, и пока переменная i меньше 4, то тело цикла выполняется.

Тело цикла выполняется четыре раза так как переменная i была по умолчанию проинициализирована нулем.

Оператор foreach

Начиная с версии JDK 5 в Java можно использовать вторую форму цикла for, реализующую цикл в стиле foreach (“для каждого”). Цикл в стиле foreach предназначен для строго последовательного выполнения повторяющихся действий по отношению к коллекциям объектов, например, таких как массивы. В Java возможность применения цикла foreach реализована за счет усовершенствования цикла for . Общая форма версии foreach цикла for имеет следующий вид:

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

Тип это тип переменной, итерационная переменная — имя итерационной переменной, которая последовательно будет принимать значения из коллекции , от первого до последнего. Элемент коллекция указывает коллекцию, по которой должен выполняться цикл. С циклом for можно применять различные типы коллекций, но пока мы будем использовать только массивы, кстати которые тоже пока не проходили, но по крайней мере уже было много примеров с приветствиями из массива строк, куда попадают аргументы командной строки.

На заметку: оператор foreach применим к массивам и классам, реализующим интерфейс java.lang.Iterable.

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

Хотя повторение цикла for в стиле foreach выполняется до тех пор, пока не будут обработаны все элементы массива (коллекции), цикл можно прервать и раньше, используя оператор break .

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

Чтобы понять побудительные причины применения циклов в стиле foreach , рассмотрим тип цикла for , для замены которого предназначен этот стиль.

Возьмем опять наш пример с приветствием аргументов из командной строки:

Не правда ли, это куда элегантней, чем применение других операторов цикла, для этой цели?

Собственно у этой программы простой вывод:

Мы его уже много раз видели в разных вариантах, но повторенье – мать ученья.

Для полной ясности рассмотрим еще несколько примеров.

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

Вывод этой части программы такой:

Хотя повторение цикла for в стиле foreach выполняется до тех пор, пока не будут обработаны все элементы массива, цикл можно прервать и раньше, используя оператор break . Например:

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

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

Данный код выведет следующее:

Любой метод, возвращающий массив, может использоваться с foreach . Например класс String содержит метод toCharArray, возвращающий массив char. Пример:

Данный код просто выведет посимвольно строку Привет Мир!

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

На последок, приведу еще пару примеров продвинутого оператора for . По большому счету, это просто отрефактореный код того примера что я уже приводил.

Не правда ли, что этот код стал более читаем и понятен, чем тот, что я уже приводил? Или же не понятно? Ну тогда смотрим на другой пример кода, который делает тоже самое.

Неужели опять не понятно?

Оба этих кода делают одинаковый вывод:

Конечно при условии что аргументами в командной строке были Вася и Петя.

На этом с оператором for и его тенью foreach закончим.