CodeGym /జావా బ్లాగ్ /యాదృచ్ఛికంగా /జావాలోని ప్రతి లూప్ కోసం
John Squirrels
స్థాయి
San Francisco

జావాలోని ప్రతి లూప్ కోసం

సమూహంలో ప్రచురించబడింది

ప్రతి లూప్ అంటే ఏమిటి?

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

for (type itVar : array) 
{ 
    // Operations
}
ఇటరేటర్ వేరియబుల్ రకం (ఇది శ్రేణిలోని మూలకాల యొక్క డేటాటైప్‌తో సరిపోలుతుంది!), itVar అనేది దాని పేరు, మరియు శ్రేణి ఒక శ్రేణి (ఇతర డేటా నిర్మాణాలు కూడా అనుమతించబడతాయి, ఉదాహరణకు, ArrayList వంటి కొన్ని రకాల సేకరణలు కూడా అనుమతించబడతాయి. ), అనగా లూప్ అమలు చేయబడిన వస్తువు. మీరు చూడగలిగినట్లుగా, ఈ నిర్మాణం కౌంటర్‌ను ఉపయోగించదు: ఇటరేటర్ వేరియబుల్ కేవలం శ్రేణి లేదా సేకరణ యొక్క మూలకాలపై పునరావృతమవుతుంది. అటువంటి లూప్ అమలు చేయబడినప్పుడు, ఇటరేటర్ వేరియబుల్ శ్రేణి లేదా సేకరణ యొక్క ప్రతి మూలకం యొక్క విలువను వరుసగా కేటాయించబడుతుంది, దాని తర్వాత పేర్కొన్న స్టేట్‌మెంట్‌ల బ్లాక్ (లేదా స్టేట్‌మెంట్) అమలు చేయబడుతుంది.

ప్రతి లూప్‌తో పాటు, జావాలో forEach() పద్ధతి కూడా ఉంది. మీరు దాని గురించి "లూప్‌లు రాయడం ఆపు!" అనే వ్యాసంలో చదువుకోవచ్చు. జావా 8లో సేకరణలతో పని చేయడానికి టాప్ 10 ఉత్తమ పద్ధతులు

గమనిక:java.lang.Iterable ఇంటర్‌ఫేస్‌ను అమలు చేసే శ్రేణులు మరియు ఏవైనా తరగతులకు ప్రతి లూప్‌ని వర్తింపజేయవచ్చు . లూప్ కోసం కిందివి పైన ఉన్న కోడ్‌కి సమానం:

for (int i=0; i < array.length; i++) 
{ 
    
    // Statements 
}

ప్రతి లూప్‌కి ఉదాహరణ

మేము విద్యార్థుల స్కోర్‌ల శ్రేణిని సృష్టిస్తాము. అప్పుడు మేము అన్ని అంచనాలను ప్రింట్ చేయడానికి, సగటు స్కోర్‌ను లెక్కించడానికి మరియు టాప్ స్కోర్‌ను కనుగొనడానికి ప్రతి లూప్‌ని ఉపయోగిస్తాము .

public class ForEachTest {
    
// A method that prints all scores     
public static void printAllScores(int[] scores) {
        System.out.print("|");
        for (int num : scores) {

            System.out.print(num + "|");
        }
        System.out.println();
    }

// A method that displays the average score 
    
public static double getAverageScore(int[] numbers) {
        int totalScore = 0;

        for (int num : numbers) {
            totalScore = num + totalScore;
        }
        return ((double) totalScore / numbers.length);

    }
// A method that determines the best (maximum) score 
    public static int getBestScore(int[] numbers) {
        int maxScore = numbers[0];

        for (int num : numbers) {
            if (num > maxScore) {
                maxScore = num;
            }
        }
        return maxScore;
    }

public static void main(String[] args) {
      
// Array of scores 
int[] scores = {5, 10, 7, 8, 9, 9, 10, 12};

        
  int bestScore = getBestScore(scores);
        System.out.print("All the scores: ");
        printAllScores(scores);
        System.out.println("The highest score is " + bestScore);
        System.out.println("The average score is " + getAverageScore(scores));
    }

}
ప్రోగ్రామ్ అవుట్‌పుట్:

All the scores: |5|10|7|8|9|9|10|12|
The highest score is 12
The average score is 8.75
ఇప్పుడు, మనం సాధారణ లూప్‌ని ఉపయోగిస్తే, అన్ని స్కోర్‌లను ముద్రించే పద్ధతి ఎలా ఉంటుందో చూద్దాం :

public static void printAllScores(int[] scores) {
        System.out.print("|");
        for (int i = 0; i < scores.length; i++) {

            System.out.print(scores[i] + "|");
        }
        System.out.println();
    }
మేము ఈ పద్ధతిని ప్రధాన పద్ధతి నుండి పిలిస్తే , మేము ఈ ఫలితాన్ని పొందుతాము:

All the scores: |5|10|7|8|9|9|10|12|

సేకరణలతో ప్రతి లూప్‌కి ఉదాహరణ

మేము పేర్ల సేకరణను సృష్టిస్తాము మరియు స్క్రీన్‌పై అన్ని పేర్లను ప్రదర్శిస్తాము.

List<String> names = new ArrayList<>();
        names.add("Snoopy");
        names.add("Charlie");
        names.add("Linus");
        names.add("Shroeder");
        names.add("Woodstock");

        for(String name : names){
            System.out.println(name);
        }

ప్రతి లూప్ యొక్క పరిమితులు

ప్రతి లూప్ యొక్క కాంపాక్ట్ ఫారమ్ ఫర్ లూప్ కంటే సులభంగా చదవబడుతుంది మరియు సాధ్యమైన చోట ప్రతి లూప్‌ను ఉపయోగించడం ఉత్తమ అభ్యాసంగా పరిగణించబడుతుంది . అయినప్పటికీ, ప్రతి లూప్ సాధారణ లూప్ కంటే తక్కువ సార్వత్రిక నిర్మాణం . ఇక్కడ కొన్ని సాధారణ సందర్భాలు ఉన్నాయి, వీటిలో ప్రతి లూప్ అస్సలు పని చేయదు లేదా పని చేస్తుంది, కానీ కష్టంతో మాత్రమే.
  1. మీరు చివరి నుండి ప్రారంభం వరకు లూప్ ద్వారా అమలు చేయాలనుకుంటే. అంటే, క్రింది కోడ్‌కు ప్రత్యక్ష అనలాగ్‌గా ఉండే ప్రతి లూప్‌కు ఏదీ లేదు :

    
    for (int i= array.length-1; i>0; i--) 
    {
          System.out.println(array[i]);
    }
    
  2. మీరు శ్రేణికి మార్పులు చేయాలనుకుంటే ప్రతి కోసం సరిపోదు. ఉదాహరణకు, మీరు శ్రేణిని దాని మూలకాల స్థానాన్ని మార్చకుండా క్రమబద్ధీకరించలేరు. అదనంగా, కింది కోడ్‌లో, ఇటరేటర్ వేరియబుల్ మాత్రమే మారుతుంది, శ్రేణి యొక్క మూలకం కాదు:

    
    for (int itVar : array) 
    {
        itVar = itVar++; 
    }
    
  3. మీరు శ్రేణిలో ఒక మూలకం కోసం వెతుకుతున్నట్లయితే మరియు మీరు వెతుకుతున్న మూలకం యొక్క సూచికను తిరిగి (లేదా పాస్) చేయాల్సి ఉంటే, అప్పుడు లూప్ కోసం సాధారణాన్ని ఉపయోగించడం ఉత్తమం.

ప్రతి లూప్ గురించి ఉపయోగకరమైన వీడియో

కోడ్‌జిమ్ కోర్సులో లూప్‌లు

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

ప్రతి మరియు ఇతర లూప్‌ల గురించి మరింత సమాచారం

  1. అయితే ప్రకటన . వ్యాసం సరళమైన రకమైన లూప్ గురించి ఉంది: whileవిద్యార్థులకు లూప్‌లను పరిచయం చేయడానికి కోడ్‌జిమ్ ఉపయోగించే లూప్.
  2. లూప్‌లు రాయడం ఆపు! Java 8లో సేకరణలతో పని చేయడానికి టాప్ 10 ఉత్తమ పద్ధతులు . ఈ కథనం కనీసం సగం కోర్సులో ఉన్న కోడ్‌జిమ్ విద్యార్థులకు సేకరణలతో పని చేయడం గురించి అనేక ఆసక్తికరమైన విషయాలను తెలుసుకోవడానికి సహాయపడుతుంది.
వ్యాఖ్యలు
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION