జావా లూప్ అయితే

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

చక్రాలు దేనికి?

మీ మొట్టమొదటి ప్రోగ్రామ్‌లు ఒకదాని తర్వాత మరొకటి దశలవారీగా అమలు చేయబడిన సూచనల క్రమం. ఫోర్కులు మరియు పునరావృత్తులు లేకుండా. తర్వాత మేము షరతులతో కూడిన ఆపరేటర్ల సహాయంతో శాఖలను ఉపయోగించడం ప్రారంభించాము. బాగా, పునరావృత చర్యలను నిర్వహించడానికి, చక్రాలు ఉన్నాయి. ప్రాసెస్ ఆటోమేషన్ అందించే అనుభవం లేని ప్రోగ్రామర్‌లకు సైకిల్స్ చాలా స్పష్టమైన ప్రయోజనాల్లో ఒకటి. మీరు ఒక రోజులో తీసుకున్న దశల సంఖ్యను లెక్కించే ట్రాకర్ ప్రోగ్రామ్‌ను వ్రాయవలసి ఉంటుందని ఊహించండి. మరియు మీరు ఉత్తీర్ణత సాధించినప్పుడు, ఉదాహరణకు, 10,000 దశలు, ప్రోగ్రామ్ సాధించిన లక్ష్యం గురించి మీకు నోటిఫికేషన్‌ను పంపుతుంది. నోటిఫికేషన్ జారీ చేసే పనిని ఇలా పదాలలో (లేదా సూడోకోడ్) వ్యక్తీకరించవచ్చు:

While (number of steps less than 10,000)
{
Count steps
}

Send notification "you have reached the goal"

అంటే, కండిషన్‌లో పేర్కొన్న వాటికి దశల సంఖ్య సమానంగా ఉన్న వెంటనే, ప్రోగ్రామ్ ఈ చక్రం నుండి నిష్క్రమించి నోటిఫికేషన్‌ను పంపుతుంది. లేదా మరొక ఉదాహరణ. మీరు ఒక పద్యం (లేదా ప్రసంగం) గుర్తుంచుకోవాలని ఆలోచించండి. ఒక పద్యం పీకి చూడకుండా వరుసగా మూడు సార్లు చదవగలిగితే అది కంఠస్థం అయినట్లు పరిగణిస్తారు. పద్యాన్ని పఠించడానికి మీరు చేసిన ప్రయత్నాలను క్యాప్చర్ చేసే ప్రోగ్రామ్‌ను మీరు ఊహించినట్లయితే, అది కూడా లూప్‌ని ఉపయోగించాల్సి ఉంటుంది:

While (success < 3)
learn a poem

ఉపయోగించే అన్ని ఆధునిక విద్యా యాప్‌లలో ఇలాంటి నిర్మాణాలు ఉపయోగించబడతాయి, ఉదాహరణకు, భాషలను నేర్చుకోవడంలో లేదా సంగీత వాయిద్యాలను ప్లే చేయడంలో.

అయితే లూప్ మరియు దాని నిర్మాణం

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

while(condition == true) {
    // statement or loop body
}

షరతు తప్పనిసరిగా బూలియన్ వ్యక్తీకరణ అయి ఉండాలి, అంటే నిజం లేదా తప్పు అని చెప్పవచ్చు. బూలియన్ వ్యక్తీకరణల యొక్క కొన్ని ఉదాహరణలు ఇక్కడ ఉన్నాయి:

s != "exit";
a > 5;
true;

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

లూప్ ఉదాహరణలు అయితే

కాసేపు లూప్‌ని ఉపయోగించి 1 నుండి 10 వరకు ఉన్న అన్ని సంఖ్యలను సంక్షిప్తీకరించడానికి ప్రోగ్రామ్‌ను వ్రాద్దాం :

public class WhileTest0 {
   public static void main(String[] args) {
       int i = 0;
       int sum = 0;
   //while loop     
   while (i < 11) {
           sum = sum + i;
           i++;
       }
       System.out.println(sum);
   }
}

అవుట్‌పుట్: మేము 1 (లేదా సున్నా నుండి, అది పట్టింపు లేదు) నుండి 10 వరకు అన్ని సంఖ్యల మొత్తాన్ని లెక్కించాలి. మేము ప్రారంభ మొత్తాన్ని మరియు మొదటి మూలకాన్ని సున్నాకి సమానంగా చేస్తాము మరియు మేము ప్రతి పాస్‌తో మూలకాన్ని ఒక్కొక్కటిగా పెంచుతాము లూప్. ఆర్గ్యుమెంట్ 10కి సమానం అయ్యే వరకు మేము సంకలనం కొనసాగిస్తాము (అంటే, 11 కంటే తక్కువ. అదేవిధంగా, మేము షరతు i <= 10 ) వ్రాయవచ్చు . మరొక జావా లూప్ ఉదాహరణ తీసుకుందాం . వినియోగదారులు సానుకూల పూర్ణాంకాలను నమోదు చేసే ప్రోగ్రామ్‌ను మేము వ్రాయబోతున్నాము. వారు సున్నా లేదా ప్రతికూల సంఖ్యను నమోదు చేస్తే, ప్రోగ్రామ్ దీన్ని నివేదించాలి మరియు పనిని పూర్తి చేయాలి.

import java.util.Scanner;

public class WhileTest {
   public static void main(String[] args) {
       int positiveNumber = 1;
       Scanner scanner = new Scanner(String.valueOf(positiveNumber));
       while (positiveNumber > 0) {
           Scanner sc = new Scanner(System.in);
           System.out.println("Enter positive number:");
           positiveNumber = sc.nextInt();
           System.out.println("ok, next");
       }
       System.out.println("The number should be positive");
   }
}

మీరు ప్రోగ్రామ్‌ను మెరుగుపరచవచ్చు మరియు దానికి జోడించవచ్చు, ఉదాహరణకు, వినియోగదారు సరిగ్గా ఒక సంఖ్యను నమోదు చేసారా మరియు ఏదైనా ఇతర అక్షరాన్ని నమోదు చేయలేదా లేదా సంఖ్య పూర్ణాంకం అని తనిఖీ చేయడం.

డూ-వేల్ లూప్

క్లాసిక్ అయితే లూప్, పై ఉదాహరణలలో వలె, పరిస్థితి నిజమో కాదో వెంటనే తనిఖీ చేస్తుంది. అందువల్ల, దీనిని ముందస్తు షరతులతో కూడిన చక్రం అని పిలుస్తారు. అయితే లూప్‌లో ఒక సోదరుడు డూ-వైల్, పోస్ట్ కండిషన్‌తో కూడిన లూప్‌ని కలిగి ఉంటుంది. అంటే, పరిస్థితి యొక్క సత్యాన్ని పరీక్షించే ముందు, అటువంటి లూప్ కనీసం ఒక్కసారైనా అమలు చేయబడుతుంది:

do {
     // Loop body - periodically executed statement(s)
}while(Boolean expression);

కాబట్టి, అటువంటి లూప్‌తో మొదటి ఉదాహరణ ఇలా ఉంటుంది:

public class WhileTest0 {
   public static void main(String[] args) {
       int i = 0;
       int sum = 0;
       do
        {
           sum = sum + i;
           i++;
       } while (i < 11);
       System.out.println(sum);
   }
}

అంతులేని చక్రం

అయితే (నిజం) రూపంలో అనంతమైన లూప్‌లను నిర్వహించడానికి అయితే లూప్‌ను ఉపయోగించవచ్చు : ఉదాహరణకు, ఇక్కడ ఒక ప్రోగ్రామ్ అనంతంగా (కొన్ని సూక్ష్మ నైపుణ్యాలతో) పూర్ణాంకాల శ్రేణిని ముద్రిస్తుంది:

public class EndlessLoop {
    public static void main(String[] args) {
        int i = 0;
        while (true) {
            System.out.println(i++);
        }
    }
}

మీరు నేర్చుకున్న వాటిని బలోపేతం చేయడానికి, మా జావా కోర్సు నుండి వీడియో పాఠాన్ని చూడమని మేము మీకు సూచిస్తున్నాము