ஜாவாவில் சுழல்கள்

1. நம் வாழ்வில் சுழல்கள்

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

• முதல் பக்கத்தை ஸ்கேனரில் வைக்கவும்
• ஸ்கேன் பொத்தானை அழுத்தவும்
• அடுத்த பக்கத்தை ஸ்கேனரில் வைக்கவும்

இதை கைமுறையாக செய்வது கடினம். இந்த செயல்முறையை எப்படியாவது தானியங்குபடுத்தினால் நன்றாக இருக்கும்.

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

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

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

2. whileவளையம்

if-else அறிக்கையானது எங்கள் நிரலாக்க திறன்களை கணிசமாக விரிவுபடுத்தியது, வெவ்வேறு சூழ்நிலைகளில் வெவ்வேறு செயல்களைச் செய்யும் நிரல்களை எழுதுவதை சாத்தியமாக்கியது. ஆனால் எங்கள் நிரல்களை அதிக சக்தி வாய்ந்த வரிசையாக மாற்றும் மற்றொரு விஷயம் உள்ளது - லூப்கள் .

ஜாவாவில் 4 வகையான சுழல்கள் உள்ளன: while, for, for-eachமற்றும் do-while. இவற்றில் முதன்மையானதை நாம் இப்போது தோண்டி எடுப்போம்.

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

while (condition)
   statement;

while (condition)
{
   block of statements
}

இது மிகவும் எளிமையானது. லூப் நிபந்தனை சமமாக இருக்கும் வரை அறிக்கை அல்லது அறிக்கைகளின் தொகுதி மீண்டும் மீண்டும் செயல்படுத்தப்படும் .true

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

நிபந்தனை எப்போதும் உண்மையாக இருந்தால் , நிரல் இயங்குவதை நிறுத்தாது. அது நிரந்தரமாக சுழலில் சிக்கியிருக்கும்.

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

3. சுழல்களின் எடுத்துக்காட்டுகள்

செயலில் உள்ள சுழல்களின் சில நடைமுறை எடுத்துக்காட்டுகள் இங்கே.

int n = 5;
while (n > 0)
{
   System.out.println(n);
   n--;
}

5
4
3
2
1

int  n = 0;
while (n < 10)
{
   System.out.println(n);
   n++;
}

0
1
...
8
9

Scanner console = new Scanner(System.in);
while(console.hasNextInt())
{
   int x = console.nextInt();
} 

while (true)
   System.out.println("C");

Scanner console = new Scanner(System.in);
boolean isExit = false;
while (!isExit)
{
   String s = console.nextLine();
   isExit = s.equals("exit");
}

முந்தைய எடுத்துக்காட்டில், equals()சரங்களை ஒப்பிடுவதற்கு முறை பயன்படுத்தப்படுகிறது. சரங்கள் சமமாக இருந்தால், செயல்பாடு திரும்பும் true. சரங்கள் சமமாக இல்லாவிட்டால், அது திரும்பும் false.

4. ஒரு வளையத்திற்குள் லூப்

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

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

while (condition for outer loop)
{
   while (condition for inner loop)
   {
     block of statements
   }
}

மூன்று பணிகளைப் பார்ப்போம்.

பணி 1 . Mom4 முறை திரையில் வார்த்தை காண்பிக்கும் ஒரு நிரலை எழுத விரும்புகிறோம் என்று வைத்துக்கொள்வோம் . ஒரு வளையம் நமக்குத் தேவையானது. எங்கள் குறியீடு இப்படி இருக்கும்:

int  n = 0;
while (n < 4)
{
   System.out.println("Mom");
   n++;
}

Mom
Mom
Mom
Mom

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

int n = 0;
while (n < 5)
{
   System.out.print("A");
   n++;
}

AAAAA

பணி 3 . s என்ற எழுத்தைக் கொண்ட ஒரு செவ்வகத்தைக் காட்ட விரும்புகிறோம் A. செவ்வகமானது 4 வரிசைகள் மற்றும் 5 நெடுவரிசைகளைக் கொண்டிருக்க வேண்டும். இதை நிறைவேற்ற, இப்போது நமக்கு ஒரு உள்ளமை வளையம் தேவை. எங்களின் முதல் உதாரணத்தை எடுத்துக்கொள்வோம் (நாம் 4 வரிகளை வெளியிடுவது) மற்றும் ஒரு வரியை வெளியிடுவதற்கான குறியீட்டை இரண்டாவது எடுத்துக்காட்டில் உள்ள குறியீட்டைக் கொண்டு மாற்றுவோம்.

int n = 0;

while (n < 4)
{

   int m = 0;

   
while (m < 5)
{
   System.out.print("A");
   m++;
}

   System.out.println();

   n++;

}
 

AAAAA
AAAAA
AAAAA
AAAAA

லூப் மறு செய்கைகளின் எண்ணிக்கையை எண்ணுவதற்கு வெளி மற்றும் உள் சுழல்கள் வெவ்வேறு மாறிகளைப் பயன்படுத்த வேண்டும். System.out.println()உள் வளையத்திற்குப் பிறகு நாங்கள் கட்டளையைச் சேர்க்க வேண்டியிருந்தது , ஏனெனில் அந்த வளையம் As என்ற எழுத்தை அதே வரியில் காண்பிக்கும். ஒரு வரியில் உள்ள எழுத்துக்கள் காட்டப்பட்டவுடன், யாராவது கர்சரை புதிய வரிக்கு நகர்த்த வேண்டும்.

5. ஜாவா vs பாஸ்கல் சுழல்களை ஒப்பிடுதல்

உங்களில் பலர் உயர்நிலைப் பள்ளியில் பாஸ்கல் படித்தீர்கள். இங்குள்ள விஷயங்களைப் புரிந்துகொள்வதை எளிதாக்க, whileபாஸ்கல் மற்றும் ஜாவாவில் எழுதப்பட்ட லூப்களின் இந்த ஒப்பீட்டைப் பாருங்கள். பாஸ்கல் பற்றி உங்களுக்குத் தெரியாவிட்டால், இந்தப் பகுதியைத் தவிர்க்கவும்.

i := 3;
While i >= 0 Do
   Begin
      WriteLn(i);
      i := i - 1;
   End;

int i = 3;
while (i >= 0)
{
   System.out.println(i);
   i--;
}

i := 0;
While i < 3 Do
   Begin
      WriteLn(i);
      i := i + 1;
   End;

int i = 0;
while (i < 3)
{
   System.out.println(i);
   i++;
}

IsExit := False;
While Not isExit Do
   Begin
      ReadLn(s);
      isExit :=  (s = 'exit');
   End;

boolean isExit = false;
while (!isExit)
{
   String s = console.nextLine();
   isExit = s.equals("exit");
}

While True Do
   WriteLn('C');

while (true)
   System.out.println("C");

While True Do
   Begin
     ReadLn(s);
     If s = 'exit' Then
       Break;
   End;

while (true)
{
   String s = console.nextLine();
   if (s.equals("exit"))
     break;
}