Java For-Schleife

Mark Zuckerberg stellte einmal fest, dass Computer sehr gut darin sind, Befehle zu wiederholen. Für einen Menschen ist das nicht einfach. Wir werden müde, wenn wir das Gleiche viele Male hintereinander wiederholen, aber ein Computer kann das Millionen und Milliarden Mal tun und wird sich nie langweilen. Wenn du versuchst, allen Facebook-Nutzern Grüße zu schicken, reicht kein Menschenleben, um das zu tun. Du kannst jedoch einen Computer dazu bringen, diese Aufgabe zu lösen, indem du ein paar Zeilen Code schreibst. So funktionieren Schleifen. Dank ihnen müssen wir nicht ständig die gleichen Routinehandlungen wiederholen. Die beliebteste Schleife in Java ist die sogenannte definierte Schleife oder for-Schleife.

Wie schreibt man eine for-Schleife in Java? For-Schleife im Allgemeinen

Die for-Schleife führt bestimmte Anweisungen für eine bestimmte Anzahl von Wiederholungen aus. Zum Beispiel fünfzig Mal „Ich soll nicht dies und das tun“ schreiben oder Einladungen an alle deine Freunde schicken; das sind typische Aufgaben für diese Art von Schleife. Die Syntax der gebräuchlichsten Version der for-Schleife:

for ([counter initialization]; [checking conditions]; [changing of the counter])
{
    //  statements
}

Der Initialisierungsausdruck wird einmal ausgeführt, dann wird die Bedingung ausgewertet, die ein boolescher Ausdruck sein muss.

• Wenn die Schleife beginnt, werden die Initialisierungen ausgeführt.
• Wenn die Bedingungen false ergeben, beendet unsere Schleife ihre Arbeit.

Der Zähler ändert sich, normalerweise wird er nach jedem Durchlauf der Schleife erhöht (oder erniedrigt).

Du kannst jeden der drei Schleifenausdrücke (Initialisierung, Prüfbedingung, Änderung des Zählers) auslassen. Die Schleifenbedingung wird vor der nächsten Ausführung der Schleife überprüft. Wenn die Bedingung falsch ist, verlässt das Programm die Schleife und fährt mit der Anweisung fort, die auf das for-Konstrukt folgt. Hier sehen wir ein Blockdiagramm der for-Schleife.

Wie setzt man die for-Schleife in Java ein? Ein einfaches Beispiel.

Hier ist ein spezielles Beispiel für die for-Schleife in Java. Schreiben wir den String "Hallo!" zehnmal, jedes Mal in eine neue Zeile mit einer Zeilennummer. Wir sollten die folgende Ausgabe erhalten:

1. Hallo!
2. Hallo!
3. Hallo!
4. Hallo!
5. Hallo!
6. Hallo!
7. Hallo!
8. Hallo!
9. Hallo!
10. Hallo!

Hier ist unser Java-Programm, das dieses Problem löst:

public class ForExample {
   public static void main(String[] args) {
       for (int i = 0; i < 10; i++) {
           System.out.println(i + 1 + ". Hello!");
       }
   }
}

Wie funktioniert das?

Schritt 1. Zähler i = 0. Die Schleife prüft unsere Bedingung, i < 10, daher werden die Schleifenanweisungen ausgeführt. Sie gibt den Satz aus: "1. Hallo!". 1 ist ein String i + 1 (weil wir von Null an gezählt haben, aber die erste Zeile ist trotzdem die erste). Der Zähler i wird inkrementiert. Also, i = 1. Schritt 2. Zähler i = 1. i < 10, also haben wir den Satz: "2. Hallo!" und i + 1 = 2. … Schritt 10. Zähler i = 9, wir erhalten "10. Hallo!" und i wird auf 10 hochgezählt. Schritt 11. Zähler i = 10. i < 10 ? Nein, das ist falsch (false). Damit ist die Schleife beendet.

While-Schleife und for-Schleife: Unterschiede und Gemeinsamkeiten

In Java wird eine unbestimmte Schleife oder eine while-Schleife kontinuierlich ausgeführt, wenn die boolesche Bedingung erfüllt ist. Die Syntax der while-Schleife:

while (boolean condition)
       {
            loop statements...
       }

Ziemlich oft kannst du dir aussuchen, welche Schleife du benutzen willst. Manchmal sind sie sich sehr ähnlich und du kannst beide verwenden. Hier ist zum Beispiel der Code für dieselbe Aufgabe (zehnmal "Hallo!" mit einer Zeilennummer schreiben), der mit einer while-Schleife geschrieben wurde:

public class ForAndForEach {
   public static void main(String[] args) {
       int j = 0;  //  we use the counter this way
       while (j < 10) {
           System.out.println(j + 1 + ". Hello!");
           j++;
       }
   }
}

Professionelle Programmierer mögen die while-Schleife allerdings nicht so sehr und versuchen, wo immer möglich, die for-Schleife zu verwenden.

Wie man eine for-Schleife in Java verlässt

Normalerweise läuft eine for-Schleife immer weiter, bis die Bedingung einen false-Wert annimmt. Es gibt jedoch zwei Steueranweisungen, mit denen du die Schleife verlassen kannst, bevor du einen false-Wert einer Bedingung erhältst – break und continue.

• Mit break kannst du den aktuellen Schleifenkörper verlassen, als ob die Schleifenbedingung als false ausgewertet worden wäre.
• continue bewirkt, dass die Schleife zum nächsten Schritt (Iteration des Zählers) springt, ohne die Anweisungen auszuführen.

Lösen wir das nächste Problem mit break und continue. Wir haben eine Reihe von Namen und grüßen jeden aus dieser Reihe, außer die Fremden. Wenn wir also während unserer Schleife auf einen "Fremder"-String treffen, verlassen wir die Schleife (gehen weg und sagen jemand anderem Hallo).

public class ForBreakExample {
   public static void main(String[] args) {
       String[] names = {"Mike", "Dustin", "Stranger", "Lucas", "Will"};
       for (int i = 0; i < names.length; i++) {
//  how to break out of a for loop, java: check if we have any "Stranger" in  //  our array
if (names[i].equals("Stranger")) {
               System.out.println("I don't chat with strangers");
               break;
           }
           System.out.println("Hello," + names[i]);
       }
   }
}

Das Ergebnis der Ausführung unseres Programms ist:

Hello,Mike
Hello,Dustin
I don't chat with strangers

Siehst du? Wir haben die Schleife verlassen, bevor wir Lucas und Will begrüßten. Jetzt benutzen wir continue, um einen "Fremden" zu ignorieren, aber innerhalb der Schleife zu bleiben, um unseren anderen Freunden Hallo zu sagen.

public class ForContinueExample {
   public static void main(String[] args) {
       String[] names = {"Mike", "Dustin", "Stranger", "Lucas", "Will"};
       for (int i = 0; i < names.length; i++) {
           if (names[i].equals("Stranger")) {
               System.out.println("I don't chat with strangers");
               continue;
           }
           System.out.println("Hello," + names[i]);
       }
   }
}

Das Ergebnis ist:

Hello,Mike
Hello,Dustin
I don't chat with strangers
Hello,Lucas
Hello,Will

Hervorragend! Wir haben alle unsere Freunde gegrüßt, aber nicht mit einem Fremden gesprochen.

Verbesserte Version der for-Schleife oder for-each

For-each ist eine Art for-Schleife, die verwendet wird, wenn du alle Elemente eines Arrays oder einer Collection verarbeiten musst. Tatsächlich wird der Ausdruck for-each dabei gar nicht verwendet. Die Syntax lautet wie folgt:

for (type itVar: array)
{
    Block of operators;
}

Dabei ist type der Typ der iterativen Variablen (derselbe wie der Datentyp des Arrays), ItVar ist ihr Name, array ist das Array oder kann eine andere Datenstruktur sein, z. B. ArrayList. Wie du siehst, gibt es keinen Zähler, die Iterationsvariable iteriert über die Elemente eines Arrays oder einer Collection und nicht über die Indexwerte. Wenn eine solche Schleife ausgeführt wird, wird der Iterationsvariable nacheinander der Wert jedes Elements des Arrays oder der Collection zugewiesen, woraufhin der angegebene Block von Anweisungen (oder der Operator) ausgeführt wird. Achtung: Die for-each-Schleife kann auf Arrays und alle Klassen angewendet werden, die das Interface java.lang.Iterable implementieren. Jetzt wollen wir wieder unsere Freunde grüßen und Fremde ignorieren, aber diesmal mit einer for-each-Schleife.

public class ForEachExample {
   public static void main(String[] args) {
       String[] names = {"Mike", "Dustin", "Stranger", "Lucas", "Will"};
	//  for each loop, Java code
       for (String name : names) {
           if (name.equals("Stranger")) {
               System.out.println("I don't chat with strangers");
               continue;
           }
           System.out.println("hello, " + name);
       }
   }
}