Циклы в 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

Таким образом, мы замкнули программу в цикле 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 Ответ на упражнение 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.

Дата обновления: 28.07.2019

  • Текущий 0.00/5
  • 1
  • 2
  • 3
  • 4
  • 5

/Рейтинг: 0.0/5 (0 голос(ов) всего)

Добавить комментарий (без регистрации)