중단 문과 계속 문 사이의 차이

중단 문과 계속 문 사이의 차이

누가 나에게 사이의 차이점을 말해줄 수 있니?break그리고continue진술서?

break고리를 남기면continue다음 반복으로 건너뛰다

자세한 내용 및 코드 샘플은 분기 문을 참조하십시오.

break

브레이크 문장은 라벨과 라벨이 부착되지 않은 두 가지 형태를 가지고 있다.스위치 문장의 이전 토론에서 레이블이 없는 양식을 보셨습니다.또한 라벨이 부착되지 않은 중단 시간을 사용하여 a for, while 또는 do-while 루프 [...]를 종료할 수 있다.

라벨이 부착되지 않은 브레이크 문은 가장 안쪽의 스위치를 종료하는 동안 또는 실행 중 문을 종료하지만, 라벨이 부착된 브레이크는 외부 문을 종료한다.

continue

계속 문장은 a for, while 또는 do-while 루프에 대한 현재 반복을 생략한다.라벨이 부착되지 않은 형태는 가장 안쪽 루프의 몸통 끝으로 건너뛰고 루프를 제어하는 부울 식을 평가한다.[...]

라벨이 부착된 계속 문장은 주어진 라벨로 표시된 외부 루프의 현재 반복을 생략한다.

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");

이는 다음과 같은 출력으로 이어진다.

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

블록에 레이블을 지정한 다음 내포 블록에서 외부 블록으로 중단/계속할 수 있다.이 방법이 유용할 수 있는 경우는 거의 없지만, 프로그램의 논리가 다음 예시보다 훨씬 더 잘 이해된다는 점을 제외하면 일반적으로 그러한 코드를 피하려고 할 것이다.

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));
        }
    }       
}

가능하기 때문에 꼭 써야 한다는 뜻은 아니다.

우스꽝스러운 방법으로 코드를 난독화하려면 비열한 이름을 선택하는 것이 아니라 http: 소스 코드의 웹어드레스처럼 외계인처럼 보이는 코멘트를 사용하여 다음을 수행하십시오.

http://stackoverflow.com/questions/462373
for (int i = 0; i < 4; ++i) 
{
     if (i == 2) 
         break http;

조슈아 블록 퀴즐에서 나온 것 같아.:)

Break는 루프를 완전히 벗어나고 루프가 끝난 후에 문장을 실행한다.반면에 Continue는 현재 반복을 남겨두고 루프의 다음 값으로 실행한다.

모든 것을 설명하는 코드:

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");
    }
}

출력:

0   1   2   3   
0   1   2   3   5   6   7   8   9

break고리를 완전히 벗어나다 continue계속성명 후 진술을 건너뛰고 계속 반복한다.

중단문

때때로 루프가 모든 단계 값에 대해 완전히 반복을 완료하기 전에 루프를 종료해야 한다.예를 들어, 특정 조건을 만족하는 숫자를 찾을 때까지 숫자 목록을 반복하는 것.특정 문자를 읽을 때까지 파일에서 문자 스트림을 반복하는 경우.

다음 예에서는 루프가 0에서 9까지의 값을 출력하는 간단한 예를 사용한다.

for(int i=0; i<10; i++) {
  System.out.println(i);
}

출력:

0
1
2
3
4
5
6
7
8
9

이제 i==4일 때 브레이크 문구를 추가하면, 우리 코드는 내가 4가 되면 루프를 벗어날 것이다.브레이크 문을 사용하여 루프와 실행 중 루프에서 분리할 수 있다.브레이크 문장은 현재 고리를 벗어날 뿐이다.내포된 내부 루프에서 외부 루프를 분리하려면 브레이크 문과 함께 레이블을 사용해야 한다.

for(int i=0; i<10; i++) {
  System.out.println(i);
  if(i==4) {
    break;
  }
}

출력:

0
1
2
3
4

계속 문

Java의 계속성명은 루프의 현재 반복을 건너뛰고 바로 다음 반복으로 간다.루프를 위해 계속 문을 호출한 후, 루프 실행은 다음 반복을 진행하기 전에 단계 값을 실행하고 부울 조건을 평가한다.다음 예에서는 0에서 9까지의 값을 모두 루프에 인쇄하고 있지만 4를 인쇄하는 것은 건너뛰고 있다.

for(int i=0; i<10; i++) {
  if(i==4) {
    continue;
  }
  System.out.println(i);
}

출력:

0
1
2
3
5 <---- SKIPPED OVER 4 and continued with next loop iteration
6
7
8
9

Loop Label - Break 문 내부 루프를 이탈한 후 실행할 위치를 지정하여 중첩된 루프 내의 레이블을 사용할 수 있다.일반적으로, 브레이크 문장은 가장 안쪽의 루프에서만 발생하므로, 외부 루프에서 벗어나고 싶을 때, 이것을 달성하기 위해 라벨을 사용할 수 있으며, 기본적으로 goto 문과 유사한 것을 할 수 있다.

다음 예제는 3개의 루프를 사용하며, 모두 서로 내포되어 있다.가장 안쪽 루프 안에서 가장 바깥쪽 루프를 완전히 벗어날 수 있는 방법이 없기 때문에, 우리는 "outer1"이라는 라벨을 사용하여 이것을 수행하고 브레이크 문 옆에 라벨을 지정할 수 있다.

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;
      }
    }
  }
}

출력:

[0][0][0]
[0][0][1]
[0][1][0]
[0][1][1]
[0][2][0]
[0][2][1]
[0][3][0]

표시된 마지막 선이 "0[0]"이고, 여기서 j == 3이며, 가장 바깥쪽 루프를 벗어나기 위해 "break outer1;"이라고 불렀다.

반복 레이블 - 계속 문

또한 계속 키워드와 함께 레이블을 사용하여 특정 지점에서 루핑을 계속할 수 있다. 한 '이명'의 '이명'을 하는 것이다.continue outer1;대신에break outer1;루프가 로프에서 루프를 계속 반복하도록 할 것이다.outer1루프를 이탈하는 대신 라벨을 붙인다.매번 어떻게 하는지 기록하십시오.continue outer1;이 코드는 루프 인덱스 i를 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]

출처: Java의 루프 – Ultimate 가이드

A breakswitch for do또는while).

A continue문은 현재 루프 반복을 종료하고 루프 문에 대한 제어를 되돌리기 위해 사용된다.

간단하고 정확한 탁월한 답변.

나는 코드 샘플을 추가할 것이다.

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

continue반면에 현재 실행 루프를 건너뛰고 MOVES TO 다음 루프로 이동한다.break MOVERSOK OUT를 루프 밖으로 이동하고 루프 후 다음 문을 실행한다.나는 다음 코드를 사용하여 그 차이를 배웠다.다양한 출력을 확인하십시오.이게 도움이 되길 바래.

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

다음을 고려하십시오.

int n;
for(n = 0; n < 10; ++n) {
    break;
}
System.out.println(n);

break는 루프가 종료되고 n의 값이 0이 된다.

int n;
for(n = 0; n < 10; ++n) {
    continue;
}
System.out.println(n);

계속하면 프로그램 카운터가 루프의 첫 번째 라인으로 돌아가게 되고(조건이 확인되고 n 값이 증가함) n의 최종 값은 10이다.

또한 파손은 다음 범위 내에 있는 루프의 실행을 종료할 뿐이라는 점에 유의해야 한다.

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);

의 효과에 어떤 것을 산출할 것이다.

0
0
0
0
0
5

그break문장이 루프에서 나오는 동안(다음 실행될 문장은 닫힘 가새 후 첫 번째 문이다)continue다음 반복에서 루프를 다시 시작한다.

그break문에는 현재 루프 제어 구조가 존재하며, 그 뒤로 점프하는 동안continue루핑 상태로 다시 뛰어오르지만 역시 탈출한다.

간단한 예:

break고리를 떠나다

int m = 0;
for(int n = 0; n < 5; ++n){
  if(n == 2){
    break;
  }
  m++;
}

System.out.printl("m:"+m); // m:2

continue다시 시작할 거야

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

조건이 충족될 경우 실행되지 않도록 하려면 계속을 사용하고 조건이 충족될 경우 루프를 벗어날 때는 중단 시간을 사용해야 한다.

예를 들어, 아래에 언급된 코드.

 for(int i=0;i<5;i++){

        if(i==3){

           continue;

        }
       System.out.println(i);
     }

위의 코드는 결과를 인쇄할 것이다: 0 1 2 4

NOw 이 코드 고려

 for(int i=0;i<5;i++){


            if(i==3){

                break;

            }
            System.out.println(i);
         }

이 코드는 0 1 2를 인쇄할 것이다.

그것이 연속과 단절의 기본적인 차이점이다.

여기 'break'의 의미가 있다.

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:;

다음은 '계속'의 의미:

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:;
}

우선, 나는 네가 자바에 두 가지 종류의 휴식이 있다는 것을 알아야 한다고 생각한다. 두 종류는 브레이크, 라벨링되지 않은 브레이크, 라벨링되지 않은 브레이크라고 표시되어 있다.이제, 나는 그들 사이의 차이점에 대해 말할 것이다.

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");
    }
}

라벨이 부착되지 않은 브레이크 문은 가장 안쪽의 스위치를 종료하는 동안 , , while , 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.
        }
    }
}

라벨이 붙은 브레이크는 외부 문을 종료한다. 만약 당신이 이 데모를 자바와 자바한다면, 당신은 다음을 얻을 것이다.

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.");
}

라벨이 부착되지 않은 계속 문장은 현재 반복된 "그동안" 문구를 생략한다.

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
        }
    }
}

라벨이 부착된 계속 문장이 주어진 라블이 표시된 외부 루프의 현재 반복을 생략한 경우, 당신이 자바와 자바 데모에 참여한다면, 당신은 다음을 얻을 수 있을 것이다.

0 - 0
0 - 1
0 - 2
0 - 3
1 - 0
1 - 1
1 - 2
1 - 3
2 - 0
2 - 1
2 - 2
2 - 3

질문이 있으면 Java 자습서를 참조하십시오.링크 설명을 입력하십시오.

간단히 말해서: 중단은 현재 루프를 종료하고, 루프가 종료된 후 첫 번째 라인에서 실행을 계속한다. 계속은 루프 상태로 다시 점프하여 루프를 계속 실행한다.

for (int i = 1; i <= 3; i++) {
        if (i == 2) {

            continue;
        }
        System.out.print("[i:" + i + "]");

이 코드를 순두콩으로 해보면 당신은 깨지는 것과 계속되는 것의 차이점을 이해할 것이다.

for (int i = 1; i <= 3; i++) {
        if (i == 2) {

            break;
        }
        System.out.print("[i:" + i + "]");

계속과 중단의 차이를 이해하는 간단한 프로그램

언제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

언제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

Statement 계속하기 Itration을 중지하고 다음 Itration 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 + "]");
    }

Break Statement Statement(분석 중단) 루프를 중지하거나 Loop에서 종료

그래서 당신은 a 루프 안에 있거나 혹은 루프를 하는 동안 있다.휴식 시간을 사용하면 당신을 루프의 바깥으로 나오게 할 것이다.인과 같이, 그것은 끝이 난다.계속하라; 다음 번 반복을 실행하라고 말할 것이다.

if 문장이 유용한 경우 계속을 사용할 필요가 없지만 break;는 유용하다.switch...case에서는 항상 break를 사용하십시오. 사례를 종료하려면 다른 사례를 실행하지 마십시오.

참조URL: https://stackoverflow.com/questions/462373/difference-between-break-and-continue-statement