Do-loopen i Java: börja med att utföra kodblocket en gång, och kontrollera sedan villkoret

Den här artikeln kommer gå igenom do-loopen (engelska: do-while loop) i Java. En do-loop är en villkorsloop som är nära besläktad med while-loopen. Vi kommer se hur vi kan använda do-loopen för att först utföra loopens kodblock, och sedan kontrollera villkoret. Vi kommer avsluta sidan med ett par exempel som visar på skillnaderna gentemot while-loopen och när do-loopen kan vara att föredra.

Vad är en do-loop?

Do-loopen är likt while-loopen en så kallad villkorsloop. Det innebär att man upprepa en kodsekvens, om och om igen, tills dess att ett villkor är uppfyllt. Skillnaden mellan en do-loop och en while-loop är att do-loopen utför kodblocket med alla operationer först, och sedan kontrollerar villkoret. Med andra ord, do-loopen utför alltså alla operationer minst en gång.

Do-loopen utför alla operationer minst en gång.

Hur fungerar en do-loop i Java?

Som nämnt, do-loopen fungerar på liknande sätt som while-loopen som vi sett på föregående sida. Om vi tar och illustrerar for-loopen med hjälp av ett flödesschema så får vi flödesschemat i figur 1 nedan.

Om vi tar och beskriver det vi ser i figur 1 med ord ser vi att

• Do-loopen inleder med att utföra kodblocket som innehåller en sekvens av operationer.
• När kodblocket är utfört så går do-loopen vidare för att kontrollerar om villkoret är uppfyllt eller ej.
• Är villkoret uppfyllt (true) så loopar tillbaka till kodblocket och utför sekvensen av operationer igen.
• När dessa operationer är slutförda, kommer koden återgå till do-loopens villkor och utvärdera. ifall villkoret fortsatt är uppfyllt.
• Är villkoret inte uppfyllt (false) fortsätter programmet vidare.

Varför använda en do-loop i Java?

För att inte behöva skriva din kod flera gånger om, kan vi istället upprepa en operation flera gånger. Detta kan vi göra med en do-loop. Do-loopen upprepar sig så länge ett villkor är uppfyllt (true).  Vi använder vanligtvis do-loopen när vi inte vet i förväg hur många gånger det ska upprepas, men alltid vill utföra minst en operation.

Sammanfattningsvis så är en do-loop:

• En loop som upprepar en sekvens av operationer så länge ett villkor är uppfyllt.
• Möjliggör generella och dynamiska program eftersom man kan återanvända kod.
• Lämpar sig bäst när antal iterationer av loopen inte är fixerat.
• Exekverar (utför) operationerna först och kontrollerar därefter villkoret.

Hur skapar man en do-loop i Java?

Do-loopen har många likheter med while-loopen i hur de båda looparna fungerar, men notera skillnaderna i deklarationen.

• Man do-loopen med det reserverade ordet do, följt av måsvingar { }.
• Innanför måsvingarna specificerar man alla operationer som man vill exekvera (utföra) om och om igen, så länge som villkoret är true (uppfyllt). Kom ihåg, detta kodblock kommer utföras minst en gång.
• Efter kodblocket avslutar man do-loopen genom att skriva while följt av ett villkor inom parantes ( ). Är detta villkor uppfyllt, så kommer do-loopen återigen utföra kodblocket, tills dess att villkoret blir false.
• Notera att efter while (villkor) så måste vi avsluta med ett semikolon ; .

Syntax: Deklarera en do-loop i Java

Om vi använder punkterna i listan ovan så får vi

do {

      // Operation / Flera operationer ... 

} while (villkor);

Exempel: Do-loopen i Java

Vi ska nu se ett par exempel på hur vi kan använda do-loopen i Java.

Exempel 1: Skapa en do-loop i Java

Låt oss börja med ett enkelt exempel för att visa hur vi skapar en do-loop för att skriva ut värdet på en variabel.

int num = 0;                                       

do{                                              
    System.out.println("num har värdet: " + num);    
    num++;     

}while (num < 3);                                

Vidare, utskriften blir i detta fall:

num har värdet: 0 
num har värdet: 1 
num har värdet: 2

Skulle vi däremot ändra värdet på variabeln num till

int num = 20; 

och kör vårt program igen så skulle vi få utskriften

num har värdet: 20

Nu när vi uppdaterade variabeln num och om vi hade använt en while-loop så hade loopen aldrig startat eftersom villkoret aldrig blir sant, men eftersom vi använder en do-loop så utförs operationen alltid en gång innan vi loopen kollar ifall villkoret är uppfyllt.

Vill du testa koden ovan själv, klicka på knappen nedan för att testa den online.

Exempel 2: Do-loopen med ett random och scanner objekt

Vi tar ett till exempel för att tydligt visa hur vi kan använda do-loopen. Det vi ska göra i det här exemplet är att:

• Be användaren ange ett heltal mellan 0 – 9.
• Generera ett slumpmässigt heltal mellan 0 – 9.
• Skriva ut vad användaren har angett för tal och sedan vad det genererade slumpmässiga heltalet är.
• Använda en do-loop och uppdatera slumptalet tills det talet användaren anget är samma som det slumpmässiga talet.

Vi kommer använda klassen scanner för att ta in information av användaren och använda oss av ett klassen random för att generera ett slumptal. Genom att vi använder en do-loop så kommer vi alltid att få minst en utskrift, så i de fall då användarens angivna tal överensstämmer med det slumpmässiga talet på första försöket så får vi även då en utskrift.

 // Importerar klassen Random
import java.util.Random;

// Importerar klassen Scanner
import java.util.Scanner;

public class exempel {
        public static void main(String[] args) {

            // Skapar en instans av klassen scanner
            Scanner input = new Scanner(System.in);

            // Skapar en instans av klassen random
            Random rand = new Random();

            // Ber användaren skriva in information
            System.out.println("Ange ett heltal mellan 0-9");

            // Spara ned input från användaren
            int num = input.nextInt();

            // Slumpmässigt heltal mellan 0 - 9
            int randomNum = rand.nextInt(10);

            // Do-loopen
            do{

                // Generera ett nytt slumptal
                randomNum = rand.nextInt(10);

                // Skriv ut information till användaren
                System.out.println("Användaren: " + num + 
                " : " + "Slumptalet: " + randomNum);

            // Medans input är skiljt från slumptalet
            } while (num != randomNum);
        }
}

Avslutningsvis, i det här fallet blir det svårt att skriva ut vad svaret kommer bli eftersom vi får olika svar varje gång. Men en utskrift skulle kunna se ut som följande:

Användaren: 8 : Slumptalet: 3
Användaren: 8 : Slumptalet: 6
Användaren: 8 : Slumptalet: 3
Användaren: 8 : Slumptalet: 0
Användaren: 8 : Slumptalet: 9
Användaren: 8 : Slumptalet: 8

Sammanfattning av do-loopen i Java

Do-loopen i Java är en villkorsloop och är nära besläktad med while-loopen. Likt en while-loop så upprepar en do-loop en kodsekvens, om och om igen, tills dess att ett villkor är uppfyllt. Skillnaden mellan en do-loop och en while-loop är att en do-loop utför kodblocket med alla operationer först, och sedan kontrollerar villkoret. 

Man skapar do-loopen med det reserverade ordet do, följt av måsvingar { }. Innanför måsvingarna specificerar man det koblock som man vill utföra. Efter kodblocket avslutar man do-loopen genom att skriva while följt av ett villkor inom parantes ( ), och avslutningsvis ett semikolon ; .

Vanliga frågor och svar: Do-loopen i Java