జావాలో లూప్‌లు

1. మన జీవితంలో ఉచ్చులు

చాలా తరచుగా మన జీవితాలు ఒకే విధమైన చర్యలను చాలాసార్లు చేయవలసి ఉంటుంది. ఉదాహరణకు, నేను చాలా పేజీలతో కూడిన పత్రాన్ని స్కాన్ చేయవలసి ఉందని అనుకుందాం. మేము అదే విధానాన్ని మళ్లీ మళ్లీ పునరావృతం చేస్తాము:

• స్కానర్‌లో మొదటి పేజీని ఉంచండి
• స్కాన్ బటన్‌ను నొక్కండి
• తదుపరి పేజీని స్కానర్‌లో ఉంచండి

దీన్ని మాన్యువల్‌గా చేయడం కష్టం. ఈ ప్రక్రియ ఏదో ఒకవిధంగా స్వయంచాలకంగా జరిగితే బాగుంటుంది.

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

కానీ ప్రోగ్రామర్లు సోమరితనం, కాబట్టి వారు చాలా కాలం క్రితం ఈ ప్రక్రియను ఆటోమేట్ చేసారు: ఇప్పుడు మీరు ఏదైనా అక్షరాల జాబితాను ఎంచుకుని, "స్పామ్‌గా గుర్తించు" క్లిక్ చేయండి, ఆపై మీ ఇమెయిల్ క్లయింట్ జాబితా ద్వారా నడుస్తుంది మరియు ప్రతి ఇమెయిల్‌ను స్పామ్ ఫోల్డర్‌కు తరలిస్తుంది.

మనం ఇక్కడ ఏమి చెప్పగలం? ఒక కంప్యూటర్ లేదా ప్రోగ్రామ్ ఒక క్లిక్‌తో వందల లేదా వేల మార్పులేని కార్యకలాపాలను అమలు చేయగలిగినప్పుడు ఇది చాలా సౌకర్యవంతంగా ఉంటుంది. మరియు ఇప్పుడు మీరు దీన్ని ఎలా చేయాలో కూడా నేర్చుకుంటారు.

2. whileలూప్

if-else స్టేట్‌మెంట్ మా ప్రోగ్రామింగ్ సామర్థ్యాలను గణనీయంగా విస్తరించింది, వివిధ పరిస్థితులలో విభిన్న చర్యలను చేసే ప్రోగ్రామ్‌లను వ్రాయడం సాధ్యపడుతుంది. కానీ మా ప్రోగ్రామ్‌లను మరింత శక్తివంతంగా మార్చే మరో విషయం ఉంది — లూప్స్ .

జావాలో 4 రకాల లూప్‌లు ఉన్నాయి: while, for, for-eachమరియు do-while. మేము ఇప్పుడు వీటిలో మొదటిదాన్ని పరిశీలిస్తాము.

ఒక whileలూప్ చాలా సులభం. ఇది కేవలం రెండు భాగాలను మాత్రమే కలిగి ఉంటుంది: ఒక కండిషన్ మరియు లూప్ బాడీ . పరిస్థితి ఉన్నంత వరకు లూప్ బాడీ మళ్లీ మళ్లీ అమలు చేయబడుతుంది true. సాధారణంగా, whileలూప్ ఇలా కనిపిస్తుంది:

while (condition)
   statement;

while (condition)
{
   block of statements
}

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

ఇది ఎలా పని చేస్తుంది: మొదట, పరిస్థితి తనిఖీ చేయబడుతుంది. ఇది నిజమైతే, లూప్ బాడీ అమలు చేయబడుతుంది ( స్టేట్‌మెంట్ లేదా స్టేట్‌మెంట్‌ల బ్లాక్ ). అప్పుడు పరిస్థితి మళ్లీ తనిఖీ చేయబడుతుంది మరియు లూప్ బాడీ మళ్లీ అమలు చేయబడుతుంది. మరియు పరిస్థితి తప్పుగా మారే వరకు .

షరతు ఎల్లప్పుడూ నిజమైతే , ప్రోగ్రామ్ ఎప్పటికీ రన్ అవ్వదు. ఇది శాశ్వతంగా లూప్‌లో చిక్కుకుపోతుంది.

మొదటి సారి తనిఖీ చేయబడినప్పుడు షరతు తప్పు అయితే , లూప్ యొక్క శరీరం ఒక్కసారి కూడా అమలు చేయబడదు.

3. లూప్‌ల ఉదాహరణలు

చర్యలో లూప్‌ల యొక్క కొన్ని ఆచరణాత్మక ఉదాహరణలు ఇక్కడ ఉన్నాయి.

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

మునుపటి ఉదాహరణలో, equals()తీగలను పోల్చడానికి పద్ధతి ఉపయోగించబడుతుంది. స్ట్రింగ్‌లు సమానంగా ఉంటే, ఫంక్షన్ తిరిగి వస్తుంది true. తీగలు సమానంగా లేకుంటే, అది తిరిగి వస్తుంది false.

4. లూప్ లోపల లూప్ చేయండి

మీరు షరతులతో కూడిన ప్రకటనల గురించి తెలుసుకున్నట్లుగా, మీరు బహుళ షరతులతో కూడిన ప్రకటనలను కలపడం ద్వారా సంక్లిష్ట తర్కాన్ని అమలు చేయడానికి వాటిని ఉపయోగించవచ్చని మీరు చూశారు. మరో మాటలో చెప్పాలంటే, ifస్టేట్‌మెంట్ లోపల స్టేట్‌మెంట్‌ను ఉపయోగించడం ద్వారా if.

మీరు లూప్‌లతో అదే పనిని చేయవచ్చు. లూప్‌లో లూప్‌ను వ్రాయడానికి, మీరు మొదటి లూప్ యొక్క శరీరం లోపల రెండవ లూప్‌ను వ్రాయాలి. ఇది ఇలా కనిపిస్తుంది:

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

మూడు పనులు చూద్దాం.

టాస్క్ 1 . Momస్క్రీన్‌పై పదాన్ని 4 సార్లు ప్రదర్శించే ప్రోగ్రామ్‌ను వ్రాయాలనుకుంటున్నాము . ఒక లూప్ ఖచ్చితంగా మనకు అవసరం. మరియు మా కోడ్ ఇలా కనిపిస్తుంది:

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

Mom
Mom
Mom
Mom

టాస్క్ 2 . Aమేము ఒకే పంక్తిలో 5 అక్షరాలను ప్రదర్శించే ప్రోగ్రామ్‌ను వ్రాయాలనుకుంటున్నాము . దీన్ని చేయడానికి, మనకు మరోసారి లూప్ అవసరం. కోడ్ ఇలా కనిపిస్తుంది:

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

AAAAA

టాస్క్ 3 . మేము అక్షరం sతో కూడిన దీర్ఘచతురస్రాన్ని ప్రదర్శించాలనుకుంటున్నాము A. దీర్ఘచతురస్రం 5 నిలువు వరుసలతో 4 వరుసలను కలిగి ఉండాలి. దీన్ని సాధించడానికి, మనకు ఇప్పుడు ఒక సమూహ లూప్ అవసరం. మేము మా మొదటి ఉదాహరణను తీసుకుంటాము (మనం 4 లైన్లను అవుట్‌పుట్ చేసేది) మరియు రెండవ ఉదాహరణలోని కోడ్‌తో ఒక లైన్ అవుట్‌పుట్ చేయడానికి కోడ్‌ను భర్తీ చేస్తాము.

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

లూప్ పునరావృతాల సంఖ్యను లెక్కించడానికి బయటి మరియు లోపలి లూప్‌లు తప్పనిసరిగా వేర్వేరు వేరియబుల్‌లను ఉపయోగించాలి. System.out.println()మేము లోపలి లూప్ తర్వాత కమాండ్‌ను కూడా జోడించాల్సి ఉంటుంది , ఎందుకంటే ఆ లూప్ Aఅదే లైన్‌లో s అనే అక్షరాన్ని ప్రదర్శిస్తుంది. ఒక లైన్‌లోని అక్షరాలు ప్రదర్శించబడిన తర్వాత, ఎవరైనా కర్సర్‌ను కొత్త లైన్‌కి తరలించాలి.

5. జావా vs పాస్కల్ లూప్‌లను పోల్చడం

మీలో చాలామంది హైస్కూల్లో పాస్కల్ చదివారు. whileఇక్కడ ఉన్న విషయాన్ని మీరు సులభంగా అర్థం చేసుకోవడానికి, పాస్కల్ మరియు జావాలో వ్రాసిన ఈ లూప్‌ల పోలికను చూడండి . మీకు పాస్కల్ తెలియకపోతే, ఈ భాగాన్ని దాటవేయండి.

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