Содержание

Циклы в Java | Блог о программировании

Циклы в Java – это часть программы Java, которая позволяет вернуться к нужной части кода и запустить код заново. Цикл значительно упрощает программу и уменьшает код. В этом уроке мы рассмотрим цикл for в Java.

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

В последнем уроке вы видели, что один из способов «сказать» Java, что не следует выполнять каждую строку, — это использование оператора if для разделения областей кода.

Другой способ прервать поток сверху вниз — использовать циклы. Цикл в Java — это то, что заставляет программу вернуться обратно. Если принудительно выполнить резервное копирование, вы можете выполнять строки кода повторно.

В качестве примера, предположим, что вы хотите сложить числа от 1 до 10. Вы можете сделать это довольно легко в Java следующим образом:

int addition = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10;

Но если вам нужно сложить числа от 1 до 1000, вы уже не захотите использовать подобный метод. Вместо этого в Java вы можете использовать цикл для многократного прохождения строки кода, пока не достигнете 1000. Затем можно выйти из цикла и продолжить путь по коду.

Цикл for в Java

Мы начнем с цикла For, одного из самых распространенных типов циклов. Можно представить это так: «Цикл FOR (ДЛЯ) заданного числа раз.»

Структура цикла For в Java такова:

for (start_value; end_value; increment_number) {

      // Здесь ваш код

}

Таким образом, после слова «for» (в нижнем регистре) мы имеем пару круглых скобок, внутри которых вам нужны три вещи:

начальное значение для цикла, конечное значение для цикла и способ перехода от одного числа к другому. Это называется числом приращения и обычно равно 1. Но не обязательно.

После круглых скобок вам понадобится пара фигурных скобок. Фигурные скобки используются для разделения кода, который вы хотите повторно выполнить.

Пример может прояснить ситуацию.

Для циклов в Java начните новый проект. Назовите Project и Class как захотите. (Мы назвали наш проект «Loops», а класс «ForLoops»). Теперь добавьте следующий код:

package loops;

public class ForLoops {
   
    public static void main(String[] args) {

        int loopVal;
        int end_value = 11;
        
        for(loopVal = 0; loopVal < end_value; loopVal++) {
            System.out.println("Значение цикла = " + loopVal);
        }
    }
    
}

Мы начинаем с установки переменной int, которую мы назвали loopVal. Следующая строка устанавливает вторую переменную int. Эта переменная будет использоваться для конечного значения цикла и установлена ​​в 11. Мы собираемся циклически вывести числа от 0 до 10.

Внутри круглых скобок цикла for мы имеем следующее:

loopVal = 0; loopVal < end_value; loopVal++

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

. Это будет первое число в цикле. Во второй части используется условная конструкция:

loopVal < end_value

Это говорит «loopVal меньше, чем end_value». То есть цикл for будет продолжаться, пока значение в переменной loopVal будет меньше значения в переменной end_value. Пока это true (loopVal меньше end_value), Java будет продолжать вращать код цикла в фигурных скобках.

Последняя часть в круглых скобках цикла for выглядит так:

loopVal++ 

Здесь мы говорим Java, как перейти от начального значения loopVal к следующему в последовательности. Мы хотим считать от 0 до 10. Следующее число после 0 будет 1. loopVal ++ — это сокращенный способ сказать «добавь 1 к значению в переменной

».

Вместо loopVal ++, мы могли бы написать это:

loopVal = loopVal + 1

Справа от знака равенства идет loopVal + 1. То есть Java добавит 1 к тому, что в данный момент хранится в переменной loopVal. Как только Java добавит 1 к значению, программа сохранит результат внутри переменной слева от знака равенства. Это снова переменная loopVal. В результате 1 продолжает добавляться к переменной. Это называется приращением переменной. Столь распространено, что была изобретена сокращенная запись ++:

int some_number = 0; 
some_number ++;

Когда этот код начнет выполняться, значение some_number будет 1. Это короткий способ сказать это:

int some_number = 0; 
some_number = some_number + 1;

Напомним, что наш цикл for говорит следующее:

Начальное значение цикла

: 0
Продолжается цикл, пока: начальное значение меньше 11
Как перейти к конечному значению: прибавление 1 к начальному значению

Внутри фигурных скобок цикла for мы имеем следующее:

System. out.println("Значение цикла = " + loopVal);

Все, что находится внутри переменной loopVal, будет напечатано вместе с текстом.

Запустите свою программу, и вы должны увидеть это в окне вывода:

Таким образом, мы замкнули программу в цикле Java и заставили ее вращаться. Каждый раз в цикле добавляется 1 к переменной loopVal. Цикл продолжает запускаться, пока значение внутри loopVal меньше значения в end_value. Все, что находится внутри фигурных скобок цикла, — это код, который будет выполняться снова и снова. И в этом весь смысл цикла в Java: выполнять код в фигурных скобках снова и снова.

Попробуйте этот код. Он суммирует числа от 1 до 10:

public static void main(String[] args) {
               
     int loopVal;
     int end_value = 11;
     int addition = 0;
        
     for(loopVal = 1; loopVal < end_value; loopVal++) {
         addition = addition + loopVal;
     }
        
     System. out.println("Общее = " + addition);
              
}   

Ответ, который вы должны получить в окне вывода — 55.

Сам код более или менее совпадает с предыдущим циклом for. У нас есть две переменные int, установленные в верхней части кода, loopVal

и end_value. Также есть третья целочисленная переменная, которую мы назвали addition. Она будет содержать значения от 1 до 10.

В круглых скобках цикла for почти то же самое, что и в прошлый раз: мы запускаем цикл, пока loopVal меньше end_value, и добавляем 1 к переменной loopVal каждый раз в цикле (loopVal ++). Разница лишь в том, что начальное значение теперь равно 1 (loopVal = 1).

В фигурных скобках у нас есть только одна строка кода:

addition = addition + loopVal;

Эта строка кода складывает числа от 1 до 10. Если вы не понимаете, как это работает, начните справа от знака равенства:

addition + loopVal;

При первом запуске цикла переменная addition содержит значение 0.

В то же время переменная loopVal содержит значение 1 (его начальное значение). Java добавит 0 к 1. Затем программа сохранит результат в переменной слева от знака равенства. Опять же, это переменная addition. Все, что ранее содержалось в переменной addition (0), будет удалено и заменено новым значением (1).

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

addition(1) + loopVal(2);

1 + 2 — это, очевидно, 3. Таким образом, это новое значение, которое будет сохранено слева от знака равенства.

В третий раз в цикле новые значения:

addition(3) + loopVal(3);

Java добавляет 3 + 3 и сохраняет 6 слева от знака равенства. Так продолжается, пока не закончится цикл. Результат 55.

(Обратите внимание, что наша строка печати находится

за пределами цикла for в Java после последней фигурной скобки цикла.)

Упражнение

Измените свой код так, чтобы цикл суммировал числа от 1 до 100. Ответ, который вы должны получить, — 5050.

Упражнение E

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

Окно вывода должно выглядеть примерно так:

Ответ на упражнение E

Помощь для этого упражнения

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

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

Полей в таблице должно быть только от 1 до 10, как у нас на изображении выше.

Упражнение F

Выведите нечетные числа от 1 до 10. Используйте для этого цикл for.

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

Сложность в выполнении вышеупомянутого упражнения в том, что необходимо использовать оператор, с которым вы еще не встречались, — оператор модуля числа. Модуль числа — это когда вы делите число на число и остается остаток от деления.

Например, 10 модуль 3 равно 1. То есть 10 делим на 3, равно 3. Остаток от деления равен 1. Модуля числа в Java — знак процента, довольно запутанно. Используется так:

int remainder;
int total = 10;
remainder = total%3;

То есть, число (или переменная), которую вы хотите разделить, идет первым. Затем вы пишите знак процента, а затем число делителя. Ответ остаток.

В приведенном выше упражнении вы можете использовать 2 в качестве модуля числа, а затем использовать оператор if в цикле for, чтобы проверить, что является остатком. (Вы понимаете, почему число 2 должно быть модулем числа?)

Ответ на упражнение F

В следующем уроке мы рассмотрим циклы Java while.

Java — Циклы и операторы цикла / ProgLang

Цикл — операторы выполняются последовательно: первый оператор функции выполняется первым, затем второй и так далее. Цикл используется в ситуации, когда Вам нужно выполнить блок кода несколько раз.

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

Циклы

Объявления цикла позволяет выполнить оператор или группу операторов несколько раз, ниже приводится общая структура оператора цикла в большинстве языков программирования:

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

ЦиклОписание
whileПовторяет оператор или группу операторов, пока заданное условие является true. Цикл проверяет условие до выполнения тела цикла.
forВыполняет последовательность операторов несколько раз и сокращает код, которым управляет переменная цикла.
улучшенный forВыполняет последовательность операторов несколько раз и сокращает код, которым управляет переменная цикла.
do…whileВыполняется цикл while, за исключением того, что он проверяет условия в конце тела цикла.

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

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

Java поддерживает следующие управляющие операторы цикла.

ОператорОписание
breakЗавершает работу цикла или оператора switch, и передаёт выполнение следующему, который находится сразу же после цикла или оператора switch.
continueЗаставляет цикл, пропустить оставшуюся часть его тела и сразу перепроверить вновь его состояние сначала.
Поделитесь:

Pro Java: Операторы for и foreach

Начиная с версии 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 стала более наглядный я приведу небольшой пример. Хотя методы мы еще не изучали, но я надеюсь идея этой программы будет вам понята. Смысл ее в том, чтобы наглядно показать последовательность выполнения всех частей оператора 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 закончим.

Руководство по циклам Java

1. Обзор

В этой статье мы рассмотрим основной аспект языка Java — многократное выполнение оператора или группы операторов с использованием циклов.

2. Введение в циклы

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

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

Вот типы циклов, которые мы можем найти в Java:

  • Простой для петли
  • Расширенный для каждого цикла
  • Пока петля
  • Do-while Петля

3. Для петли

Цикл для — это управляющая структура, которая позволяет нам повторять определенные операции, увеличивая и оценивая счетчик цикла.

Подробный пример см. В специальной публикации: Java For Loop.

4. Пока Цикл

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

Подробный пример см. В специальной публикации: Java While Loop.

5. Do-While Цикл

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

Подробный пример см. В специальной публикации: Java Do-While Loop.

6. Заключение

В этом кратком руководстве мы показали различные типы циклов, которые доступны в языке программирования Java.

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

Как всегда, примеры можно найти на GitHub.

Java For Loop, For-Each Loop, While, Do-While Loop (ULTIMATE GUIDE)

В этом руководстве мы рассмотрим четыре типа циклов в Java: цикл for, улучшенный цикл for (для каждого), цикл while и цикл do-while. Мы также рассмотрим концепции потока управления циклом с вложенными циклами, помеченными циклами, оператором прерывания, оператором продолжения, оператором возврата и областью локальных переменных. Мы также рассмотрим распространенные исключения и ошибки цикла, такие как бесконечные циклы, java.lang.ArrayIndexOutOfBoundsException и java.lang.OutOfMemoryError.

Каждый тип цикла будет показан с несколькими примерами, чтобы вы могли увидеть, как он используется в самых разных обстоятельствах. Мы рассмотрим, как вы перебираете символы в строке, массиве строк, массиве целых чисел, а также перебираете коллекции, такие как java.util.List, java.util.Set и java.util.Map.

Введение

Циклы используются в большинстве программ по разным причинам. Основная причина использования циклов — это необходимость повторять повторяющееся действие снова и снова.Обычно это будет для набора данных. Лучше и эффективнее использовать циклы, чем явно писать код для обработки каждого действия. А иногда программист не знает заранее, сколько фрагментов данных встретит программа, поэтому цикл будет необходим.

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

Понятия петель

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

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

На протяжении этого руководства мы будем обращаться к этим концепциям по мере знакомства с каждым циклом.

для петли

Циклы

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

для петлевой структуры

Циклы for в Java структурированы так, чтобы следовать этому порядку выполнения:

1) инициализация цикла
2) логическое условие — если истинно, перейти к следующему шагу; если false, выйти из цикла
3) тело цикла
4) значение шага
5) повторить с шага 2 (логическое условие)

Пример — увеличение значения шага

Вот простой цикл для увеличения значений от 0 до 99.

Обратите внимание на настройки для петли:

  • индекс цикла инициализируется 0
  • логическое условие проверяет, что индекс цикла меньше 100
  • Значение шага
  • увеличивает индекс цикла на 1 после каждого цикла
  • Цикл
  • завершается, когда я дохожу до 100 и логическое условие оценивается как ложное
 

1
2
3

для (int i = 0; i <100; i ++) {
System. out.println (я);
}

Выход:

 

1
2
3
4
5
6
7
8
9
10

0
1
2
3
4
...
96

Пример — уменьшение значения шага

Вот аналогичное значение цикла for с уменьшением значений от 100 до 1.

 

1
2
3

для (int i = 100; i> 0; i--) {
System.out.println (я);
}

Обратите внимание, что мы изменили следующее:

  • Цикл инициализируется на 100
  • логическое условие проверяет, что индекс цикла больше 0
  • значение шага уменьшает индекс цикла на 1 после каждого цикла
  • Цикл
  • завершается, когда я дохожу до 0, и логическое условие оценивается как ложное

Выход:

 

1
2
3
4
5
6
7
8
9

100
99
98
97
. ..
4
3
2
1

Пример — несколько переменных цикла

Вы также можете использовать более одной переменной в инициализации цикла, тестовом выражении и для значения шага. Единственное ограничение заключается в том, что логическое тестовое выражение должно оцениваться как одно значение (истина или ложь). Вот пример использования 3 разных переменных для инициализации цикла, условия проверки и значения шага. Обратите внимание, что условие теста имеет только одно значение, хотя мы используем три переменные.

 

1
2
3

для (int i = 0, j = 5, k = 30; (i + j + k) <500; i + = 5, j * = 2, k - = 2) {
System.out.println (i + j + k);
}

Выход:


 

Пример — без инициализации

Каждая часть цикла необязательна. Таким образом, вам не нужно иметь инициализацию цикла и значение шага, или даже условие тестирования.

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

 

1
2
3
4

int i = 0;
для (; i <5; i ++) {
System.out.println (i);
}

Выход:


 

Пример — Без значения шага

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

 

1
2
3
4

int i = 0;
для (; i <5;) {
System.out.println (я ++);
}

Выход:


 

Пример — бесконечный цикл

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

 

1
2
3
4

int i = 0;
для (;;) {
System.out.println (i ++);
}

Выход:

 

1
2
3
4
5
6
7
8
9
10

0
1
2
3
4
5
6
7.. продолжает расти без конца

Пример — целочисленный массив

Для перебора целочисленного массива с помощью цикла for мы инициализируем переменную цикла значением 0, которое является первым индексом массива. Логическое выражение проверяет, что i меньше размера массива, потому что последний индекс массива будет на 1 меньше размера массива.

 

1
2
3
4

int [] intArray = {1, 3, 5, 7, 9};
для (int i = 0; i длина; i ++) {
System.out.println (intArray [i]);
}

Выход:


 

Пример — строковые символы

Чтобы перебрать строку символов с помощью цикла for, мы инициализируем переменную цикла значением 0, а затем используем метод String.charAt () для получения символа по указанному индексу. Как и в примере с целочисленным массивом, мы начинаем индекс цикла с 0 и увеличиваем его на 1 меньше размера строки.Это связано с тем, что строковые индексы работают аналогично массивам в Java: индекс первого символа равен 0, а индекс последнего символа будет на 1 меньше, чем размер строки.

 

1
2
3
4
5

Строка myString = "привет";

для (int i = 0; i System.out.print (myString.charAt (i));
}

Выход:


 

Пример — строковый массив

Чтобы перебрать массив строк с помощью цикла for, мы будем использовать ту же технику, что и для перебора массива целых чисел. Индекс цикла инициализируется значением 0, и мы продолжаем цикл до тех пор, пока на 1 не будет меньше размера массива строк.

 

1
2
3
4
5
6
7
8
9
10

String [] myStrings = {
"alpha",
"beta",
"gamma"
"дельта"
};

для (int i = 0; i System.out.println (myStrings [i]);
}

Выход:


 

Пример — Список

Чтобы перебрать java.util.List с циклом for, мы инициализируем переменную цикла равным 0 и продолжаем цикл до тех пор, пока 1 не станет меньше размера списка. Мы используем метод List.get () для получения определенного элемента списка с текущим индексом цикла. В примере используется список строк, но структура будет работать точно так же для списка других элементов.

 

1
2
3
4
5
6
7
8
9

Список myList = new ArrayList ();
myList. добавить ("альфа");
myList.add («бета»);
myList.add («гамма»);
myList.add ("дельта");

для (int i = 0; i System.out.println (myList.get (i));
}

Выход:


 

Пример — Набор 1

Мы не можем перебирать java.util.Set напрямую с помощью цикла for, обращаясь к его элементам с помощью индекса, как мы это делали для списка. Вместо этого нам нужно сначала преобразовать набор в массив, а затем выполнить итерацию по массиву.Это один из способов преобразования java.util.Set в массив. Обратите внимание, что преобразованный массив является универсальным массивом объектов, даже если исходный набор состоял из строк. После преобразования в массив мы перебираем его таким же образом, как и для массива целых чисел. Также обратите внимание, что набор хранит только уникальные строки, которые мы добавили, а не в том порядке, в котором мы их добавляли.

 

1
2
3
4
5
6
7
8
9
10
11
12
13

Set mySet = new HashSet mySet. добавить ("альфа");
mySet.add («альфа»);
mySet.add («бета»);
mySet.add («гамма»);
mySet.add («гамма»);
mySet.add ("дельта");

Объект [] mySetStrings = mySet.toArray ();

для (int i = 0; i System.out.println (mySetStrings [i]);
}

Обратите внимание, порядок вывода отличается от порядка, в котором мы вставляли элементы в набор:


 

Пример — Набор 2

Мы также можем использовать цикл for для перебора java.util.Set, сначала преобразовав его в массив определенного типа. В этом примере мы перебираем элементы набора в цикле for после того, как они были преобразованы в массив строк.

 

1
2
3
4
5
6
7
8
9
10
11
12
13

Set mySet = new HashSet mySet. add («альфа»);
mySet.add («альфа»);
mySet.добавить («бета»);
mySet.add («гамма»);
mySet.add («гамма»);
mySet.add ("дельта");

Строка [] mySetStrings = mySet.toArray (новая Строка [mySet.size ()]);

для (int i = 0; i System.out.println (mySetStrings [i]);
}

Обратите внимание, порядок вывода отличается от порядка, в котором мы вставляли элементы в набор:


 

Пример — Карта

Чтобы перебрать java.util.Map с циклом for, мы сначала получаем набор ключей карты, а затем конвертируем этот java.util.Set в массив String.

 

1
2
3
4
5
6
7
8
9
10
11
12
13

Map myMap = new HashMap );
myMap.put («а», «альфа»);
myMap.put («б», «бета»);
myMap. put («с», «гамма»);
myMap.put («д», «дельта»);

Установите keySet = myMap.keySet ();

String [] keys = keySet.toArray (новая строка [keySet.size ()]);

для (int i = 0; i System.out.println ("Key:" + keys [i] + "Value:" + myMap.get (keys [i])) ;
}

Выход:

 

1
2
3
4

Ключ: a Значение: альфа
Ключ: b Значение: бета
Ключ: c Значение: гамма
Ключ: d Значение: дельта

Дополнительная литература

Оператор for (Учебные пособия по Java ™)
Учебник по программированию на Java — 22 — для циклов (YouTube)
Как выполнять итерацию по Set / HashSet без итератора?

Расширенный для цикла

Расширенные циклы for (также известные как циклы for-each или foreach) — это упрощенная версия цикла for. Преимущество состоит в том, что нужно писать меньше кода и меньше переменных для управления. Обратной стороной является то, что у вас нет контроля над значением шага и нет доступа к индексу цикла внутри тела цикла.

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

Улучшенная структура петли

Enhanced for циклы следуют этому порядку выполнения:

1) тело цикла
2) повторять с шага 1 до тех пор, пока не будет пройден весь массив или коллекция

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

Пример — целочисленный массив

Вы можете использовать расширенный цикл for для обхода элементов массива int один за другим:

 

1
2
3
4

int [] intArray = {1, 3, 5, 7, 9};
для (int currentValue: intArray) {
System. out.println (currentValue);
}

Переменная currentValue содержит текущее значение, по которому выполняется цикл в массиве intArray.Обратите внимание, что здесь нет явного значения шага — это всегда приращение на 1.

Двоеточие может означать «в». Таким образом, улучшенное объявление цикла for гласит: перебрать intArray и сохранить текущее значение массива int в переменной currentValue.

Вывод:


 

Пример — строковые символы

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

 

1
2
3
4
5
6

Строка myString = "привет";

// ошибка времени компиляции: можно выполнять итерацию только по массиву или экземпляру java. lang.Iterable
for (char c: myString) {

}

Выход:

 

1
2

Исключение в потоке "main" java.lang.Error: Неразрешенная проблема компиляции:
Можно выполнять итерацию только по массиву или экземпляру java.lang.Iterable

Чтобы решить эту проблему, мы можем преобразовать строку в массив символов, а затем выполнить итерацию по массиву:

 

1
2
3
4
5

Строка myString = "привет";

для (char c: myString.toCharArray ()) {
System.out.print (c);
}

Выход:


 

Пример — строковый массив

Мы можем использовать цикл for-each для перебора массива строк.Объявление цикла гласит: выполнить цикл по массиву String myStrings и сохранить текущее значение String в переменной currentString.

 

1
2
3
4
5
6
7
8
9
10

Строка [] myStrings = {
«Альфа»,
«бета»,
«гамма»,
«дельта»
};

для (String currentString: myStrings) {
System.out.println (currentString);
}

Выход:


 

Пример — Список

Улучшенный цикл for также может использоваться для итерации по java.util.List следующий:

 

1
2
3
4
5
6
7
8
9

Список myList = new ArrayList ();
myList.add («альфа»);
myList.add («бета»);
myList.add («гамма»);
myList.add ("дельта");

для (String currentItem: myList) {
System.out.println (currentItem);
}

Объявление цикла гласит: выполнить цикл по списку строк myList и сохранить текущее значение списка в переменной currentItem.

Выход:


 

Пример — Установить

Расширенный цикл for также можно использовать для перебора java.util.Set следующим образом:

 

1
2
3
4
5
6
7
8
9
10
11

Set mySet = new HashSet ();
mySet.add («альфа»);
mySet.add («альфа»);
mySet.add («бета»);
mySet.add («гамма»);
mySet.добавить ("гамма");
mySet.add ("дельта");

для (String currentItem: mySet) {
System.out.println (currentItem);
}

В объявлении цикла говорится: выполнить цикл по набору строк mySet и сохранить текущее значение набора в переменной currentItem. Обратите внимание, что, поскольку это Set, повторяющиеся строковые значения не сохраняются. Кроме того, нет необходимости преобразовывать элементы Set в массив, как мы делали для обычного цикла for.

Выход:


 

Пример — Карта

Чтобы перебрать java.util.Map с помощью цикла for-each, мы можем перебрать набор ключей карты:

 

1
2
3
4
5
6
7
8
9
10
11

Map myMap = new HashMap ();
myMap.put («а», «альфа»);
myMap.put («б», «бета»);
myMap.положить ("с", "гамма");
myMap.put («д», «дельта»);

Установить keySet = myMap.keySet ();

для (String currentKey: keySet) {
System.out.println ("Ключ:" + currentKey + "Значение:" + myMap.get (currentKey));
}

Выход:

 

1
2
3
4

Ключ: a Значение: альфа
Ключ: b Значение: бета
Ключ: c Значение: гамма
Ключ: d Значение: дельта

Дополнительная литература

For-Each Loop — Документация по Java 5
Каков синтаксис расширенного цикла for в Java?
Учебное пособие по программированию на Java — 31 — Улучшено для цикла (YouTube)
Синтаксис цикла для Java: «for (T obj: objects)»

Цикл пока

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

Структура цикла while

Циклы While в Java имеют более простую структуру, чем циклы for, поскольку у них нет значения инициализации или шага. Их структура соответствует следующему порядку исполнения:

1) логическое условие — если истинно, перейти к следующему шагу; если false, выйти из цикла
2) тело цикла
3) повторить с шага 1 (логическое условие)

Пример — целочисленный массив

Чтобы перебрать целочисленный массив с помощью цикла while, мы инициализируем локальную переменную значением 0, которое является первым индексом массива.Логическое выражение проверяет, что i меньше размера массива, потому что последний индекс массива будет на 1 меньше размера массива. Мы также увеличиваем локальную переменную внутри тела цикла.

 

1
2
3
4
5

int [] intArray = {1, 3, 5, 7, 9};
int я = 0;
в то время как (я length) {
System.out.println (intArray [i ++]);
}

Выход:


 

Пример — строковые символы

Чтобы перебрать строку символов с помощью цикла while, мы инициализируем локальную переменную до 0, а затем используем String.charAt (), чтобы получить символ по указанному индексу. Как и в предыдущем примере, мы увеличиваем локальную переменную внутри тела цикла.

 

1
2
3
4
5
6

Строка myString = "привет";

int я = 0;
while (i System.out.print (myString.charAt (i ++));
}

Выход:


 

Пример — строковый массив

Чтобы перебрать массив строк с помощью цикла while, мы будем использовать ту же технику, что и для перебора массива целых чисел.Локальная переменная инициализируется значением 0, и мы продолжаем цикл до тех пор, пока на 1 не будет меньше размера массива строк, при этом увеличивая локальную переменную внутри тела цикла.

 

1
2
3
4
5
6
7
8
9
10
11

Строка [] myStrings = {
«Альфа»,
«бета»,
«гамма»,
«дельта»
};

int я = 0;
в то время как (i System.out.println (myStrings [i ++]);
}

Выход:


 

Пример — Список

Чтобы перебрать java.util.List с помощью цикла while, мы инициализируем локальную переменную равной 0, чтобы использовать ее в качестве индекса списка, и продолжаем цикл до тех пор, пока на 1 не будет меньше размера списка. Мы используем метод List.get () для извлечения определенного элемента списка с локальной переменной и увеличения его в теле цикла.

 

1
2
3
4
5
6
7
8
9
10

Список myList = new ArrayList ();
мой список. добавить ("альфа");
myList.add («бета»);
myList.add («гамма»);
myList.add ("дельта");

int я = 0;
while (i System.out.println (myList.get (i ++));
}

Выход:


 

Пример — Набор 1

Мы не можем перебирать java.util.Set напрямую с помощью цикла while, получая доступ к его элементам с помощью индекса, как мы это делали для списка. Вместо этого нам нужно сначала преобразовать набор в массив, а затем выполнить итерацию по массиву.Преобразованный массив представляет собой общий массив объектов, даже если исходный набор состоял из строк. После преобразования в массив мы перебираем его таким же образом, как и для массива целых чисел.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14

Set mySet = new HashSet;
mySet. add ("альфа");
mySet.добавить ("альфа");
mySet.add («бета»);
mySet.add («гамма»);
mySet.add («гамма»);
mySet.add ("дельта");

Объект [] mySetStrings = mySet.toArray ();

int я = 0;
while (i System.out.println (mySetStrings [i ++]);
}

Выход:


 

Пример — Набор 2

Мы также можем использовать цикл while для перебора java.util.Set, сначала преобразовав его в массив определенного типа.В этом примере мы перебираем элементы набора в цикле while после того, как они были преобразованы в массив строк.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Set mySet = new Hash );
mySet.add ("альфа");
mySet.add ("альфа");
mySet.add («бета»);
mySet. add («гамма»);
mySet.добавить ("гамма");
mySet.add ("дельта");

Строка [] mySetStrings = mySet.toArray (новая строка [mySet.size ()]);

int я = 0;

while (i System.out.println (mySetStrings [i ++]);
}

Выход:


 

Пример — Карта

Чтобы перебрать java.util.Map с помощью цикла while, мы сначала получаем набор ключей карты, а затем конвертируем этот java.util.Установите в массив String. Обратите внимание, как мы должны вручную увеличивать i внутри тела цикла, потому что мы не используем цикл for.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Map myMap = new Hash , Строка> ();
myMap.put («а», «альфа»);
myMap.put («б», «бета»);
myMap.put («с», «гамма»);
myMap. положить ("д", "дельта");

Установить keySet = myMap.keySet ();

Строка [] keys = keySet.toArray (новая строка [keySet.size ()]);

int я = 0;
while (i System.out.println («Ключ:» + keys [i] + «Значение:» + myMap.get (keys [i]));
i ++;
}

Выход:

 

1
2
3
4

Ключ: a Значение: альфа
Ключ: b Значение: бета
Ключ: c Значение: гамма
Ключ: d Значение: дельта

Пример — бесконечный цикл

Бесконечный цикл while будет иметь место, если логическое условие всегда истинно.Этот цикл все равно можно было бы прервать, если бы внутри тела цикла использовался оператор break или return.

 

1
2
3
4

int i = 0;
while (истина) {
System. out.println (i ++);
}

Выход:


 

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

 

1
2
3
4
5
6
7
8
9
10
11

Строка [] myStrings = {
«Альфа»,
«бета»,
«гамма»,
«дельта»
};

int я = 0;
в то время как (я Система.out.println (myStrings [i ++]);
}

Дополнительная литература

Операторы while и do-while — Учебные пособия по Java ™
Цикл while в java (учебные пособия)
Учебник по программированию на Java — 13 — Цикл while (YouTube)

Цикл Do-While

Циклы Do-while (также известные как циклы do) лучше всего использовать, когда вы не знаете, сколько раз вам нужно перебирать что-то, И вы хотите выполнить цикл хотя бы один раз. Например, если программа непрерывно принимает ввод от пользователя и выводит его, пока пользователь не введет букву «q», тогда вы должны использовать цикл do-while, поскольку вам нужно будет принять ввод пользователя хотя бы один раз.

Структура цикла Do-While

Как и циклы while, циклы do-while в Java имеют более простую структуру, чем циклы for, потому что у них нет значения инициализации или шага. Они похожи на циклы while, но порядок операций другой. Их структура соответствует следующему порядку исполнения:

1) тело цикла
2) логическое условие — если истинно, перейти к следующему шагу; если false, выйти из цикла
3) повторить с шага 1 (тело цикла)

Разница между циклом do-while и циклом while заключается в том, что цикл do-while сначала выполняет тело перед вычислением логического условия, тогда как цикл while сначала оценивает логическое условие перед выполнением тела цикла.

Пример — целочисленный массив

Чтобы перебрать целочисленный массив с помощью цикла do-while, мы инициализируем локальную переменную до 0, который является первым индексом массива. Логическое выражение проверяет, что i меньше размера массива, потому что последний индекс массива будет на 1 меньше размера массива. Мы также увеличиваем локальную переменную внутри тела цикла. Поскольку цикл do сначала выполняет тело цикла перед проверкой логического выражения, код генерирует исключение ArrayIndexOutOfBoundsException, если массив был пуст.

 

1
2
3
4
5

int [] intArray = {1, 3, 5, 7, 9};
int я = 0;
сделать {
System.out.println (intArray [i ++]);
} в то время как (я

Выход:


 

Пример — строковые символы

Чтобы перебрать строку символов с помощью цикла do-while, мы инициализируем локальную переменную до 0, а затем используем String.charAt (), чтобы получить символ по указанному индексу. Как и в предыдущем примере, мы увеличиваем локальную переменную внутри тела цикла. Если бы строка была пустой, код вызвал бы исключение StringIndexOutOfBoundsException.

 

1
2
3
4
5
6

Строка myString = "привет";

int я = 0;
сделать {
System.out.print (myString.charAt (i ++));
} while (i

Выход:


 

Пример — строковый массив

Чтобы перебрать строку символов с помощью цикла do-while, мы инициализируем локальную переменную до 0, а затем используем метод String.charAt () для получения символа по указанному индексу. Как и в предыдущем примере, мы увеличиваем локальную переменную внутри тела цикла. Код вызовет исключение ArrayIndexOutOfBoundsException, если массив был пуст.

 

1
2
3
4
5
6
7
8
9
10
11

Строка [] myStrings = {
«Альфа»,
«бета»,
«гамма»,
«дельта»
};

int я = 0;
do {
System. out.println (myStrings [i ++]);
} while (я

Выход:


 

Пример — Список

Чтобы перебрать java.util.List с помощью цикла do-while, мы инициализируем локальную переменную равной 0, чтобы использовать ее в качестве индекса списка, и продолжаем цикл до тех пор, пока размер списка не станет на 1 меньше. Мы используем метод List.get () для извлечения определенного элемента списка с локальной переменной и увеличения его в теле цикла. Код вызовет исключение ArrayIndexOutOfBoundsException, если список будет пуст.

 

1
2
3
4
5
6
7
8
9
10

Список myList = new ArrayList ();
myList.add ("альфа");
myList.add («бета»);
myList.add («гамма»);
myList.add ("дельта");

int я = 0;
сделать {
System.out.println (myList. get (i ++));
} а (я

Выход:


 

Пример — Набор 1

Мы не можем перебирать java.util.Set напрямую с помощью цикла do-while, обращаясь к его элементам с помощью индекса, как мы это делали для списка. Вместо этого нам нужно сначала преобразовать набор в массив, а затем выполнить итерацию по массиву. Преобразованный массив представляет собой общий массив объектов, даже если исходный набор состоял из строк. После преобразования в массив мы перебираем его таким же образом, как и для массива целых чисел. Код вызовет исключение ArrayIndexOutOfBoundsException, если набор был пуст.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14

Set mySet = new HashSet;
mySet.добавить ("альфа");
mySet.add ("альфа");
mySet.add («бета»);
mySet. add («гамма»);
mySet.add («гамма»);
mySet.add ("дельта");

Объект [] mySetStrings = mySet.toArray ();

int я = 0;
сделать {
System.out.println (mySetStrings [i ++]);
} в то время как (я

Выход:


 

Пример — Набор 2

Мы также можем использовать цикл do-while для итерации по java.util.Set, сначала преобразовав его в массив определенного типа. В этом примере мы перебираем элементы набора в цикле do-while после того, как они были преобразованы в массив строк. Код вызовет исключение ArrayIndexOutOfBoundsException, если набор был пуст.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Set mySet = new Hash );
mySet.добавить ("альфа");
mySet.add ("альфа");
mySet. add («бета»);
mySet.add («гамма»);
mySet.add («гамма»);
mySet.add ("дельта");

Строка [] mySetStrings = mySet.toArray (новая строка [mySet.size ()]);

int я = 0;

делать {
System.out.println (mySetStrings [i ++]);
} в то время как (я

Выход:


 

Пример — Карта

Чтобы перебрать java.util.Map с циклом do-while, мы сначала получаем набор ключей карты, а затем конвертируем этот java.util.Set в массив String. Код вызовет исключение ArrayIndexOutOfBoundsException, если карта будет пустой.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Map myMap = new Hash , Строка> ();
myMap.put («а», «альфа»);
myMap.положить ("б", "бета");
myMap.put («с», «гамма»);
myMap. put («д», «дельта»);

Установить keySet = myMap.keySet ();

Строка [] keys = keySet.toArray (новая строка [keySet.size ()]);

int я = 0;
do {
System.out.println («Ключ:» + keys [i] + «Значение:» + myMap.get (keys [i]));
i ++;
} в то время как (i

Выход:

 

1
2
3
4

Ключ: a Значение: альфа
Ключ: b Значение: бета
Ключ: c Значение: гамма
Ключ: d Значение: дельта

Пример — бесконечный цикл

Бесконечный цикл while будет иметь место, если логическое условие всегда истинно.Этот цикл все равно можно было бы прервать, если бы внутри тела цикла использовался оператор break или return.

 

1
2
3
4

int i = 0;
делать {
System. out.println (i ++);
} while (истина);

Выход:


 

Дополнительная литература

Операторы while и do-while — Учебники по Java ™
Учебное пособие по программированию на Java — 24 — Циклы do while (YouTube)
Синтаксис Do while для java — упражнение по отладке

Контур управления потоком

Заявление о разрыве

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

В следующем примере мы используем простой цикл for для вывода значений от 0 до 9:

 

1
2
3

для (int i = 0; i <10; i ++) {
System.out.println (i);
}

Выход:


 

Теперь, если мы добавим оператор break, когда i == 4, наш код выйдет из цикла, когда i станет равным 4. Вы можете использовать оператор break для выхода из циклов for, while и do-while. Оператор break только выйдет из текущего цикла. Чтобы выйти из внешнего цикла из вложенного внутреннего цикла, вам нужно будет использовать метки с оператором break.

 

1
2
3
4
5
6

для (int i = 0; i <10; i ++) {
System.out.println (i);
if (i == 4) {
break;
}
}

Выход:


 

Продолжить Заявление

Оператор continue в Java пропускает текущую итерацию цикла и переходит непосредственно к следующей итерации.После вызова оператора continue в цикле for выполнение цикла выполнит значение шага и оценит логическое условие перед переходом к следующей итерации. В следующем примере мы печатаем все значения от 0 до 9 в цикле, но пропускаем печать 4.

 

1
2
3
4
5
6

for (int i = 0; i <10; i ++) {
if (i == 4) {
continue;
}
Система. out.println (я);
}

Выход:

 

1
2
3
4
5
6
7
8
9

0
1
2
3
5 <---- ПРОПУСКАЕТСЯ НАВЕРХ 4 и продолжается следующей итерацией цикла
6
7
8
9

Вы также можете использовать оператор continue в цикле while, но вам нужно будет перебирать значение шага внутри цикла.Обратите внимание, как итерация i ++ выполняется в двух местах: прямо перед вызовом coninue и в конце тела цикла. Если бы я не был увеличен до продолжения, цикл застрял бы в бесконечном цикле, потому что я застрял бы на 4 и продолжал бы вызывать continue, чтобы перейти к началу цикла.

 

1
2
3
4
5
6
7
8
9

int i = 0;
while (i <10) {
if (i == 4) {
i ++;
продолжить;
}
Система. out.println (я);
i ++;
}

Выход:

 

1
2
3
4
5
6
7
8
9

0
1
2
3
5 <---- ПРОПУСКАЕТСЯ НАВЕРХ 4 и продолжается следующей итерацией цикла
6
7
8
9

Оператор continue в цикле do-while используется аналогично циклу while — переменная цикла должна увеличиваться вручную в двух местах в теле цикла, чтобы предотвратить состояние бесконечного цикла, точно так же, как некоторое время петля.

 

1
2
3
4
5
6
7
8
9

int i = 0;
do {
if (i == 4) {
i ++;
продолжить;
}
System.out.println (i);
i ++;
} while (i <10);

Выход:

 

1
2
3
4
5
6
7
8
9

0
1
2
3
5 <---- ПРОПУСКАЕТСЯ НАВЕРХ 4 и продолжается следующей итерацией цикла
6
7
8
9

Вложенные циклы

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

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

 

1
2
3
4
5
6
7

for (int i = 0; i <5; i ++) {// цикл 1
for (int j = 0; j <4; j ++) {// цикл 2
for (int k = 0; k <2; k ++) {// цикл 3
System.out.println ("[" + i + "] [" + j + "] [" + k + "]");
}
}
}

Выход:

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

[0] [0] [0]
[ 0] [0] [1]
[0] [1] [0]
[0] [1] [1]
[0] [2] [0]
[0] [2] [1]
[ 0] [3] [0]
[0] [3] [1]
[1] [0] [0]
[1] [0] [1]
[1] [1] [0]
[ 1] [1] [1]
[1] [2] [0]
[1] [2] [1]
[1] [3] [0]
[1] [3] [1]
[ 2] [0] [0]
[2] [0] [1]
[2] [1] [0]
[2] [1] [1]
[2] [2] [0]
[ 2] [2] [1]
[2] [3] [0]
[2] [3] [1]
[3] [0] [0]
[3] [0] [1]
[ 3] [1] [0]
[3] [1] [1]
[3] [2] [0]
[3] [2] [1]
[3] [3] [0]
[ 3] [3] [1]
[4] [0] [0]
[4] [0] [1]
[4] [1] [0]
[4] [1] [1]
[ 4] [2] [0] 9 0129 [4] [2] [1]
[4] [3] [0]
[4] [3] [1]

Этикетка петли

Многие ранние языки программирования, такие как C / C ++, использовали ключевое слово goto , чтобы программа перескакивала или «переходила» в другую часть программы, откуда она в настоящее время выполняется. У оператора goto определенно плохая репутация из-за того, что он может усложнить понимание программы и привести к «спагетти-коду», за которым очень трудно следить за ходом выполнения.

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

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

В следующем примере используются 3 цикла, вложенных друг в друга. Поскольку нет способа полностью выйти из самого внешнего цикла изнутри самого внутреннего цикла, мы можем использовать метку «external1» для выполнения этого и указать метку рядом с оператором break.

 

1
2
3
4
5
6
7
8
9
10
11

external1:
для (int i = 0; i <5; i ++) {
для (int j = 0; j <4; j ++) {
для (int k = 0; k <2; k ++) {
System.out.println ("[" + i + "] [" + j + "] [" + k + "]");
if (j == 3) {
break external1;
}
}
}
}

Выход:

 

1
2
3
4
5
6
7

[0] [0] [0]
[0] [0] [1]
[0] [1] [ 0]
[0] [1] [1]
[0] [2] [0]
[0] [2] [1]
[0] [3] [0]

Обратите внимание, что последняя отображаемая строка — это «[0] [3] [0]», где j == 3, и именно здесь мы вызвали «break external1;» чтобы вырваться из самого внешнего цикла.Мы также можем разместить метку на втором цикле, чтобы позволить разорвать его, не прерывая весь цикл:

 

1
2
3
4
5
6
7
8
9
10
11

для (int i = 0; i <5; i ++) {
external2:
для (int j = 0; j <4; j ++) {
для (int k = 0; k <2; k ++) {
System. out.println ("[" + i + "] [" + j + "] ["+ k +"] ");
if (j == 3) {
break external2;
}
}
}
}

Выход:

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
24
25
26
27
28
29
30
31
32
33
34
35

[0] [0] [0]
[0] [0] [1]
[ 0] [1] [0]
[0] [1] [1]
[0] [2] [0]
[0] [2] [1]
[0] [3] [0] <- --- ВЫРЫВ ВТОРОЙ ПЕТЛИ
[1] [0] [0]
[1] [0] [1]
[1] [1] [0]
[1] [1] [1]
[ 1] [2] [0]
[1] [2] [1]
[1] [3] [0] <---- РАЗРЫВ ВТОРОЙ ПЕТЛИ
[2] [0] [0]
[ 2] [0] [1]
[2] [1] [0]
[2] [1] [1]
[2] [2] [0]
[2] [2] [1]
[ 2] [3] [0] <---- ВЫХОДИТ ИЗ 2-Й ПЕТЛИ
[3] [0] [0]
[3] [0] [1]
[3] [1] [0]
[ 3] [1] [1]
[3] [2] [0]
[3] [2] [1]
[3] [3] [0] <---- ВЫРЫВАЕТСЯ ИЗ 2-Й ПЕТЛИ
[ 4] [0] [0]
[4] [0] [1]
[4] [1] [0]
[4] [1] [1]
[4] [2] [0]
[4] [2] [1]
[4] [3] [0] <---- РАЗРЫВ ВТОРОЙ ПЕТЛИ

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

Вы также можете использовать метки с ключевым словом continue, чтобы продолжить цикл с определенной точки. Взяв первый пример помеченного цикла и просто изменив одну строку, чтобы указать «continue outer1;» вместо «break external1;» вызовет продолжение цикла с метки «external1» вместо выхода из цикла. Обратите внимание, как каждый раз, когда вызывается «continue external1», код продолжается с внешнего цикла после увеличения индекса цикла i на 1.

 

1
2
3
4
5
6
7
8
9
10

external1:
для (int i = 0; i <5; i ++) {
для (int j = 0; j <4; j ++) {
для (int k = 0; k <2; k ++) {
System.out.println ("[" + i + "] [" + j + "] [" + k + "]");
if (j == 3) {
continue external1;
}
}
}

Выход:

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
24
25
26
27
28
29
30
31
32
33
34
35

[0] [0] [0]
[0] [0] [1]
[ 0] [1] [0]
[0] [1] [1]
[0] [2] [0]
[0] [2] [1]
[0] [3] [0] <- --- ПРОДОЛЖИТЬ С ЭТИКЕТКОЙ НАЗВАННОЙ ЗДЕСЬ
[1] [0] [0] <---- ПРОДОЛЖАЕТСЯ С СЛЕДУЮЩЕЙ ИТЕРАЦИИ ВНЕШНЕЙ ПЕТЛИ
[1] [0] [1]
[1] [1] [0]
[1] [1] [1]
[1] [2] [0]
[1] [2] [1]
[1] [3] [0] <---- ПРОДОЛЖИТЬ С ЭТИКЕТКОЙ, НАЗВАННОЙ ЗДЕСЬ
[2] [0] [0] <---- ПРОДОЛЖАЕТСЯ С СЛЕДУЮЩЕЙ ИТЕРАЦИИ ВНЕШНЕЙ ПЕТЛИ
[2] [0] [1]
[2] [1] [0]
[2] [1] [ 1]
[2] [2] [0]
[2] [2] [1]
[2] [3] [0] <---- ПРОДОЛЖИТЬ С ЭТИКЕТКОЙ, НАЗВАННОЙ ЗДЕСЬ
[3] [0] [ 0] <---- ПРОДОЛЖАЕТСЯ С СЛЕДУЮЩЕЙ ИТЕРАЦИИ ВНЕШНЕЙ ПЕТЛИ
[3] [0] [1]
[3] [1] [0]
[3] [1] [1]
[3] [2] [0]
[3] [2] [1]
[3] [3] [0] < ---- ПРОДОЛЖИТЬ С ЭТИКЕТКОЙ НАЗВАННОЙ ЗДЕСЬ
[4] [0] [0] <---- ПРОДОЛЖАЕТСЯ С СЛЕДУЮЩЕЙ ИТЕРАЦИИ ВНЕШНЕЙ ПЕТЛИ
[4] [0] [1]
[4] [1] [0 ]
[4] [1] [1]
[4] [2] [0]
[4] [2] [1]
[4] [3] [0]

Заявление о возврате в циклах

Оператор возврата Java используется для выхода из выполнения программы из метода. Его также можно использовать для выхода из цикла (или вложенного цикла) в методе. Его поведение аналогично оператору break, но в то время как оператор break выходит из текущего цикла, оператор return завершает весь метод.

 

1
2
3
4
5
6

for (int i = 0; i <10; i ++) {
if (i == 4) {
return; // выход из текущего метода
}
System.out.println (i);
}

Выход:


 

Область локальной переменной

Локальные переменные, определенные в циклах, видны только внутри цикла.Если вы попытаетесь использовать одну из этих переменных вне цикла, вы получите ошибку компиляции. Например, циклы for обычно инициализируют переменную цикла, и они доступны только из цикла for. В следующем примере используется цикл do-while с двумя локальными переменными: i и j. i был определен до цикла, поэтому он все еще доступен после цикла. Но j определяется внутри цикла, поэтому компилятор выдаст ошибку при попытке доступа к j вне цикла.

 

1
2
3
4
5
6
7
8

int i = 0;
сделать {
int j = 0; // определяется в цикле
System.out.println (я ++);
} в то время как (i <5);

i = 0; // ошибки нет - определено перед циклом
j = 1; // ошибка компиляции - определяется в цикле

Выход:

 

1
2

Исключение в потоке «main» java.lang.Ошибка: Неразрешенная проблема компиляции:
j не может быть разрешено в переменную

Дополнительная литература

Выход из вложенных циклов в Java
«цикл:» в коде Java.Что это, зачем компилируется?

Ошибки и исключения цикла

Циклы

имеют свои уникальные ошибки и исключения, которые мы рассмотрим ниже.

Бесконечные петли

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

Вот еще один пример бесконечного цикла for, в котором возникает небольшая ошибка. В коде используются 2 переменных цикла: i и j.Обратите внимание, как в логическом выражении используется i, а в значении шага j. Это вызовет бесконечный цикл, потому что i никогда не увеличивается, а логическое выражение всегда будет иметь значение true.

 

1
2
3
4
5

int [] intArray = {1, 3, 5, 7, 9};

для (int i = 0, j = 0; i System.out.println (intArray [i]);
}

Выход:


 

Исключение индекса массива вне границ

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

 

1
2
3
4
5

int [] intArray = {1, 3, 5, 7, 9};

для (int i = 0; i <= intArray.length; i ++) {
System.out.println (intArray [i]);
}

Выход:

 

1
2
3
4
5
6

1
3
5
7
9
Исключение в потоке «main» java.lang.ArrayIndexOutOfBoundsException: 5

Исключение возникает из-за того, что логическое выражение цикла проверяет, меньше ли i или равно размеру массива. Но поскольку в массиве 5 элементов, последний действительный индекс массива будет 4. Поэтому, когда цикл пытается получить доступ к массиву с индексом 5, JVM выдает исключение ArrayIndexOutOfBoundsException. Вот почему в выходных данных отображается «5», когда возникает исключение.

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

 

1
2
3
4
5

int [] intArray = {};
int я = 0;
сделать {
System.out.println (intArray [i ++]);
} в то время как (я

Выход:

 

1

Исключение в потоке "main" java.lang.ArrayIndexOutOfBoundsException: 0

Исключение строкового индекса за пределами границ

Это исключение может возникать при доступе к несуществующему элементу в строке. Он похож на ArrayIndexOutOfBoundsException, но более специфичен для строк. В следующем цикле do-while код пытается получить доступ к первому символу в пустой строке.

 

1
2
3
4
5
6

Строка myString = "";

int я = 0;
do {
System.out.print (myString.charAt (i ++));
} while (я

Выход:

 

1

Исключение в потоке «main» java.lang.StringIndexOutOfBoundsException: индекс строки вне допустимого диапазона: 0

Ошибка нехватки памяти

Часто циклы обнаруживают ошибку java.lang.OutOfMemoryError, когда каждая итерация цикла выделяет все больше и больше памяти.Вот простой пример, показывающий, как каждая итерация цикла выделяет память для все большего массива целых чисел, пока JVM не выдаст OutOfMemoryError. Каждая итерация цикла увеличивает размер массива в 5 раз.

 

1
2
3
4
5
6

int arraySize = 100;
для (int i = 0; i <15; i ++) {
int [] intArray = new int [arraySize];
System.out.println ("Созданный целочисленный массив размером:" + arraySize);
arraySize * = 5;
}

Выход:

 

1
2
3
4
5
6
7
8
9
10
11

Созданный массив целых чисел размера: 100
Созданный массив целых чисел размера: 500
размером: 2500
Создан целочисленный массив размером: 12500
Создан целочисленный массив размером: 62500
Создан целочисленный массив размером: 312500
Создан целочисленный массив размером: 1562500
Создан целочисленный массив размером: 7812500
Создан целочисленный массив размером : 3
00
Создан целочисленный массив размером: 195312500
Исключение в потоке "main" java. lang.OutOfMemoryError: пространство кучи Java

Дополнительная литература

Очень простая ошибка цикла для Java
Для цикла в Java | Важные моменты
java.lang.ArrayIndexOutOfBoundsException: 3 в цикле while

Java для цикла — Linux Подсказка

Иногда требуется многократно выполнять некоторые операторы для получения какого-либо конкретного вывода для решения проблемы, и этот тип задачи может быть легко выполнен с помощью любого типа цикла.Как правило, большинство языков программирования поддерживает три типа циклов. Цикл «for» является одним из них. Этот цикл очень полезен для выполнения различных типов задач программирования. В этом руководстве объясняется, как цикл « для» можно использовать в Java для различных целей.

Типы цикла for:

A. Цикл for для заданного количества итераций

Синтаксис:

for (инициализация; условие завершения; увеличение / уменьшение) {
Инструкция 1. ..n
}

Этот цикл состоит из трех частей. Первая часть содержит переменную инициализации, с которой цикл начнет итерацию. Вторая часть включает условие завершения, которое используется для завершения цикла. Третья часть содержит оператор увеличения или уменьшения на основе переменной инициализации для достижения условия завершения.

B. Цикл for для неопределенного количества итераций

Синтаксис:

for (переменная: массив или коллекция) {
Заявление 1…n
}

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

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

Пример-1: Вычислить факториал числа

Логическая проблема может быть решена очень легко с помощью цикла «for» . В этом примере показано, как факториальное значение числа может быть вычислено с помощью цикла for. Целочисленное значение будет получено от пользователя и сохранено в переменной с именем « n». Другая переменная, «результат» инициализируется значением 1, чтобы сохранить это значение n! . «for» будет повторяться n раз и умножать значение « result» на значение « на каждой итерации. Переменная результата будет содержать значение n! после выхода из цикла, который будет напечатан позже.

// Импортировать пакет сканера
import java.util.Scanner;
public class for1 {

public static void main (String [] args) {

// Создаем объект сканера
Scanner input = new Scanner (System.in);

System.out.print («Введите число:»);
// Берем строковые данные от пользователя
int n = input.nextInt ();

// Инициализируем переменную результата
int result = 1;

/ * Цикл будет повторяться n раз
* для вычисления n!
* /
for (int i = 1; i <= n; i ++) {
// Умножить значение i на результат и сохранить в результате
result * = i;
}

// Распечатайте факториал.
System.out.print («Факториал» + n + «равен» + результат «);

// Закройте объект сканера
input.close ();
}
}

Выход:

На следующем изображении показан результат выполнения кода. Здесь 5 принимается как значение n , а 5! — это напечатанное 120 .

Пример-2: Подсчет положительных, отрицательных и нулевых чисел из массива

В этом примере показано, как цикл « для» можно использовать для чтения значений числового массива и подсчета общего количества положительных, отрицательных и нулевых чисел в массиве.В коде определен числовой массив из 10 элементов. Свойство length используется в Java для подсчета общего количества элементов объекта массива. Он используется в цикле «for» для определения количества повторений цикла. Положительный , отрицательный, и нулевой Переменные счетчика инициализируются значением 0 для сохранения результата. Затем, , цикл «for» используется для чтения каждого значения массива и увеличения конкретного значения счетчика путем проверки условия « if» .Все переменные счетчика печатаются позже.

public class for2 {

public static void main (String [] args) {

// Объявить числовой массив
int numberic_arr [] = {34, -45, 12, 0, -5, 23, 0, 98, 21 , 7};

// Инициализировать счетчики
int положительное = 0, отрицательное = 0, ноль = 0;

/ * Итерируем массив с помощью цикла и
* находим положительные, отрицательные и нулевые числа
* /
для (int i = 0; i 0)
{
positive ++;
}
else if (numberic_arr [i] <0)
{
отрицательный ++;
}
else
{
ноль ++;
}
}

// Распечатать значения счетчика
System.out.print («Положительные числа:» + положительные + «\ n» +
«Отрицательные числа:» + отрицательные + «\ n» +
«Нулевые числа:» + ноль);
}
}

Выход:

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

Пример-3: Распечатать конкретное сообщение на основе каждого значения массива

Сколько раз будет повторяться цикл «for» , определено в двух предыдущих примерах.В этом примере цикл «for» используется с оператором «switch-case» для печати конкретного сообщения на основе каждого значения массива. Сколько раз будет повторяться этот цикл, зависит от количества элементов массива. Итак, цикл будет повторяться до тех пор, пока не будут проанализированы все элементы массива. На каждой итерации он сопоставляет значение элемента со значением case и печатает конкретное сообщение, в котором найдено совпадение; в противном случае он распечатает сообщение, определенное в разделе по умолчанию.

public class for_each {

public static void main (String [] args) {
// Объявить числовой массив
String fruit [] = {«Манго», «Банан», «Виноград», «Груша», «Клубника»} ;

// Цикл будет повторяться до тех пор, пока все значения не будут проанализированы из массива
for (String fruit: fruit) {

// Распечатать сообщение на основе фруктов
switch (fruit)
{
case «Mango»:
System. out.println («Цвет манго — зеленый»);
перерыв;

кейс «Банан»:
System.out.println («Цвет банана — желтый»);
перерыв;

ящик «Виноград»:
System.out.println («Цвет винограда — пурпурный или салатовый»);
перерыв;

шкаф «Клубника»:
Система.out.println («Цвет клубники красный»);
перерыв;

по умолчанию:
System.out.println («Информация о цвете« + fruit +
»не найдена»);
}
}
}
}

Выход:

На следующем изображении показан результат выполнения кода. Здесь не найдено совпадение для «Груша», , и сообщение по умолчанию печатается только для этого значения.

Вывод:

«for» loop очень полезен для простого решения многих типов проблем. Итерационный цикл фиксированное количество раз и чтение данных из объектов массива объясняются в этом руководстве с использованием различных примеров. Я надеюсь, что это руководство поможет новым пользователям Java правильно применить цикл « for» в своем коде.

Цикл For в java с примером

В java доступно несколько операторов цикла. Один из них — цикл в java.
For цикл в java используется для многократного выполнения некоторых операторов, пока условие не вернет false .
Цикл for состоит из трех частей.

  • Инициализация
  • Условие
  • Увеличение или уменьшение

Синтаксис для цикла for в java

for (инициализация; условие; увеличение / уменьшение) {

// блок операторов

}

Инициализация: Оператор инициализации выполняется в начале цикла только один раз.
условие: Условие оценивается на каждой итерации. Цикл For многократно выполняет блок операторов, если условие не возвращает false .
Увеличение / уменьшение: Эти операторы выполняются на каждой итерации.

Давайте возьмем очень простой пример

Распечатать число от 1 до 10, используя цикл for

открытый класс ForLoopMain {

public static void main (String [] args) {

for (int i = 1; i <11; i ++) {

Система. out.print («» + я);

}

}

}

Вывод:

1 2 3 4 5 6 7 8 9 10

Если вы все еще не понимаете приведенное выше понятие, давайте разберемся с ним с помощью схема.

Давайте теперь попробуем печатать только четные числа.

открытый класс ForLoopMain {

public static void main (String [] args) {

for (int i = 1; i <11; i ++) {

if (i% 2 == 0)

Систем.out.print («» + я);

}

}

}

Вывод:

2 4 6 8 10

Exercise

Если вам дан массив целых чисел, вам нужно найти элемент в этом массиве.

Ввод:

{32,45,53,65,43,23}

Вам нужно написать программу для поиска элемента в массиве . Если элемент найден в массиве, верните «PRESENT», иначе верните «NOT PRESENT»

Я бы порекомендовал вам попробовать это самостоятельно, а затем посмотреть на приведенный ниже код.

Программа:

1

2

3

4

5

6

7

8

9

10

000

11

000 14

15

16

17

18

19

20

21

22

23

24

пакет orjgava2arpit

открытый класс ForStatementExample {

public static void main (String [] args) {

ForStatementExample bse = new ForStatementExample ();

int arr [] = {32,45,53,65,43,23};

Система.out.println (bse.findElementInArr (arr, 53));

}

public String findElementInArr (int arr [], int elementTobeFound)

{

for (int i = 0; i

if (arr [i] == elementTobeFound)

{

System.out.println (elementTobeFound + «присутствует в массиве»);

возврат «НАСТОЯЩЕЕ»;

}

}

возврат «НЕТ»;

}

}

Выход:

53 присутствует в массиве
PRESENT

Бесконечный цикл for в java

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

package org.arpit.java2blog;

открытый класс ForLoopMain {

public static void main (String [] args) {

for (int i = 10; i> 0; i—) {

System.out.print («» + я);

}

}

}

Вывод:

10 9 8 7 6 5 4 3 2 1

Теперь в приведенном выше коде вместо i– вы поставили i ++.В этом коде цикл перейдет в бесконечный цикл.

пакет org.arpit.java2blog;

открытый класс ForLoopMain {

public static void main (String [] args) {

for (int i = 10; i> 0; i ++) {

System.out.print («» + i) ;

}

}

}

Другой пример бесконечного цикла находится под кодом:

package org. arpit.java2blog;

пакет org.arpit.java2blog;

открытый класс ForLoopMain {

public static void main (String [] args) {

for (;;) {

}

}

}

Используйте две переменные в цикл в java

Вы также можете использовать несколько переменных в цикле for.
Например:
Допустим, вы хотите проверить, является ли String палиндромом или нет.Вы можете использовать две переменные в цикле for, как показано ниже:

1

2

3

4

5

6

7

8

9

11

000 11

000

13

14

15

16

17

18

19

20

21

22

23

24

25

0007

25

29

30

31

32

33

34

пакет орг. arpit.java2blog;

импорт java.util.Scanner;

открытый класс StringUsingHalfLoop {

public static void main (String [] args) {

Scanner scanner = new Scanner (System.in);

System.out.print («Введите строку:»);

Строка str = scanner.nextLine ();

логическое isPalin = isPalindrome (str);

if (isPalin)

System.out.println («Строка — это палиндром»);

еще

Систем.out.println («Строка не палиндром»);

}

static boolean isPalindrome (String str)

{

for (int i = 0, j = str.length () — 1; i

if (str.charAt (i)! = str.charAt (j))

{

return false;

}

}

возврат true;

}

}

Вывод:

Введите строку: мадам
Строка — палиндром
Введите строку: adam
Строка не палиндром

java .

Как перебирать список Java? Семь (7) способов обхода цикла в Java • Crunchify

пакет crunchify.com.tutorials;

import java.util. *;

/ **

* @author Crunchify.com

* Как перебирать список Java? Семь (7) способов обхода цикла в Java.

* 1. Простой цикл For

* 2. Расширенный цикл For

* 3. Итератор

* 4. ListIterator

* 5.Цикл while

* 6. Iterable.forEach () util

* 7. Stream.forEach () util

* /

открытый класс CrunchifyIterateThroughList {

public static void main (String [] argv) {

// создать список

List crunchifyList = new ArrayList ();

// добавить 4 разных значения в список

crunchifyList.add («Facebook»);

crunchifyList.добавить («Paypal»);

crunchifyList.add («Google»);

crunchifyList.add («Yahoo»);

// Другой способ определения списка — мы не будем использовать этот список 🙂

List crunchifyListNew = Arrays. asList («Facebook», «Paypal», «Google», «Yahoo»);

// Простой цикл For

System.out.println («==============> 1. Пример простого цикла For.»);

для (int i = 0; i

System.out.println (crunchifyList.get (i));

}

// Новый усовершенствованный цикл For

System.out.println («\ n ==============> 2. Новый усовершенствованный пример цикла For ..») ;

для (String temp: crunchifyList) {

System.out.println (temp);

}

// Итератор — возвращает итератор по элементам в этом списке в правильной последовательности.

System.out.println («\ n ==============> 3. Пример итератора …»);

Итератор crunchifyIterator = crunchifyList.iterator ();

while (crunchifyIterator.hasNext ()) {

System.out.println (crunchifyIterator.next ());

}

// ListIterator — пройти по списку элементов в прямом или обратном порядке

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

// и получаем текущую позицию итератора в списке.

System.out.println («\ n ==============> 4. Пример ListIterator …»);

ListIterator crunchifyListIterator = crunchifyList.listIterator ();

в то время как (crunchifyListIterator.hasNext ()) {

System.out.println (crunchifyListIterator.next ());

}

// цикл while

System.out.println («\ n ==============> 5. Пример цикла while ….»);

int я = 0;

в то время как (i

System.out.println (crunchifyList.get (i));

я ++;

}

// Iterable.forEach () util: возвращает последовательный поток с этой коллекцией в качестве источника

System.out.println («\ n ============= => 6. Пример Iterable.forEach () …. «);

crunchifyList.forEach ((temp) -> {

System.out.println (temp);

});

// Коллекция Stream.forEach () util: возвращает последовательный поток с этой коллекцией в качестве источника

System.