For-Schleife in Java

Sie sagen, dass der beste Programmierer ein fauler Programmierer ist. Anstatt dieselben Aktionen mehrmals auszuführen, wird er einen Algorithmus entwickeln, der die Arbeit für ihn erledigt. Und er wird es gut machen, so dass es nicht nötig ist, es noch einmal zu machen. Um zu vermeiden, dass immer wieder derselbe Code geschrieben wird, wurden Schleifen erfunden. Stellen wir uns vor, wir müssen Zahlen von 0 bis 99 auf der Konsole anzeigen. Code ohne Schleife:

System.out.println(0);
System.out.println(1);
System.out.println(2);
System.out.println(3);
System.out.println(4);
System.out.println(5);
// Usw

Dieser Code benötigt 100 Zeilen! Sehr viel. Und so würde es mit einer Schleife aussehen:

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

Nur 3 Zeilen!

Was sind For-Schleifen?

Eine for-Schleife ist eine Kontrollstruktur des Programmcodes, die die Linearität der Ausführung des Algorithmus unterbricht und es Ihnen ermöglicht, den angegebenen Code viele Male auszuführen. Beispielsweise müssen Sie 30 Tropfen des Arzneimittels einnehmen. Der Algorithmus sieht etwa so aus:

1. Bereiten Sie ein Glas vor.
2. Öffne den Deckel.
3. Holen Sie sich 1 Tropfen.
4. Nimm 2 Tropfen.
...
32. Holen Sie sich 30 Tropfen.
33. Schließen Sie das Arzneimittel.
34. Nehmen Sie den erhaltenen Teil.

Dieser Algorithmus lässt sich viel schneller erklären:

1. Bereiten Sie ein Glas vor.
2. Öffnen Sie die Tropfkappe.
3. Holen Sie sich 30 Tropfen.
4. Schließen Sie das Arzneimittel.
5. Nehmen Sie den erhaltenen Teil.

Wir verwenden die for-Schleife fast täglich im Gespräch mit anderen Menschen: „...20 Schritte die Straße hinunter...“, „...mach 10 Wiederholungen und noch einmal 5 bei 2-mal langsamer…“, „... .5 Einkäufe in verschiedenen Kategorien tätigen und einen Preis gewinnen…“ Ich könnte noch lange so weitermachen, aber die Bedeutung ist klar. In Java ist die for-Schleife unerlässlich, um Ihren Code kurz und prägnant zu halten.

So funktioniert die for-Schleife

Eine for-Schleife wird wie folgt verwendet:

for(<начальная точка>; <Zustand выхода>; <операторы счетчика>) {
	// Schleifenkörper
}
Пример перебора цифр от 0 до 5 и вывод каждой в консоль:
for(int i = 0; i < 5; i++) {
   System.out.println(i);
}

Abschluss:

0
1
2
3
4

Wenn wir diesen Eintrag in die menschliche Sprache übersetzen, erhalten wir Folgendes: „ Erstellen Sie eine Variable i mit einem Anfangswert von 0, bis sie 5 erreicht, addieren Sie 1 dazu und schreiben Sie bei jedem Schritt den Wert von i in die Konsole .“ Die for-Schleife in Java basiert auf drei Stufen, die durch das folgende Diagramm dargestellt werden können: Die Bedingung zum Verlassen der Schleife ist ein boolescher Ausdruck. Wenn es falsch ist, wird die Schleife beendet. Im obigen Beispiel iwird die Variable um 1 erhöht. Wenn ihr Wert kleiner als 5 ist, wird die Schleife fortgesetzt. Sobald ier jedoch größer oder gleich 5 wird, stoppt der Zyklus. Der Zähleroperator ist ein Ausdruck, der eine Konvertierung einer Zählervariablen durchführt. Im obigen Beispiel iwurde die Variable um 1 erhöht. Das heißt, die Schleife wird genau fünfmal ausgeführt. Wenn der Zähleroperator 2 zur Variablen hinzufügt i, ist das Ergebnis anders:

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

Abschluss:

0
2
4

Sie können eine Variable auch multiplizieren, dividieren, potenzieren und im Allgemeinen tun, was Sie wollen. Hauptsache, die Transformation ergibt eine Zahl. Der Kern der Schleife ist jeder Code, der ausgeführt werden kann. Im obigen Beispiel gab der Schleifenkörper den Wert der Variablen i an die Konsole aus, aber der Inhalt dieses Körpers ist durch die Aufgabe und Vorstellungskraft begrenzt. Um das gesamte Schema zusammenzufassen, ist das Prinzip dieser for-Schleife wie folgt: Der Code im Hauptteil der Schleife wird so oft ausgeführt, wie der Zähleroperator Konvertierungen durchführt, bevor die Schleifenaustrittsbedingung erreicht ist. Wenn Sie die Schleifenausgangsbedingung wie folgt festlegen true:

for(int i = 0; true; i++) {
   if(i % 1000000 == 0) System.out.println(i);
}
System.out.println("Loop ended");

Dann wird der Code nach der Schleife mit einem Fehler markiert unreachable statement, da er nie ausgeführt wird. Eine Herausforderung für den Einfallsreichtum: Wird „ “ als Ergebnis der Ausführung des folgenden Codes Loop endedan die Konsole ausgegeben oder läuft die Schleife endlos?

for(int i = 0; i > -1; i++) {
   if(i % 1000000 == 0) System.out.println(i);
}
System.out.println("Loop ended");

Antwort: Das wird es geben. Die Variable i wird früher oder später ihren Maximalwert erreichen und durch weitere Erhöhung in einen maximalen negativen Wert umgewandelt werden, wodurch die Austrittsbedingung erfüllt ist (i < = -1).

forEach-Schleife

Wenn Sie mit Schleifen arbeiten, müssen Sie manchmal über Arrays oder Sammlungen iterieren. Normalerweise können Sie ein Array mithilfe einer for-Schleife durchlaufen:

public void printAllElements(String[] stringArray) {
   for(int i = 0; i < stringArray.length; i++) {
       System.out.println(stringArray[i]);
   }
}

Und es ist richtig. Um jedoch alle Elemente des Arrays einzeln zu durchlaufen, haben sie sich die forEach-Konstruktion ausgedacht. Seine Signatur lautet wie folgt:

for(<Тип Element> <Name переменной, куда будет записан очередной элемент> : <Название массива>) {
	// Schleifenkörper
}

Sie können ein Array von Zeichenfolgen durchlaufen und sie wie folgt auf der Konsole ausgeben:

public void printAllElements(String[] stringArray) {
   for(String s : stringArray) {
       System.out.println(s);
   }
}

Auch kurz und prägnant. Am wichtigsten ist, dass Sie sich keine Gedanken über den Zähler und die Ausgangsbedingung machen müssen, alles ist bereits für uns erledigt.

Wie for-Schleifen verwendet werden

Schauen wir uns nun einige Beispiele für die Verwendung der for-Schleife in Java zur Lösung verschiedener Probleme an.

Rückwärtszyklus (von größer nach kleiner)

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

Abschluss:

5
4
3
2
1

Mehrere Variablen und Inkrementieren des Zählers im Schleifenkörper

Sie können mehrere Variablen in einer for-Schleife verwenden, sie können beispielsweise in einer Zähleranweisung konvertiert werden:

int a = 0;
for(int i = 5; i > 0; i--, a++) {
   System.out.print(„Schritt:“ + a + " Bedeutung: ");
   System.out.println(i);
}

Abschluss:

Шаг: 0 Значение: 5
Шаг: 1 Значение: 4
Шаг: 2 Значение: 3
Шаг: 3 Значение: 2
Шаг: 4 Значение: 1

Oder deklarieren Sie zwei Variablen und führen Sie eine Schleife aus, bis sie einander gleich sind:

for(int i = 5, j = 11; i != j; i++, j--) {
   System.out.println("i: " + i + " j: " + j);
}

Abschluss:

i: 5 j: 11
i: 6 j: 10
i: 7 j: 9

Es ist unwahrscheinlich, dass diese Aktion irgendeinen Wert hat, aber es ist nützlich, über diese Möglichkeit Bescheid zu wissen. Sie können auch innere Schleifen innerhalb einer for-Schleife erstellen. In diesem Fall wird die Anzahl der Schleifenschritte vervielfacht:

for(int i = 0; i < 5; i++) {
   System.out.print(i + " | ");
   for(int j = 0; j < 5; j++) {
       System.out.print(j + " ");
   }
   System.out.print('\n');
}

Abschluss:

0 | 0 1 2 3 4 
1 | 0 1 2 3 4 
2 | 0 1 2 3 4 
3 | 0 1 2 3 4 
4 | 0 1 2 3 4

In einer Zählerschleife jist es möglich, auf den Zähler der äußeren Schleife zuzugreifen. Dies macht verschachtelte Schleifen zu einer idealen Möglichkeit, zweidimensionale, dreidimensionale und andere Arrays zu durchlaufen:

int[][] array = { {0, 1, 2, 3, 4 },
                       {1, 2, 3, 4, 5},
                       {2, 3, 4, 5, 6},
                       {3, 4, 5, 6, 7}};

for(int i = 0; i < array.length; i++) {
   for(int j = 0; j < array[i].length; j++) {
       System.out.print(array[i][j] + " ");
   }
   System.out.print('\n');
}

Abschluss:

0 1 2 3 4 
1 2 3 4 5 
2 3 4 5 6 
3 4 5 6 7 

Vorzeitiger Abschluss des Zyklus

Wenn Sie während der Verarbeitung einer Schleife eine Schleife unterbrechen müssen, verwenden Sie den Operator break, der den aktuellen Schleifenkörper stoppt. Alle nachfolgenden Iterationen werden ebenfalls übersprungen:

public void getFirstPosition(String[] stringArray, String element) {
   for (int i = 0; i < stringArray.length; i++) {
       if(stringArray[i].equals(element)) {
           System.out.println(i);
           break;
       }
   }
}

Die Methode gibt die Position des ersten gesuchten Elements im Array aus:

String[] array = {"one", "two", "three", "Jeronimo"};
getFirstPosition(array, "two");

Abschluss:

1

Endloser Kreislauf

Eine andere Möglichkeit, eine Endlosschleife zu erstellen, besteht darin, den Zählerdeklarationsbereich, die Exit-Bedingung und die Zähleranweisung leer zu lassen:

for (;;) {
}

Bedenken Sie jedoch, dass eine Endlosschleife in den meisten Fällen ein Beweis für einen logischen Fehler ist. Eine solche Schleife muss eine Beendigungsbedingung haben.