Was ist das Schlüsselwort "continue" und wie funktioniert es in Java?

Ich habe dieses Schlüsselwort zum ersten Mal gesehen und mich gefragt, ob mir jemand erklären könnte, was es tut.

• Was ist das continueSchlüsselwort?
• Wie funktioniert es?
• Wann wird es verwendet?

Eine continueAnweisung ohne Beschriftung wird aus der Bedingung der innersten whileoder doSchleife und aus dem Aktualisierungsausdruck der innersten forSchleife erneut ausgeführt. Es wird häufig verwendet, um die Verarbeitung einer Schleife vorzeitig zu beenden und dadurch tief verschachtelte ifAnweisungen zu vermeiden . Im folgenden Beispiel continuewird die nächste Zeile abgerufen, ohne die folgende Anweisung in der Schleife zu verarbeiten.

while (getNext(line)) {
  if (line.isEmpty() || line.isComment())
    continue;
  // More code here
}

continueWird bei einem Label von der Schleife mit dem entsprechenden Label und nicht von der innersten Schleife erneut ausgeführt. Dies kann verwendet werden, um tief verschachtelten Schleifen zu entkommen, oder einfach aus Gründen der Übersichtlichkeit.

Manchmal continuewird es auch als Platzhalter verwendet, um einen leeren Schleifenkörper klarer zu machen.

for (count = 0; foo.moreData(); count++)
  continue;

Die gleiche Anweisung ohne Label existiert auch in C und C ++. Das Äquivalent in Perl ist next.

Diese Art des Kontrollflusses wird nicht empfohlen, aber wenn Sie dies wünschen, können Sie auch continueeine begrenzte Form von simulieren goto. Im folgenden Beispiel continuewird die leere for (;;)Schleife erneut ausgeführt.

aLoopName: for (;;) {
  // ...
  while (someCondition)
  // ...
    if (otherCondition)
      continue aLoopName;

continueist irgendwie wie goto. Kennen Sie sich aus break? Im Gegensatz dazu ist es einfacher, über sie nachzudenken:

• break Beendet die Schleife (springt zum Code darunter).

• continue Beendet den Rest der Verarbeitung des Codes innerhalb der Schleife für die aktuelle Iteration, setzt die Schleife jedoch fort.

Sehen wir uns ein Beispiel an:

int sum = 0;
for(int i = 1; i <= 100 ; i++){
    if(i % 2 == 0)
         continue;
    sum += i;
}

Dies würde die Summe von nur ungeraden Zahlen von 1 bis 100 erhalten.

Wenn Sie sich den Körper einer Schleife als Unterprogramm vorstellen, continueist das ähnlich return. Das gleiche Schlüsselwort existiert in C und dient dem gleichen Zweck. Hier ist ein erfundenes Beispiel:

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

Dadurch werden nur die ungeraden Zahlen ausgedruckt.

Im Allgemeinen sehe ich continue(und break) als Warnung, dass der Code möglicherweise umgestaltet wird, insbesondere wenn die Deklaration whileoder die forSchleifendeklaration nicht sofort in Sicht ist. Das gleiche gilt für returndie Mitte einer Methode, jedoch aus einem etwas anderen Grund.

Wie andere bereits gesagt haben, continuegeht es weiter zur nächsten Iteration der Schleifebreak sich aus der einschließenden Schleife herausbewegt.

Dies können Wartungszeitbomben sein, da es keine unmittelbare Verbindung zwischen dem continue/ breakund der Schleife gibt, die fortgesetzt / unterbrochen wird, außer dem Kontext. Fügen Sie eine innere Schleife hinzu oder verschieben Sie die "Eingeweide" der Schleife in eine separate Methode, und Sie haben einen versteckten Effekt des continue/ breakFehlschlags.

IMHO ist es am besten, sie als Maß für den letzten Ausweg zu verwenden und dann sicherzustellen, dass ihre Verwendung am Anfang oder Ende der Schleife eng zusammengefasst ist, damit der nächste Entwickler die "Grenzen" der Schleife auf einem Bildschirm sehen kann .

continue, breakUnd return(anders als der One True Return am Ende Ihrer Methode) fallen alle in die allgemeine Kategorie der „versteckten GOTOs“. Sie platzieren die Schleifen- und Funktionssteuerung an unerwarteten Stellen, was schließlich zu Fehlern führt.

"Weiter" in Java bedeutet, dass zum Ende der aktuellen Schleife gewechselt wird. Wenn der Compiler sieht, dass in einer Schleife fortgesetzt wird, wird zur nächsten Iteration übergegangen

Beispiel: Dies ist ein Code zum Drucken der ungeraden Zahlen von 1 bis 10

Der Compiler ignoriert den Druckcode, wenn er sieht, dass er mit der nächsten Iteration fortfährt

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

Wie bereits erwähnt, continuewird die Verarbeitung des Codes darunter und bis zum Ende der Schleife übersprungen. Dann werden Sie in den Zustand der Schleife versetzt und führen die nächste Iteration aus, wenn dieser Zustand weiterhin besteht (oder wenn ein Flag vorhanden ist, in den Zustand der angegebenen Schleife).

Es muss hervorgehoben werden, dass im Fall von do - whileSie nach a in den Zustand unten verschoben wird continue, nicht am Anfang der Schleife.

Aus diesem Grund antworten viele Leute nicht richtig, was der folgende Code generiert.

    Random r = new Random();
    Set<Integer> aSet= new HashSet<Integer>();
    int anInt;
    do {
        anInt = r.nextInt(10);
        if (anInt % 2 == 0)
            continue;
        System.out.println(anInt);
    } while (aSet.add(anInt));
    System.out.println(aSet);

* Wenn Ihre Antwort lautet, dass aSetsie nur zu 100% ungerade Zahlen enthält ... liegen Sie falsch!

Fortsetzen ist ein Schlüsselwort in Java und wird verwendet, um die aktuelle Iteration zu überspringen.

Angenommen, Sie möchten alle ungeraden Zahlen von 1 bis 100 drucken

public class Main {

    public static void main(String args[]) {

    //Program to print all odd numbers from 1 to 100

        for(int i=1 ; i<=100 ; i++) {
            if(i % 2 == 0) {
                continue;
            }
            System.out.println(i);
        }

    }
}

Die Anweisung continue im obigen Programm überspringt einfach die Iteration, wenn i ist, und gibt den Wert von i aus, wenn er ungerade ist.

Die Continue- Anweisung verlässt Sie einfach aus der Schleife, ohne die verbleibenden Anweisungen innerhalb der Schleife auszuführen, und löst die nächste Iteration aus.

Betrachten Sie eine If Else-Bedingung. Eine continue-Anweisung führt aus, was in einer Bedingung vorhanden ist, und verlässt die Bedingung, dh springt zur nächsten Iteration oder Bedingung. Aber eine Pause verlässt die Schleife. Betrachten Sie das folgende Programm. '

public class ContinueBreak {
    public static void main(String[] args) {
        String[] table={"aa","bb","cc","dd"};
        for(String ss:table){
            if("bb".equals(ss)){
                continue;
            }
            System.out.println(ss);
            if("cc".equals(ss)){
                break;
            }
        }
        System.out.println("Out of the loop.");
    }

}

Es wird gedruckt: aa cc Out of the loop.

Wenn Sie break anstelle von continue (After if.) Verwenden, wird nur aa und out of the loop gedruckt .

Wenn die Bedingung "bb" gleich ss ist, ist erfüllt: Für Weiter: Es geht zur nächsten Iteration, dh "cc" .equals (ss). Für Pause: Es kommt aus der Schleife und druckt "Aus der Schleife".

Ich bin ein bisschen zu spät zur Party, aber ...

Erwähnenswert ist, dass continuedies für leere Schleifen nützlich ist, bei denen die gesamte Arbeit im bedingten Ausdruck ausgeführt wird, der die Schleife steuert. Zum Beispiel:

while ((buffer[i++] = readChar()) >= 0)
    continue;

In diesem Fall erfolgt die gesamte Arbeit zum Lesen und Anhängen eines Zeichens bufferin dem Ausdruck, der die whileSchleife steuert . Die continueAnweisung dient als visueller Indikator dafür, dass die Schleife keinen Körper benötigt.

Es ist etwas offensichtlicher als das Äquivalent:

while (...)
{ }

und definitiv besserer (und sicherer) Codierungsstil als die Verwendung einer leeren Anweisung wie:

while (...)
    ;

Grundsätzlich ist continue in Java eine Aussage. Daher wird die continue-Anweisung normalerweise mit den Schleifen verwendet, um die aktuelle Iteration zu überspringen.

Wie und wann es in Java verwendet wird, finden Sie unter dem folgenden Link. Es hat eine Erklärung mit Beispiel.

https://www.flowerbrackets.com/continue-java-example/

Ich hoffe es hilft !!

continue muss sich in einer Schleife befinden Andernfalls wird der folgende Fehler angezeigt:

Fahren Sie außerhalb der Schleife fort

Die continue-Anweisung wird in der Schleifensteuerungsstruktur verwendet, wenn Sie sofort zur nächsten Iteration der Schleife springen müssen.

Es kann mit for-Schleife oder while-Schleife verwendet werden. Die Java-Anweisung continue wird verwendet, um die Schleife fortzusetzen. Es setzt den aktuellen Programmfluss fort und überspringt den verbleibenden Code unter den angegebenen Bedingungen.

Bei einer inneren Schleife wird nur die innere Schleife fortgesetzt.

Wir können die Java-Anweisung continue in allen Arten von Schleifen verwenden, z. B. for-Schleife, while-Schleife und do-while-Schleife.

beispielsweise

class Example{
    public static void main(String args[]){
        System.out.println("Start");
        for(int i=0; i<10; i++){
            if(i==5){continue;}
            System.out.println("i : "+i);   
        }
        System.out.println("End.");
    }
}

Ausgabe:

Start
i : 0
i : 1
i : 2
i : 3
i : 4
i : 6
i : 7
i : 8
i : 9
End.

[Nummer 5 ist überspringen]