ஜாவா லூப் போது

கிட்டத்தட்ட ஒவ்வொரு நிரலாக்க மொழியிலும் லூப் காணப்படுகிறது, மேலும் ஜாவாவும் இதற்கு விதிவிலக்கல்ல. ஜாவா மற்றும் பிற மொழிகளில் உள்ள லூப் ஒரு அறிக்கையை அல்லது அறிக்கைகளின் தொகுதியை செயல்படுத்தும் போது , ​​அதைத் தூண்டிய நிபந்தனையின் மதிப்பு உண்மையாக இருக்கும் வரை. இந்த கட்டுரையில், while loop உடன் எவ்வாறு வேலை செய்வது என்பது பற்றி பேசப் போகிறோம் .

சுழற்சிகள் எதற்காக?

உங்களின் முதல் நிரல்கள், ஒன்றன் பின் ஒன்றாக படிப்படியாக செயல்படுத்தப்பட்ட வழிமுறைகளின் வரிசையாகும். முட்கரண்டி மற்றும் மறுபடியும் இல்லாமல். பின்னர் நிபந்தனை ஆபரேட்டர்களின் உதவியுடன் கிளைகளைப் பயன்படுத்தத் தொடங்கினோம். சரி, மீண்டும் மீண்டும் செயல்களைச் செய்ய, சுழற்சிகள் உள்ளன. செயல்முறை ஆட்டோமேஷன் வழங்கும் புதிய புரோகிராமர்களுக்கு சுழற்சிகள் மிகவும் வெளிப்படையான நன்மைகளில் ஒன்றாகும். ஒரு நாளில் எடுக்கப்பட்ட படிகளின் எண்ணிக்கையைக் கணக்கிடும் டிராக்கர் நிரலை நீங்கள் எழுத வேண்டும் என்று கற்பனை செய்து பாருங்கள். எடுத்துக்காட்டாக, 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;

நிபந்தனை வெளிப்பாடு உண்மையாக இருக்கும் வரை லூப்பின் உடல் செயல்படுத்தப்படும். நிபந்தனை தவறானதாக மாறும்போது, ​​லூப்பிற்குப் பிறகு வரும் குறியீட்டின் வரிக்கு கட்டுப்பாடு மாற்றப்படும். லூப்பில் ஒரே ஒரு அறிக்கை பயன்படுத்தப்பட்டால், சுருள் பிரேஸ்கள் தவிர்க்கப்படலாம் (ஆனால் இதைச் செய்யாமல் இருப்பது நல்லது). லாஜிக்கல் எக்ஸ்ப்ரெஷன், while லூப் தொடங்குவதற்கு முன் மதிப்பீடு செய்யப்படுகிறது , பின்னர் ஒவ்வொரு முறையும் அறிக்கையின் அடுத்த மறுபரிசீலனைக்கு முன் செயல்படுத்தப்படும்.

லூப் எடுத்துக்காட்டுகள்

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

முடிவற்ற சுழற்சி

அதே நேரத்தில் (உண்மை) வடிவத்தில் எல்லையற்ற சுழல்களை ஒழுங்கமைக்க while லூப்பைப் பயன்படுத்தலாம் : எடுத்துக்காட்டாக, இங்கே ஒரு நிரல் முடிவில்லாமல் (சில நுணுக்கங்களுடன்) முழு எண்களின் வரிசையை அச்சிடுகிறது:

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

நீங்கள் கற்றுக்கொண்டதை வலுப்படுத்த, எங்கள் ஜாவா பாடத்திட்டத்திலிருந்து வீடியோ பாடத்தைப் பார்க்க பரிந்துரைக்கிறோம்