ஜாவாவில் உள்ள ஒவ்வொரு வளையத்திற்கும்

ஒவ்வொரு வளையத்திற்கும் என்ன?

ஒவ்வொன்றிற்கும் ஒரு வகையான லூப் ஆகும் , நீங்கள் ஒரு வரிசை அல்லது சேகரிப்பின் அனைத்து கூறுகளையும் செயலாக்க வேண்டும். அதாவது, ஒவ்வொன்றிற்கும் என்ற சொற்றொடர் உண்மையில் இந்த வளையத்தில் பயன்படுத்தப்படவில்லை. அதன் தொடரியல் பின்வருமாறு:

for (type itVar : array)
{
    // Operations
}

வகை என்பது இடிரேட்டர் மாறியின் வகை (அணியில் உள்ள உறுப்புகளின் தரவு வகையுடன் பொருந்துகிறது!), itVar என்பது அதன் பெயர், மற்றும் வரிசை என்பது ஒரு வரிசை (பிற தரவு கட்டமைப்புகளும் அனுமதிக்கப்படுகின்றன, எடுத்துக்காட்டாக, ArrayList போன்ற சில வகையான சேகரிப்புகள் ), அதாவது லூப் செயல்படுத்தப்படும் பொருள். நீங்கள் பார்க்க முடியும் என, இந்த கட்டமைப்பானது ஒரு கவுண்டரைப் பயன்படுத்தாது: இடிரேட்டர் மாறி வரிசை அல்லது சேகரிப்பின் கூறுகளின் மீது வெறுமனே திரும்புகிறது. அத்தகைய லூப் செயல்படுத்தப்படும் போது, ​​வரிசை அல்லது சேகரிப்பின் ஒவ்வொரு தனிமத்தின் மதிப்பை இடிரேட்டர் மாறி வரிசையாக ஒதுக்குகிறது, அதன் பிறகு குறிப்பிட்ட அறிக்கைகளின் தொகுதி (அல்லது அறிக்கை) செயல்படுத்தப்படுகிறது. குறிப்பு: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. நீங்கள் ஒரு அணிவரிசையில் ஒரு உறுப்பைத் தேடுகிறீர்கள் என்றால், நீங்கள் தேடும் உறுப்பின் குறியீட்டை நீங்கள் திரும்ப (அல்லது அனுப்ப) வேண்டும் என்றால், லூப்பிற்கான சாதாரண ஒன்றைப் பயன்படுத்துவது நல்லது .

ஒவ்வொரு லூப் பற்றிய பயனுள்ள வீடியோ

ஒவ்வொரு மற்றும் பிற லூப்கள் பற்றிய கூடுதல் தகவல்

1. போது அறிக்கை . கட்டுரை எளிய வகையான லூப்பைப் பற்றியது: whileலூப், மாணவர்களுக்கு லூப்களை அறிமுகப்படுத்த கோட்ஜிம் பயன்படுத்தும்.
2. சுழல்கள் எழுதுவதை நிறுத்து! ஜாவா 8 இல் சேகரிப்புகளுடன் பணிபுரிவதற்கான சிறந்த 10 சிறந்த நடைமுறைகள் . பாடநெறியின் பாதியிலேயே இருக்கும் கோட்ஜிம் மாணவர்களுக்கு சேகரிப்புகளுடன் பணிபுரிவது பற்றி பல சுவாரஸ்யமான விஷயங்களைக் கற்றுக்கொள்ள இந்தக் கட்டுரை உதவும்.