Sequentielle Programmanweisungen können nur einmal ausgeführt werden. Wenn Sie denselben Vorgang mehrmals ausführen möchten, müssen Sie eine Schleifenstruktur verwenden.
In Java gibt es drei Hauptschleifenstrukturen:
while-Schleife
do...while-Schleife
for-Schleife
In Java5 wurde eine erweiterte for-Schleife hauptsächlich für Arrays eingeführt.
while ist die grundlegendste Schleife, ihre Struktur ist:
while(Boolescher Ausdruck) {
//Schleifeninhalt}Solange der boolesche Ausdruck wahr ist, wird der Schleifenkörper weiterhin ausgeführt.
öffentlicher Klassentest {
public static void main(String args[]) {
int x = 10;
while( x < 20 ) {
System.out.print("Wert von x: " + x);
x++;
System.out.print("n");
}
}
}Die Kompilierungs- und Ausführungsergebnisse des obigen Beispiels lauten wie folgt:
Wert von x: 10
Wert von x: 11
Wert von x: 12
Wert von x: 13
Wert von x: 14
Wert von x: 15
Wert von x: 16
Wert von x: 17
Wert von x: 18
Wert von x: 19Wenn bei der while-Anweisung die Bedingung nicht erfüllt ist, kann die Schleife nicht betreten werden. Aber manchmal müssen wir es mindestens einmal ausführen, auch wenn die Bedingungen nicht erfüllt sind.
Die do...while-Schleife ähnelt der while-Schleife, außer dass die do...while-Schleife mindestens einmal ausgeführt wird.
Tun {
//Code-Anweisung}while(Boolean expression);Hinweis: Der boolesche Ausdruck steht nach dem Schleifenkörper, sodass der Anweisungsblock ausgeführt wurde, bevor der boolesche Ausdruck erkannt wurde. Wenn der boolesche Ausdruck „true“ ergibt, wird der Anweisungsblock ausgeführt, bis der boolesche Ausdruck „false“ ergibt.
öffentlicher Klassentest {
public static void main(String args[]){
int x = 10;
Tun{
System.out.print("Wert von x: " + x);
x++;
System.out.print("n");
}while( x < 20 } );Die Kompilierungs- und Ausführungsergebnisse des obigen Beispiels lauten wie folgt:
Wert von x: 10
Wert von x: 11
Wert von x: 12
Wert von x: 13
Wert von x: 14
Wert von x: 15
Wert von x: 16
Wert von x: 17
Wert von x: 18
Wert von x: 19Obwohl alle Schleifenstrukturen mit while oder do...while ausgedrückt werden können, bietet Java eine weitere Anweisung – die for-Schleife, die einige Schleifenstrukturen einfacher macht.
Die Anzahl der Ausführungen der for-Schleife wird vor der Ausführung bestimmt. Das Syntaxformat ist wie folgt:
for(Initialisierung; Boolescher Ausdruck; Update) {
//Code-Anweisung}Hier ein paar Hinweise zur for-Schleife:
Zuerst wird der Initialisierungsschritt durchgeführt. Ein Typ kann deklariert werden, es können jedoch eine oder mehrere Schleifensteuerungsvariablen initialisiert werden oder es kann sich um eine leere Anweisung handeln.
Testen Sie dann den Wert des booleschen Ausdrucks. Wenn true, wird der Schleifenkörper ausgeführt. Wenn es falsch ist, wird die Schleife beendet und die Ausführung der auf den Schleifenkörper folgenden Anweisungen beginnt.
Nachdem Sie die Schleife einmal ausgeführt haben, aktualisieren Sie die Schleifensteuerungsvariablen.
Überprüfen Sie den booleschen Ausdruck noch einmal. Führen Sie den obigen Vorgang in einer Schleife aus.
öffentlicher Klassentest {
public static void main(String args[]) {
for(int x = 10; x < 20; x = x+1) {
System.out.print("Wert von x: " + x);
System.out.print("n");
}
}
}Die Kompilierungs- und Ausführungsergebnisse des obigen Beispiels lauten wie folgt:
Wert von x: 10
Wert von x: 11
Wert von x: 12
Wert von x: 13
Wert von x: 14
Wert von x: 15
Wert von x: 16
Wert von x: 17
Wert von x: 18
Wert von x: 19Java5 führte eine erweiterte for-Schleife hauptsächlich für Arrays ein.
Das Java-erweiterte for-Loop-Syntaxformat lautet wie folgt:
for (Deklarationsanweisung: Ausdruck)
{
//Codesatz}Deklarationsanweisung: Deklarieren Sie eine neue lokale Variable. Der Typ der Variablen muss mit dem Typ des Array-Elements übereinstimmen. Sein Geltungsbereich ist auf den Schleifenanweisungsblock beschränkt und sein Wert entspricht zu diesem Zeitpunkt dem Wert des Array-Elements.
Ausdruck: Der Ausdruck ist der Name des Arrays, auf das zugegriffen werden soll, oder eine Methode, die ein Array zurückgibt.
öffentlicher Klassentest {
public static void main(String args[]){
int [] Zahlen = {10, 20, 30, 40, 50};
for(int x : Zahlen ){
System.out.print(x);
System.out.print(",");
}
System.out.print("n");
String [] Namen ={"James", "Larry", "Tom", "Lacy"};
for( Stringname: Namen) {
System.out.print( name );
System.out.print(",");
}
}
}Die Kompilierungs- und Ausführungsergebnisse des obigen Beispiels lauten wie folgt:
10,20,30,40,50,
James, Larry, Tom, Lacy,break wird hauptsächlich in Schleifenanweisungen oder Switch-Anweisungen verwendet, um aus dem gesamten Anweisungsblock zu springen.
break springt aus der innersten Schleife und führt die Anweisungen unterhalb der Schleife weiter aus.
Die Verwendung von break ist sehr einfach, es handelt sich um eine Anweisung in der Schleifenstruktur:
brechen; öffentlicher Klassentest {
public static void main(String args[]) {
int [] Zahlen = {10, 20, 30, 40, 50};
for(int x : Zahlen ) {
if( x == 30 ) {
brechen;
}
System.out.print(x);
System.out.print("n");
}
}
}Die Kompilierungs- und Ausführungsergebnisse des obigen Beispiels lauten wie folgt:
10
20continue gilt für jede Schleifenkontrollstruktur. Die Funktion besteht darin, dem Programm zu ermöglichen, sofort zur nächsten Iteration der Schleife zu springen.
In der for-Schleife bewirkt die continue-Anweisung, dass das Programm sofort zur update-Anweisung springt.
In einer while- oder do...while-Schleife springt das Programm sofort zur Beurteilungsanweisung des booleschen Ausdrucks.
continue ist eine einfache Anweisung im Schleifenkörper:
weitermachen; öffentlicher Klassentest {
public static void main(String args[]) {
int [] Zahlen = {10, 20, 30, 40, 50};
for(int x : Zahlen ) {
if( x == 30 ) {
weitermachen;
}
System.out.print(x);
System.out.print("n");
}
}
}Die Kompilierungs- und Ausführungsergebnisse des obigen Beispiels lauten wie folgt:
10
20
40
50