Java следующая итерация цикла

Branching Statements

The break statement has two forms: labeled and unlabeled. You saw the unlabeled form in the previous discussion of the switch statement. You can also use an unlabeled break to terminate a for , while , or do-while loop, as shown in the following BreakDemo program:

class BreakDemo < public static void main(String[] args) < int[] arrayOfInts = < 32, 87, 3, 589, 12, 1076, 2000, 8, 622, 127 >; int searchfor = 12; int i; boolean foundIt = false; for (i = 0; i < arrayOfInts.length; i++) < if (arrayOfInts[i] == searchfor) < foundIt = true; break; > > if (foundIt) < System.out.println("Found " + searchfor + " at index " + i); >else < System.out.println(searchfor + " not in the array"); >> >

This program searches for the number 12 in an array. The break statement, shown in boldface, terminates the for loop when that value is found. Control flow then transfers to the statement after the for loop. This program’s output is:

An unlabeled break statement terminates the innermost switch , for , while , or do-while statement, but a labeled break terminates an outer statement. The following program, BreakWithLabelDemo , is similar to the previous program, but uses nested for loops to search for a value in a two-dimensional array. When the value is found, a labeled break terminates the outer for loop (labeled «search»):

class BreakWithLabelDemo < public static void main(String[] args) < int[][] arrayOfInts = < < 32, 87, 3, 589 >, < 12, 1076, 2000, 8 >, < 622, 127, 77, 955 >>; int searchfor = 12; int i; int j = 0; boolean foundIt = false; search: for (i = 0; i < arrayOfInts.length; i++) < for (j = 0; j < arrayOfInts[i].length; j++) < if (arrayOfInts[i][j] == searchfor) < foundIt = true; break search; >> > if (foundIt) < System.out.println("Found " + searchfor + " at " + i + ", " + j); >else < System.out.println(searchfor + " not in the array"); >> >

This is the output of the program.

The break statement terminates the labeled statement; it does not transfer the flow of control to the label. Control flow is transferred to the statement immediately following the labeled (terminated) statement.

The continue Statement

The continue statement skips the current iteration of a for , while , or do-while loop. The unlabeled form skips to the end of the innermost loop’s body and evaluates the boolean expression that controls the loop. The following program, ContinueDemo , steps through a String , counting the occurrences of the letter «p». If the current character is not a p, the continue statement skips the rest of the loop and proceeds to the next character. If it is a «p», the program increments the letter count.

class ContinueDemo < public static void main(String[] args) < String searchMe = "peter piper picked a " + "peck of pickled peppers"; int max = searchMe.length(); int numPs = 0; for (int i = 0; i < max; i++) < // interested only in p's if (searchMe.charAt(i) != 'p') continue; // process p's numPs++; >System.out.println("Found " + numPs + " p's in the string."); > >

Here is the output of this program:

To see this effect more clearly, try removing the continue statement and recompiling. When you run the program again, the count will be wrong, saying that it found 35 p’s instead of 9.

A labeled continue statement skips the current iteration of an outer loop marked with the given label. The following example program, ContinueWithLabelDemo , uses nested loops to search for a substring within another string. Two nested loops are required: one to iterate over the substring and one to iterate over the string being searched. The following program, ContinueWithLabelDemo , uses the labeled form of continue to skip an iteration in the outer loop.

class ContinueWithLabelDemo < public static void main(String[] args) < String searchMe = "Look for a substring in me"; String substring = "sub"; boolean foundIt = false; int max = searchMe.length() - substring.length(); test: for (int i = 0; i > foundIt = true; break test; > System.out.println(foundIt ? "Found it" : "Didn't find it"); > >

Here is the output from this program.

The return Statement

The last of the branching statements is the return statement. The return statement exits from the current method, and control flow returns to where the method was invoked. The return statement has two forms: one that returns a value, and one that doesn’t. To return a value, simply put the value (or an expression that calculates the value) after the return keyword.

The data type of the returned value must match the type of the method’s declared return value. When a method is declared void , use the form of return that doesn’t return a value.

The Classes and Objects lesson will cover everything you need to know about writing methods.

Источник

Операторы перехода в Java

Привет! Сегодня поговорим об операторах перехода в языке Java:

• return
• break
• continue
• goto

Для начала определимся с тем, что это вообще такое. Как известно, в обычной ситуации программа выполняется линейно — сверху вниз, команда за командой. Линейный ход программы могут изменить так называемые управляющие конструкции: например, ветвления ( if ) и циклы ( for , while и тд). Помимо управляющих конструкций, линейное выполнение программы могут изменить операторы перехода. Они отвечают за перенаправление выполнения программы в определенное место, которое зависит от контекста и конкретного оператора.Давай рассмотрим каждый из четырех операторов повнимательнее.

return

1. Немедленно заканчивает выполнение метода.
2. Немедленно заканчивает выполнение метода и возвращает какое-то значение в качестве результата работы метода.

 return; return value; // где value — некоторое возвращаемое значение 

В методах, которые возвращают некоторое значение, обязателен как минимум один оператор return с возвращаемым значением, который гарантированно вызовется, и недопустимо наличие оператора return без возвращаемого значения. Рассмотрим примеры ниже:

 public int sum(int a, int b) < return a + b; >public String getGreetings(String name) < return "Hello " + name; >public int max(int x, int y) < if (x >y) < return x; >else < return y; >> 

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

 public void print(String s) < // наличие return в void методах не обязательно System.out.println(s); >//Метод выведет в консоль число, если оно нечетное public void printIfOdd(int number) < if (number % 2 == 0) < // Если число четное, метод завершит свою работу // Наличие return в void методах опционально return; >System.out.println(number); > // Метод выведет в консоль наибольшее значение из массива private void printMaxInArray(int[] array) < if (array == null || array.length == 0) < /* Если массив пуст, метод завершит свою работу. Иногда полезно проверять подобным образом аргументы метода вначале и прерывать выполнение метода, если аргументы не подходят для дальнейшей корректной работы */ System.out.println("Empty array"); return; >int max = array[1]; for (int i = 1; i < array.length; i++) < if (array[i] >max) < max = array[i]; >> System.out.println(max); > 

labels (метки)

Прежде чем рассматривать операторы break и continue , хотелось бы поговорить о метках в ЯП Java. Это важно, потому что в некоторых ситуациях операторы break и continue используются совместно с метками. Но для начала попробуйте ответить на вопрос, скомпилируется ли такой код:

 public static void main(String[] args) < https://www.google.com/ System.out.println("Interesting. "); >

 public static void main(String[] args) < definePrintName: System.out.println("Таблица Умножения"); loop1: for (int i = 1; i System.out.println(); > > 

 Таблица Умножения 1 2 3 4 5 6 7 8 9 10 2 4 6 8 10 12 14 16 18 20 3 6 9 12 15 18 21 24 27 30 4 8 12 16 20 24 28 32 36 40 5 10 15 20 25 30 35 40 45 50 6 12 18 24 30 36 42 48 54 60 7 14 21 28 35 42 49 56 63 70 8 16 24 32 40 48 56 64 72 80 9 18 27 36 45 54 63 72 81 90 10 20 30 40 50 60 70 80 90 100 Process finished with exit code 0 

В примере выше definePrintName , loop1: и loop2: — это метки. loop1: и loop2: “отмечают” два цикла — внешний и внутренний. Использование меток мы рассмотрим в разделе ниже. А пока, если вы ответили “нет” на вопрос скомпилируется ли такой код:

 public static void main(String[] args) < https://www.google.com/ System.out.println("Interesting. "); >

break

1. Для завершения какой-либо ветки выполнения в блоке switch-case.
2. Для прерывания выполнения цикла.

 break labelName; // Синтаксис оператора с меткой break; // Синтаксис оператора без метки 

 public static void main(String[] args) < int dayOfWeekInt = 4; String dayOfWeek; switch (dayOfWeekInt) < case 1: dayOfWeek = "Понедельник"; break; case 2: dayOfWeek = "Вторник"; break; case 3: dayOfWeek = "Среда"; break; case 4: dayOfWeek = "Четверг"; break; case 5: dayOfWeek = "Пятница"; break; case 6: dayOfWeek = "Суббота"; break; case 7: dayOfWeek = "Воскресенье"; break; default: dayOfWeek = "Неизвестный день"; break; >System.out.println("Сегодня " + dayOfWeek); > 

В циклах оператор break используют для прерывания дальнейших итераций после того, как достигнуты определенные условия. Часто такое можно встретить, когда необходимо перебрать массив или коллекцию элементов и найти в ней какой-то элемент, удовлетворяющий нужным условиям. Рассмотрим такой пример. У нас есть массив и нам необходимо определить, содержит ли массив отрицательные элементы:

 int a[] = ; boolean arrayHasNegativeElements = false; for (int i = 0; i < a.length; i++) < if (a[i] < 0) < /* Как только найдется хотя бы один отрицательный элемент, мы прервем цикл с помощью оператора break, потому что мы выяснили то, что нас интересовало, и дальнейший перебор элементов не имеет смысла. */ arrayHasNegativeElements = true; break; >> 

 public static void main(String[] args) < int a[] = ; boolean arrayHasNegativeElements = false; for (int number : a) < if (number < 0) < arrayHasNegativeElements = true; break; >> > 

 public static void main(String[] args) < int a[] = ; boolean arrayHasNegativeElements = false; int counter = 0; while (counter < a.length) < if (a[counter] < 0) < arrayHasNegativeElements = true; break; >counter ++; > > 

 public static void main(String[] args) < int a[] = ; boolean arrayHasNegativeElements = false; int counter = 0; do < if (a[counter] < 0) < arrayHasNegativeElements = true; break; >counter ++; > while (counter

Еще одним примером оператора break в циклах является прерывание бесконечного цикла при достижении определенных условий. Приведем пример программы, выводящей строку, которую ввел пользователь до тех пор, пока юзер не введёт слово “stop”:

 public static void main(String[] args) < Scanner scanner = new Scanner(System.in); String line; while (true) < line = scanner.nextLine(); if ("stop".equals(line))< /* Прерываем бесконечный цикл, при достижении определенного условия */ break; >System.out.println("Пользователь ввел: " + line); > > 

Рассмотрим использование оператора break совместно с меткой. Прерывание с меткой используется в случаях с несколькими циклами, причем вложенными один в другой. В таком случае один из циклов (или же все циклы) помечается меткой. Далее оператор break совместно с указанием метки прерывает нужный цикл. Рассмотрим пример, в котором нам необходимо понять, есть ли отрицательный элемент, но только не в массиве, а в матрице:

 public static void main(String[] args) < int[][] a = < , , >; boolean hasNegative = false; searchNegative: for (int i = 0; i < a.length; i++) < for (int j = 0; j < a[i].length; j++) < if (a[i][j] < 0) < /* Если использовать break без метки, тогда прервется вложенный цикл for, но внешний продолжит выполнять свои итерации и поиск продолжится. Поэтому мы "помечаем" внешний цикл меткой `searchNegative` и прерываем внешний цикл оператором break совместно с нужной меткой. */ hasNegative = true; break searchNegative; >> > > 

сontinue

 continue; // форма оператора без метки continue labelName; // форма оператора с меткой 

В отличии от оператора break , который прерывает все оставшиеся итерации цикла, оператор continue прерывает текущую итерацию и приводит к запуску следующей.Такое может быть полезно, если нужно провести некоторые операции над элементами, которые удовлетворяют определенным условиям. Скажем, у нас есть строка, и мы хотим посчитать количество слов, начинающихся с буквы “м”:

 public static void main(String[] args) < String sentence = "Мама мыла раму"; String[] words = sentence.split(" "); int mWordsCount = 0; for (int i = 0; i < words.length; i++) < if ( ! words[i].toLowerCase().startsWith("м")) < /* Если слово не начинается с буквы м, то текущая итерация прервется и цикл ПРОДОЛЖИТ выполнение со следующей итерации */ continue; >mWordsCount ++; > System.out.println("Кол-во слов, начинающихся с буквы М в предложении: " + "[" + sentence + "] lang-java line-numbers"> Кол-во слов, начинающихся с буквы М в предложении: [Мама мыла раму] = 2 

 public static void main(String[] args) < int[][] a = < , , , , >; int rowsWithNegativeElementsCount = 0; rowsLoop: // Проходим по каждой строке for (int[] arr : a) < for (int number : arr) < if (number < 0) < /* Если в текущей строке найдется хотя бы 1 отрицательный элемент, тогда мы увеличим переменную счетчик, и с помощью оператора continue rowsLoop прервем текущую итерацию внешнего цикла и принудительно начнем следующую */ rowsWithNegativeElementsCount ++; continue rowsLoop; >> > System.out.println("Rows With Negative Elements Count lang-java line-numbers"> Rows With Negative Elements Count = 3 

public static void main(String[] args) < int[][] a = < , , , , >; int rowsWithNegativeElementsCount = 0; for (int[] arr : a) < for (int number : arr) < if (number < 0) < rowsWithNegativeElementsCount ++; break; >> > System.out.println("Rows With Negative Elements Count lang-java line-numbers">public static void main(String[] args) < int[][] a = < , , , , >; int rowsWithNegativeElementsCount = 0; for (int[] arr : a) < if (arrayHasNegativeElements(arr)) < rowsWithNegativeElementsCount ++; >> System.out.println("Rows With Negative Elements Count https://docs.oracle.com/javase/tutorial/java/nutsandbolts/_keywords.html" rel="nofollow" target="_blank">Список ключевых слов в Java включает слово goto. Однако данный оператор помечен как not used (не используется). Дело в том, что Джеймс Гослинг, создатель ЯП Java изначально заложил в JVM поддержку оператора goto. Однако впоследствии эту фичу выпилили. Одна из причин заключается в том, что блоки кода содержащие оператор goto, читались не так хорошо, как блоки кода, выполняющие те же функции, но без goto, а с альтернативными подходами (break, continue, вынесение блока кода в методы). Были, собственно и другие, как например: 

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

 Для многих не секрет, что в некоторых языках программирования оператор goto вполне успешно функционирует. Однако программисты избегают его использование. Почитать о причинах этого можно в одной статье на хабре. Но зачем тогда оставлять goto в списке зарезервированных слов? Все просто: на будущее. Если, к примеру, по всему миру в коде Java разработчиков переменные, методы или классы будут называться goto, если этот оператор вернут в одной из будущих версий Java, весь старый код сломается. Чтобы избежать такого сценария, goto остался в списке ключевых слов Java, но не несет в себе никакой функциональности. Возможно когда-нибудь goto вернется в наши ряды, но вероятность этого невысока.
Итоги
Мы рассмотрели различные операторы перехода в Java: 

  
return — завершение метода, возвращение значения из метода. 

  
с возвращаемым значением: методы, которые возвращают значения;
  
без возвращаемого значения: void методы.


  
break — прерывание циклов, switch-case блоки. 

  
с метками: циклы различной вложенности;
  
без меток: ветки switch-case блока; прерывание цикла, в котором был вызван.


  
continue. 

  
с метками: циклы различной вложенности;
  
без меток: продолжение цикла, в котором был вызван.


  
goto. 

  
есть в списке ключевых слов, но не используется.



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