¿Es una buena práctica usar una rotura etiquetada en Java?

Estoy mirando un código antiguo de 2001 y encontré esta declaración:

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

Nunca había visto esto antes y descubrí roturas etiquetadas aquí:

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

¿No funciona esto esencialmente goto? ¿Es incluso una buena práctica usarlo? Me hace sentir incómodo.

No, no es como un goto, ya que no puede "ir" a otra parte del flujo de control.

Desde la página que vinculó:

La sentencia break termina la sentencia etiquetada; no transfiere el flujo de control a la etiqueta. El flujo de control se transfiere a la declaración inmediatamente después de la declaración etiquetada (terminada).

Esto significa que solo puede romper los bucles que se estén ejecutando actualmente.

Considere este ejemplo:

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++) {

}

Puede reemplazar xxxcon firsto second(para romper el bucle externo o interno), ya que ambos bucles se están ejecutando, cuando presiona la breakinstrucción, pero reemplazar xxxcon thirdno se compilará.

No es tan terrible gotoporque solo envía el control al final de la declaración etiquetada (generalmente una construcción de bucle). Lo que lo hace gotodesagradable es que es una rama arbitraria a cualquier lugar, incluidas las etiquetas que se encuentran más arriba en la fuente del método, de modo que puede tener un comportamiento de bucle propio. La funcionalidad de rotura de etiquetas en Java no permite ese tipo de locura porque el control solo avanza.

Solo lo usé una vez hace unos 12 años, en una situación en la que necesitaba romper con los bucles anidados, la alternativa más estructurada habría hecho pruebas más complicadas en los bucles. No recomendaría usarlo mucho, pero no lo marcaría como un olor automático a código incorrecto.

Siempre es posible reemplazarlo breakcon un nuevo método.

Considere la verificación de código para cualquier elemento común en dos listas:

List list1, list2;

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

Puedes reescribirlo así:

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

Por supuesto, para buscar elementos comunes entre dos listas, es mejor usar el list1.retainAll(new HashSet<>(list2))método para hacerlo O(n)con O(n)memoria adicional, o ordenar ambas listas en O(n * log n)y luego encontrar elementos comunes en O(n).

Antes de leer el resto de esta respuesta, lea Ir a la declaración considerada dañina . Si no quiere leerlo en su totalidad, aquí está lo que considero el punto clave:

El uso desenfrenado de la declaración go to tiene una consecuencia inmediata de que resulta terriblemente difícil encontrar un conjunto significativo de coordenadas en las que describir el progreso del proceso.

O para reformular, el problema con gotoes que el programa puede llegar en medio de un bloque de código, sin que el programador comprenda el estado del programa en ese punto. Las construcciones estándar orientadas a bloques están diseñadas para delinear claramente las transiciones de estado, un etiquetado breakestá destinado a llevar el programa a un estado conocido específico (fuera del bloque etiquetado que lo contiene).

En un programa imperativo del mundo real, el estado no está claramente delimitado por límites de bloque, por lo que es cuestionable si la etiqueta breakes una buena idea. Si el bloque cambia de estado que es visible desde fuera del bloque, y hay varios puntos para salir del bloque, entonces una etiqueta breakes equivalente a la primitiva goto. La única diferencia es que, en lugar de la posibilidad de aterrizar en medio de un bloque con un estado indeterminado, comienzas un nuevo bloque con un estado indeterminado.

Entonces, en general, consideraría una etiqueta breakcomo peligrosa. En mi opinión, es una señal de que el bloque debe convertirse en una función, con acceso limitado al alcance adjunto.

Sin embargo, este código de ejemplo fue claramente el producto de un generador de analizador (el OP comentó que era el código fuente de Xerces). Y los generadores de analizadores sintácticos (o generadores de código en general) a menudo se toman libertades con el código que generan, porque tienen un conocimiento perfecto del estado y los humanos no necesitan entenderlo.

Esto no es como una gotodeclaración en la que se hace retroceder el control de flujo. Una etiqueta simplemente le muestra a usted (el programador) dónde ha ocurrido la ruptura. Además, el control de flujo se transfiere a la siguiente declaración después de break.

Sobre su uso, personalmente creo que no es de gran utilidad, ya que una vez que comienzas a escribir un código que vale miles de líneas, se vuelve insignificante. Pero de nuevo, dependería del caso de uso.

Una forma más limpia de expresar la intención podría ser, al menos en mi opinión, poner el fragmento de código que contiene el bucle en un método separado y simplemente return partir de él.

Por ejemplo, cambie esto:

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

dentro de esto:

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

Esto también es más idiomático para los desarrolladores que dominan otros lenguajes que podrían funcionar con su código en el futuro (o en el futuro ).