java - usar - Diferencia entre ruptura y continuar declaración.
usar break en if (21)
¿Puede alguien decirme la diferencia entre las declaraciones de break y continue ?
Aquí está la semántica de la ruptura:
int[] a = new int[] { 1, 3, 4, 6, 7, 9, 10 };
// find 9
for(int i = 0; i < a.Length; i++)
{
if (a[i] == 9)
goto goBreak;
Console.WriteLine(a[i].ToString());
}
goBreak:;
Aquí está la semántica de continuar:
int[] a = new int[] { 1, 3, 4, 6, 7, 9, 10 };
// skip all odds
for(int i = 0; i < a.Length; i++)
{
if (a[i] % 2 == 1)
goto goContinue;
Console.WriteLine(a[i].ToString());
goContinue:;
}
Break abandona el bucle completamente y ejecuta las instrucciones después del bucle. Considerando que Continuar deja la iteración actual y se ejecuta con el siguiente valor en el bucle.
Este código lo explica todo:
public static void main(String[] args) {
for(int i=0;i<10;i++)
{
if (i==4)
{
break;
}
System.out.print(i+"/t");
}
System.out.println();
for(int i=0;i<10;i++)
{
if (i==4)
{
continue;
}
System.out.print(i+"/t");
}
}
Salida:
0 1 2 3
0 1 2 3 5 6 7 8 9
Considera lo siguiente:
int n;
for(n = 0; n < 10; ++n) {
break;
}
System.out.println(n);
break hace que el bucle termine y el valor de n es 0.
int n;
for(n = 0; n < 10; ++n) {
continue;
}
System.out.println(n);
continuar hace que el contador del programa vuelva a la primera línea del bucle (se comprueba la condición y el valor de n es incrementado) y el valor final de n es 10.
También se debe tener en cuenta que break solo termina la ejecución del bucle en el que se encuentra:
int m;
for(m = 0; m < 5; ++m)
{
int n;
for(n = 0; n < 5; ++n) {
break;
}
System.out.println(n);
}
System.out.println(m);
Saldrá algo al efecto de
0
0
0
0
0
5
Continuar Declaración detener la iteración y comenzar la siguiente iteración Ex:
System.out.println("continue when i is 2:");
for (int i = 1; i <= 3; i++) {
if (i == 2) {
System.out.print("[continue]");
continue;
}
System.out.print("[i:" + i + "]");
}
y Break Statment detiene el bucle o sale del bucle
Ejemplo simple:
break deja el bucle.
int m = 0;
for(int n = 0; n < 5; ++n){
if(n == 2){
break;
}
m++;
}
System.out.printl("m:"+m); // m:2
continue volverá a iniciar bucle.
int m = 0;
for(int n = 0; n < 5; ++n){
if(n == 2){
continue; // Go back to start and dont execute m++
}
m++;
}
System.out.printl("m:"+m); // m:4
En pocas palabras, break terminará el bucle actual y continuará la ejecución en la primera línea después de que finalice el bucle. continuar salta de nuevo a la condición de bucle y continúa ejecutando el bucle.
La declaración de break existe en la estructura de control de bucle actual y salta detrás de ella mientras que la continue también pero saltando de nuevo a la condición de bucle.
La instrucción de break rompe fuera del bucle (la siguiente instrucción que se ejecutará es la primera después de la llave de cierre), mientras que continue comienza el bucle en la siguiente iteración.
Para evitar que se ejecute algo si se cumple una condición, se debe usar la continuación y para salir del bucle, si se cumple una condición, se debe usar la interrupción.
Por ejemplo en el siguiente código mencionado.
for(int i=0;i<5;i++){
if(i==3){
continue;
}
System.out.println(i);
}
El código anterior imprimirá el resultado: 0 1 2 4
Ahora consideremos este código
for(int i=0;i<5;i++){
if(i==3){
break;
}
System.out.println(i);
}
Este código se imprimirá 0 1 2
Esa es la diferencia básica en el continuar y romper.
Primero, creo que deberías saber que hay dos tipos de interrupciones y continuar en Java que están etiquetadas como rotura, rotura no etiquetada, etiquetadas continuar y continuar sin etiquetar. Ahora, hablaré sobre la diferencia entre ellas.
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;//this is an unlabeled break,an unlabeled break statement terminates the innermost switch,for,while,do-while statement.
}
}
if (foundIt) {
System.out.println("Found " + searchfor + " at index " + i);
} else {
System.out.println(searchfor + " not in the array");
}
}
Una declaración de interrupción sin etiqueta termina el interruptor más interno, para, mientras que, la instrucción do-while.
public class BreakWithLabelDemo {
public static void main(String[] args) {
search:
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 5; j++) {
System.out.println(i + " - " + j);
if (j == 3)
break search;//this is an labeled break.To notice the lab which is search.
}
}
}
Una ruptura etiquetada termina una declaración externa. Si obtienes javac y java en esta demostración, obtendrás:
0 - 0
0 - 1
0 - 2
0 - 3
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;//this is an unlabeled continue.
// process p''s
numPs++;
}
System.out.println("Found " + numPs + " p''s in the string.");
}
Una instrucción de continuar sin etiquetar omite la iteración actual de una instrucción for, while, do-while.
public class ContinueWithLabelDemo {
public static void main(String[] args) {
search:
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 5; j++) {
System.out.println(i + " - " + j);
if (j == 3)
continue search;//this is an labeled continue.Notice the lab which is search
}
}
}
Una instrucción de continuar etiquetada omite la iteración actual de un bucle externo marcado con la etiqueta dada, si javac y java la demostración, obtendrá:
0 - 0
0 - 1
0 - 2
0 - 3
1 - 0
1 - 1
1 - 2
1 - 3
2 - 0
2 - 1
2 - 2
2 - 3
Si tiene alguna pregunta, puede ver el tutorial de Java de esto: ingrese la descripción del enlace aquí
Simple programa para entender la diferencia entre continuar y romper.
Cuando se usa continue
public static void main(String[] args) {
System.out.println("HelloWorld");
for (int i = 0; i < 5; i++){
System.out.println("Start For loop i = " + i);
if(i==2){
System.out.println("Inside if Statement for i = "+i);
continue;
}
System.out.println("End For loop i = " + i);
}
System.out.println("Completely out of For loop");
}
OutPut:
HelloWorld
Start For loop i = 0
End For loop i = 0
Start For loop i = 1
End For loop i = 1
Start For loop i = 2
Inside if Statement for i = 2
Start For loop i = 3
End For loop i = 3
Start For loop i = 4
End For loop i = 4
Completely out of For loop
Cuando se usa el break
public static void main(String[] args) {
System.out.println("HelloWorld");
for (int i = 0; i < 5; i++){
System.out.println("Start For loop i = " + i);
if(i==2){
System.out.println("Inside if Statement for i = "+i);
break;
}
System.out.println("End For loop i = " + i);
}
System.out.println("Completely out of For loop");
}
Output:
HelloWorld
Start For loop i = 0
End For loop i = 0
Start For loop i = 1
End For loop i = 1
Start For loop i = 2
Inside if Statement for i = 2
Completely out of For loop
Una declaración de break da como resultado la terminación de la declaración a la que se aplica ( switch , for , do o while ).
Una instrucción de continue se utiliza para finalizar la iteración del bucle actual y devolver el control a la instrucción de bucle.
Ver declaraciones de sucursales para más detalles y ejemplos de código:
break
La declaración de ruptura tiene dos formas: etiquetada y sin etiqueta. Usted vio la forma sin etiqueta en la discusión anterior de la declaración de cambio. También puede usar un salto sin etiqueta para terminar un ciclo for, while o do-while [...]
Una instrucción break sin etiqueta termina el interruptor más interno, para, while, o do-while, pero una ruptura etiquetada termina con una declaración externa.
continue
La instrucción continue omite la iteración actual de un bucle for, while o do-while. La forma sin etiqueta salta al final del cuerpo del bucle más interno y evalúa la expresión booleana que controla el bucle. [...]
Una instrucción de continuar etiquetada omite la iteración actual de un bucle externo marcado con la etiqueta dada.
así que estás dentro de un bucle for o while. Utilizando el descanso te pondrá fuera del bucle. Como en, terminará. Continuar; Le diré que ejecute la siguiente iteración.
No tiene sentido usar la instrucción if en if, pero break; es útil. En el interruptor ... caso, siempre usa break; Para terminar un caso, por lo que no ejecuta otro caso.
Excelente respuesta simple y precisa.
Me gustaría añadir un ejemplo de código.
C:/oreyes/samples/java/breakcontinue>type BreakContinue.java
class BreakContinue {
public static void main( String [] args ) {
for( int i = 0 ; i < 10 ; i++ ) {
if( i % 2 == 0) { // if pair, will jump
continue; // don''t go to "System.out.print" below.
}
System.out.println("The number is " + i );
if( i == 7 ) {
break; // will end the execution, 8,9 wont be processed
}
}
}
}
C:/oreyes/samples/java/breakcontinue>java BreakContinue
The number is 1
The number is 3
The number is 5
The number is 7
break completamente sale del bucle. continue salta las declaraciones después de la instrucción continue y continúa en bucle.
break deja un bucle, continue salta a la siguiente iteración.
continue omite el bucle de ejecución actual y MUEVE AL bucle siguiente, mientras que la break SE MUEVE FUERA del bucle y ejecuta la siguiente instrucción después del bucle. Aprendí la diferencia usando el siguiente código. Echa un vistazo a las diferentes salidas. Espero esto ayude.
public static void main(String[] args) {
for(int i = 0; i < 5; i++){
if (i == 3) {
continue;
}
System.out.print(i);
}
}//prints out 0124, continue moves to the next iteration skipping printing 3
public static void main(String[] args) {
for(int i = 0; i < 5; i++){
if (i == 3) {
break;
}
System.out.print(i);
}
}//prints out 012, break moves out of the loop hence doesnt print 3 and 4
Declaración de ruptura
A veces es necesario salir de un bucle antes de que el bucle haya terminado de iterar completamente sobre todos los valores de paso. Por ejemplo, repasar una lista de números hasta encontrar un número que satisfaga una determinada condición. O hacer un bucle sobre una secuencia de caracteres de un archivo hasta que se lea un carácter determinado.
En el siguiente ejemplo, estamos usando un simple bucle for para imprimir valores de 0 a 9:
for(int i=0; i<10; i++) {
System.out.println(i);
}
Salida:
0
1
2
3
4
5
6
7
8
9
Ahora, si agregamos una declaración de ruptura cuando i == 4, nuestro código saldrá del bucle una vez que sea igual a 4. Puede usar la instrucción de ruptura para separarse de los bucles, los bucles while y los ciclos do-while. La sentencia de ruptura solo saldrá del bucle actual. Para salir de un bucle externo de un bucle interno anidado, necesitaría usar etiquetas con la instrucción break.
for(int i=0; i<10; i++) {
System.out.println(i);
if(i==4) {
break;
}
}
Salida:
0
1
2
3
4
Continuar declaración
La instrucción de continuación de Java omite la iteración actual de un bucle y va directamente a la siguiente iteración. Después de llamar a la instrucción continue en un bucle for, la ejecución del bucle ejecutará el valor del paso y evaluará la condición booleana antes de continuar con la siguiente iteración. En el siguiente ejemplo, estamos imprimiendo todos los valores de 0 a 9 en un bucle, pero omitimos la impresión 4.
for(int i=0; i<10; i++) {
if(i==4) {
continue;
}
System.out.println(i);
}
Salida:
0
1
2
3
5 <---- SKIPPED OVER 4 and continued with next loop iteration
6
7
8
9
Etiqueta de bucle - Declaración de interrupción Puede usar etiquetas dentro de bucles anidados especificando dónde desea que continúe la ejecución después de salir de un bucle interno. Normalmente, la declaración de ruptura solo saldrá del bucle más interno, de modo que cuando quiera salir de un bucle externo, puede usar etiquetas para lograr esto, esencialmente haciendo algo similar a una instrucción goto.
El siguiente ejemplo utiliza 3 bucles, todos anidados uno dentro del otro. Ya que no hay forma de salir completamente del bucle más externo desde dentro del bucle más interno, podemos usar la etiqueta "outer1" para lograr esto y especificar la etiqueta al lado de la instrucción break.
outer1:
for(int i=0; i<5; i++) {
for(int j=0; j<4; j++) {
for(int k=0; k<2; k++) {
System.out.println("[" + i + "][" + j + "][" + k + "]");
if(j == 3) {
break outer1;
}
}
}
}
Salida:
[0][0][0]
[0][0][1]
[0][1][0]
[0][1][1]
[0][2][0]
[0][2][1]
[0][3][0]
Observe que la última línea que se muestra es " 0 [0]", que es donde j == 3 y es donde llamamos "break outer1;" para salir del bucle más exterior.
Etiquetas de bucle - Continuar declaración
También puede usar etiquetas con la palabra clave continue para continuar en bucle desde un punto específico. Tomando el ejemplo anterior y simplemente cambiando una línea para especificar continue outer1; en lugar de break outer1; hará que el bucle continúe en bucle desde la etiqueta outer1 lugar de salir del bucle. Observe cómo cada vez continue outer1; se llama, el código continúa desde el bucle externo después de incrementar el índice de bucle i en 1.
outer1:
for(int i=0; i<5; i++) {
for(int j=0; j<4; j++) {
for(int k=0; k<2; k++) {
System.out.println("[" + i + "][" + j + "][" + k + "]");
if(j == 3) {
continue outer1;
}
}
}
[0][0][0]
[0][0][1]
[0][1][0]
[0][1][1]
[0][2][0]
[0][2][1]
[0][3][0] <---- CONTINUE WITH LABEL CALLED HERE
[1][0][0] <---- CONTINUES FROM NEXT ITERATION OF OUTER LOOP
[1][0][1]
[1][1][0]
[1][1][1]
[1][2][0]
[1][2][1]
[1][3][0] <---- CONTINUE WITH LABEL CALLED HERE
[2][0][0] <---- CONTINUES FROM NEXT ITERATION OF OUTER LOOP
[2][0][1]
[2][1][0]
[2][1][1]
[2][2][0]
[2][2][1]
[2][3][0] <---- CONTINUE WITH LABEL CALLED HERE
[3][0][0] <---- CONTINUES FROM NEXT ITERATION OF OUTER LOOP
[3][0][1]
[3][1][0]
[3][1][1]
[3][2][0]
[3][2][1]
[3][3][0] <---- CONTINUE WITH LABEL CALLED HERE
[4][0][0] <---- CONTINUES FROM NEXT ITERATION OF OUTER LOOP
[4][0][1]
[4][1][0]
[4][1][1]
[4][2][0]
[4][2][1]
[4][3][0]
Fuente: 0
System.out.println ("starting loop:");
for (int n = 0; n < 7; ++n)
{
System.out.println ("in loop: " + n);
if (n == 2) {
continue;
}
System.out.println (" survived first guard");
if (n == 4) {
break;
}
System.out.println (" survived second guard");
// continue at head of loop
}
// break out of loop
System.out.println ("end of loop or exit via break");
Esto conducirá a la siguiente salida:
starting loop:
in loop: 0
survived first guard
survived second guard
in loop: 1
survived first guard
survived second guard
in loop: 2
in loop: 3
survived first guard
survived second guard
in loop: 4
survived first guard
end of loop or exit via break
Puede etiquetar un bloque, no solo un bucle for, y luego romper / continuar desde un bloque anidado a uno externo. En algunos casos, esto puede ser útil, pero en general tratará de evitar dicho código, excepto que la lógica del programa es mucho mejor de entender que en el siguiente ejemplo:
first:
for (int i = 0; i < 4; ++i)
{
second:
for (int j = 0; j < 4; ++j)
{
third:
for (int k = 0; k < 4; ++k)
{
System.out.println ("inner start: i+j+k " + (i + j + k));
if (i + j + k == 5)
continue third;
if (i + j + k == 7)
continue second;
if (i + j + k == 8)
break second;
if (i + j + k == 9)
break first;
System.out.println ("inner stop: i+j+k " + (i + j + k));
}
}
}
Porque es posible, no significa que debas usarlo.
Si quiere ofuscar su código de una manera divertida, no elija un nombre significativo, sino http: y sígalo con un comentario, que parece extraño, como una dirección web en el código fuente:
http://.com/questions/462373
for (int i = 0; i < 4; ++i)
{
if (i == 2)
break http;
Supongo que esto es de un quizzle Joshua Bloch. :)
for (int i = 1; i <= 3; i++) {
if (i == 2) {
continue;
}
System.out.print("[i:" + i + "]");
Pruebe este código en NetBeans. Comprenderá las diferencias entre romper y continuar.
for (int i = 1; i <= 3; i++) {
if (i == 2) {
break;
}
System.out.print("[i:" + i + "]");