Goto label in java

Labeled Break and Continue Statements in Java

In Java, we can label the loops and give them names. These named or labeled loops help in the case of nested loops when we want to break or continue a specific loop out of those multiple nested loops.

The labeled blocks in Java are logically similar to goto statements in C/C++.

A label is any valid identifier followed by a colon. For example, in the following code, we are creating two labeled statements:

outer_loop: for (int i = 0; i < array.length; i++) < inner_loop: for (int j = 0; j < array.length; j++) < //. >//. >

In the above example, we have two loops, and we have labeled them as outer_loop and inner_loop. This is helpful when we want to terminate the outer loop from a condition written in the inner loop.

2. Difference between Simple break and Labeled break

The simple break statement in Java terminates only the immediate loop in which it is specified. So even if we break from the inner loop, it will still continue to execute the current iteration of the outer loop.

We must use the labeled break statement to terminate a specific loop, as the outer_loop in the above example.

In the same way, we can use the labeled continue statements to jump to the next iteration of any specific loop in the hierarchy of nested loops.

3. Labeled Statement with Other Conditional Statements

It is worth mentioning that labeled break and continue statements can be used with other flow control statements such as if-else statements, while-loop etc.

The following program uses the labeled break statement with a while-loop. Whenever during the program execution, the labeled break statement is encountered, then the control immediately goes out of the enclosing labeled block.

hackit: while (Some condition) < if ( a specific condition ) break hackit; //label else //normal business logic goes here.. >

Similarly, we can use these statements with the classical if-else statements as well.

int i = 10; outer_if: if(i > 0) < inner_if: if( i>5) < //. break outer_if; >else < //. >> 

In this simple Java tutorial, we discussed the following points:

• Java does not have a general goto statement like a few other programming languages.
• The simple break and continue alter the normal flow control of the program. We can specify the named labels. A label should be a valid java identifier with a colon.
• Labeled blocks can only be used with break and continue statements.
• Labeled break and continue statements must be called within their scope. We can not refer them outside the scope of the labeled block.
• The break statement immediately jumps to the end (and out) of the appropriate compound statement.
• The continue statement immediately jumps to the appropriate loop’s next iteration (if any).

Источник

Операторы перехода в 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. 

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



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