Циклы в android java
Статья проплачена кошками – всемирно известными производителями котят.
Если статья вам понравилась, то можете поддержать проект.
Конструкция for управляет циклами. Команда выполняется до тех пор, пока управляющее логическое выражение не станет ложным.
Блок-схема.
Цикл for является наиболее распространённым циклом в программировании, поэтому его следует изучить. Цикл for проводит инициализацию перед первым шагом цикла. Затем выполняется проверка условия цикла, и в конце каждой итерации происходит изменение управляющей переменной. Выглядит следующим образом:
for(инициализация; логическое выражение (условие); шаг (итерация)) команда
Любое из трёх выражений цикла (инициализация, логическое выражение или шаг) можно пропустить. Перед выполнением каждого шага цикла проверяется условие цикла. Если условие окажется ложным, то выполнение продолжится с инструкции, следующей за конструкцией for.
Помните, что выражение инициализации выполняется один раз, затем вычисляется условие, которое должно быть булевым выражением.
Как правило, цикл for используют для перебора. В качестве имени первой переменной часто используют i (сокр. от init), но вы можете использовать любое имя.
Простейший пример:
for (int x = 0; x < 9; x = x + 1) mTextView.append(“nЗначение x: ” + x);
В этом примере переменной x присваивается начальное значение, равное нулю. Затем выполняется проверка условия в логическом выражении (x < 9), если результат проверки истинен, то выполняется оператор после выражения цикла. После чего процесс повторяется. Процесс продолжается до тех пор, пока результат проверки условия не станет ложным.
Третье выражение в цикле – шаг, то есть, на какое значение нужно изменить переменную. Строго говоря, в таком виде (x = x + 1) современные программисты не пишут, так как есть укороченная форма записи (x++). Предыдущий пример можно переписать по другому:
for (int x = 0; x < 9; x++)
Эта запись является классической и правильной, если нам нужно посчитать от 0 до 8. Может возникнуть соблазн написать, например, так:
for (int x = 0; x
Результат будет таким же, но такой код нежелателен. Старайтесь писать традиционно. Особенно это проявляется при работе с массивами.
Увеличение значения переменной на единицу – весьма распространённый случай. Но это не является обязательным условием цикла, вы можете установить шаг и с помощью умножения, вычитания и других действий. Например, мы хотим вывести процесс уменьшения жизней у очень любопытной кошки:
for (int life = 9; life >= 0; life–) mTextView.append(“nУ кошки осталось жизней: ” + life);
Попробуйте потренироваться на кошках. Например, выводим чётные числа.
for (int x = 0; x < 9; x += 2) mTextView.append(” ” + x); // между кавычками пробел
Получим:
0 2 4 6 8
Если нужно выполнить несколько операторов в цикле, то используют фигурные скобки.
for (int kitten = 1; kitten < 10; kitten++) { mTextView.append(“nСчитаем котят: ” + kitten); mResultEditText.setText(“Ура! Нас подсчитали”); }
В этом примере выполняется цикл с выводом числа подсчитанных котят, а также выводится текст в текстовом поле. Кстати, это один из примеров неправильного кода, когда в текстовом поле девять раз подряд выводится одна и та же строка. Мы этого не замечаем, но в реальности процессор выполняет лишнюю работу и второй оператор безусловно нужно вынести за пределы блока кода, который относится к циклу. Подобные ошибки очень часто встречаются у начинающих программистов, которые забывают, как работает цикл.
Когда мы объявляем переменную в первой части оператора for(int i = 0; …), то область видимости переменной ограничена телом цикла и эта переменная не доступна на другом участке кода. Это подходящий вариант, если переменная больше нигде не используется. При этом переменная имеет область видимости и продолжительность существования, совпадающие с видимостью и продолжительностью жизни самого цикла. Вне цикла переменная прекратит своё существование.
Если управляющую переменную цикла нужно использовать в других частях приложения, то её не следует объявлять внутри цикла.
int i; // эта переменная нам понадобится не только в цикле for(i = 0; i < 10; i++){ // что-то делаем } // можем использовать переменную где-то ещё x = i + 10;
С другой стороны, если видимость переменной ограничена в пределах цикла, то не будет никакого конфликта, если вы будете использовать одинаковые имена переменных в разных циклах for, так как они не будут друг другу мешать.
Использование нескольких переменных
Иногда требуется указать несколько переменных в инициализационной части цикла. Для начала посмотрим на стандартный пример:
int a, b; b = 4; for(a = 1; a < b; a++) { mTextView.append(“a = ” + a + “n”); mTextView.append(“b = ” + b + “n”); b–; }
В данном цикле используются две переменные. Можно включить обе переменные в оператор for, чтобы не выполнять обработку второй переменной вручную:
int a, b; for(a = 1, b = 4; a < b; a++, b–) { mTextView.append(“a = ” + a + “n”); mTextView.append(“b = ” + b + “n”); }
Как видно из кода, запятая служит разделителем для двух переменных. Теперь оба разделённых запятой оператора в итерационной части цикла выполняются при каждом выполнении цикла. Данный код считается более эффективным, хотя на практике встречается редко.
Части цикла могут быть пустыми.
Оставим пустым первое выражение.
int i = 0; for(; i < 10; i++){ // что-то делаем mTextView.append(“n” + i); }
В следующем примере нет инициализационного и итерационного выражения:
int i; boolean kind = false; i = 0; for( ; !kind; ) { mTextView.append(“i равно ” + i + “n”); if(i == 10) done = true; i++; }
А можно вообще все три части оператора оставить пустыми:
for( ; 😉 { //… }
В этом случае создаётся бесконечный цикл, который никогда не завершится. Практического смысла данный код не имеет.
Работа с массивами
С обычными числами обычно не работают в цикле for. Гораздо чаще цикл используют при работе с массивами.
Основная разница между ними, что массив может состоять из неупорядоченных чисел, а число элементов может быть разным. К счастью, у массива есть специальное свойство length – длина массива. Первый пример можно переписать следующим образом.
int[] mice = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; for (int i = 0; i
Мы создали массив из чисел от 0 до 9. Затем проходим в цикле, но на этот раз во втором операторе не используем число 9, а вычисляем длину массива. Такой гибкий подход позволят проделывать с массивами разные трюки – упорядочивать, сортировать, переворачивать и т.д.
Например, если мы хотим вывести числа в обратном порядке, меняем логику следующим образом. Теперь нам нужно начинать вывод не с 0, а с 9, т.е. int i = 9 или int i = mice.length – 1 (для универсальности). Шаг будет не увеличиваться, а уменьшаться, значит – i–. А условием станет достижение 0, т.е. i >= 0. Проверяем.
int[] mice = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; for (int i = mice.length – 1; i >= 0; i–) { mTextView.append(” ” + mice[i]); }
Аналог foreach
Во многих языках существует более компактная форма for для перебора элементов массивов – foreach. Конструкция foreach не требует ручного изменения переменной-шага для перебора – цикл автоматически выполняет эту работу.
В Java решили не добавлять новое ключевое слово, а просто сделали усовершенствованный вид цикла for, который имеет вид:
for(тип итер_пер : коллекция) блок_операторов
Для сравнения напишем цикл для вычисления суммы значений элементов массива традиционным способом:
int[] nums = { 1, 2, 3, 4, 5 }; int sum = 0; for(int i = 0; i < 5; i++) sum += nums[i];
Этот код можно переписать следующим образом:
int[] nums = { 1, 2, 3, 4, 5 }; int sum = 0; for(int i : nums) sum += i;
При прохождении цикла переменной i автоматически присваивается значение, равное значению следующего элемента массива nums. Таким образом, при первом прохождении переменная i содержит значение 1, при втором – 2 и т.д. Кроме того при таком способе исключается возможность ошибок выхода за пределы массива.
Для этого способа можно использовать массив или любой класс с интерфейсом Iterable.
Можно прервать выполнение цикла с помощью оператора break:
int[] nums = { 1, 2, 3, 4, 5 }; int sum = 0; for(int i : nums) { sum += i; if(i == 3) break; // останавливаем цикл, если значение равно 3 }
Учтите, что в цикле в стиле foreach итерационная переменная доступна только для чтения, так как она связана только с исходным массивом. Даже если вы измените её значение, то это не повлияет на работу с массивом.
Также можно использовать данный способ для многомерных массивов.
Поскольку каждый оператор for в стиле foreach перебирает элементы массива последовательно, начиная с первого и заканчивая последним, то данный способ удобен для многих операций. Например, для поиска значения в неупорядоченном массиве. Поиск прекращается после обнаружения нужного значения.
int[] nums = { 3, 1, 6, 4, 9, 5, 8, 2 }; int val = 5; boolean found = false; // ищем значение 5 в массиве for (int x : nums) { if (x == val) { found = true; break; } } if (found) { mTextView.setText(“Значение найдено”); }
Так как у нас неупорядоченный список, то нам нужно последовательно пройтись по всем элементам. Если нам повезёт и нужное значение встретится при переборе, то выходим из цикла и идём спать.
Вложенные циклы
Также допустимо использование вложенных циклов, когда один цикл выполняется внутри другого:
int i, j; for (i = 0; i < 10; i++) { for (j = i; j < 10; j++) { mTextView.append(“*”); } mTextView.append(“n”); }
В результате получим:
********** ********* ******** ******* ****** ***** **** *** ** *
При вложенных циклах количество повторений перемножается. В предыдущем примере было 100 повторений. Например, можно написать таблицу умножения.
int i, j, a = 0; for (i = 1; i < 10; i++) { for (j = 1; j < 10; j++) { a = i * j; System.out.(a + ” | “); } System.out.ln(); }
Результат смотрите в вкладке LogCat.
Цикл for является более удобным вариантом цикла while.
for(int i = 10; i > 0; i–){ System.out.ln(“Отсчёт пошёл… ” + i); }
Этот же вариант с while:
int i = 10; while(i > 0){ System.out.ln(“Отсчёт пошёл… ” + i); i–; }
С помощью цикла можно рисовать красивые узоры, меняя координаты одной фигуры.
Треугольник Флойда
Составьте “Треугольник Флойда”, который выглядит как набор чисел, которые увеличиваются на единицу. Например, треугольник с высотой шесть строк выглядит следующим образом.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
Ответ
Реклама
Источник
<<Предыдущий урок Список уроков Следующий урок>>
Уроки удобно выполнять в среде разработки IntelliJ IDEA, ссылка на страницу загрузки.
Циклы в Java
Есть два вида циклов в Java, for и while.
For
Цикл for состоит из трех секций:
for (int i = 0; i < 3; i++) {} |
Первая секция выполняется один раз, когда мы входим в цикл. В нашем примере здесь задается начальное значение переменной i. Вторая секция проверяет логическое условие, если оно возвращает true, выполняются операторы в цикле, если false, выход из цикла. Вторая секция в первый раз запускается сразу после первой секции, и выполняется каждый раз, пока условие верно, вызывая третью секцию. Третья секция – заключительный оператор, его действие выполняется каждый раз при выполнении цикла. В нашем примере это инкремент, который при каждом выполнении увеличивает значение переменной на единицу.
Таким образом, цикл будет работать 3 раза. Вот порядок команд:
int i = 0; i < 3 // 0 < 3 = true // Inside of loop i++ // i is now 1 i < 3 // 1 < 3 = true // Inside of loop i++ // i is now 2 i < 3 // 2 < 3 = true // Inside of loop i++ // i is now 3 i < 3 // 3 < 3 = false // Loop is done… |
Мы можем опустить первую и третью секции цикла (как бы странно это ни выглядело), и цикл все еще будет работать:
Для случаев, где нужно использовать цикл схожих повторяющихся действий, мы используем цикл while
While
Синтаксис похож на предыдущий:
Условие будет работать впервые при вводе и каждый раз, когда вызывается цикл. Если условие возвратит false, то цикл не будет работать.
Если мы хотим, чтобы цикл всегда выполнял по крайней мере одно действие, мы можем использовать do-while:
Не забудьте точку с запятой в конце.
Foreach
Другая версия for, это foreach. Но в Java решили не добавлять новое ключевое слово each. Ключевое слово, которое мы используем, все еще for, но когда мы хотим выполнить действия над элементами массива, делаем так:
int[] arr = {2, 0, 1, 3}; for (int el : arr) { System.out.ln(el); } |
Это была короткая версия, эквивалентная следующей записи:
int[] arr = {1, 9, 9, 5}; for (int i = 0; i < arr.length; i++) { int el = arr[i]; System.out.ln(el); } |
Заметьте, что, если вы хотите использовать индекс элемента в цикле, Вы должны использовать более длинную версию и не можете использовать foreach.
break and continue
Эти два ключевых слова помогают нам управлять циклом из него. Оператор break останавливает цикл и переходит к оператору, следующему за ним:
int i; for (i = 0; i < 5; i++) { if (i >= 2) { break; } System.out.ln(“Yuhu”); } System.out.ln(i); // Output: // Yuhu // Yuhu // 2 |
Оператор continue остановит текущую итерацию и переместится в следующую. Заметьте, что в цикле for действие в третьей секции будет выполнено при этом.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | int i; for (i = 0; i < 5; i++) { if (i >= 3) { break; } System.out.ln(“Yuhu”); if (i >= 1) { continue; } System.out.ln(“Tata”); } System.out.ln(i); // Output // Yuhu // Tata // Yuhu // Yuhu // 3 |
Упражнение
Используя цикл, выведите на экран все четные числа из списка чисел в порядке получения. Не выводите числа, идущие после числа 237 в последовательности.
Выполните упражнение, прежде чем перейти к следующему уроку.
Дополнительное чтение:
Общие сведения о циклах в Java
Конструкции выбора в Java
Инструкции выхода в Java
<<Предыдущий урок Список уроков Следующий урок>>
Источник
Что такое циклы
Программа, написанная на языке Java, состоит из определенного кода. Обычно он в выполняется последовательно: строка за строкой, сверху вниз. Но есть и такие конструкции кода, которые меняют линейное выполнение программы. Их называют управляющими конструкциями. 
Благодаря им, код можно выполнять выборочно. Например, запустить один блок кода вместо другого. Циклы – это разновидность управляющих конструкций для организации многократного выполнения одного и того же участка кода. Код внутри такой управляющей конструкции выполняется циклично. Каждое выполнение кода – это итерация цикла. Количество итераций регулируется условием цикла. Код, который выполняется внутри цикла, называют телом цикла. Известны такие виды циклов:
Циклы с предусловием: условие выполнения определяется перед первой итерацией.
Циклы с постусловием: условие выполнения определяется после первой итерации (поэтому они всегда выполняются минимум один раз). Полезны, когда нужно выполнять некое действие, пока не реализуется некое условие: например, считывать ввод пользователя, пока он не введет слово “stop”.
Циклы со счетчиком: количество итераций определяется смоделированным счетчиком. В условии цикла задается его начальное и конечное значение. Каждую итерацию счетчик наращивается. Мы можем заранее определить количество итераций.
Эти циклы бывают полезны, когда нужно перебрать все элементы в какой-то коллекции. Циклы со счетчиком называют “циклами для…”. “Для каждого элемента некоторой коллекции осуществить следующие действия”.
Допустимы случаи, когда выполнение цикла можно прервать до достижения его условия. Например, если у нас есть коллекция из 100 чисел и нам необходимо понять, содержит ли она отрицательные числа. Мы можем начать перебор всех чисел, используя цикл “для”. Но когда мы найдем первое отрицательное число, нам не обязательно перебирать оставшиеся числа. Мы можем прервать выполнение цикла, если его дальнейшее выполнение не имеет смысла. Подобные ситуации называют прерыванием цикла.
Безусловные циклы – циклы, которые выполняются бесконечно. Например: “Пока 1=1, печатать “1=1″”. Такая программа будет выполняться, пока ее вручную не прервут.
Данные циклы тоже бывают полезны, когда используются вместе с прерыванием цикла “изнутри”. Используйте их осторожно, чтобы не спровоцировать зависание программы.
Подробнее с циклами в языке программирования Java можно познакомиться на 4-ом уровне курса JavaRush. В частности, с циклами while и for.
Циклы в Java
Теперь рассмотрим циклы в Java. В этом ЯП их есть несколько типов:
- while – цикл с предусловием;
- do..while – цикл с постусловием;
- for – цикл со счетчиком (цикл для);
- for each.. – цикл “для каждого…” – разновидность for для перебора коллекции элементов.
while, do.. while и for можно использовать в качестве безусловных циклов. Сравнить синтаксис циклов в разных языках программирования можно на четвертом уровне обучения курса JavaRush. Например циклов for и while. Рассмотрим кратко каждый из представленных типов.
Цикл while
Этот цикл в Java структурно выглядит так:
while (expression) { ement(s) }
Здесь:
- expression – условие цикла, выражение, которое должно возвращать boolean значение.
- ement(s) – тело цикла (одна или более строк кода).
Перед каждой итерацией будет вычисляться значение выражения expression. Если результатом выражения будет true, выполняется тело цикла – ement(s). Пример:
public class WhileExample { public ic void main(String[] args) { int countDown = 10; while (countDown >= 0) { System.out.ln(“До старта: ” + countDown); countDown –; } System.out.ln(“Поехали !”); } }
Вывод:
До старта: 10 До старта: 9 До старта: 8 До старта: 7 До старта: 6 До старта: 5 До старта: 4 До старта: 3 До старта: 2 До старта: 1 До старта: 0 Поехали !
Используя while, можно создать бесконечный цикл:
while (true) { // тело цикла }
Чтобы прервать выполнение цикла, используется оператор break. Например:
public class WhileExample { public ic void main(String[] args) { int count = 1; while (true) { System.out.ln(“Строка №” + count); if (count > 3) { break; } count++; // Без наращивания цикл будет выполняться вечно } } }
Вывод:
Строка №1 Строка №2 Строка №3 Строка №4
Попрактиковаться в написании своих циклов можно уже на 4-ом уровне курса JavaRush.
Цикл do..while
Структура do.. while выглядит так:
do { ement(s) } while (expression);
Здесь:
- expression – условие цикла, выражение, которое должно возвращать boolean значение.
- ement(s) – тело цикла (одна или более строк кода).
В отличие от while, значение expression будет вычисляться после каждой итерации. Если результатом выражения будет true, в очередной раз выполнится тело цикла – ement(s) (как минимум раз). Пример:
public class DoWhileExample { public ic void main(String[] args) { int count = 1; do { System.out.ln(“count = ” + count); count ++; } while (count < 11); } }
Вывод:
count = 1 count = 2 count = 3 count = 4 count = 5 count = 6 count = 7 count = 8 count = 9 count = 10
Цикл for
Этот Java цикл выглядит так:
for (initialization; termination; increment) { ement(s) }
Здесь:
- initialization – выражение, которое инициализирует выполнение цикла. Исполняется только раз в начале цикла. Чаще всего в данном выражении инициализируют счетчик цикла
- termination – boolean выражение, которое регулирует окончание выполнения цикла. Если результат выражения будет равен false, цикл for прервется.
- increment – выражение, которое исполняется после каждой итерации цикла. Чаще всего в данном выражении происходит инкрементирование или декрементирование переменной счетчика.
- ement(s) – тело цикла.
Выражения initialization, termination, increment опциональны. Если опустить каждое из них, мы получим бесконечный цикл:
// бесконечный цикл for ( ; ; ) { // код тела цикла }
Пример цикла for:
public class ForExample { public ic void main(String[] args) { for (int i = 1; i < 6; i++) { System.out.ln(“Строка №” + i); } } }
Вывод:
Строка №1 Строка №2 Строка №3 Строка №4 Строка №5
Практикум по циклу for представлен на четвертом уровне курса JavaRush.
Цикл for each
Этот цикл Java – разновидность цикла for для итерации коллекций и массивов. Структура for each выглядит так:
for (Type var : vars) { ement(s) }
Здесь:
- vars – переменная, существующий список или массив
- Type var – определение новой переменной того же типа (Type), что и коллекция vars.
Данную конструкцию можно прочитать так: “Для каждого var из vars сделать…”. Предположим, у нас есть массив строк из названий дней недели. Выведем каждый элемент этого массива на печать:
public class ForExample { public ic void main(String[] args) { String[] daysOfWeek = { “Понедельник”, “Вторник”, “Среда”, “Четверг”, “Пятница”, “Суббота”, “Воскресенье” }; for (String dayOfWeek : daysOfWeek) { System.out.ln(dayOfWeek); } } }
Циклы Java изучаются на курсе JavaRush на четвертом уровне квеста Java Syntax. Попробуйте свои силы в решении задач по этой теме 🙂 
Источник