[Einführung in Java] Informationen zur iterativen Verarbeitung (while, do-while, for, Erweiterung für, break, continue)

Zweck

Für diejenigen, die gerade mit dem Programmieren einschließlich der Java-Sprache begonnen haben, und für diejenigen, die es bereits gelernt haben, zur Überprüfung Dieses Mal schreibe ich, um mehr über ** iterative Verarbeitung und iterative Steueranweisungen ** zu erfahren.

[Einführung in Java]

• Variationen und Typen ・ Typkonvertierung ・ Umfang der Variablen
• String-Operation
• Vereinbarung ・ Operator ・ Bedingter Zweig ・ Verarbeitung wiederholen ← Jetzt hier ・ Über den Unterricht (in Vorbereitung) ・ Abstrakter Unterricht (in Vorbereitung) ・ Schnittstelle (in Vorbereitung) ・ Einkapselung (in Vorbereitung) ・ Über das Modul (in Vorbereitung) ・ Informationen zur Ausnahmebehandlung ・ Informationen zum Lambda-Ausdruck ・ Informationen zur Stream-API

Was ist iterative Verarbeitung?

Es ist ein bestimmter Vorgang zu wiederholen, indem angegeben wird, wie oft und "solange die Bedingung erfüllt ist".

python

int a = 0;
System.out.println("a => " + a);
a += 1;
System.out.println("a => " + a);
a += 1;
System.out.println("a => " + a);

Eine Reihe von Prozessen wie das Ausgeben von a wie oben beschrieben, +1 und das erneute Ausgeben können durch iterative Verarbeitung sauber beschrieben werden.

Die iterative Verarbeitung wird auch als ** Schleife ** bezeichnet. In diesem Artikel werden "while-Anweisung, do-while-Anweisung, for-Anweisung und erweiterte for-Anweisung" behandelt.

while-Anweisung

** Während die angegebene Bedingung erfüllt ist (true) **, wird der Vorgang wiederholt.

Syntax

while(Bedingter Ausdruck) {
Prozessanweisung; //Wird ausgeführt, wenn der bedingte Ausdruck wahr ist
}

Der bedingte Ausdruck nach while muss ein Ausdruck sein, der einen booleschen Wert (true, false) zurückgibt.

Beispiel für eine while-Anweisung

int num = 0;
while(num < 5) {
  System.out.println("num => " + num);
  num++;
}

Ausführungsergebnis

num => 0
num => 1
num => 2
num => 3
num => 4

Es ist möglich, eine Reihe von Verarbeitungen klar zu beschreiben, z. B. die Ausgabe der am Anfang erscheinenden Variablen +1 und die erneute Ausgabe. Dieser Vorgang wird wiederholt, während num kleiner als 5 ist, wenn ** num, das pro Schleife erhöht wird, 5 wird, **, Da false zurückgegeben wird, wenn die Bedingung beurteilt wird, endet die while-Anweisung.

Anmerkungen zur while-Anweisung

Endlosschleife

Der iterative Prozess kann weiterhin ohne Unterbrechung ausgeführt werden. Bitte beachten Sie die folgenden Punkte.

Endlosschleifenbeispiel 1

int num = 0;
while(num < 5) {
  System.out.println("num => " + num);
  num++;
}

Wenn dieser Code keine Beschreibung von num ++ enthält, bleibt die Variable num 0. Der bedingte Ausdruck num <5 gibt immer wieder true zurück, was zu einer ** Endlosschleife ** führt.

Endlosschleifenbeispiel 2

int num = 0;
while(true) {
  System.out.println("num => " + num);
  num++;
}

Als nächstes, wenn Sie im bedingten Ausdruck "while (true)" ausführen. Dies wird auch immer als true zurückgegeben, was zu einer ** Endlosschleife ** führt.

Die ** Wiederholungssteuerungsanweisung **, die verwendet wird, um eine Endlosschleife zu verhindern (um aus der Schleife herauszukommen), wird in einem separaten Artikel erläutert. Erinnern wir uns auch daran.

Schleife startet nicht

Schlechtes Beispiel

while(false) {
  //wird bearbeitet
}

Wenn der bedingte Ausdruck "while (false)" lautet, tritt ein Kompilierungsfehler auf, da der Prozess nicht gestartet werden kann.

Keine Leistung

In einigen Fällen wird nichts ausgegeben, obwohl kein Fehler auftritt.

Beispiel für keine Ausgabe

int num = 0;
while(num > 0) {
  System.out.println("num => " + num);
  num--;
}

Es wird keine Ausgabe des obigen Ausführungsergebnisses ausgegeben. Dies liegt daran, dass verglichen wird, ob die while-Bedingung größer als 0 ist, sodass plötzlich false zurückgegeben wird und der Prozess endet, ohne in die Schleife einzutreten.

Wenn die Variable num auf 1 oder mehr gesetzt ist, wird die Verarbeitung innerhalb der Schleife ausgeführt.

Verbesserungsplan

int num = 3;
while(num > 0) {
  System.out.println("num => " + num);
  num--;
}

Ausführungsergebnis

num => 3
num => 2
num => 1

do-while-Anweisung

Wie bei der while-Anweisung wird über ** iteriert, während die angegebene Bedingung erfüllt ist (true) **.

Syntax

do {
Prozessanweisung;
}while(Bedingter Ausdruck);

Ähnlich wie bei der while-Anweisung muss der bedingte Ausdruck ein Ausdruck sein, der einen booleschen Wert (true, false) zurückgibt.

do-Beispiel für eine while-Anweisung

int num = 0;
do {
  System.out.println("num => " + num);
  num++;
}while(num < 5);

Ausführungsergebnis

num => 0
num => 1
num => 2
num => 3
num => 4

Dieser Vorgang wird wiederholt, während num kleiner als 5 ist, wenn ** num, das pro Schleife erhöht wird, 5 wird, **, Die do-while-Anweisung endet, weil false zurückgegeben wird, wenn die Bedingung beurteilt wird.

Unterschied zwischen while-Anweisung und do-while-Anweisung

Der Zeitpunkt, zu dem die Zustandsbeurteilung durchgeführt wird, ist unterschiedlich.

In der while-Anweisung wird die Bedingung ** zuerst ** beurteilt, sodass der Prozess möglicherweise nicht wie oben beschrieben ausgeführt wird. In der do-while-Anweisung befindet sich jedoch vor dem Bedingungsurteil ** ein do-Block, und das Bedingungsurteil wird nach ** ausgeführt. Daher wird der Prozess unabhängig von den Bedingungen einmal ausgeführt.

Beispiel für eine Zustandsbeurteilung_while

int num = 0;
while(num > 0) {
  System.out.println("while_num => " + num);
  num--;
}

In der obigen while-Anweisung wird nichts ausgegeben.

Beispiel für eine Zustandsbeurteilung_do-while

int num = 0;
do {
  System.out.println("do-while_num => " + num);
  num--;
}while(num > 0);

Ausführungsergebnis

do-while_num => 0

In der do-while-Anweisung wird der Prozess nur einmal ausgeführt, und die do-while-Anweisung endet, weil der bedingte Ausdruck falsch ist.

Beachten Sie, dass es solche Unterschiede gibt.

Gemeinsame Punkte zwischen while- und do-while-Anweisungen

Wenn es nur eine Anweisung gibt, die sowohl while- als auch do-while-Anweisungen verarbeiten kann, kann {} weggelassen werden.

Im Falle von while

int num = 0;
while (num < 5) System.out.println("num => " + num++);

Ausführungsergebnis

while_num => 0
while_num => 1
while_num => 2
while_num => 3
while_num => 4

do-Im Falle von while

int num = 5;
do
  System.out.println("do-while_num => " + num--);
while(num > 0);

Ausführungsergebnis

do-while_num => 5
do-while_num => 4
do-while_num => 3
do-while_num => 2
do-while_num => 1

zur Aussage

Die for-Anweisung wiederholt auch den Vorgang, während das Bedingungsurteil wahr ist.

In der while-Anweisung und der do-while-Anweisung wurde nur der bedingte Ausdruck in () beschrieben. In () der for-Anweisung deklarieren ** die Zählvariable, initialisieren **, ** den bedingten Ausdruck ** und ** aktualisieren die Zählvariable **.

Syntax

for(Gleichung 1;Gleichung 2;Gleichung 3;) {
Prozessanweisung;
}

Der Ablauf der for-Anweisung ist wie folgt.

• Deklarieren und initialisieren Sie eine Variable (Zählervariable), die die Anzahl der Wiederholungen in Gleichung 1 angibt. ・ Die Bedingung wird nach Gleichung 2 beurteilt. -Wenn das Bedingungsurteil wahr ist, wird die Verarbeitungsanweisung ausgeführt.
• Nachdem der Prozess ausgeführt wurde, wird die Zählervariable durch Gleichung 3 aktualisiert. ・ Die Bedingung wird erneut durch Gleichung 2 beurteilt. -Wenn das Urteil in Gleichung 2 falsch ist, wird die for-Anweisung beendet.

Sehen wir uns den Code und das Ausführungsergebnis an.

Beispiel für for-Anweisung

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

Ausführungsergebnis

i => 0
i => 1
i => 2
i => 3
i => 4

Auf diese Weise kann die for-Anweisung auch dieselbe Verarbeitung wie die while-Anweisung und die do-while-Anweisung beschreiben.

Ausgelassene Beschreibungsmethode für for-Anweisung

Die for-Anweisung wird auch von der folgenden Beschreibungsmethode ausgeführt.

Deklaration von Zählervariablen, Weglassen der Initialisierung

Ausgelassene Beschreibungsmethode für for-Anweisung_Beispiel 1

int num = 0;
for(; num < 5; num++) {
  System.out.println("num => " + num);
}

Ausführungsergebnis

num => 0
num => 1
num => 2
num => 3
num => 4

Anstatt die Zählervariable mit der for-Anweisung zu deklarieren und zu initialisieren, erfolgt dies im Voraus. Es funktioniert auch mit dieser Beschreibungsmethode.

Auslassen der Aktualisierung von Zählervariablen

Ausgelassene Beschreibungsmethode für for-Anweisung_Beispiel 2

for(int num = 0; num < 5; ) {
  System.out.println("num => " + num++);
}

Ausführungsergebnis

num => 0
num => 1
num => 2
num => 3
num => 4

Die Variable num wird in der Verarbeitungsanweisung inkrementiert und aktualisiert. Es funktioniert auch mit dieser Beschreibungsmethode.

Beachten Sie, dass Sie eine ** Endlosschleife ** erhalten, wenn Sie das Inkrementieren vergessen.

Verschiedene Beschreibungsmethoden und Vorsichtsmaßnahmen für Aussagen

Es gibt einige Regeln, wie man in () der for-Anweisung schreibt, also mal sehen.

Ausdruck 1 muss eine Aussage sein

Das Folgende führt zu einem Fehler, da nur die Variablen in Gleichung 1 beschrieben sind.

Kompilierungsfehler

int num = 1;
for(num; num < 5; num++) {
  System.out.println("num => " + num);
}

Gleichung 1 muss eine Aussage wie folgt sein:

Verbesserungsplan

int num = 1;
for(num += 1; num < 5; num++) {
  System.out.println("num => " + num);
}

Ausführungsergebnis

num => 2
num => 3
num => 4

Ausdruck 1 hat nur einen Deklarationsausdruck

Das Folgende führt zu einem Fehler, da der Ausdruck für mehrere Deklarationen in Ausdruck 1 beschrieben ist.

Kompilierungsfehler

for(int i = 0, int = j = 0; i < 5; i++) {
  System.out.println("i => " + i);
  System.out.println("j => " + (j+=2));
  System.out.println("===============");
}

Es darf nur einen deklarativen Ausdruck in Gleichung 1 geben, wie unten gezeigt.

Verbesserungsplan

for(int i = 0, j = 0; i < 5; i++) {
  System.out.println("i => " + i);
  System.out.println("j => " + (j+=2));
  System.out.println("===============");
}

Ausführungsergebnis

i => 0
j => 2
===============
i => 1
j => 4
===============
i => 2
j => 6
===============
i => 3
j => 8
===============
i => 4
j => 10
===============

Es ist möglich, mehrere Formeln 3 einzugeben

Durch Trennen von Ausdrücken durch Kommas können Sie mehrere Aktualisierungsprozesse für Zählervariablen eingeben. Lassen Sie uns den obigen Code neu schreiben.

Beispiel für das Einfügen eines Vielfachen in Gleichung 3

for(int i = 0, j = 2; i < 5; i++, j+=2) {
  System.out.println("i => " + i);
  System.out.println("j => " + j);
  System.out.println("===============");
}

Ausführungsergebnis

i => 0
j => 2
===============
i => 1
j => 4
===============
i => 2
j => 6
===============
i => 3
j => 8
===============
i => 4
j => 10
===============

Sie können das gleiche Ergebnis ausgeben.

Für Aussage erweitert

Als bequemere Beschreibungsmethode für die for-Anweisung wird sie verwendet, wenn alle Elemente eines Arrays oder einer Sammlung der Reihe nach herausgenommen und verarbeitet werden.

Syntax

for(Variable Aussage:Name der Referenzvariablen) {
Prozessanweisung;
}

Sehen wir uns den Code und das Ausführungsergebnis an.

Beispiel einer erweiterten for-Anweisung

int[] numbers = {1, 2, 3, 4, 5};
for(int val : numbers) {
  System.out.println(val);
}

Ausführungsergebnis

val => 1
val => 2
val => 3
val => 4
val => 5

Der Fluss von "Zahlenelementen" wird der Wertvariablen nacheinander zugewiesen und die Ausgabe wird wiederholt.

Lassen Sie uns den gleichen Prozess mit einer for-Anweisung beschreiben und vergleichen.

Zur Aussage

int[] numbers = {1, 2, 3, 4, 5};
for(int i = 0; i < numbers.length; i++) {
  System.out.println("numbers[" + i + "] => " + numbers[i]);
}

Ausführungsergebnis

numbers[0] => 1
numbers[1] => 2
numbers[2] => 3
numbers[3] => 4
numbers[4] => 5

Durch die Beschreibung in der erweiterten for-Anweisung ist es nicht erforderlich, die Zählervariable zu deklarieren, den Ausdruck zu initialisieren oder zu bedingen und den Aktualisierungsprozess der Zählervariable zu beschreiben. Es kann einfacher beschrieben werden als die for-Anweisung.

Hinweise zur erweiterten Erklärung

Der Typ der Variablendeklaration muss mit dem Typ der referenzierten Variablen übereinstimmen. Folgendes führt zu einem Fehler.

Kompilierungsfehler

String[] names = {"Tanaka", "Sato", "Suzuki"};
for(int val : names) {
  System.out.println("name => " + val);
}

Dies liegt daran, dass die Referenzvariable ein Array vom Typ String ist, während die Variablendeklaration ein Typ vom Typ int ist.

Achten Sie darauf, die Typen der Referenzvariablen und die Variable, die jedes Element empfängt, abzugleichen.

Verbesserungsplan

String[] names = {"Tanaka", "Sato", "Suzuki"};
for(String val : names) {
  System.out.println("name => " + val);
}

Ausführungsergebnis

name =>Tanaka
name =>Sato
name =>Suzuki

Gemeinsame Punkte zwischen for-Anweisung und erweiterter for-Anweisung

** Wenn nur eine Anweisung vorhanden ist, um sowohl die for-Anweisung als auch die erweiterte for-Anweisung zu verarbeiten, kann {} weggelassen werden. ** **.

Zur Aussage

for(int i = 0; i < 3; i++)
  System.out.println("i => " + i);

Ausführungsergebnis

i => 0
i => 1
i => 2

Für erweiterte Erklärung

int[] numbers = {10, 20, 30};
for(int val : numbers)
  System.out.println("val => " + val);

Ausführungsergebnis

val => 10
val => 20
val => 30

** Inferenz des lokalen Variablentyps (var) ist verfügbar. ** **. (Ich werde die Inferenz des lokalen Variablentyps in einem anderen Artikel zusammenfassen.)

Zur Aussage

for(var i = 0; i < 3; i++) {
  //Kürzung
}

Für erweiterte Erklärung

for(var val : numbers) {
  //Kürzung
}

Was ist eine Wiederholungssteueranweisung?

Der oben beschriebene iterative Prozess war, dass ** der bedingte Ausdruck weiterhin ausgeführt wird, solange er wahr ist **.

Wenn Sie den iterativen Prozess unter bestimmten Bedingungen beenden möchten, verwenden Sie die iterativen Steueranweisungen ** break-Anweisung ** und ** continue-Anweisung **.

break-Anweisung

Es wird verwendet, wenn Sie aus dem ausgeführten iterativen Prozess ausbrechen möchten oder wenn Sie aus der Endlosschleife wiederholter Anweisungen herauskommen möchten. Es wird auch im Fall der switch-Anweisung verwendet.

Gehen Sie nach dem Verlassen der Schleife wie folgt vor:

Beispiel für eine Break-Anweisung

for(int i = 0; ; i++) {
  if(i == 5) {
    break;
  }
  System.out.println("i => " + i);
}
System.out.println("Verarbeitung nach der for-Anweisung");

Ausführungsergebnis

i => 0
i => 1
i => 2
i => 3
i => 4
Verarbeitung nach der for-Anweisung

Es gibt keinen bedingten Ausdruck, da ich vergessen habe, Ausdruck 2 zu schreiben. Daher wird es eine Endlosschleife. Da es jedoch im Block von "if (i == 5)" eine "Pause" gibt, brechen Sie aus der Schleife aus, wenn ** i zu 5 wird. ** **.

Und die Verarbeitung nach der for-Anweisung wird ausgeführt.

Aussage fortsetzen

Es wird verwendet, um die sich wiederholende Verarbeitung zu überspringen, die ausgeführt wird, aber um den bedingten Ausdruck zu beurteilen und die sich wiederholende Verarbeitung fortzusetzen.

Beispiel für eine continue-Anweisung

for(int i = 0; i < 10; i++) {
  if((i % 3) == 0) {
    continue;
  }
  System.out.println("i => " + i);
}
System.out.println("Verarbeitung nach der for-Anweisung");

Ausführungsergebnis

i => 1
i => 2
i => 4
i => 5
i => 7
i => 8
Verarbeitung nach der for-Anweisung

Indem Sie "fortfahren" im Block von "if ((i% 3) == 0)" haben, ** i wird durch 3 geteilt und die Verarbeitung wird übersprungen, wenn der Rest 0 ist. (Die Schleife wird fortgesetzt, solange die Bedingungsbeurteilung in Gleichung 2 wahr ist.) **

Nach dem Ende der for-Anweisung wird die nachfolgende Verarbeitung ausgeführt.

Gemeinsamkeitsbezeichnung zwischen break- und continue-Anweisungen

Wenn die sich wiederholenden Anweisungen verschachtelt sind (wenn mehrere vorhanden sind), werden die in den inneren sich wiederholenden Anweisungen beschriebenen break- und continue-Anweisungen nur auf den inneren iterativen Prozess angewendet. Wenn Sie die äußere Schleife verlassen oder überspringen möchten, können Sie ** label ** verwenden.

Syntax

Markenname:
for(Gleichung 1;Gleichung 2;Gleichung 3;) {
  for(Gleichung 1;Gleichung 2;Gleichung 3;) {
Labelnamen brechen oder fortsetzen;
  }
}

Mal sehen, wie sich der Prozess unterscheidet, je nachdem, ob die break-Anweisung und die continue-Anweisung Beschriftungen haben.

Im Falle einer break-Anweisung

Wenn Sie das Etikett nicht verwenden, sieht es wie folgt aus. Ich möchte die Schleife beenden, wenn i und j 1 sind. Es wird unter der Annahme implementiert, dass.

Kein Etikett

for(int i = 0; i < 3; i++) {
  for(int j = 0; j < 3; j++) {
    System.out.println("i: " + i + ", j: " + j);
    if(i == 1 && j == 1) {
      break;
    }
  }
}

Ausführungsergebnis

i: 0, j: 0
i: 0, j: 1
i: 0, j: 2
i: 1, j: 0
i: 1, j: 1
i: 2, j: 0
i: 2, j: 1
i: 2, j: 2

Die Schleife endet nicht, i wird zur nächsten Schleife inkrementiert.

Bei Verwendung eines Etiketts ist dies wie folgt.

Mit Etikett

loop:
for(int i = 0; i < 3; i++) {
  for(int j = 0; j < 3; j++) {
    System.out.println("i: " + i + ", j: " + j);
    if(i == 1 && j == 1) {
      break loop;
    }
  }
}

Ausführungsergebnis

i: 0, j: 0
i: 0, j: 1
i: 0, j: 2
i: 1, j: 0
i: 1, j: 1

Wenn i und j 1 sind, kann auch die äußere Schleife verlassen werden.

Zur weiteren Aussage

Wenn Sie das Etikett nicht verwenden, sieht es wie folgt aus. Wenn i und j 1 sind, möchte ich zur nächsten Schleife springen, die i erhöht. Es wird unter der Annahme implementiert, dass.

Kein Etikett

for(int i = 0; i < 3; i++) {
  for(int j = 0; j < 3; j++) {
    if(i == 1 && j == 1) {
      continue;
    }
    System.out.println("i: " + i + ", j: " + j);
  }
}

Ausführungsergebnis

i: 0, j: 0
i: 0, j: 1
i: 0, j: 2
i: 1, j: 0
i: 1, j: 2
i: 2, j: 0
i: 2, j: 1
i: 2, j: 2

Es wird nur übersprungen, wenn i und j 1 sind.

Bei Verwendung eines Etiketts ist dies wie folgt.

Mit Etikett

loop2:
for(int i = 0; i < 3; i++) {
  for(int j = 0; j < 3; j++) {
    if(i == 1 && j == 1) {
      continue loop2;
    }
    System.out.println("i: " + i + ", j: " + j);
  }
}

Ausführungsergebnis

i: 0, j: 0
i: 0, j: 1
i: 0, j: 2
i: 1, j: 0
i: 2, j: 0
i: 2, j: 1
i: 2, j: 2

Wenn i und j 1 sind, können Sie zur nächsten Schleife springen, die i erhöht.

Durch die Verwendung von "Labels" auf diese Weise ist es möglich, aus mehreren Schleifen herauszukommen oder diese zu überspringen.

Am Ende

Ich habe die Syntax zum Wiederholen desselben Prozesses und die iterative Steueranweisung zum Unterbrechen oder Überspringen des Prozesses gemäß den Bedingungen gelernt. Wenn Sie sie richtig verwenden, können Sie den Code klar schreiben, und Sie müssen nicht viele Male denselben Prozess schreiben, also möchte ich ihn beherrschen.

Referenzseite

** [Einführung in Java] Beherrschen wir die iterative Verarbeitung! (für und während) ** ** Erweitert für Anweisung (für jede Anweisung) **