Android java выход из цикла. Циклы. Использование breakв качестве goto
Последнее обновление: 31.10.2018
Еще одним видом управляющих конструкций являются циклы. Циклы позволяют в зависимости от определенных условий выполнять определенное действие множество раз. В языке Java есть следующие виды циклов:
Цикл for
Цикл for имеет следующее формальное определение:
For ([инициализация счетчика]; [условие]; [изменение счетчика]) { // действия }
Рассмотрим стандартный цикл for:
For (int i = 1; i < 9; i++){ System.out.printf("Квадрат числа %d равен %d \n", i, i * i); }
Первая часть объявления цикла - int i = 1 создает и инициализирует счетчик i. Счетчик необязательно должен представлять тип int . Это может быть и любой другой числовой тип, например, float. Перед выполнением цикла значение счетчика будет равно 1. В данном случае это то же самое, что и объявление переменной.
Вторая часть - условие, при котором будет выполняться цикл. В данном случае цикл будет выполняться, пока i не достигнет 9.
И третья часть - приращение счетчика на единицу. Опять же нам необязательно увеличивать на единицу. Можно уменьшать: i-- .
В итоге блок цикла сработает 8 раз, пока значение i не станет равным 9. И каждый раз это значение будет увеличиваться на 1.
Нам необязательно указывать все условия при объявлении цикла. Например, мы можем написать так:
Int i = 1; for (; ;){ System.out.printf("Квадрат числа %d равен %d \n", i, i * i); }
Определение цикла осталось тем же, только теперь блоки в определении у нас пустые: for (; ;) . Теперь нет инициализированной переменной-счетчика, нет условия, поэтому цикл будет работать вечно - бесконечный цикл.
Либо можно опустить ряд блоков:
Int i = 1; for (; i<9;){ System.out.printf("Квадрат числа %d равен %d \n", i, i * i); i++; }
Этот пример эквивалентен первому примеру: у нас также есть счетчик, только создан он вне цикла. У нас есть условие выполнения цикла. И есть приращение счетчика уже в самом блоке for.
Цикл for может определять сразу несколько переменных и управлять ими:
Int n = 10; for(int i=0, j = n - 1; i < j; i++, j--){ System.out.println(i * j); }
Цикл do
Цикл do сначала выполняет код цикла, а потом проверяет условие в инструкции while. И пока это условие истинно, цикл повторяется. Например:
Int j = 7; do{ System.out.println(j); j--; } while (j > 0);
В данном случае код цикла сработает 7 раз, пока j не окажется равным нулю. Важно отметить, что цикл do гарантирует хотя бы однократное выполнение действий, даже если условие в инструкции while не будет истинно. Так, мы можем написать:
Int j = -1; do{ System.out.println(j); j--; } while (j > 0);
Хотя переменная j изначально меньше 0, цикл все равно один раз выполнится.
Цикл while
Цикл while сразу проверяет истинность некоторого условия, и если условие истинно, то код цикла выполняется:
Int j = 6; while (j > 0){ System.out.println(j); j--; }
Операторы continue и break
Оператор break позволяет выйти из цикла в любой его момент, даже если цикл не закончил свою работу:
Например:
< nums.length; i++){ if (nums[i] > 10) break; System.out.println(nums[i]); }
Так как в цикле идет проверка, больше ли элемент массива 10, то мы не увидим на консоли последние два элемента, так как когда nums[i] окажется больше 10 (то есть равно 12), сработает оператор break, и цикл завершится.
Правда, мы также не увидим и последнего элемента, который меньше 10. Теперь сделаем так, чтобы если число больше 10, цикл не завершался, а просто переходил к следующему элементу. Для этого используем оператор continue :
Int nums = new int { 1, 2, 3, 4, 12, 9 }; for (int i = 0; i < nums.length; i++){ if (nums[i] > 10) continue; System.out.println(nums[i]); }
В этом случае, когда выполнение цикла дойдет до числа 12, которое не удовлетворяет условию проверки, то программа просто пропустит это число и перейдет к следующему элементу массива.
Когда Вам необходимо, чтобы одно и то же самое действие выполнилось несколько раз или до определенного условия, здесь нам на помощь приходят циклы.
В языке Java есть несколько способов создать циклы. Как Вы уже могли догадаться, мы будем рассматривать их все.
Первый способ объявить цикл — это использовать такую конструкцию: for (условие начала цикла; условие конца; шаг, с которым будет идти цикл) { тело цикла }
Перейдем сразу к примерам. Допустим у нас есть задача вывести фразу «привет мир» 10 раз. Если не использовать циклы, то можно просто написать System.out.println(«Привет мир»); десять раз и решим задачу. Давайте же для это цели используем циклы. Создайте новый класс и назовите его например CuclesInJava. Теперь объявите условие цикла (пусть это будет 0), условие конца — 10, и шаг. Будем идти с шагом в единицу. В тело цикла поместите строку System.out.println(«Привет мир»);
Вот пример кода:
Результатом такого кода будет 10 строк подряд фразы «Hello world!».
Как насчет написать что то более сложное. Мы уже выучили и базовые . Давайте их и используем.
Напишем простое приложение, которое будет выводить строку с оповещением каждый раз, когда шаг + некоторая переменная будет равна 5. У меня очень плохо с фантазией))
Для начала напишем код, который будет принимать на вход переменную введенную из консоли. В предыдущей статье, я давал пример этого кода и мы условились, что потом я объясню, как он работает и откуда пошел. А сейчас мы просто будем им пользоваться:
Далее нужно написать цикл, который будет начинаться с нуля и считать до десяти (как в предыдущем примере). В тело цикла запишем условный оператор, который будет проверять, является эта переменная равна 5 и если это так, то будем выводить строку «ОК». Вот, что у меня получилось:
import java.util.Scanner ;
public class CuclesInJava {
int variable = scanner.nextInt () ; //мы дойдем до этого постепенно и тогда будет понятно, как это работает
for (int i = 1 ; i < 10 ; i++ ) {
int newVariable = i + variable;
if (newVariable== 5) {
Получилось не очень замысловато. Этим примером, я хотел показать, как можно использовать циклы с ветвлениями в связке.
Следующим способом объявить циклы является конструкция: while(условие истинно){блок кода, который нужно выполнить}. У данной конструкции есть другая форма:
do{блок кода, который нужно выполнить}while(условие истинно). Отличие первого от второго в том, что второе выполнить один цикл независимо истинно условие или нет. Можете сами подумать: сначала мы выполняем кода, а потом уже проверяем условие. И даже если условие будет не истинным, код все равно выполниться один раз, в том время, когда в первом виде конструкции сначала проверяется условие и пока оно не будет истинным, код не выполнится.
Код должен быть интуитивно понятен. Думаю, стоит упомянуть, что с помощью конструкций while и do-while можно «зациклить» программу если не прописать или неправильно прописать условие выхода из цикла. Посмотрите на пример выше и подумайте, что было, если бы я написал не i—, а i++; или вместо i>0, i<0. Моя программа никогда не вышла бы из цикла и продолжала бы выводить строку Hello world! до тех пор, пока не завис компьютер. Поэтому, будьте очень осторожными с циклами и всегда следите, чтобы из них Ваша программа могла выйти или закончить работу.
Ну и пример с do-while:
На этом, думаю, можно закончить статью о циклах в Java . Как видите, конструкции не очень сложны, но очень полезны. Особенно полезными они будут, когда мы познакомимся с массивами и строками.
Вы задумывались когда-нибудь над тем, зачем вообще существуют программы? Если упростить и обобщить ответ на этот вопрос, то выяснится, что программы необходимы для автоматизации рабочего процесса, увеличения скорости выполняемой работы, избавления человека от тысяч монотонных действий и так далее. Давайте остановимся на повторяющихся друг за другом действиях, или говоря простым языком циклах.
Цикл – это последовательное выполнение повторяющихся действий на основе заданного предусловия. Например, нужно переставить сто ящиков из одного угла в другой. Если это каким-то образом записать на языке 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 возможно использование оператора декремента, например.
Цикл - это блок команд, который выполняется снова и снова, пока соблюдается определённое условие. Повторяемый фрагмент кода называют «телом цикла». Одно выполнение тела цикла называют итерацией.
В Яве можно работать с циклами нескольких типов - для этого есть следующие операторы:
while – цикл с предусловием – сначала проверяем условие, затем выполняем тело цикла;
do… while – цикл с постусловием – сначала выполняем один раз тело цикла, затем проверяем условие и, если оно соблюдается, продолжаем;
for – цикл со счётчиком – выполняется и при каждой итерации обновляет счётчик, пока условие в объявлении цикла соблюдается (т.е. проверка условия возвращает true);
сокращенный for (в других языках известен как foreach) – перебирает массив от первого элемента до последнего и на каждой итерации выполняет тело цикла.
Суть условия цикла – проверка выражения с одной или несколькими переменными: «Пока a<11, в каждой итерации выполняем тело цикла и увеличиваем "а" на 1». Но чему равно «а» при первом выполнении цикла?
Если мы используем конструкции с while, значение нужно указать перед началом цикла:
int a = 1;
while (a < 11) {
System.out.println(a);
a++; //увеличиваем а на единицу
}
Если же переменная работает как счётчик цикла, а за его пределами не используется, её инициализируют прямо в условии. И тут же пишут, что с ней делать в конце каждой итерации. Всё это – в одну строку – с помощью for:
for (а=1, a<11, i++) {
System.out.println(a);
}
Получаем тот же результат. Список можно было начать с нуля или с отрицательного значения – диапазон определяем сами.
Сокращенный вариант цикла for не содержит указаний ни на число повторов, ни на действия в конце шага. Цикл типа foreach используют для перебора массивов. От первого элемента нужно переходить к следующему – пока массив не кончится.
int ms = { 1, 2, 3, 4}; //создаем массив
int s = 0;
for(int i: ms) { //указываем, что перебирать
s *= i; //последовательно перемножаем элементы
}
System.out.println(s);
Вложенные циклы Java
Циклы можно вкладывать один в другой. При этом число повторов наружного и вложенных циклов умножается. Если внешний должен выполняться 5 раз и внутренний – 5, всего цикл будет выполнен 25 раз.
Выведем таблицу умножения с помощью двух массивов:
int a, b, result = 0;
for (a = 2; a < 10; a++) {
for (b = 2; b < 10; b++) {
result = a*b;
System.out.println(a+"x"+b+" = "+result);
}
}
Cоздание объектов в цикле Java
Циклы удобны, когда нужно создать и пронумеровать множество объектов. Их число бывает неизвестно заранее: объекты могут создаваться по запросу пользователя. Вот мы спросили, сколько нужно чего-то, и записали число в переменную n. Теперь создадим объекты в нужном количестве:
Something array = new Something[n]; //создаем массив типа “что-то” из n элементов
for(int i = 0; i < n; i++){
array[i] = new Something(); //создаем “что-то” и помещаем его в массив
}
Как выйти из цикла Java
Для выхода из цикла есть ключевые слова break - «прервать», continue - «возобновить» и return - «вернуться». Команда break переключает программу на выполнение следующих за циклом операторов. Условия прерывания цикла в Java оформляют через if-ветвление. Главное, чтобы проверка выполнялась перед основной частью тела цикла.
//после создания массива m пишем:
for (a: m) {
if (a==5) break;
System.out.println(a);
}
Операторы ветвления и цикла в Java часто работают вместе: запускаем цикл, а внутри него проверяем, не выполнено ли еще условие, при котором нужно прервать цикл или сделать что-то ещё.
Если использовать break во вложенном цикле, прервётся только он, а внешний продолжит выполняться.
Для досрочного прерывания итерации цикла for в Java используют continue. Когда программа до него доходит, она пропускает невыполненную часть итерации, обновляет счётчик и переходит к следующей итерации.
В конструкциях while тот же continue работает иначе: возвращает нас к проверке условия продолжения цикла. Другая команда – return – возвращает программу к месту, откуда был вызван метод, в котором цикл находится.
И continue, и break можно использовать с меткой - для перехода к нужной части кода - по аналогии с goto:
break Mark1; //при условии, что где-то выше стоит метка Mark1:
Бесконечный цикл Java
Создать бесконечный цикл легко - достаточно не указывать параметры в for:
for (; ;) {}
Сложнее извлечь из этого пользу. Обычно бесконечность цикла – критическая ошибка, которая мешает выполнению программы. Поэтому каждый цикл стоит проверять на способность корректно завершиться в нужный момент. Для этого нужно:
- указать в теле цикла условия прерывания,
- убедиться, что переменная в условии прерывания может принять значение, при котором цикл будет остановлен.
Цикл — это многократно повторяющийся фрагмент программы.
В 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, Алексей Николаевич Костин. Кафедра ТИДМ математического факультета МПГУ.
