எடுத்துக்காட்டுகளுடன் ஜாவாவில் ஃபார், ஆயில் மற்றும் டூ வேல் லூப்ஸை எப்படி பயன்படுத்துவது

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

நிரல் வளர்ச்சியில் சுழல்கள் ஒரு முக்கிய பகுதியாகும், ஏனெனில் அவை பல தேர்வு அறிக்கைகளை மீண்டும் செய்யாமல் மறு செய்கை செய்வதற்கான எளிய வழியை வழங்குகின்றன.

---

---

1. வளையத்திற்கு

இது எதிர்-கட்டுப்படுத்தப்பட்ட மறு செய்கை அறிக்கை. தி க்கான லூப்புக்கு கவுண்டரின் துவக்கம் மற்றும் அது உண்மையாக இருக்கும்போது மீண்டும் மீண்டும் செய்ய ஒரு நிபந்தனை தேவை.

ஒரு அறிக்கையைப் பயன்படுத்துவதற்கான தொடரியல் பின்வருமாறு:

for (initialization; condition; increment){ // statements}

அறிக்கையில் உள்ள அனைத்து வெளிப்பாடுகளும் விருப்பமானவை. அரைப்புள்ளிகள் ( ; என்றாலும், கட்டாயமாகும்.

தொடர்புடையது: ஜாவாவில் ஒரு வளையத்தை எழுதுவது எப்படி

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

---

---

int x=4;
for ( ;x<10;x++){
System.out.println('x'); // print out x
}

உங்கள் நிலைமையை விட்டுவிடவும் முடியும் க்கான வளையம். ஜாவா தொகுப்பாளர் நிபந்தனையை எப்போதும் உண்மை என விளக்குவதால் இது எல்லையற்ற வளையத்தை ஏற்படுத்தும்.

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

---

---

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

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

இருப்பது சாத்தியம் க்கான உள்ளே சுழல்கள் க்கான சுழல்கள். இது உள்ளமைக்கப்பட்ட சுழல்களைக் கொண்டதாக அறியப்படுகிறது.

for ( int x=2; x<9; x=x+2){
for ( int y=5;y>=3;y--){
System.out.println(x*y); // print product of x and y
}}

3 க்கும் மேற்பட்ட கூடுகளை வைத்திருக்காமல் இருப்பது நல்லது. தர்க்கத்தைப் பின்பற்றுவது அல்லது ஏதேனும் பிழைகளை எண்ணாக சரிசெய்வது உங்களுக்கு கடினமாகி வருகிறது க்கான சுழல்கள் அதிகரிக்கும்.

முதலில் கவனிக்கவும் க்கான வளையம். அதிகரிப்பு ஆகும் x = x+2 . அதிகரிப்பு எப்போதும் +1 ஆக இருக்க வேண்டியதில்லை. நீங்கள் விரும்பும் எந்த மதிப்பும் இருக்கலாம்.

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

2. லூப் போது

போலல்லாமல் க்கான வளையம், தி போது அறிக்கை ஒரு கவுண்டர் இல்லாமல் பயன்படுத்தப்படலாம். தி போது கொடுக்கப்பட்ட நிபந்தனை உண்மையாக இருக்கும்போது அறிக்கை சில அறிக்கைகள் மூலம் திரும்பத் திரும்பப் பயன்படுத்தப்படுகிறது.

அதன் உடலில் அறிக்கை (களை) செயல்படுத்துவதற்கு முன் ஒரு நிபந்தனை உண்மையா என்பதை அது முதலில் சரிபார்க்கிறது.

தொடரியல் பின்வருமாறு:

while (condition){ // statements}

நீங்கள் பயன்படுத்த விரும்பினால் போது அதற்கு மாற்றாக வளையம் க்கான அறிக்கை, பின்னர் தொடரியல் கீழே காட்டப்பட்டுள்ளது:

initialization;
while (condition){
//statements
increment;
}

நீங்கள் ஒரு அறிக்கையை வழங்கவில்லை என்றால் போது இறுதியாக அது பொய்யாக மாறும் உடல், ஒரு தர்க்க பிழை ஏற்படும். நீங்கள் எல்லையற்ற வளையத்தைப் பெறுவீர்கள்.

3. போது செய்யுங்கள்

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

இது முதலில் கொடுக்கப்பட்டுள்ள அறிக்கைகளை செயல்படுத்துவதன் மூலம் தொடங்குகிறது செய்{} உடல், பின்னர் லூப்-தொடரும் நிலை உண்மையா என்று சோதிக்கிறது. நிபந்தனை தவறானது என கண்டறியப்பட்டால், சுழற்சியை நிறுத்துதல் மற்றும் நிரல் கட்டுப்பாடு வளையத்திற்குப் பிறகு அடுத்த அறிக்கைகளுக்கு மாற்றப்படும்.

கீழே உள்ளது செய்யும் போது தொடரியல்:

do{
// statements to execute
} while (loop-continuation condition);

ஜாவா வரிசைகளுக்குத் திரும்புகிறது

லூப்-தொடரும் நிலையைச் சொல்லும் போது புரோகிராமர்கள் ஒருவருக்கு ஒரு பிழை இருப்பது மிகவும் பொதுவானது. இதைத் தவிர்க்க, இதைப் பயன்படுத்துவது நல்லது > = , <= ஆபரேட்டர்களை விட > , < .

எதிர் மாறிகள் பயன்படுத்திய நோக்கத்தையும் நீங்கள் கவனத்தில் கொள்ள வேண்டும். பயன்பாட்டில் அலட்சியம் உங்கள் குறியீட்டில் தர்க்கப் பிழைகளை ஏற்படுத்தலாம்.

உங்கள் புரோகிராமரின் பெல்ட்டில் மற்றொரு உச்சிக்காக For, while, Do Do loops பற்றிய உங்கள் அறிவைக் கொண்டு, ஜாவாவில் வரிசைகளைக் கற்றுக்கொள்ள நீங்கள் தயாராக வேண்டும்.

மென்பொருள் இல்லாமல் வங்கி கணக்கை எப்படி ஹேக் செய்வது

பகிர் பகிர் ட்வீட் மின்னஞ்சல் ஜாவாவில் வரிசைகளில் செயல்பாடுகளை உருவாக்குவது மற்றும் செயல்படுத்துவது எப்படி

ஜாவா கற்றல்? வரிசைகள் உங்கள் தரவை எளிதாகக் கையாளட்டும்.

அடுத்து படிக்கவும் தொடர்புடைய தலைப்புகள்

• நிரலாக்க
• ஜாவா
• குறியீட்டு பயிற்சிகள்

எழுத்தாளர் பற்றி ஜெரோம் டேவிட்சன்(22 கட்டுரைகள் வெளியிடப்பட்டன)

ஜெரோம் MakeUseOf இல் ஒரு எழுத்தாளர். அவர் நிரலாக்க மற்றும் லினக்ஸ் பற்றிய கட்டுரைகளை உள்ளடக்கியுள்ளார். அவர் ஒரு கிரிப்டோ ஆர்வலராகவும், கிரிப்டோ தொழிற்துறையில் எப்பொழுதும் தாவல்களை வைத்திருப்பார்.

ஜெரோம் டேவிட்சனிடமிருந்து மேலும்

எங்கள் செய்திமடலுக்கு குழுசேரவும்

தொழில்நுட்ப குறிப்புகள், மதிப்புரைகள், இலவச மின் புத்தகங்கள் மற்றும் பிரத்யேக ஒப்பந்தங்களுக்கு எங்கள் செய்திமடலில் சேரவும்!

குழுசேர இங்கே சொடுக்கவும்