లూప్ కోసం జావా

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

జావాలో లూప్ రాయడం ఎలా? సాధారణంగా లూప్ కోసం

లూప్ నిర్దిష్ట సంఖ్యలో కొన్ని స్టేట్‌మెంట్‌లను అమలు చేస్తుంది. ఉదాహరణకు, "నేను అలా ఉండకూడదు, హో-హో, హో" అని యాభై సార్లు రాయడం లేదా మీ స్నేహితులందరికీ ఆహ్వానాలు పంపడం ఈ రకమైన లూప్ కోసం సాధారణ పనులు. లూప్ యొక్క అత్యంత సాధారణ వెర్షన్ యొక్క సింటాక్స్:

for ([counter initialization]; [checking conditions]; [changing of the counter])
{
    //  statements
}

ప్రారంభ వ్యక్తీకరణ ఒకసారి అమలు చేయబడుతుంది, తర్వాత పరిస్థితి మూల్యాంకనం చేయబడుతుంది, ఇది బూలియన్ వ్యక్తీకరణ అయి ఉండాలి.

• లూప్ ప్రారంభమైనప్పుడు ప్రారంభాలు అమలు చేయబడతాయి.
• పరిస్థితులు తప్పు అని మూల్యాంకనం చేసినప్పుడు, మా లూప్ దాని పనిని ఆపివేస్తుంది.

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

జావాలో లూప్ కోసం ఎలా ఉపయోగించాలి. సాధారణ ఉదాహరణ.

లూప్ ఉదాహరణ కోసం ఇక్కడ ఒక నిర్దిష్ట జావా ఉంది. పదిసార్లు వ్రాస్తాము "హలో!" ప్రతిసారి స్ట్రింగ్ ఈ లైన్‌లోని అనేక కొత్త లైన్ నుండి వస్తుంది. మేము తదుపరి అవుట్‌పుట్‌ని పొందాలి:

1. హలో!
2. హలో!
3. హలో!
4. హలో!
5. హలో!
6. హలో!
7. హలో!
8. హలో!
9. హలో!
10. హలో!

ఈ సమస్యను పరిష్కరించే మా జావా ప్రోగ్రామ్ ఇక్కడ ఉంది:

public class ForExample {
   public static void main(String[] args) {
       for (int i = 0; i < 10; i++) {
           System.out.println(i + 1 + ". Hello!");
       }
   }
}

అది ఎలా పని చేస్తుంది?

దశ 1. కౌంటర్ i = 0. లూప్ మా పరిస్థితిని తనిఖీ చేస్తుంది, i << 10, అందుకే, లూప్ స్టేట్‌మెంట్‌లు అమలు చేయబడతాయి. ఇది "1. హలో!" అనే పదబంధాన్ని ముద్రిస్తుంది. 1 అనేది స్ట్రింగ్ i + 1 (ఎందుకంటే మనం సున్నా నుండి లెక్కించాము, కానీ మొదటి పంక్తి ఇప్పటికీ మొదటిది). కౌంటర్ i పెరిగింది. ఇప్పుడు, i = 1. దశ 2. కౌంటర్ i = 1. i < 10, కాబట్టి మనకు "2. హలో!" అనే పదబంధం వచ్చింది. మరియు i + 1 = 2. … దశ 10. కౌంటర్ i = 9, మేము "10. హలో!" మరియు నేను 10కి పెంచబడ్డాను. దశ 11. కౌంటర్ i = 10. i <10 ? లేదు, అది అబద్ధం. అందువలన, లూప్ ముగిసింది.

అయితే లూప్ మరియు లూప్ కోసం: తేడాలు మరియు సారూప్యతలు

జావాలో నిరవధిక లూప్ లేదా బూలియన్ కండిషన్ నిజమైతే లూప్ నిరంతరంగా అమలు చేయబడుతుంది. while లూప్ యొక్క సింటాక్స్:

while (boolean condition)
       {
            loop statements...
       }

చాలా తరచుగా మీరు ఏ లూప్‌ని ఉపయోగించాలనుకుంటున్నారో ఎంచుకోవచ్చు. కొన్నిసార్లు అవి చాలా దగ్గరగా ఉంటాయి మరియు మీరు రెండింటినీ ఉపయోగించవచ్చు. ఉదాహరణకు, అదే పనికి సంబంధించిన కోడ్ ఇక్కడ ఉంది (పది సార్లు "హలో!" అని అనేక పంక్తితో వ్రాయడం) while లూప్‌తో వ్రాయబడింది:

public class ForAndForEach {
   public static void main(String[] args) {
       int j = 0;  //  we use the counter this way 
       while (j < 10) {
           System.out.println(j + 1 + ". Hello!");
           j++;
       }
   }
}

అయితే, ప్రొఫెషనల్ ప్రోగ్రామర్లు అయితే లూప్‌ని ఇష్టపడరు మరియు సాధ్యమైన చోట, లూప్‌ని ఉపయోగించడానికి ప్రయత్నించండి.

జావాలో లూప్ నుండి ఎలా నిష్క్రమించాలి

సాధారణంగా a for loop ఒక ప్రవాహం వలె నడుస్తుంది మరియు ఒక షరతు తప్పుడు విలువను తీసుకున్నప్పుడు లూప్ నుండి నిష్క్రమించడానికి సహజ మార్గం. అయితే మీరు షరతు యొక్క తప్పుడు విలువను పొందే ముందు లూప్ నుండి నిష్క్రమించడానికి మిమ్మల్ని అనుమతించే రెండు నియంత్రణ ప్రకటనలు ఉన్నాయి - బ్రేక్ మరియు కొనసాగించండి.

• బ్రేక్ లూప్ పరిస్థితి తప్పుగా మూల్యాంకనం చేయబడినట్లుగా ప్రస్తుత లూప్ బాడీ నుండి నిష్క్రమించడానికి అనుమతిస్తుంది.
• continue లూప్‌ను స్టేట్‌మెంట్‌లను అమలు చేయకుండా తదుపరి దశకు (కౌంటర్‌ని మళ్ళించడం)కి వెళ్లేలా చేస్తుంది.

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

public class ForBreakExample {
   public static void main(String[] args) {
       String[] names = {"Mike", "Dustin", "Stranger", "Lucas", "Will"};
       for (int i = 0; i < names.length; i++) {
//  how to break out of a for loop, java: check if we have any "Stranger" in  //  our array            
if (names[i].equals("Stranger")) {
               System.out.println("I don't chat with strangers");
               break;
           }
           System.out.println("Hello," + names[i]);
       }
   }
}

మా ప్రోగ్రామ్ అమలు ఫలితం:

Hello,Mike
Hello,Dustin
I don't chat with strangers

చూడండి? మేము లూకాస్ మరియు విల్‌లను పలకరించే ముందు మేము లూప్ నుండి పారిపోయాము. ఇప్పుడు "అపరిచితుడు"ని విస్మరించడానికి కొనసాగించడాన్ని ఉపయోగిస్తాము, కానీ ఇతర స్నేహితులకు హలో చెప్పడానికి లూప్‌లో ఉండండి.

public class ForContinueExample {
   public static void main(String[] args) {
       String[] names = {"Mike", "Dustin", "Stranger", "Lucas", "Will"};
       for (int i = 0; i < names.length; i++) {
           if (names[i].equals("Stranger")) {
               System.out.println("I don't chat with strangers");
               continue;
           }
           System.out.println("Hello," + names[i]);
       }
   }
}

ఫలితం:

Hello,Mike
Hello,Dustin
I don't chat with strangers
Hello,Lucas
Hello,Will

అద్భుతమైన! మేము స్నేహితులందరినీ పలకరించాము, కాని తెలియని వ్యక్తితో మాట్లాడలేదు.

లూప్ కోసం లేదా ప్రతి కోసం మెరుగైన సంస్కరణ

For-each అనేది ఒక రకమైన లూప్, ఇది మీరు శ్రేణి లేదా సేకరణ యొక్క అన్ని అంశాలను ప్రాసెస్ చేయవలసి వచ్చినప్పుడు ఉపయోగించబడుతుంది. నిజానికి, ఈ సైకిల్‌లో ప్రతి కోసం అనే పదం ఉపయోగించబడలేదు. వాక్యనిర్మాణం క్రింది విధంగా ఉంది:

for (type itVar: array)
{
    Block of operators;
}

రకం అనేది పునరుక్తి వేరియబుల్ రకం (అరే యొక్క డేటా రకం వలె ఉంటుంది), ItVar అనేది దాని పేరు, శ్రేణి శ్రేణి లేదా మరొక డేటా నిర్మాణం ఉండవచ్చు, ఉదాహరణకు, ArrayList. మీరు చూడగలిగినట్లుగా, కౌంటర్ లేదు, పునరావృత వేరియబుల్ శ్రేణి లేదా సేకరణ యొక్క మూలకాలపై పునరావృతమవుతుంది మరియు సూచిక విలువలపై కాదు. అటువంటి లూప్ అమలు చేయబడినప్పుడు, పునరావృత వేరియబుల్ శ్రేణి లేదా సేకరణ యొక్క ప్రతి మూలకం యొక్క విలువను వరుసగా కేటాయించబడుతుంది, దాని తర్వాత పేర్కొన్న స్టేట్‌మెంట్‌ల బ్లాక్ (లేదా ఆపరేటర్) అమలు చేయబడుతుంది. శ్రద్ధ: ప్రతి లూప్‌ని శ్రేణులకు మరియు java.lang.Iterable ఇంటర్‌ఫేస్‌ని అమలు చేసే ఏవైనా తరగతులకు వర్తింపజేయవచ్చు. అపరిచితులను ("అపరిచితుడు") విస్మరించి, స్నేహితుల శుభాకాంక్షలతో అదే సమస్యను పరిష్కరిద్దాం, కానీ ఈసారి ప్రతి లూప్ కోసం ఉపయోగించండి.

public class ForEachExample {
   public static void main(String[] args) {
       String[] names = {"Mike", "Dustin", "Stranger", "Lucas", "Will"};
	//  for each loop, Java code
       for (String name : names) {
           if (name.equals("Stranger")) {
               System.out.println("I don't chat with strangers");
               continue;
           }
           System.out.println("hello, " + name);
       }
   }
}

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