Schleifen in Java

1. Schleifen in unserem Leben

Sehr oft erfordert unser Leben, dass wir die gleichen Handlungen viele Male ausführen. Angenommen, ich muss ein Dokument scannen, das aus vielen Seiten besteht. Dass wir den gleichen Vorgang immer wieder wiederholen:

• Legen Sie die erste Seite auf den Scanner
• Drücken Sie die Scan-Taste
• Legen Sie die nächste Seite auf den Scanner

Dies ist manuell nur schwer zu bewerkstelligen. Es wäre schön, wenn dieser Prozess irgendwie automatisiert werden könnte.

Oder betrachten Sie ein anderes Beispiel: Nehmen wir an, ich möchte alle ungelesenen E-Mails in meinem Posteingang als Spam markieren. Früher musste ich jede E-Mail einzeln auswählen und als Spam markieren.

Aber Programmierer sind faul, deshalb haben sie diesen Prozess schon vor langer Zeit automatisiert: Jetzt wählen Sie einfach eine beliebige Liste von Briefen aus und klicken auf „Als Spam markieren“, und dann geht Ihr E-Mail-Client die Liste durch und verschiebt jede E-Mail in den Spam-Ordner.

Was können wir hier sagen? Es ist super praktisch, wenn ein Computer oder ein Programm mit einem Klick Hunderte oder Tausende monotoner Vorgänge ausführen kann. Und jetzt erfahren Sie auch, wie das geht.

2. whileSchleife

Die if-else-Anweisung hat unsere Programmierfähigkeiten erheblich erweitert und es ermöglicht, Programme zu schreiben, die in verschiedenen Situationen unterschiedliche Aktionen ausführen. Aber es gibt noch etwas, das unsere Programme um eine Größenordnung leistungsfähiger machen wird – Schleifen .

Java verfügt über vier Arten von Schleifen : while, und . Wir werden uns nun mit dem allerersten davon befassen.forfor-eachdo-while

Eine whileSchleife ist sehr einfach. Es besteht nur aus zwei Teilen: einer Bedingung und einem Schleifenkörper . Der Schleifenkörper wird immer wieder ausgeführt, solange die Bedingung erfüllt ist true. Im Allgemeinen whilesieht eine Schleife so aus:

while (condition)
   statement;

while (condition)
{
   block of statements
}

Es ist sehr einfach. Die Anweisung oder der Anweisungsblock wird immer wieder ausgeführt, solange die Schleifenbedingung gleich ist true.

So funktioniert es: Zunächst wird die Bedingung überprüft. Wenn es wahr ist, wird der Schleifenkörper ausgeführt (die Anweisung oder der Anweisungsblock ). Anschließend wird die Bedingung erneut überprüft und der Schleifenkörper erneut ausgeführt. Und so weiter, bis die Bedingung falsch wird.

Wenn die Bedingung immer wahr ist , wird die Ausführung des Programms nie gestoppt. Es bleibt dauerhaft in der Schleife hängen.

Wenn die Bedingung beim allerersten Mal falsch ist , wird der Schleifenkörper kein einziges Mal ausgeführt.

3. Beispiele für Schleifen

Hier sind einige praktische Beispiele für Schleifen in Aktion.

int n = 5;
while (n > 0)
{
   System.out.println(n);
   n--;
}

5
4
3
2
1

int  n = 0;
while (n < 10)
{
   System.out.println(n);
   n++;
}

0
1
...
8
9

Scanner console = new Scanner(System.in);
while(console.hasNextInt())
{
   int x = console.nextInt();
} 

while (true)
   System.out.println("C");

Scanner console = new Scanner(System.in);
boolean isExit = false;
while (!isExit)
{
   String s = console.nextLine();
   isExit = s.equals("exit");
}

Im vorherigen Beispiel equals()wird die Methode zum Vergleichen von Zeichenfolgen verwendet. Wenn die Zeichenfolgen gleich sind, gibt die Funktion zurück true. Wenn die Zeichenfolgen nicht gleich sind, wird zurückgegeben false.

4. Schleife innerhalb einer Schleife

Als Sie etwas über bedingte Anweisungen gelernt haben, haben Sie gesehen, dass Sie damit komplexe Logik implementieren können, indem Sie mehrere bedingte Anweisungen kombinieren. Mit anderen Worten: durch die Verwendung einer ifAnweisung innerhalb einer ifAnweisung.

Das Gleiche können Sie auch mit Schleifen machen. Um eine Schleife innerhalb einer Schleife zu schreiben, müssen Sie die zweite Schleife in den Hauptteil der ersten Schleife schreiben. Es wird ungefähr so ​​aussehen:

while (condition for outer loop)
{
   while (condition for inner loop)
   {
     block of statements
   }
}

Schauen wir uns drei Aufgaben an.

Aufgabe 1 . Nehmen wir an, wir möchten ein Programm schreiben, das das Wort Momviermal auf dem Bildschirm anzeigt. Eine Schleife ist genau das, was wir brauchen. Und unser Code wird in etwa so aussehen:

int  n = 0;
while (n < 4)
{
   System.out.println("Mom");
   n++;
}

Mom
Mom
Mom
Mom

Aufgabe 2 . Wir wollen ein Programm schreiben, das 5 Buchstaben As in einer einzigen Zeile anzeigt. Dazu benötigen wir noch einmal eine Schleife. So sieht der Code aus:

int n = 0;
while (n < 5)
{
   System.out.print("A");
   n++;
}

AAAAA

Aufgabe 3 . Wir möchten ein Rechteck anzeigen, das aus den Buchstaben As besteht. Das Rechteck sollte aus 4 Zeilen mal 5 Spalten bestehen. Um dies zu erreichen, benötigen wir nun eine verschachtelte Schleife. Wir nehmen einfach unser erstes Beispiel (das, in dem wir 4 Zeilen ausgeben) und ersetzen den Code für die Ausgabe einer Zeile durch den Code aus dem zweiten Beispiel.

int n = 0;

while (n < 4)
{

   int m = 0;

   
while (m < 5)
{
   System.out.print("A");
   m++;
}

   System.out.println();

   n++;

}
 

AAAAA
AAAAA
AAAAA
AAAAA

Die äußere und die innere Schleife müssen unterschiedliche Variablen verwenden, um die Anzahl der Schleifeniterationen zu zählen. Wir mussten den System.out.println()Befehl auch nach der inneren Schleife hinzufügen, da diese Schleife den Buchstaben As in derselben Zeile anzeigt. Sobald die Buchstaben einer Zeile angezeigt werden, muss jemand den Cursor in eine neue Zeile bewegen.

5. Vergleich der Schleifen Java und Pascal

Viele von Ihnen haben Pascal in der High School studiert. Um Ihnen das Verständnis des Materials hier zu erleichtern, werfen Sie einen Blick auf diesen Vergleich von whilein Pascal und Java geschriebenen Schleifen. Wenn Sie Pascal nicht kennen, überspringen Sie diesen Teil einfach.

i := 3;
While i >= 0 Do
   Begin
      WriteLn(i);
      i := i - 1;
   End;

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

i := 0;
While i < 3 Do
   Begin
      WriteLn(i);
      i := i + 1;
   End;

int i = 0;
while (i < 3)
{
   System.out.println(i);
   i++;
}

IsExit := False;
While Not isExit Do
   Begin
      ReadLn(s);
      isExit :=  (s = 'exit');
   End;

boolean isExit = false;
while (!isExit)
{
   String s = console.nextLine();
   isExit = s.equals("exit");
}

While True Do
   WriteLn('C');

while (true)
   System.out.println("C");

While True Do
   Begin
     ReadLn(s);
     If s = 'exit' Then
       Break;
   End;

while (true)
{
   String s = console.nextLine();
   if (s.equals("exit"))
     break;
}