Является ли использование маркированного прерывания хорошей практикой в ​​Java?

Я смотрю на какой-то старый код 2001 года и наткнулся на это утверждение:

   else {
     do {
       int c = XMLDocumentFragmentScannerImpl.this.scanContent();
       if (c == 60) {
         XMLDocumentFragmentScannerImpl.this.fEntityScanner.scanChar();
         XMLDocumentFragmentScannerImpl.this.setScannerState(1);
         break label913;
       }

Я никогда раньше такого не видел и обнаружил здесь помеченные разрывы:

http://docs.oracle.com/javase/tutorial/java/nutsandbolts/branch.html

Разве это не работает по существу goto? Это вообще хорошая практика? Меня это беспокоит.

Нет, это не похоже на goto, поскольку вы не можете «перейти» к другой части потока управления.

Со страницы, на которую вы указали:

Оператор break завершает помеченный оператор; он не передает поток управления метке. Поток управления передается оператору, следующему за помеченным (завершенным) оператором.

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

Рассмотрим этот пример:

first:
for( int i = 0; i < 10; i++) {
  second:
  for(int j = 0; j < 5; j ++ )
  {
    break xxx;
  }
}

third:
for( int a = 0; a < 10; a++) {

}

Вы можете заменить xxxна firstили second(чтобы разорвать внешний или внутренний цикл), так как оба цикла выполняются, когда вы нажимаете breakоператор, но замена xxxна thirdне будет компилироваться.

Это не так ужасно, gotoпотому что он отправляет управление только в конец помеченного оператора (обычно это конструкция цикла). Дело в том, что делает gotoнесимпатичным, что это произвольная ветвь в любое место, в том числе этикетки нашла выше в источнике метода, так что вы можете иметь доморощенное зацикливание поведения. Функциональность разрыва ярлыков в Java не допускает такого безумия, потому что контроль только продвигается вперед.

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

Всегда можно заменить break на новый метод.

Рассмотрим проверку кода на наличие общих элементов в двух списках:

List list1, list2;

boolean foundCommonElement = false;
for (Object el : list1) {
    if (list2.contains(el)) {
        foundCommonElement = true;
        break;
    }
}

Вы можете переписать это так:

boolean haveCommonElement(List list1, List list2) {
    for (Object el : list1) {
        if (list2.contains(el)) {
            return true;
        }
    }
    return false;
}

Конечно, чтобы проверить общие элементы между двумя списками, лучше использовать list1.retainAll(new HashSet<>(list2))метод O(n)с O(n)дополнительной памятью или отсортировать оба списка по адресу, O(n * log n)а затем найти общие элементы по адресу O(n).

Прежде чем читать оставшуюся часть этого ответа, прочтите « Перейти к заявлению, которое считается вредным» . Если вы не хотите читать его полностью, вот что я считаю ключевым:

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

Или, перефразируя, проблема gotoв том, что программа может прибыть в середину блока кода, при этом программист не понимает состояние программы в этот момент. Стандартные блочно-ориентированные конструкции предназначены для четкого разграничения переходов между состояниями, обозначенногоbreak предназначен для перевода программы в определенное известное состояние (за пределами содержащего помеченный блок).

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

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

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

Это не похоже на gotoутверждение, в котором вы перемещаете управление потоком назад. Ярлык просто показывает вам (программисту), где произошел разрыв. Кроме того, управление потоком передается следующему оператору после break.

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

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

Например, измените это:

someLabel:
for (int j = 0; j < 5; j++)
{
    // do something
    if ...
        break someLabel;
}

в это:

private void Foo() {
    for (int j = 0; j < 5; j++)
    {
        // do something
        if ...
            return;
    }
}

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