Java как работает цикл for
Говорят, что лучший программист — ленивый программист. Вместо того, чтобы совершать однотипные действия по нескольку раз, он придумает алгоритм, который сделает эту работу за него. А еще он сделает его хорошо, чтобы не нужно было переделывать.
Примерно так, чтобы много раз не писать один и тот же код, придумали циклы. Представим, что нам нужно вывести в консоль числа от 0 до 99. Код без цикла:
System.out.println(0);
System.out.println(1);
System.out.println(2);
System.out.println(3);
System.out.println(4);
System.out.println(5);
// И так далее
Этот код займет 100 строк! Очень много. А вот как это будет выглядеть с циклом:
for(int i = 0; i < 100; i++) {
System.out.println(i);
}
Всего 3 строки!
Что такое циклы for?
Цикл for – это управляющая конструкция программного кода, которая нарушает линейность исполнения алгоритма и позволяет выполнить указанный код множество раз. Например, необходимо принять 30 капель лекарства. Алгоритм будет примерно такой:
- Приготовить стакан.
- Открыть крышку.
- Получить 1 каплю.
- Получить 2 каплю.
- Получить 30 каплю.
- Закрыть лекарство.
- Принять полученную порцию.
…
Этот алгоритм можно объяснить гораздо быстрее:
- Приготовить стакан.
- Открыть крышку капель.
- Получить 30 капель.
- Закрыть лекарство.
- Принять полученную порцию.
Мы практически каждый день используем цикл for в разговоре с другими людьми: “…20 шагов дальше по улице…”, “…сделай 10 повторений и еще 5 в 2 раза медленнее…”, “…сделай 5 покупок в различных категориях и получи приз…” можно продолжать долго, но смысл ясен.
В Java Цикл for необходим для сокращения кода и его лаконичности.
Принцип работы цикла for
For цикл используется следующим образом:
for(<начальная точка>; <условие выхода>; <оператори счетчика>) {
// Тело цикла
}
Пример перебора цифр от 0 до 5 и вывод каждой в консоль:
for(int i = 0; i < 5; i++) {
System.out.println(i);
}
Вывод:
1
2
3
4
Если перевести данную запись на человеческий язык, получится следующее:
“Создай переменную i с начальным значением 0, пока она не достигнет 5, прибавляй к ней по 1 и на каждом шаге записывай значение i в консоль.”
В основе работы цикла for в Java лежат три стадии, их можно изобразить следующей схемой:
Условие выхода из цикла — это булево выражение. Если оно ложно, цикл будет завершен. В примере выше переменная i увеличивается на 1. Если ее значение менее 5, цикл продолжается. Но как только i станет больше или равно 5, цикл прекратится.
Оператор счетчика — выражение, которое выполняет преобразование переменной счетчика. В примере выше переменная i увеличивалась на 1. То есть цикл будет выполнен ровно 5 раз. Если оператор счетчика будет прибавлять по 2 к переменной i, результат будет иным:
for(int i = 0; i < 5; i = i + 2) {
System.out.println(i);
}
Вывод:
2
4
Также можно умножать переменную, делить, возводить в степень, в общем, делать все, что угодно. Главное, чтобы в результате преобразования получилось число.
Тело цикла — любой код, который может быть выполнен. В примере выше в теле цикла был вывод значения переменной i в консоль, однако содержимое данного тела ограничено задачей и фантазией.
Обобщая всю схему, принцип данного цикла — for — следующий: код, который находится в теле цикла, будет выполнен столько раз, сколько преобразований выполнит оператор счетчика до того, как будет достигнуто условие выхода из цикла.
Если задать условие выхода из цикла как true:
for(int i = 0; true; i++) {
if(i % 1000000 == 0) System.out.println(i);
}
System.out.println(“Loop ended”);
То код после цикла будет помечен ошибкой unreachable statement, так как никогда не будет исполнен.
Задача на смекалку: в результате запуска кода ниже будет ли выведено в консоль “Loop ended” или цикл будет выполняться бесконечно?
for(int i = 0; i > -1; i++) {
if(i % 1000000 == 0) System.out.println(i);
}
System.out.println(“Loop ended”);
Ответ: будет. Переменная i рано или поздно достигнет максимального значения, а дальнейшее увеличение превратит ее в максимальное отрицательное, в результате чего условие выхода будет выполнено (i < = -1).
Цикл forEach
При работе с циклами иногда приходится перебирать массивы или коллекции. Обычно массив можно перебрать с помощью цикла for:
public void printAllElements(String[] stringArray) {
for(int i = 0; i < stringArray.length; i++) {
System.out.println(stringArray[i]);
}
}
И это правильно. Однако, для перебора всех элементов массива по очереди придумали конструкцию forEach. Ее сигнатура следующая:
for(<Тип элемента> <Имя переменной, куда будет записан очередной элемент> : <Название массива>) {
// Тело цикла
}
Перебрать массив строк и вывести каждую в консоль можно следующим способом:
public void printAllElements(String[] stringArray) {
for(String s : stringArray) {
System.out.println(s);
}
}
Тоже кратко и лаконично. Самое главное, нет нужды думать о счетчике и об условии выхода, все уже сделано за нас.
Как используются циклы for
А теперь рассмотрим несколько примеров использование цикла for в Java для решения разнообразных задач.
Обратный цикл (от большего к меньшему)
for(int i = 5; i > 0; i–) {
System.out.println(i);
}
Вывод:
5
4
3
2
1
Несколько переменных и увеличение счетчика в теле цикла
В цикле for можно использовать несколько переменных, например их можно преобразовывать в операторе счетчика:
int a = 0;
for(int i = 5; i > 0; i–, a++) {
System.out.print(“Шаг: ” + a + ” Значение: “);
System.out.println(i);
}
Вывод:
Шаг: 0 Значение: 5
Шаг: 1 Значение: 4
Шаг: 2 Значение: 3
Шаг: 3 Значение: 2
Шаг: 4 Значение: 1
Или объявить две переменные и идти по циклу, пока они не будут равны друг другу:
for(int i = 5, j = 11; i != j; i++, j–) {
System.out.println(“i: ” + i + ” j: ” + j);
}
Вывод:
i: 5 j: 11
i: 6 j: 10
i: 7 j: 9
Вряд ли это действие имеет какую-либо ценность, но знать о такой возможности полезно.
В цикле for также можно создавать внутренние циклы. В этом случае количество шагов цикла будет умножаться:
for(int i = 0; i < 5; i++) {
System.out.print(i + ” | “);
for(int j = 0; j < 5; j++) {
System.out.print(j + ” “);
}
System.out.print(‘n’);
}
Вывод:
0 | 0 1 2 3 4
1 | 0 1 2 3 4
2 | 0 1 2 3 4
3 | 0 1 2 3 4
4 | 0 1 2 3 4
В цикле со счетчиком j есть возможность обращаться к счетчику внешнего цикла. Благодаря этому вложенные циклы — идеальный способ обхода двумерного, трехмерного и прочих массивов:
int[][] array = { {0, 1, 2, 3, 4 },
{1, 2, 3, 4, 5},
{2, 3, 4, 5, 6},
{3, 4, 5, 6, 7}};
for(int i = 0; i < array.length; i++) {
for(int j = 0; j < array[i].length; j++) {
System.out.print(array[i][j] + ” “);
}
System.out.print(‘n’);
}
Вывод:
0 1 2 3 4
1 2 3 4 5
2 3 4 5 6
3 4 5 6 7
Досрочное завершение цикла
Если при обработке цикла нужно его прервать, используйте оператор break, который останавливает работу текущего тела цикла. Все последующие итерации также пропускаются:
public void getFirstPosition(String[] stringArray, String element) {
for (int i = 0; i < stringArray.length; i++) {
if(stringArray[i].equals(element)) {
System.out.println(i);
break;
}
}
}
Метод выведет позицию первого искомого элемента в массиве:
String[] array = {“one”, “two”, “three”, “Jeronimo”};
getFirstPosition(array, “two”);
Вывод:
1
Бесконечный цикл
Еще один способ создать бесконечный цикл for — оставить пустой область объявления счетчика, условие выхода и оператор счетчика:
for (;;) {
}
Но учти, что в большинстве случаев бесконечный цикл — свидетельство логической ошибки. У такого цикла обязательно должно быть условие выхода.
На курсе JavaRush знакомство с циклами происходит на четвертом уровне обучения в первом квесте (Java Syntax). Отдельные лекции посвящены циклу for, сравнением этого цикла в Java и языке Pascal. Также в курсе есть подборка задач по этой теме.
Источник
Что такое циклы
Программа, написанная на языке 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) {
statement(s)
}
Здесь:
- expression — условие цикла, выражение, которое должно возвращать boolean значение.
- statement(s) — тело цикла (одна или более строк кода).
Перед каждой итерацией будет вычисляться значение выражения expression. Если результатом выражения будет true, выполняется тело цикла — statement(s).
Пример:
public class WhileExample {
public static void main(String[] args) {
int countDown = 10;
while (countDown >= 0) {
System.out.println(“До старта: ” + countDown);
countDown –;
}
System.out.println(“Поехали !”);
}
}
Вывод:
До старта: 10
До старта: 9
До старта: 8
До старта: 7
До старта: 6
До старта: 5
До старта: 4
До старта: 3
До старта: 2
До старта: 1
До старта: 0
Поехали !
Используя while, можно создать бесконечный цикл:
while (true) {
// тело цикла
}
Чтобы прервать выполнение цикла, используется оператор break.
Например:
public class WhileExample {
public static void main(String[] args) {
int count = 1;
while (true) {
System.out.println(“Строка №” + count);
if (count > 3) {
break;
}
count++; // Без наращивания цикл будет выполняться вечно
}
}
}
Вывод:
Строка №1
Строка №2
Строка №3
Строка №4
Попрактиковаться в написании своих циклов можно уже на 4-ом уровне курса JavaRush.
Цикл do..while
Структура do.. while выглядит так:
do {
statement(s)
} while (expression);
Здесь:
- expression — условие цикла, выражение, которое должно возвращать boolean значение.
- statement(s) — тело цикла (одна или более строк кода).
В отличие от while, значение expression будет вычисляться после каждой итерации. Если результатом выражения будет true, в очередной раз выполнится тело цикла — statement(s) (как минимум раз).
Пример:
public class DoWhileExample {
public static void main(String[] args) {
int count = 1;
do {
System.out.println(“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) {
statement(s)
}
Здесь:
- initialization — выражение, которое инициализирует выполнение цикла. Исполняется только раз в начале цикла. Чаще всего в даннов выражении инициализируют счетчик цикла
- termination — boolean выражение, которое регулирует окончание выполнения цикла. Если результат выражения будет равен false, цикл for прервется.
- increment — выражение, которое исполняется после каждой итерации цикла. Чаще всего в данном выражении происходит инкрементирование или декрементирование переменной счетчика.
- statement(s) — тело цикла.
Выражения initialization, termination, increment опциональны. Если опустить каждое из них, мы получим бесконечный цикл:
// бесконечный цикл
for ( ; ; ) {
// код тела цикла
}
Пример цикла for:
public class ForExample {
public static void main(String[] args) {
for (int i = 1; i < 6; i++) {
System.out.println(“Строка №” + i);
}
}
}
Вывод:
Строка №1
Строка №2
Строка №3
Строка №4
Строка №5
Практикум по циклу for представлен на четвертом уровне курса JavaRush.
Цикл for each
Этот цикл Java — разновидность цикла for для итерации коллекций и массивов.
Структура for each выглядит так:
for (Type var : vars) {
statement(s)
}
Здесь:
- vars — переменная, существующий список или массив
- Type var — определение новой переменной того же типа (Type), что и коллекция vars.
Данную конструкцию можно прочитать так: “Для каждого var из vars сделать…”.
Предположим, у нас есть массив строк из названий дней недели. Выведем каждый элемент этого массива на печать:
public class ForExample {
public static void main(String[] args) {
String[] daysOfWeek =
{ “Понедельник”, “Вторник”, “Среда”, “Четверг”, “Пятница”, “Суббота”, “Воскресенье” };
for (String dayOfWeek : daysOfWeek) {
System.out.println(dayOfWeek);
}
}
}
Циклы Java изучаются на курсе JavaRush на четвертом уровне квеста Java Syntax. Попробуйте свои силы в решении задач по этой теме 🙂
Источник
Конструкция for управляет циклами. Команда выполняется до тех пор, пока управляющее логическое выражение не станет ложным.
Блок-схема.
Цикл for является наиболее распространённым циклом в программировании, поэтому его следует изучить. Цикл for проводит инициализацию перед первым шагом цикла. Затем выполняется проверка условия цикла, и в конце каждой итерации происходит изменение управляющей переменной. Выглядит следующим образом:
for(инициализация; логическое выражение (условие); шаг (итерация))
команда
Любое из трёх выражений цикла (инициализация, логическое выражение или шаг) можно пропустить. Перед выполнением каждого шага цикла проверяется условие цикла. Если условие окажется ложным, то выполнение продолжится с инструкции, следующей за конструкцией for.
Помните, что выражение инициализации выполняется один раз, затем вычисляется условие, которое должно быть булевым выражением.
Как правило, цикл for используют для перебора. В качестве имени первой переменной часто используют i (сокр. от init), но вы можете использовать любое имя.
Простейший пример:
for (int x = 0; x < 9; x = x + 1)
mInfoTextView.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–)
mInfoTextView.append(“nУ кошки осталось жизней: ” + life);
Попробуйте потренироваться на кошках. Например, выводим чётные числа.
for (int x = 0; x < 9; x += 2)
mInfoTextView.append(” ” + x); // между кавычками пробел
Получим:
0 2 4 6 8
Если нужно выполнить несколько операторов в цикле, то используют фигурные скобки.
for (int kitten = 1; kitten < 10; kitten++) {
mInfoTextView.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++) {
mInfoTextView.append(“a = ” + a + “n”);
mInfoTextView.append(“b = ” + b + “n”);
b–;
}
В данном цикле используются две переменные. Можно включить обе переменные в оператор for, чтобы не выполнять обработку второй переменной вручную:
int a, b;
for(a = 1, b = 4; a < b; a++, b–) {
mInfoTextView.append(“a = ” + a + “n”);
mInfoTextView.append(“b = ” + b + “n”);
}
Как видно из кода, запятая служит разделителем для двух переменных. Теперь оба разделённых запятой оператора в итерационной части цикла выполняются при каждом выполнении цикла. Данный код считается более эффективным, хотя на практике встречается редко.
Части цикла могут быть пустыми.
Оставим пустым первое выражение.
int i = 0;
for(; i < 10; i++){
// что-то делаем
mInfoTextView.append(“n” + i);
}
В следующем примере нет инициализационного и итерационного выражения:
int i;
boolean kind = false;
i = 0;
for( ; !kind; ) {
mInfoTextView.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–) {
mInfoTextView.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) {
mInfoTextView.setText(“Значение найдено”);
}
Так как у нас неупорядоченный список, то нам нужно последовательно пройтись по всем элементам. Если нам повезёт и нужное значение встретится при переборе, то выходим из цикла и идём спать.
Вложенные циклы
Также допустимо использование вложенных циклов, когда один цикл выполняется внутри другого:
int i, j;
for (i = 0; i < 10; i++) {
for (j = i; j < 10; j++) {
mInfoTextView.append(“*”);
}
mInfoTextView.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.print(a + ” | “);
}
System.out.println();
}
Результат смотрите в вкладке LogCat.
Цикл for является более удобным вариантом цикла while.
for(int i = 10; i > 0; i–){
System.out.println(“Отсчёт пошёл… ” + i);
}
Этот же вариант с while:
int i = 10;
while(i > 0){
System.out.println(“Отсчёт пошёл… ” + i);
i–;
}
С помощью цикла можно рисовать красивые узоры, меняя координаты одной фигуры.
Треугольник Флойда
Составьте “Треугольник Флойда”, который выглядит как набор чисел, которые увеличиваются на единицу. Например, треугольник с высотой шесть строк выглядит следующим образом.
1
2 3
4 5 6
7 8 9 10
11 12 13 14 15
16 17 18 19 20 21
Ответ
Реклама
Источник