Løkker i Java

1. Løkker i livet vårt

Svært ofte krever livene våre at vi utfører de samme handlingene mange ganger. Anta for eksempel at jeg trenger å skanne et dokument som består av mange sider. At vi gjentar samme prosedyre om og om igjen:

• Legg den første siden på skanneren
• Trykk på skanneknappen
• Legg neste side på skanneren

Dette er vanskelig å gjøre manuelt. Det ville vært fint om denne prosessen kunne automatiseres på en eller annen måte.

Eller tenk på et annet eksempel: la oss si at jeg vil merke alle uleste e-poster i innboksen min som spam. En gang i tiden måtte jeg velge hver e-post om gangen og merke den som spam.

Men programmerere er late, så de automatiserte denne prosessen for lenge siden: nå velger du bare en hvilken som helst liste over bokstaver og klikker på "merk som spam", og deretter kjører e-postklienten din gjennom listen og flytter hver e-post til spam-mappen.

Hva kan vi si her? Det er veldig praktisk når en datamaskin eller et program kan utføre hundrevis eller tusenvis av monotone operasjoner med ett klikk. Og nå vil du også lære hvordan du gjør dette.

2. whileløkke

If-else-setningen utvidet programmeringsevnene våre betydelig, noe som gjorde det mulig å skrive programmer som utfører forskjellige handlinger i forskjellige situasjoner. Men det er en ting til som vil gjøre programmene våre til en størrelsesorden kraftigere – loops .

Java har 4 typer løkker: while, for, for-eachog do-while. Vi skal nå grave i den aller første av disse.

En whileløkke er veldig enkel. Den består av bare to deler: en tilstand og en løkkekropp . Løkkekroppen utføres om og om igjen så lenge tilstanden er true. Generelt whileser en løkke slik ut:

while (condition)
   statement;

while (condition)
{
   block of statements
}

Det er veldig enkelt. Utsagnet eller blokken med setninger utføres om og om igjen så lenge løkkebetingelsen er lik .true

Slik fungerer det: Først sjekkes tilstanden . Hvis det er sant, blir loop-kroppen utført ( setningen eller blokken med setninger ). Deretter kontrolleres tilstanden igjen og løkkelegemet utføres på nytt. Og så videre til tilstanden blir falsk.

Hvis betingelsen alltid er sann , vil programmet aldri slutte å kjøre. Den vil bli permanent fast i løkken.

Hvis betingelsen er usann den aller første gangen den kontrolleres , vil ikke selve sløyfen bli utført en gang.

3. Eksempler på løkker

Her er noen praktiske eksempler på løkker i aksjon.

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");
}

I forrige eksempel equals()brukes metoden for å sammenligne strenger. Hvis strengene er like, vil funksjonen returnere true. Hvis strengene ikke er like, vil den returnere false.

4. Løkke i en løkke

Etter hvert som du lærte om betingede setninger, så du at du kan bruke dem til å implementere kompleks logikk ved å kombinere flere betingede setninger. Med andre ord, ved å bruke et ifutsagn inne i et ifutsagn.

Du kan gjøre det samme med løkker. For å skrive en sløyfe i en sløyfe, må du skrive den andre sløyfen inne i kroppen til den første sløyfen. Det vil se omtrent slik ut:

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

La oss se på tre oppgaver.

Oppgave 1 . La oss si at vi vil skrive et program som viser ordet Mompå skjermen 4 ganger. En løkke er akkurat det vi trenger. Og koden vår vil se omtrent slik ut:

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

Mom
Mom
Mom
Mom

Oppgave 2 . Vi ønsker å skrive et program som viser 5 bokstaver As på en enkelt linje. For å gjøre dette trenger vi en løkke igjen. Slik vil koden se ut:

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

AAAAA

Oppgave 3 . Vi ønsker å vise et rektangel som består av bokstaven As. Rektangelet skal bestå av 4 rader ganger 5 kolonner. For å oppnå dette trenger vi nå en nestet løkke. Vi tar ganske enkelt vårt første eksempel (det der vi sender ut 4 linjer) og erstatter koden for å skrive ut én linje med koden fra det andre eksemplet.

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

Den ytre og indre løkken må bruke forskjellige variabler for å telle antall løkkeiterasjoner. Vi måtte også legge til System.out.println()kommandoen etter den indre løkken, siden den løkken viser bokstaven As på samme linje. Når bokstavene på en linje vises, må noen flytte markøren til en ny linje.

5. Sammenligning av loops Java vs Pascal

Mange av dere studerte Pascal på videregående. For å gjøre det lettere for deg å forstå materialet her, ta en titt på denne sammenligningen av whileløkker skrevet i Pascal og Java. Hvis du ikke kjenner Pascal, så bare hopp over denne delen.

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;
}