Beispiel 1:Java-Continue-Anweisung

class Main {
  public static void main(String[] args) {

    // for loop
    for (int i = 1; i <= 10; ++i) {

      // if value of i is between 4 and 9
      // continue is executed
      if (i > 4 && i < 9) {
        continue;
      }
      System.out.println(i);
    }
  }
}

Ausgabe :

1
2
3
4
9
10

Im obigen Programm verwenden wir den for Schleife, um den Wert von i auszugeben in jeder Iteration. Um zu wissen, wie for Schleife funktioniert, besuchen Sie Java für Schleife. Beachten Sie die Anweisung,

if (i > 4 && i < 9) {
    continue;
}

Hier die continue Anweisung wird ausgeführt, wenn der Wert von i wird mehr als 4 und weniger als 9 .

Es überspringt dann die Druckanweisung für diese Werte. Daher überspringt die Ausgabe die Werte 5 , 6 , 7 und 8 .

Beispiel 2:Berechne die Summe von 5 positiven Zahlen

import java.util.Scanner;

class Main {
  public static void main(String[] args) {

    Double number, sum = 0.0;
    // create an object of Scanner
    Scanner input = new Scanner(System.in);

    for (int i = 1; i < 6; ++i) {
      System.out.print("Enter number " + i + " : ");
      // takes input from the user
      number = input.nextDouble();

      // if number is negative
      // continue statement is executed
      if (number <= 0.0) {
        continue;
      }

      sum += number;
    }
    System.out.println("Sum = " + sum);
    input.close();
  }
}

Ausgabe :

Enter number 1: 2.2
Enter number 2: 5.6
Enter number 3: 0
Enter number 4: -2.4
Enter number 5: -3
Sum = 7.8

Im obigen Beispiel haben wir die for-Schleife verwendet, um die Summe von 5 positiven Zahlen auszugeben. Beachten Sie die Zeile,

if (number < 0.0) {
    continue;
}

Hier wird, wenn der Benutzer eine negative Zahl eingibt, die continue Anweisung ausgeführt wird. Dies überspringt die aktuelle Iteration der Schleife und bringt die Programmsteuerung zum Aktualisierungsausdruck der Schleife.

Hinweis :Um Eingaben vom Benutzer entgegenzunehmen, haben wir den Scanner verwendet Objekt. Um mehr zu erfahren, besuchen Sie Java Scanner.

Java fährt mit Nested Loop fort

Bei verschachtelten Schleifen in Java ist der continue -Anweisung überspringt die aktuelle Iteration der innersten Schleife.

---

Beispiel 3:Mit Nested Loop fortfahren

class Main {
  public static void main(String[] args) {

    int i = 1, j = 1;

    // outer loop
    while (i <= 3) {

      System.out.println("Outer Loop: " + i);

      // inner loop
      while(j <= 3) {

        if(j == 2) {
          j++;
          continue;
        }

        System.out.println("Inner Loop: " + j);
        j++;
      }
      i++;
    }
  }
}

Ausgabe

Outer Loop: 1
Inner Loop: 1
Inner Loop: 3
Outer Loop: 2
Outer Loop: 3

Im obigen Beispiel haben wir die verschachtelte While-Schleife verwendet. Beachten Sie, dass wir den continue verwendet haben Anweisung innerhalb der inneren Schleife.

if(j == 2) {
  j++;
  continue:
}

Hier, wenn der Wert von j ist 2 , der Wert von j erhöht und die continue Anweisung wird ausgeführt.

Dadurch wird die Iteration der inneren Schleife übersprungen. Daher der Text Inner Loop:2 wird bei der Ausgabe übersprungen.

---

Beschriftete Continue-Anweisung

Bisher haben wir den unbeschrifteten continue verwendet Aussage. Es gibt jedoch eine andere Form von continue Anweisung in Java, bekannt als labeled Continue .

Es enthält das Label der Schleife zusammen mit dem continue Stichwort. Zum Beispiel

continue label;

Hier der continue -Anweisung überspringt die aktuelle Iteration der durch label angegebenen Schleife .

Wir können sehen, dass der Label-Identifikator die äußere Schleife angibt. Beachten Sie die Verwendung von Continue innerhalb der inneren Schleife.

Hier der continue -Anweisung überspringt die aktuelle Iteration der beschrifteten Anweisung (d. h. äußere Schleife). Dann geht die Programmsteuerung zur nächsten Iteration der beschrifteten Anweisung.

---

Beispiel 4:beschriftete Continue-Anweisung

class Main {
  public static void main(String[] args) {

    // outer loop is labeled as first
    first:
    for (int i = 1; i < 6; ++i) {

      // inner loop
      for (int j = 1; j < 5; ++j) {
        if (i == 3 || j == 2)

          // skips the current iteration of outer loop
          continue first;
        System.out.println("i = " + i + "; j = " + j);
      }
    }
  }
}

Ausgabe :

i = 1; j = 1
i = 2; j = 1
i = 4; j = 1
i = 5; j = 1

Im obigen Beispiel der labeled continue -Anweisung wird verwendet, um die aktuelle Iteration der Schleife mit der Bezeichnung first zu überspringen .

if (i==3 || j==2)
    continue first;

Hier sehen wir die äußerste for Schleife ist als first gekennzeichnet ,

first:
for (int i = 1; i < 6; ++i) {..}

Daher die Iteration des äußeren for Schleife wird übersprungen, wenn der Wert von i ist 3 oder der Wert von j ist 2.

Hinweis :Die Verwendung des gekennzeichneten continue wird oft davon abgeraten, da es Ihren Code schwer verständlich macht. Wenn Sie sich in einer Situation befinden, in der Sie den gekennzeichneten continue verwenden müssen , refaktorisieren Sie Ihren Code und versuchen Sie, ihn auf andere Weise zu lösen, um ihn besser lesbar zu machen.

Java-break-Anweisung Java-Arrays