లూప్ కోసం

1. లూప్‌లను పోల్చడం: forvswhile

ఒక స్టేట్‌మెంట్ లేదా స్టేట్‌మెంట్‌ల సమూహాన్ని చాలాసార్లు ప్రదర్శించాల్సిన అవసరం ఉన్న చోట లూప్‌ను whileఉపయోగించవచ్చు. కానీ సాధ్యమయ్యే అన్ని దృశ్యాలలో, ఒకటి హైలైట్ చేయడం విలువ.

ప్రోగ్రామర్ (ప్రోగ్రామ్ యొక్క సృష్టికర్త) లూప్‌ను ఎన్నిసార్లు అమలు చేయాలనేది ముందుగానే తెలిసినప్పుడు మేము పరిస్థితి గురించి మాట్లాడుతున్నాము. ఇది సాధారణంగా ప్రత్యేక కౌంటర్ వేరియబుల్‌ను ప్రకటించడం ద్వారా నిర్వహించబడుతుంది, ఆపై 1లూప్ యొక్క ప్రతి పునరావృతంతో వేరియబుల్‌ను పెంచడం (లేదా తగ్గించడం).

ప్రతిదీ తప్పక పని చేస్తున్నట్లు అనిపిస్తుంది, కానీ ఇది చాలా సౌకర్యవంతంగా లేదు. లూప్ ముందు, మేము కౌంటర్ వేరియబుల్ యొక్క ప్రారంభ విలువను సెట్ చేస్తాము. అప్పుడు పరిస్థితిలో ఇది ఇప్పటికే తుది విలువకు చేరుకుందో లేదో తనిఖీ చేస్తాము. కానీ మేము సాధారణంగా లూప్ బాడీ చివరిలో విలువను మారుస్తాము.

మరియు లూప్ యొక్క శరీరం పెద్దది అయితే? లేదా మనకు అనేక సమూహ లూప్‌లు ఉంటే? సాధారణంగా, ఈ సందర్భాలలో కౌంటర్ వేరియబుల్స్ గురించిన ఈ మొత్తం సమాచారాన్ని ఒకే చోట సేకరించడం మంచిది. మరియు అందుకే మనకు forజావాలో లూప్ ఉంది. ఇది కూడా చాలా క్లిష్టంగా కనిపించడం లేదు:

for (statement 1; condition; statement 2)
{
   block of statements
}

ఒక whileలూప్ కుండలీకరణాల్లో కేవలం ఒక షరతును కలిగి ఉంటుంది, కానీ forలూప్ సెమికోలన్‌లతో వేరు చేయబడిన రెండు స్టేట్‌మెంట్‌లను జోడిస్తుంది.

వాస్తవికత ధ్వనించే దానికంటే చాలా సులభం: కంపైలర్ ఒక లూప్‌ను ఇలా forసాధారణ లూప్‌గా మారుస్తుంది:while

statement 1;
while (condition)
{
   block of statements
   statement 2;
}

లేదా ఇంకా మంచిది, దీనిని ఒక ఉదాహరణతో ప్రదర్శిస్తాము. దిగువన ఉన్న రెండు కోడ్ స్నిప్పెట్‌లు ఒకేలా ఉన్నాయి.

for (int i = 0; i < 20; i++)
{
   System.out.println(i);
}

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

మేము కౌంటర్ వేరియబుల్‌కు సంబంధించిన మొత్తం కోడ్‌ను ఒకే చోట సేకరించాము i.

లూప్‌లో for, లూప్ ప్రారంభం కావడానికి ముందు స్టేట్‌మెంట్ 1 ఒక్కసారి మాత్రమే అమలు చేయబడుతుంది. ఇది రెండవ కోడ్ స్నిప్పెట్‌లో స్పష్టంగా చూడవచ్చు

స్టేట్‌మెంట్ 2 లూప్ బాడీకి సమానమైన సార్లు అమలు చేయబడుతుంది మరియు లూప్ యొక్క మొత్తం భాగం అమలు చేయబడిన తర్వాత ప్రతిసారీ ఇది అమలు చేయబడుతుంది.

2. forలూప్ ఎక్కడ ఉపయోగించబడుతుంది

లూప్ forబహుశా జావాలో ఎక్కువగా ఉపయోగించే లూప్ రకం. ఇది ప్రతిచోటా ఉపయోగించబడుతుంది, ప్రోగ్రామర్‌లకు ఇది whileలూప్ కంటే స్పష్టంగా మరియు సౌకర్యవంతంగా ఉంటుంది. వాస్తవంగా ఏదైనా whileలూప్‌ను లూప్‌గా మార్చవచ్చు for.

ఉదాహరణలు:

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

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

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

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

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

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

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

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

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

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

చివరి ఉదాహరణకి శ్రద్ధ వహించండి. లూప్ కౌంటర్‌తో పని చేయడానికి సంబంధించిన ప్రకటనలు లేవు. కౌంటర్ లేదు మరియు ప్రకటన లేదు.

లూప్‌లో for, "కౌంటర్‌ను ప్రారంభించేందుకు ప్రకటన" మరియు "కౌంటర్‌ను నవీకరించడానికి స్టేట్‌మెంట్"ని వదిలివేయడానికి జావా మిమ్మల్ని అనుమతిస్తుంది. లూప్ పరిస్థితిని నిర్వచించే వ్యక్తీకరణను కూడా విస్మరించవచ్చు.

for3. లూప్ ఉపయోగించి సూక్ష్మ నైపుణ్యాలు

forలూప్‌లు breakమరియు continueస్టేట్‌మెంట్‌లను ఉపయోగించడం గురించి ముఖ్యమైన అంశం .

breakలూప్‌లోని స్టేట్‌మెంట్ లూప్‌లో forఉన్నట్లే పని చేస్తుంది while- ఇది లూప్‌ను వెంటనే రద్దు చేస్తుంది. ఒక continueప్రకటన లూప్ బాడీని దాటవేస్తుంది, కానీ కాదు statement 2(ఇది లూప్ కౌంటర్‌ను మారుస్తుంది).

forలూప్‌లు ఎలా సంబంధం కలిగి ఉన్నాయో మరొకసారి చూద్దాం while.

for (statement 1; condition; statement 2)
{
   block of statements
}

statement 1;
while (condition)
{
   block of statements
   statement 2;
}

ఒక స్టేట్‌మెంట్ continueforలూప్‌లో అమలు చేయబడితే , మిగిలిన స్టేట్‌మెంట్‌ల బ్లాక్ దాటవేయబడుతుంది, అయితే స్టేట్‌మెంట్ 2 (లూప్ యొక్క కౌంటర్ వేరియబుల్‌తో పనిచేసేది for) ఇప్పటికీ అమలు చేయబడుతుంది.

7చే భాగించబడే స్కిప్పింగ్ సంఖ్యలతో మన ఉదాహరణకి తిరిగి వెళ్దాం.

int i = 1;
while (i <= 20)
{
   if ( (i % 7) == 0) continue;
   System.out.println(i);
   i++;
}

for (int i = 1; i <= 20; i++)
{
   if ( (i % 7) == 0) continue;
   System.out.println(i);
}

లూప్‌ని ఉపయోగించే కోడ్ whileపని చేయదు — నేను 7 కంటే ఎక్కువగా ఉండను. కానీ forలూప్‌తో ఉన్న కోడ్ బాగా పని చేస్తుంది.

4. లూప్‌ల కోసం పోల్చడం: జావా vs పాస్కల్

మార్గం ద్వారా, పాస్కల్ కూడా ఒక Forలూప్ ఉంది. సాధారణంగా, తప్పనిసరిగా ప్రతి ప్రోగ్రామింగ్ భాష ఒకటి ఉంటుంది. కానీ పాస్కల్ లో ఇది చాలా స్పష్టంగా ఉంది. ఉదాహరణలు:

For i := 1 to 10 do
Begin
   Writeln(i);
End;

for (int i = 1; i <= 10; i++)
{
   System.out.println(i);
}

For i := 1 to 10 do step 2
Begin
   Writeln(i);
End;

for (int i = 1; i <= 10; i = i + 2)
{
   System.out.println(i);
}

For i := 10 downto 0 do step 2
Begin
   Writeln(i);
End;

for (int i = 10; i >= 0; i = i - 2)
{
   System.out.println(i);
}