08. లూప్స్ మాస్టరీ — while, do-while, for & ఎన్‌హాన్స్‌డ్ for-each (Loops Mastery in Java)

☕ Java (Java 21+ LTS) 🟢 Lesson 08 of 25 📂 Part 02: Control Flow & Strings (Page 3 of 5) ⏱️ 24 min read
📌 Covered in this lesson: Running Track Analogy · Entry vs Exit Controlled Loops · for, while, do-while Mechanics · break & continue Statements · Labeled Loops Navigation · Enhanced for-each Loop · Pattern Generation · 5 Interactive Quizzes

కంప్యూటర్లకు మనుషుల లాగా అలసట ఉండదు; ఒకే పనిని మిలియన్ల సార్లు పదే పదే ఎలాంటి తప్పులు లేకుండా మెరుపు వేగంతో చేయడంలో అవి దిట్ట. డేటాబేస్ నుండి లక్షల రికార్డులను ఫిల్టర్ చేయడం, నెట్‌వర్క్ ప్యాకెట్లను వరుసగా రీడ్ చేయడం, లేదా గ్రాఫిక్స్ స్క్రీన్‌ను 60 FPS వేగంతో రీఫ్రెష్ చేయడం — వీటన్నింటి వెనుక ఉన్న మూల స్తంభాలే పునరావృత చర్యలు (Loops / Iterations).

రన్నింగ్ ట్రాక్ ల్యాప్స్ & ఆటోమేటిక్ అసెంబ్లీ లైన్ అనాలజీ (The Running Track & Conveyor Belt Analogy):
1. for Loop (ముందే తెలిసిన 400 మీటర్ల రన్నింగ్ ల్యాప్స్): అథ్లెట్ గ్రౌండ్‌లో ఎన్ని రౌండ్లు కొట్టాలో ముందే స్పష్టంగా తెలిసినప్పుడు (ఉదా: 10 ల్యాప్స్). లూప్ ప్రారంభం (Start), ముగింపు షరతు (Condition), మరియు ప్రతి రౌండ్‌కు కౌంట్ పెంచడం (Step) అన్నీ ఒకే లైన్‌లో పక్కాగా ఉంటాయి.
2. while Loop (వర్షం ఆగేంత వరకు గొడుగు పట్టుకోవడం - Event-Driven): పని ఎప్పుడు ముగుస్తుందో ముందే తెలియదు. వర్షం పడుతున్నంత కాలం (షరతు true ఉన్నంత వరకు) గొడుగు పట్టుకుంటూనే ఉంటాం. డేటాబేస్‌లో రికార్డులు అయిపోయేంత వరకు లూప్ నడవడానికి ఇది అనుకూలం.
3. do-while Loop (మొదటి షో ఫ్రీ ప్రివ్యూ - Post-Condition Check): టికెట్ లేకపోయినా మొదటి ట్రైలర్ ఫ్రీగా చూసి, నచ్చితేనే టికెట్ తీసుకున్నట్లు — షరతుతో సంబంధం లేకుండా కనీసం ఒక్కసారి ఖచ్చితంగా నడిచే ఏకైక లూప్.
4. Enhanced for-each (కన్వేయర్ బెల్ట్ నావిగేషన్): ఇండెక్స్‌లు (0, 1, 2) మరియు సైజులతో పనిలేకుండా ఒక అరేలోని ప్రతి వస్తువునూ వరుసగా చేతుల్లోకి తీసుకునే ఆధునిక క్లీన్ లూప్.

ఈ ఎనిమిదవ పాఠంలో జావాలోని 4 రకాల లూప్‌ల అంతర్గత పనితీరు, break & continue లూప్ కంట్రోల్, లేబుల్డ్ లూప్స్ ద్వారా మల్టీ-లెవల్ జంపింగ్, మరియు ఇన్వెంటరీ స్కానర్ కాప్‌స్టోన్ ప్రాజెక్ట్‌ను లోతుగా నేర్చుకుందాం!

1 లూపింగ్ కాన్సెప్ట్: Entry vs Exit Controlled ఆర్కిటెక్చర్

కంప్యూటర్ సైన్స్‌లో లూప్‌లు వాటి షరతును ఎప్పుడు తనిఖీ చేస్తాయనే దాన్ని బట్టి రెండు ప్రాథమిక వర్గాలుగా విభజించబడ్డాయి:

వర్గం (Category) లూప్‌లు షరతు తనిఖీ సమయం కనిష్ట ఎగ్జిక్యూషన్ కౌంట్
Entry-Controlled Loops (ముందే తనిఖీ) for, while లూప్ బాడీ లోపలికి అడుగుపెట్టడానికి ముందే షరతు తనిఖీ చేయబడుతుంది. 0 సార్లు (మొదటిసారే false అయితే ఒక్కసారి కూడా రన్ అవ్వదు).
Exit-Controlled Loops (చివరన తనిఖీ) do-while కోడ్ బాడీ ఒకసారి రన్ అయిన తర్వాత మాత్రమే చివరన షరతు తనిఖీ చేయబడుతుంది. కనీసం 1 సారి (షరతు మొదటి నుంచీ false అయినా సరే).

2 for లూప్ మెకానిక్స్ & 3 ఎక్స్‌ప్రెషన్స్

ఎన్ని సార్లు పునరావృతం కావాలో ముందే ఖచ్చితమైన సంఖ్య తెలిసినప్పుడు for లూప్ ప్రపంచంలోనే అత్యంత విస్తృతంగా ఉపయోగించబడుతుంది. దీని హెడర్‌లో ఉండే 3 భాగాలు:

for (int i = 1; i <= 5; i++) {
    System.out.println("ల్యాప్ సంఖ్య: " + i);
}

🔬 The 4-Step Lifecycle of a for Loop:

1. Initialization (int i = 1): లూప్ ప్రారంభంలో ఒకే ఒక్కసారి మాత్రమే రన్ అవుతుంది. ఇక్కడ ఒకే రకం గల బహుళ వేరియబుల్స్‌ను కూడా ఇనిషియలైజ్ చేయవచ్చు: for (int i = 0, j = 10; ...).
2. Condition Check (i <= 5): ప్రతి రౌండ్ ప్రారంభంలోనూ తనిఖీ చేయబడుతుంది. true అయితే బాడీ లోపలికి వెళ్తుంది, false అయితే లూప్ ముగుస్తుంది.
3. Body Execution: కర్లీ బ్రాకెట్ల లోపలి స్టేట్‌మెంట్స్ రన్ అవుతాయి.
4. Update / Increment (i++): బాడీ ముగిసిన వెంటనే వేరియబుల్ అప్‌డేట్ అవుతుంది, ఆపై తిరిగి స్టెప్ 2 కు వెళ్తుంది.

ఐచ్ఛిక భాగాలు (Optional Parts): for లూప్‌లో ఏ భాగాన్నీ తప్పనిసరిగా రాయాలనే నిబంధన లేదు. for (;;) అని రాస్తే అది ఎప్పటికీ ఆగని అనంత లూప్ అవుతుంది.

3 while లూప్ & ఇన్ఫినిట్ లూప్ నివారణ

పునరావృతాల సంఖ్య ముందే తెలియనప్పుడు, ఒక నిర్దిష్ట ఈవెంట్ లేదా షరతు మారేంత వరకు కోడ్ రన్ చేయడానికి while లూప్ ఉపయోగపడుతుంది:

int batteryPercent = 100;

while (batteryPercent > 20) {
    System.out.println("ఫోన్ ఆక్టివ్: బ్యాటరీ " + batteryPercent + "%");
    batteryPercent -= 25; // ఈ అప్‌డేట్ లేకపోతే లూప్ ఆగదు!
}

📂 Industry Use Case: Reading Database Streams & Sockets:

రియల్ టైమ్ అప్లికేషన్లలో ఫైల్స్ చదవడం లేదా నెట్‌వర్క్ సాకెట్ నుండి డేటా ప్యాకెట్లను అందుకోవడం while లూప్ ద్వారానే జరుగుతుంది:
• while ((line = bufferedReader.readLine()) != null) { ... } (ఫైల్‌లో లైన్లు ఉన్నంత వరకూ చదవడం).
• while (resultSet.next()) { ... } (డేటాబేస్ నుండి ప్రతి అకౌంట్ రికార్డును వరుసగా తీసుకోవడం).
• Sentinel-controlled loop: యూజర్ ఒక ప్రత్యేక విలువను (ఉదా: -1 లేదా 'QUIT') నమోదు చేసేంత వరకు ఇన్‌పుట్లను ప్రాసెస్ చేయడానికి while లూప్ ప్రామాణికం.

🔢 Fibonacci Sequence Generation with while loop:

గణితంలో ప్రసిద్ధి చెందిన ఫిబొనాక్సీ సిరీస్ (0, 1, 1, 2, 3, 5, 8...) ను నిర్దిష్ట పరిమితి వరకు లెక్కించడానికి while లూప్ అద్భుతంగా సరిపోతుంది: ముందున్న రెండు సంఖ్యలను కూడుతూ మూడవ సంఖ్యను కనుగొని పాయింటర్లను ముందుకు జరపడం.

⚠️ Infinite Loop Danger (అనంత లూప్ ప్రమాదం):

లూప్ లోపల కండిషన్ వేరియబుల్‌ను అప్‌డేట్ చేయడం మర్చిపోతే (ఉదా: batteryPercent -= 25 మిస్ అయితే), షరతు ఎప్పటికీ true గానే ఉండి కంప్యూటర్ CPU 100% వినియోగానికి చేరుకుని అప్లికేషన్ స్తంభించిపోతుంది (Hang/Freeze).

4 do-while లూప్: కనీసం ఒక్కసారి రన్ అయ్యే నియమం

యూజర్ నుండి పాస్‌వర్డ్ అడగడం లేదా మెనూ స్క్రీన్ చూపించడం వంటి సందర్భాలలో — షరతుతో సంబంధం లేకుండా మొదట ఒకసారి స్క్రీన్ చూపించి, ఆ తర్వాతే యూజర్ ఎంపికను సరిచూడాలి. దీనికి do-while సరైన ఎంపిక:

int pinAttempts = 0;
do {
    System.out.println("దయచేసి మీ 4-అంకెల ATM పిన్ ఎంటర్ చేయండి...");
    pinAttempts++;
} while (pinAttempts < 1); // గమనిక: do-while చివర సెమీకోలన్ తప్పనిసరి!

📱 Terminal Interactive Menu Pattern:

కమాండ్ లైన్ అప్లికేషన్లలో మెనూను డిస్‌ప్లే చేసి, యూజర్ '0' లేదా 'EXIT' ఎంపిక చేసుకునేంత వరకు మళ్లీ మళ్లీ చూపించడానికి do-while సర్వసాధారణం:
do { displayMenu(); choice = readInput(); processChoice(choice); } while (choice != 0);

5 break మరియు continue స్టేట్‌మెంట్స్

లూప్ యొక్క సాధారణ ప్రవాహాన్ని నియంత్రించడానికి రెండు కీలక జంప్ కీవర్డ్స్ ఉన్నాయి. ఇవి లూప్ ఎగ్జిక్యూషన్‌ను మధ్యలోనే ఆపడానికి లేదా నిర్దిష్ట రౌండ్‌లను మాత్రమే దాటవేయడానికి డెవలపర్లకు పూర్తి స్వేచ్ఛను ఇస్తాయి:

కీవర్డ్ పనితీరు సూత్రం ఉపయోగపడే సందర్భం
break లూప్‌ను తక్షణమే శాశ్వతంగా ముగించి (Terminate) బయటకు తెస్తుంది. ఒక లిస్ట్‌లో కావాల్సిన రికార్డు కనిపించగానే మిగిలిన లక్ష రికార్డులను వెతకకుండా ఆపడానికి.
continue ప్రస్తుత రౌండ్‌లోని మిగిలిన కోడ్‌ను దాటవేసి (Skip), తర్వాతి ఇటరేషన్‌కు దూకుతుంది. నెగెటివ్ నంబర్లను లేదా అవాంఛిత డేటాను ప్రాసెస్ చేయకుండా దాటవేయడానికి.

6 లేబుల్డ్ లూప్స్ (Labeled Loops) తో నెస్టెడ్ నావిగేషన్

ఒక లూప్ లోపల మరొక లూప్ ఉన్నప్పుడు (Nested Loops), లోపలి లూప్ నుండి సాధారణ break వేస్తే కేవలం లోపలి లూప్ మాత్రమే ఆగుతుంది. కానీ నేరుగా బయటి లూప్‌ను కూడా ఒకేసారి ముగించాలంటే జావా Labeled Loops సదుపాయాన్ని అందిస్తుంది:

outerLoop: // లేబుల్ పేరు మరియు కోలన్
for (int r = 1; r <= 5; r++) {
    for (int c = 1; c <= 5; c++) {
        if (r == 3 && c == 3) {
            break outerLoop; // నేరుగా బయటి outerLoop ను కూడా ఆపేస్తుంది!
        }
    }
}

7 Enhanced for-each లూప్ & Iterable ఇంటర్‌ఫేస్

జావా 5 లో ప్రవేశపెట్టిన Enhanced for-each loop అరేలు (Arrays) మరియు కలెక్షన్స్ (Lists, Sets) లోని విలువలను చదవడానికి అత్యంత సురక్షితమైన మరియు క్లీన్ మార్గం. ఇందులో ఇండెక్స్ బౌండరీ ఎర్రర్స్ (ArrayIndexOutOfBoundsException) వచ్చే అవకాశమే లేదు:

String[] techCities = {"హైదరాబాద్", "బెంగళూరు", "పూణే", "చెన్నై"};

for (String city : techCities) {
    System.out.println("ఐటీ హబ్: " + city);
}

🔬 How for-each Works Internally (Compiler Transformation):

1. అరేల కోసం (For Arrays): కంపైలర్ ఈ ఫర్-ఈచ్ లూప్‌ను అంతర్గతంగా ఒక సాధారణ ఇండెక్స్ ఆధారిత for (int i = 0; i < array.length; i++) లూప్‌గా మారుస్తుంది.
2. కలెక్షన్స్ కోసం (For Collections / ArrayList): java.lang.Iterable ఇంటర్‌ఫేస్ అమలుచేసిన కలెక్షన్స్ కోసం కంపైలర్ దీనిని Iterator<T> it = list.iterator(); while(it.hasNext()) { ... } గా మారుస్తుంది.
3. పరిమితి: లూప్ తిరుగుతున్న సమయంలో ఎలిమెంట్లను తొలగించడం (Remove) లేదా ఇన్సర్ట్ చేయడం సాధ్యం కాదు (అలా చేస్తే ConcurrentModificationException వస్తుంది).

8 నెస్టెడ్ లూప్స్, ప్యాటర్న్ ప్రోగ్రామింగ్ & పెర్ఫార్మెన్స్

ఒక లూప్ లోపల మరొక లూప్ రాసినప్పుడు కంప్యూటర్ చేయాల్సిన పనుల సంఖ్య ఘాతాంక రూపంలో పెరుగుతుంది. బయటి లూప్ N సార్లు, లోపలి లూప్ M సార్లు తిరిగితే మొత్తం ఎగ్జిక్యూషన్లు N * M అవుతాయి:

📐 Matrix & 2D Array Navigation Pattern:

నెస్టెడ్ లూప్స్‌లో బయటి లూప్ సాధారణంగా అడ్డు వరుసలను (Rows), లోపలి లూప్ నిలువు వరుసలను (Columns) సూచిస్తుంది:
• Floyd's Triangle: వరుసగా సంఖ్యలను 1, 2 3, 4 5 6 రూపంలో ప్రింట్ చేయడం.
• Matrix Multiplication: 3 నెస్టెడ్ లూప్స్ (O(N^3)) అవసరమవుతాయి.
• JIT Loop Unrolling: చాలా వేగంగా తిరిగే చిన్న లూప్‌లను JVM జస్ట్-ఇన్-టైమ్ కంపైలర్ 'అన్‌రోల్' చేసి జంప్ ఓవర్‌హెడ్‌ను పూర్తిగా నిర్మూలిస్తుంది.

⚡ Software Engineering Tip on Nested Loops:

రెండు లూప్‌లు కలిస్తే టైమ్ కాంప్లెక్సిటీ O(N^2) అవుతుంది. 10,000 ఎలిమెంట్స్ ఉన్నప్పుడు N^2 అంటే 10,00,00,000 (10 కోట్ల) ఆపరేషన్లు జరుగుతాయి! అందువల్ల ఎంటర్‌ప్రైజ్ ప్రొడక్షన్ సిస్టమ్స్‌లో 3 కంటే ఎక్కువ లోతైన నెస్టెడ్ లూప్స్ రాయడం నిషేధం. డేటాను ఫాస్ట్‌గా శోధించడానికి HashMaps లేదా బైనరీ సెర్చ్ వాడాలి.

9 కోడ్ డెమో 1: లూప్స్ పెర్ఫార్మెన్స్ & జంప్ స్టేట్‌మెంట్స్ డెమో

for, while లూప్స్ మరియు break, continue ల ప్రవర్తనను ప్రత్యక్షంగా పరీక్షించే లైవ్ ప్రోగ్రామ్:

LoopControlMechanics.java
public class LoopControlMechanics {
    public static void main(String[] args) {
        System.out.println("==================================================");
        System.out.println("      LOOP CONTROL & JUMP MECHANICS ENGINE        ");
        System.out.println("==================================================");

        // 1. continue statement skipping odd numbers
        System.out.print("Even numbers (1 to 10): ");
        for (int i = 1; i <= 10; i++) {
            if (i % 2 != 0) {
                continue; // Skip odds
            }
            System.out.print(i + " ");
        }
        System.out.println();

        // 2. break statement terminating loop on target search
        int target = 42;
        int[] sensorData = {12, 28, 35, 42, 59, 64, 88};
        int searchSteps = 0;
        boolean found = false;

        for (int reading : sensorData) {
            searchSteps++;
            if (reading == target) {
                found = true;
                break; // Stop immediately upon finding
            }
        }

        System.out.println("--------------------------------------------------");
        System.out.printf("Sensor Target %d Found? : %s (Found in %d steps)%n", 
                          target, found ? "YES" : "NO", searchSteps);
        System.out.println("==================================================");
    }
}
💻 Console Output (LoopControlMechanics)
==================================================
      LOOP CONTROL & JUMP MECHANICS ENGINE        
==================================================
Even numbers (1 to 10): 2 4 6 8 10 
--------------------------------------------------
Sensor Target 42 Found? : YES (Found in 4 steps)
==================================================

10 కోడ్ డెమో 2: పిరమిడ్ ప్యాటర్న్ ప్రింటింగ్ ఇంజిన్

నెస్టెడ్ లూప్స్ ద్వారా స్పేసులు మరియు స్టార్స్ (*) సమన్వయంతో పిరమిడ్ ఆకారాన్ని రూపొందించే క్లాసిక్ ప్రోగ్రామ్:

PyramidPatternEngine.java
public class PyramidPatternEngine {
    public static void main(String[] args) {
        System.out.println("--------------------------------------------------");
        System.out.println("       NESTED LOOPS PYRAMID PATTERN ENGINE        ");
        System.out.println("--------------------------------------------------");

        int totalRows = 5;

        for (int r = 1; r <= totalRows; r++) {
            // Print leading spaces
            for (int s = 1; s <= totalRows - r; s++) {
                System.out.print("  ");
            }
            // Print asterisks
            for (int k = 1; k <= (2 * r - 1); k++) {
                System.out.print("* ");
            }
            System.out.println();
        }
        System.out.println("--------------------------------------------------");
    }
}
💻 Console Output (PyramidPatternEngine)
--------------------------------------------------
       NESTED LOOPS PYRAMID PATTERN ENGINE        
--------------------------------------------------
        * 
      * * * 
    * * * * * 
  * * * * * * * 
* * * * * * * * * 
--------------------------------------------------

11 కోడ్ డెమో 3: Inventory Batch Scanner & Defective Item Rejector Engine (Capstone Mini Project)

ఒక పూర్తిస్థాయి గిడ్డంగి అసెంబ్లీ లైన్ స్కానర్: వేలాది ప్రాడక్ట్ బ్యాచ్‌లను స్కాన్ చేస్తూ, నాణ్యతా లోపం ఉన్న వస్తువులను continue తో తిరస్కరిస్తూ, అత్యవసర ఎర్రర్ రాగానే break తో కన్వేయర్ బెల్ట్‌ను ఆపే కాప్‌స్టోన్ ప్రాజెక్ట్:

InventoryBatchScannerEngine.java
public class InventoryBatchScannerEngine {
    public static void main(String[] args) {
        String[] batchSkus = {
            "SKU-OK-101", "SKU-OK-102", "SKU-DEFECT-103", 
            "SKU-OK-104", "SKU-CRITICAL-CORRUPT", "SKU-OK-105"
        };

        int approvedCount = 0;
        int rejectedCount = 0;

        System.out.println("==================================================");
        System.out.println("      AUTOMATED WAREHOUSE BATCH INSPECTOR         ");
        System.out.println("==================================================");

        batchLoop:
        for (int i = 0; i < batchSkus.length; i++) {
            String currentSku = batchSkus[i];

            // Emergency stop trigger
            if (currentSku.contains("CRITICAL")) {
                System.out.printf("[EMERGENCY STOP] Severe hazard at item #%d (%s)!%n", i + 1, currentSku);
                System.out.println("Conveyor motor shut down immediately.");
                break batchLoop;
            }

            // Quality assurance defect skip
            if (currentSku.contains("DEFECT")) {
                System.out.printf("[REJECTED] Item #%d (%s) failed quality control. Skipped.%n", i + 1, currentSku);
                rejectedCount++;
                continue;
            }

            System.out.printf("  Item #%d: %s [PASSED & PACKAGED]%n", i + 1, currentSku);
            approvedCount++;
        }

        System.out.println("--------------------------------------------------");
        System.out.printf("  Approved for Shipment : %d unit(s)%n", approvedCount);
        System.out.printf("  Defective Discarded   : %d unit(s)%n", rejectedCount);
        System.out.println("==================================================");
    }
}
💻 Console Output (InventoryBatchScannerEngine)
=================================================="
      AUTOMATED WAREHOUSE BATCH INSPECTOR         
==================================================
  Item #1: SKU-OK-101 [PASSED & PACKAGED]
  Item #2: SKU-OK-102 [PASSED & PACKAGED]
[REJECTED] Item #3 (SKU-DEFECT-103) failed quality control. Skipped.
  Item #4: SKU-OK-104 [PASSED & PACKAGED]
[EMERGENCY STOP] Severe hazard at item #5 (SKU-CRITICAL-CORRUPT)!
Conveyor motor shut down immediately.
--------------------------------------------------
  Approved for Shipment : 3 unit(s)
  Defective Discarded   : 1 unit(s)
==================================================

12 టాప్ 6 కామన్ లూప్ మిస్టేక్స్ & 5 క్విజ్‌లు

లూప్స్ రాసేటప్పుడు డెవలపర్లు తరచుగా చేసే 6 ప్రధాన సమస్యలు:

సమస్య తప్పు కోడ్ సరిదిద్దిన సరైన విధానం
ఆఫ్-బై-వన్ ఎర్రర్ (Off-by-One) for (int i = 0; i <= arr.length; i++) (IndexOutOfBoundsException వస్తుంది) అరే సైజు కంటే 1 తక్కువ ఉండాలి: i < arr.length
లూప్ హెడర్ పక్కన సెమీకోలన్ for (int i = 0; i < 5; i++); { doWork(); } (కేవలం ఒక్కసారి మాత్రమే రన్ అవుతుంది!) సెమీకోలన్ తీసేయాలి: for (int i = 0; i < 5; i++) { doWork(); }
అప్‌డేట్ స్టేట్‌మెంట్ మిస్ అవ్వడం while లూప్‌లో కౌంటర్ పెంచడం మర్చిపోవడం (CPU 100% Hang) బాడీ చివర తప్పనిసరిగా ఇంక్రిమెంట్ i++ ఉండాలి.
do-while చివర సెమీకోలన్ మర్చిపోవడం do { } while(cond) // కంపైల్ ఎర్రర్ చివర తప్పనిసరిగా while(cond); సెమీకోలన్ ఉండాలి.
ఫర్-ఈచ్ లో ఎలిమెంట్స్ మార్చడానికి ప్రయత్నించడం for (int x : arr) { x = x * 2; } (ఒరిజినల్ అరే మారదు!) అరే వాల్యూస్ మోడిఫై చేయడానికి ఇండెక్స్డ్ ఫర్ లూప్ వాడాలి: arr[i] = arr[i] * 2;
కండిషన్‌లో ఫ్లోటింగ్ పాయింట్స్ వాడటం for (double d = 0.0; d != 1.0; d += 0.1) (రౌండింగ్ వల్ల ఎప్పటికీ ఆగదు!) లూప్ కౌంటర్లుగా ఎల్లప్పుడూ int మాత్రమే వాడాలి.

🧠 మీ అవగాహనను పరీక్షించుకోండి (5 Interactive Quizzes):

ప్రశ్న 1: షరతు మొదటి నుంచీ false అయినా కనీసం ఒక్కసారి రన్ అయ్యే లూప్ ఏది?

సమాధానం: do-while లూప్. ఎందుకంటే ఇది Exit-controlled లూప్ (షరతును బాడీ రన్ అయిన తర్వాత మాత్రమే తనిఖీ చేస్తుంది).

ప్రశ్న 2: 'break' మరియు 'continue' ల మధ్య ప్రధాన వ్యత్యాసం ఏమిటి?

సమాధానం: break మొత్తం లూప్‌ను శాశ్వతంగా ముగించి బయటకు తెస్తుంది; continue కేవలం ప్రస్తుత రౌండ్‌ను మాత్రమే దాటవేసి తర్వాతి రౌండ్‌కు వెళ్తుంది.

ప్రశ్న 3: నెస్టెడ్ లూప్స్ లో లోపలి నుండి బయటి లూప్‌ను ఆపడానికి ఏమి వాడాలి?

సమాధానం: లేబుల్డ్ బ్రేక్ (Labeled break, ఉదా: break outerLoop;) వాడాలి.

ప్రశ్న 4: Enhanced for-each లూప్ లో ఒరిజినల్ అరేలోని ఎలిమెంట్ విలువను మార్చవచ్చా?

సమాధానం: మార్చలేము! ఫర్-ఈచ్ లూప్ కేవలం కాపీ విలువను మాత్రమే ఇస్తుంది (Read-only access). ఒరిజినల్ అరే ఎలిమెంట్స్ మార్చడానికి ఇండెక్స్ ఆధారిత arr[i] లూప్ వాడాలి.

ప్రశ్న 5: 'for(;;)' అని రాస్తే ఏమి జరుగుతుంది?

సమాధానం: ఇది ఒక అనంత లూప్ (Infinite Loop) గా మారుతుంది! while(true) కు ఇది సమానం.

← మునుపటి పాఠం: 07. switch Statements & Expressions తర్వాతి పాఠం: 09. Strings & Memory Pool →