Monday, 19 September 2022

Java Arrays

 Have a nice day Boys and Girls, ඔන්න අදත් ආවා Voldemort ඔයාලව හොයාගෙන 😍

අන්තිමට දාපු Post එකේදි අපි කතා කරලා ඉවර කලේ Java loops ගැනනේ.අද අපි කතා කරන්න යන්නේ, java Arrays ගැන. මේ කොටස ටිකක් ලොකු ලොකුයි වගේම චුට්ටක් සංකීර්ණයි. හැබැයි මගේ පැත්තට අවදානේ 100% දුන්නොත් එක පෝස්ට් එකයි සියල්ල Done And Dusted😁, 


ඔයාට මතකයි නෙහ් අපි variable use කරලා ඒ variable එක ඇතුලේ type එකකුයි value එකකුයි store කලා, අන්න ඒ වගේ අපි එක type එකක variable එකකට values කිහිපයක් store කරනව, ඒකට තමා array එකක් කියන්නේ. Array එකක් declare කරන්නේ සාමාන්‍යයෙන් variable එකක් ලියන විදියටම ලියලා Variable type එක ඉස්සරහින් (Square Bracket 1 ක්)“[]” දානවා


variableType[][] VariableName = {data1, data2, data3};


අපි example එකක් ගත්තොත්, cars කියන variable එක අපු string type variable එකක් කියලා assign කරලා එයාට store කරනවා පිලිවෙලින් Volvo, BMW, Ford, Mazda කියන values ටික, එතකොට අපි ඒක declare කරන්නේ,


String[] cars= {“Volvo”, “BMW”, “Ford”, “Mazda”}


ඔන්න ඕමයි array එක declare කරන්නේ.


ඔයාට ඕන නම් මේ array එකේ තියන curly braces ඇතුලේ තියන ටික ඒ විදියටම, ඒ කියන්නේ අපි {“hello world”} කියලා ගහපුවාම hello world ආවා වගේ Volvo, BMW,Ford, Mazda කියලා output එක ගන්න. කොහොමද කරන්නේ, ඒම කරන්න පුලුවන්ද? අපි බලමූ සාමාන්‍ය variable එකක් execute කරගන්න අපි පාවිච්චි කරන syntax Use කරලා Array එක Print වෙනවද කියලා. 




දැක්ක නෙහ්, program එක compile උනාට අපිට ඕන output එක array වලදී variable වලදී ගත්තා වගේ ගන්න බෑ. ඇත්තටම java වල ඒම අපි hello world output එක ගත්තා වගේ array elements කෙලින්ම print කරන්න ක්‍රමයක් නෑ.ඒම කරනව නම් අපිට කරන්න තියෙන්නේ  Arrays.toString() හෝ Arrays හෝ for loop කියන methods use කරලා.for loop එක use කරලා මේක කරන හැටි ගැන මේ post එකේදිම කතා කරලා ඉවර කරනවා අනිත් Methods ගැන මේ පාඩම ඉවර උනාට පස්සේ කතා කරනවා එතකොට අපි බලමු ඒම කරන්නේ කොහොමද කියලා,  


දැන් අපි බලමු array එකක elements ගැන. මුලින්ම කතා කරන්නේ array එකක elements හසුරවන හැටි.


Access the elements of the array


Print Elements In Array


Array එකක elements හසුරවන්න අපි පාවිච්චි කරන්නේ array එකේ අදාල element එකේ index number එක. මතකයි නෙහ් programming වලදී index පටන් ගන්නේ 0 න්, තව පැහැදිලි කරගත්තොත් ඒක උඩ example එකේ 0 වෙනි element එක තමා volvo කියන්නේ. එතකොට array එකක පලවෙනි element එක කියන්නේ [0], දෙවෙනි element එක් කියන්නේ [2] තේරුනා නේහ් 😁.


එතකොට අපිට උඩ තියන example එකේම පලවෙනි element එක print කරගන්න ඕනි කියලා හිතන්නකෝ, එතකොට element එකේ index number එක array එකේ නමත් එක්ක දාලා ගන්න ඕන, syntax එක එන්නේ මෙන්න මෙහෙමයි,


System.out.println(arrayName[index No]);


Example එකකින් පැහැදිලි කරගමු අපි මේක, උඩ ගත්තු carrs කියන Array එකේ (String[] cars= {“Volvo”, “BMW”, “Ford”, “Mazda”}) first element එක print කරගන්න ඕන නම්,



 දැක්කනේ, ඔන්න ඕකයි ක්‍රමේ.


Change Array Element


Array එක ඇතුලේ තියා element එකක් වෙනස් කරන්න ඕන නම් කරන්න ඕන array එකේ ඒ අදාල element එකේ Index No එකට අදාලව අපිට Replace කරන්න ඕන element එක ඒ index No එක යටතේ declare කරන එක. ඒක කරන්නේ,




Array Length


දැන් බලමු Array Length එක ගන්න හැටි. Array Length කියල අපිට එන්නේ Array එකේ තියන සම්පූර්ණ element ප්‍රමානේ. 



  

හරි Access Array Element යටතේ දැනට මෙච්චරක් දැනගත්තම ඇති. අපි දැන් කතා කරමූ Loop Through an array ගැන. 


Java Arrays Loop


Array එකේ සේරම output  ටික් ගන්න පාවිච්චි කරන්න පුලුවන් පලවෙනි ක්‍රමේ ගැන තම දැන් අපි කතා කරන්න යන්නේ. මතකයි නේහ්, උඩදී කිව්වා loop පාවිච්චි කරලා අපිට array එකේ element ටික ඔක්කොම ගන්න පුලුවන් කියලා. 


Loop Through an Array with For loop


මේක කරන්නේ for loop එක පාවිච්චී කරලා. මෙතනදී array එකේ length එක use කරලා loop එක run කල යුතු වාර ගාන තීරණය කරනවා, මං Array Length ගැන කතා කරනකොට කිව්වා ඔයාට මතකයි නේහ් length එක කියන්නේ තියන item ප්‍රමානේ කියලා. බලමු උදාහරණයකින්ම,




මෙතනදී i කියන variable එකට දීල තියන condition එකෙන් ඔයාලට තේරුම් ගන්න පුලුවන් එයා මෙතන represent කරන්නේ array එකේ දිග ඒ කියන්නේ length එක represent කරන int type එකේ variable එක කියලා.


Loop Through an Array with For-Each


For each loop එක ගැන අපි loops ගැන කතා කරද්දී කතා කලානෙ, එතනදී මම කිව්වනේ array ගැන කත කරනකොට මේක හොදටම තේරුම් යයි කියලා. ආයෙම පාරක් දැන් බලමු මේක array එකට apply වෙන්නේ කොහොමද කියලා, ඔයාට මෙතනදී මේක හොදටම තේරෙයි, දැන් ඉතිම් කට්ටිය array ගැන හොදට දන්නවනේ.


Syntax එක එන්නේ,

for (type variable : arrayname) 

{

  ...

}

                                                   විදියට.


මතකනේ for each loop එක පාවිච්චි කලේම array වලට. පහල උදාහරනෙන් අපි මේක ආයෙම මතක් කරගමු.




උඩ උදාහරණය පැහැදිලි කලොත්, cars කියන array එකේ String element සඳහා (i - array එකේ element වල index no එක represent කරන්නේ ) i කියන variable එකේ value එක print කරන්න කියන එක තමා පැහැදිලි වෙන්නේ. මෙතන තියන විශේශම කතාව තමයි මේ loop එක declare කරල තියෙන්නේම array සඳහාමයි. ඒක නිසා Array එකේ තියන element ටික ඔක්කොම ඉවර උනාම loop වීම නතර වෙනව conditional statements අවශ්‍ය නෑ.


Java Multidimensional arrays


Multidimensional කියන english වචනේ තේරුම එන්නේ බහුමාන කියලා, ඒ කියන්නේ මුහුනුවර කිහිපයක් සහිත ඒම නැත්නම් අවස්තා බහුල ඔය වගේ ඕන තේරුමක් ගන්න පුලුවන්. Array වලදීත් මේ multidimensional කියන්නේ එක array එකක් අතුලේ arrays කිහිපයක් තියෙයි නම්. (Two dimensional කියනවා එක array එකක ඇතුලේ array දෙකක් තියෙයි නම් Three dimensional කියනවා එක array එකක් ඇතුලේ ඇතුලේ array තුනක් තියෙයි නම්, ඔය වගේ….)


Two dimensional array එකක් හදන්න curly braces ඇතුලේ array දෙකක් එකට ලියලා කමාවකින් වෙන් කරන්න ඕන. ඊට පස්සේ array එකේ type එක දාන තැන Square Bracket දෙකක් දාන්න ඕන. දැන් ඔයාට ප්‍රශ්නයක් එනවා එතකොට එක array එකක් ඇතුලේ array 137287392378973 ආවොත් square bracket 137287392378973 දානවද කියල නෙහ්, මං දන්නවනේ 😂. ඔව් ඒකෙහෙම එනවා. හැබැයි java වල multidimensional කිව්වට array use කරන්න පුලුවන් උපරිම තත්වය එන්නේ 255, හේතුවත් එක්ක කතාව three dimensional ත් කතා කරලා ඉවර කරලා මම පැහැදිලි කරන්නම් මෙව්වා පට්ටම සංකීර්ණ කොටස්. මෙතනට ඒ කොටස් සංකීර්ණ වැඩී. අපිට උවමනා මේ ටිකට two dimensional array හා three dimensional array කියන තත්ව විතරයි. ඒ ටික මෙතනදී 100% clear කරගෙන සංකීර්ණ කොටස් ටිකට ඊට පස්සේ යමු. 



Two dimensional array


two dimensional array වලට example එකක් බලන්නකෝ පහල,


int[][] myNumbers = { {1, 2, 3, 4}, {5, 6, 7} };


එතකොට මෙතන myNumbers කියන්නේ element දෙකක් විදියට arrays දෙකක් තියන array එකක්. myNumbers array එකේ elements විදියට තියන array වලත් element වලට යන්න, index numbers දෙකක් සඳහන් කරන්න ඕනි. එකක් ලොකු array එකේ element එකක් විදියට තියන පොඩි array එකට අනික ඒ පොඩි array එක ඇතුලේ තියන int element වලට. පහල උදාහරනෙන් myNumbers array එකේ දෙවන element එක ({5, 6, 7}) තුන් වෙනි element එක (7) ට යන විදිය බලන්න පුලුවන්,




Three dimensional array


three dimensional array එක උඩ අවස්තාවට වඩා පොඩ්ඩක් complex. මෙහෙම මතක තියාගන්න, three dimensional array එකක් කියන්නේ two dimensional array දෙකකින් හැදුන array එකක් කියලා, එතකොට මතක තියාගන්න ලේසි. Example එකකින් පැහැදිලි කරගමු. 


int[][][] myNumbers = { { { 1, 2 }, { 3, 4 } }, { { 5, 6 }, { 7, 8 } } };


එතකොට මෙතන myNumbers කියන්නේ element දෙකක් විදියට two dimensional arrays දෙකක් තියන array එකක්. myNumbers array එකේ elements විදියට තියන two dimensional array වලත් element විදියට තියන array එකෙත් ඇතුලේ තියන int element වලට යන්න, index numbers තුනක් සඳහන් කරන්න ඕනි. එකක් ලොකු array එකේ element එකක් විදියට තියන two dimensional array එකට අනික ඒ two dimensional array එක ඇතුලේ තියන  array එකට. අනික ඒ array එක ඇතුලේ තියන element වලට. පහල උදාහරනෙන් myNumbers array එකේ දෙවන element එකෙත්  { { 5, 6 }, { 7, 8 } }  දෙවෙනි වෙනි element එකෙත් { 7, 8 } දෙවෙනි element එකට (8) ට යන විදිය බලන්න පුලුවන්,






දැන් ඔයාලට මම උඩ පට්ට සංකීර්ණයි කියල පැහැදිලි කරපු කතාව තේරෙන්න ඕනි. Array එකේ dimensions ගාන අනුව සංකීර්ණත්වය වැඩි වෙනව. ඒකයි මම පට්ට සංකීර්ණයි කියන වචනේ පාවිච්චි කලේ. මතකද dimensions ගාන 255 නතර වෙනව කියලා කිව්වා. කතා කරමුද එහෙනම් ටිකක් ඒ ගැන. වතුර එක්ක එහෙම ලගට අරං ලෑස්ති වෙන්න මොලේ රැලි වැඩි කරගන්නයි මේ යන්නේ 😂


මුලින්ම developer කෙනෙක් java array එකක් size කරනකොට දැනගන්න ඕන වැදගත්ම සංකල්ප ටික ගැන කතා කරන්නයි මේ යන්නේ, 


theoretically java array එකක ඇතුලත් කරන්න පුලුවන් element ගාන 2,147,483,647 යි.

Java Array එකක Size එක එහෙම නැත්නම් element ගාන හොයන්න array length එකෙන් ඒක මතකයිනේ. මේ array එකක් අපි program කරන්න පටන් ගන්නකොටම array එකට Fixed size එකක් ස්ථිර ලෙස විස්තර කරලයි පටන් ගන්න ඕන. ඒ 32 bits (2,147,483,647 elements) කියන උපරිම size එක ඉක්මවා නොයන පරිදි. සිද්දාන්තමය වශයෙන් මේ දේවල් මෙහෙම උනාට එක එක පරිගණක වල එක එක මෙහෙයුම් පද්දති වල තියන java virtual machine වල java array වල තියන හැම element එකකටම Bit වෙන් කරන්න බෑ. ඒ නිසා Java array එකකට රඳවා ගත හැකි උපරිම element සංඛ්‍යාව සාමාන්‍යයෙන් මේ theoretically ඉහළම කියන සීමාවට වඩා චුට්ටක් අඩුයි.


ඒ වගේම java array වල දිග මනිනකොට 0 හා 0 නොවන සියලුම characters element විදියට count කරනවා. String සහ ArrayList(ඉස්සරහදී කතා කරනවා) වලදී වගේ Java array වල size() හෝ length() කියල method නෑ length කියලා property එකක් විතරයි තියෙන්නේ. හොදට මේ කතාව මතක තියාගන්න Java හි array length කියන්නේ method එකක් නෙවී ගුණාංගයක්. ඒ කියන්නේ length() කියලා කොයිම තැණකදී වත් සදහන් කරන්නේ නෑ array වලදී.


Java Language එක program කරනකොට කොයිම තැනක්දී වත් dimensions මෙච්චර ප්‍රමානෙකින් මේක නතාර වෙන්න ඕන කියලා limit එකක් දාලා නෑ. හැබැයි java Virtual machine එකේ තියන specs අනුව dimensions ගාන 255 කට සීමා කරලා තියනවා. 


හරි array ගැන දැනට මේ ඇති. ඊලග දවසේ අපි කතා කරන්න යන්නේ අලුත්ම කොටසක් ගැන. ඒ java scanner class එක ගැන. එක දවසෙන් ඉවර වෙනව ඒකත්. අලුත් කොටසින් සෙට් වෙමු එහෙනම්.


අදට මෙච්චරයි. Bye මගේ කොල්ලනේ කෙල්ලනේ 😁😽



 





Friday, 9 September 2022

Java Loops

Have a nice day Boys and Girls, ඔන්න අදත් ආවා Voldemort ඔයාලව හොයාගෙන 😍

අන්තිමට අපි කතා කරලා ඉවර කලේ Java Conditional Statements ගැනනේ.අද අපි කතා කරන්න යන්නේ, java Loops ගැන. මේක හුගක්ම හුගක් වැදගත්ම වැදගත් වගේම ලොකු java Programming කොටසක්, අතිශය උනන්දුවකින් අද්‍යනය කිරීම මැනවි මා හිත මිත්‍රවරුනි 😉😁. ඉක්මනින් කතා කරලා ඉවර කරමු එක පෝස්ට් එකයි සියල්ල Done And Dusted😁, 


හරි පටන් ගමු අද මාතෘකාව ඒම නම්, Java loops.


Loops


Loop එකක් කියන්නේ මොකක්ද, මේ ඉංග්‍රීසි වචනෙ සිංහල තේරුමත් ලූපය කියන එකම තමා. එතකොට මේ Loop නැත්නම් ලූපය කියන්නේ මොකක්ද කියලා අයිඩියා එකක් තියෙයිද කාටම හරි 😁, idea එකක් තියන නොතියෙන හැමෝටම තේරුම් ගන්න මම මේක පැහැදිලි කරන්නම්කෝ.


Dictionary එකේ loop කියලා type කලොත් එන උත්තරේ තමා o shape produced by a curve that bends around and crosses itself (තමා හරස් කරන වක්‍රයකින් නිරූමපනය කරන හැඩය) කියලා. සරලව කිව්වොත් රව්මක්, වක්‍රයක් නැත්නම් වටයක්. හුගක් සමානයි ඉතිම් මේ කතාව java වලදිත්. අපි java වලදිත් loop එකක් කියලා කියන්නේ විශේශිත වෙච්ච කොන්දේසියක් execute වෙනකන් වටේට කැරකෙන code block එකකට. මේ loop හරිම handy එහෙම කියන්න හේතුව තමයි, programming වලදී මේ loops නිසා time savie වෙනවා , errors අඩු වෙනවා, වගේම code එක somple වෙන නිසා කියවාගැනීම පහසුයි.


While loop


While loop එකේදී අදාල දීල තියන Condition එක True වෙනකන් loop එක කැරකෙනවා, මේ while loop එකේ Syntax එක එන්නේ,


while (condition)

{

//code block to be executed

}


තේරුම් ගන්න අමාරුයි නේද, මේක අපි example එකකින් පැහැදිලි කරගමු, 





හරි, ඔයාලට යම් මට්ටමකට දැන් මේක තේරෙනව නේද, හොදට බලන්නකෝ Example එක. එක පාරක් හොදට අවබෝද වෙන්න බලන්න, මම දැන් එකින් එක පැහැදිලි කරන්නයි ලෑස්ති වෙන්නේ. 


int i=0, ඒ කියන්නේ මෙතන i කියන integer variable එකට ආරම්භයේදී assign කරලා තියන value එක 0. මෙයාගේ while loop එක run වෙන condition එක තමයි, i<5 කියන එක. I කියන variable එකට assign වෙන value එක 5 ට අඩු අගයක් විදියට තියනකන් loop එක rotate වෙනවා. ආරම්භය බලනකෝ i=0 කියලා තමා ලූප් එක පටන් අරන් තියෙන්නේ, i=o සහා 0<5 එතකොට while Loop එකේ condition  එකත් මෙතන i තෘප්ත කරනවා, ආ හරි මෙතනදී ඒනම් අපිට උවමනා output එක print කරනවා 0 කියලා. Output එක print කලාට පස්සේ අපි ඊලග පියවරට යනවා program එකේ, ඒකේ තියෙන්නේ i ගේ increment එක (i++). එතකොට එතනදී 0 විදියට තිබ්බ  i ට එකක් එකතු වෙලා  i=1 වෙනවා, ආ ඊට පස්සේ  i=1 කියලා තමා loop එක පටන් ගන්නේ, ඔය විදියට  i<5 කියන condition එක true වෙලා තියනකන්ම loop එක loop වෙනවා.


දැන් මම මගේ girls and boys ලගෙන් common general question එකක් අහන්නයි මේ යන්නේ.අපි ඔන්න දැන් loop එක i කියන variable එකට type එකකුයි value එකකුයි assign කරගෙන int i=0 කියල අරගෙන, ලූප් එකේ තියන Condition එක තෘප්‍ත කරනව නම් output එකත් print කරගෙන පහලට එනවා, ඒම එනකොට අපි දැක්කා i කියන variable එකට එක  value එකක් ආවට පස්සේ ඊලගට එන value එක වෙනස් වෙන්නත් condition එකකුත් දීල තියෙන්නේ කියලා, මගේ ප්‍රශ්නේ තමා ඒ condition එක නොතිබ්බා නම් මොකක් වෙයිද loop එකට.


ඒ condition එකට අනුව වෙනස් උනු i තමා ඊලගට ආයේ loop එකේ මුලට ගිහින් loop වෙන්නේ. එතකොට මේ condition එක අපි නොදැම්ම නම් මොකක්ද output එක දුන්නට පස්සේ ආයේ i ගේ value එකට වෙන්නේ, මුකුත්ම වෙන්නෙ නෑ නෙහ්. වෙනසක් වෙන්න කොන්දේසි මුකුත් අපි ඉදිරිපත් කරලා නෑනේ. එතකොට ඉතිම් program එක පටන් ගන්නේ  i=0 කියලා 0 කියන්නේ 5 ට වඩා අඩු සංඛ්‍යාවක්,  i කවදාවත් වෙනස් වෙන්නේත් නැති නිසා සදහටම මේ loop එක යනවා කවදාවත් නතර නොවී. මේ වගේ වෙන අවස්තාවලදී අපි කියනවා infinity loop කියලා. (මේක Check කරනකොට නතර කරගන්න del Key එක press කරන්න)



Do/While loop


Do/While Loop එක while loop එකෙන් ටිකක් වෙනස්, while loop එකේදී උඩ ගත්තු example එකම බැලුවොත් ඔයාට තේරුම් ගන්න පුලුවන් නේද loop එක පටන් ගන්නකොටම while එක්ක දාපු condition එක true නොවුනොත් අරම්භයේදීම loop එකෙන් එකම output එකක් වත් ලැබෙන්නෑ කියලා, ඒ කියන්නේ මෙන්න මෙහෙම කතාවක්, ආරම්භයේදිම i=5 කියලා අරං මේ ප්‍රෝග්‍රෑම් එකම ගහල තියනව මම පහල බලන්නකෝ




එකදු output එකක් වත් නෑ නෙහ් , අන්න ඒක තමා Do/While හා While Loop එකේ තියන ප්‍රදානම වෙනස් කම. පහල උදාහරණෙ බලන්නකෝ,

මේ තියෙන්නේ සාමාන්‍ය තත්වයේ, ඒ කියන්නේ ආරම්භක i අගය Condition එකට වඩා අඩුයි, එතකොට ඕනම වෙලාවක output එකක් හම්බෙනවනේ, 




සාමාන්‍ය තත්වය, දැන් ඊලගට බලමු condion එකට වඩා i ගෙ අගය වැඩි වෙන අවස්තාව,




මේකට හේතුව තේරුනාද, පලවෙනි condition එක හම්බෙන්නේ loop එක එක පාරක් එයාගේ output එක දුන්නට පස්සේ, ඒක නිසා තමා මේ වගේ දෙයක් වෙන්නේ, එක පාරක් execute වෙන්න තියන code Block එක execute උනාට පස්සෙ තමා loop එක condition එකට අහු වෙන්නේ.


කිසිම වෙලාවකදී variable එකේ value එක වෙනස් කරන්න මතක කරන්න එපා, ඉස්සෙල්ලා කිව්ව වගේ ඒක අමතක උනොත් කවදවත් loop එක ඉවර වෙන එකක් නම් නෑ 


For Loop


Loop එකක් use කරනකොට program එකේදී ඔයා දන්නවනම් Exactly program එක කී පාරක් loop වෙනවද කියලා, අන්න ඒ වේලෙව අපි use කරන loop එක තමයි for loop එක. 


මේකේ syntax එක එන්නේ,


for(statement 1; statement 2; statement 3)

{

//code block has to be executed

}



  • Statement 1 (Initialising statement) 


Initializing Value කියන්නේ ආරම්භක අගය කියන එක, loop එක අරම්භ කරන්න variable එකට දෙන value එක තමා statement 1 එහෙම නැත්නම් initialising value කියල කියන්නේ.


  • Statement 2 (Condition)


Code block එක loop වෙන එක නතර කරන්න් ඕන තැනට අදාල condition එක, මේක නැතිව syntax එක ගැහුවාම loop එක infinity කරන්න පුලුවන්, ඉස්සරහ්දි කතා කරමු ඒක ගැන.

 

  • Statement 3 (Increment and decrement)


Loop එක පටන් ගන්න ඊලගට variable එකට එන අගය වෙනස් කරන්න (අඩු හෝ වැඩි කරන්න) පාවිච්චි කරන condition එක


හරි දැන් පැහැදිලි කරගමු උදාරනෙකින් මේක,




දැන් ඔයාලට හිතාගන්න පුලුවන්ද syntax එකත් බලල උදාහරනෙත් බැලුවට පස්සේ ඇයි for Loop එක loop වෙන ප්‍රමානේ හරියටම දන්න program වලට විතරක් මේක use කරන්නේ කියලා. මේ loop එක අනන්තය වෙනකන් execute වෙන්න අරකෙ වගේම changeable condition එක මේකේ අයින් කරන්නයි තියෙන්නේ, හැබැයි මෙතනදී ඒම අයින් කරන විදිය වෙනස්. Initializing statement එක හා increment/Decrement එක විතරක් type කරලා නිකං ඉන්න බෑ, Changeable Condition එකක් දැම්මෙ නැතිවට ඒකට හිස් ඉඩක් තියන්න ඕන ඉඩක් තියන්න ඕන මොකද ඒක syntax එකේ කොටසක්. ඒක අයින් උනොත් අනන්තයට යනව නෙවී compilation error එකක් එන්නේ. 




සාමාන්‍ය programming වල සම්මතය තමා ඔයාට code Block එකක් හරහා කොපමණ වාර ගණනක් ලූප් කිරීමට අවශ්‍යද කියන එක හරිම idea එකක් තියෙයි නම් while loop එක වෙනුවට for loop භාවිතා කරන්න කියන එක, මොකද ඕනෑම තැනකදී while loop එකක් දාල තියෙයි නම් ඒකේ තේරුම ඔබට ඒ අදාල කොන්දේසියට යටත්ව program එක execute වෙල ඉවර වෙන්න ඕන කියන එක විතරයි, නමුත් ඔයා for loop එකක් use කරලා තියෙයි නම් එතනදී සාමාන්‍ය සම්මත විදියට තේරුම තමා for loop භාවිතා කිරීමෙන්, ඔයා පැහැදිලිවම පවසන්නේ ඔයාට program එක ඉවර කරන්න ඕන. හැබැයි ඒ අවසන් කිරීමේ කොන්දේසියක් සහිතව. මතකද කිව්ව තනි අකුරෙ නම් variable name එක විදියට ගන්නෙ නෑ, program එක run උනාට ඒක වැරැද්දක් සම්මතය නෙවී කියලා, අන්න ඒ වගේ. අනන්ත loop එක for loop එකෙනුත් execute කරගන්න පුලුවන් උනාට අපි එහෙම කරන්නෙ නෑ, ඒක තමා සම්මතය. ඒකයි කියන්නේ නවතින සීමාව දන්න ඒවට විතරක් for Loop එක දාන එක වඩා සුදුසුයි කියලා.



For -each Loop


කතාව පටන් ගමු For Each Loop එක ගැන. මෙක චුට්ටක් නුහුරට දැනෙයි Array ගැන කතා කරපු නැති නිසා, ඒත් array කියන වචනේ පාවිච්චි කලාට මෙතන වෙන සංසිද්දිය සම්පූර්ණයෙන්ම ඔයාට තේරෙන්න මම කියාදෙනවා චුට්ටක් වත් කලබල වෙන්නෙපා 😁.


හරි, මෙතනදී වෙන්නේ array එක හරහා loop වෙන එක. ඒ කියන්නේ array එකේ තියන elements හරහා තමා ලූප් වෙන්නේ. Syntax එක බලලා Example එක බලන්නකෝ, ඔයාට හොදටම තේරෙයි,


For (type variableName : arrayName)


{

//Code block have to be executed

}


දැන් යමු උදාහරනෙට,




තේරුනාද දැන්, මෙතනදී ඔයාට ප්‍රශ්න එයි, variable name එක දැම්ම විතරනේ, කී වෙනි variable එකද කියල දැම්මෙ නෑනේ, ඒත් පිලිවෙලටම උත්තරේ ආවනේ කියලා, මේ ඔක්කොටොම උත්තර array chapter එකේදී කතා කරලා ඉවර කරනවා, චුට්ටක් වත් හිතන්න එපා ඒක ගැන 😁. 


Java Break And Continue


Break මීට කලින් අපිට set උනා switch statement එකේදී, මතකයි නෙහ්. Program එකේ excess execution time එක ඉතුරු කරගන්න පුලුවන් මේකෙන් කියල ලොකු විස්තරයක් කතා කලේ, මතක නැත්නම් ටාර් ගාල ගිහින් break ගැන තිබ්බ post එක කියවලා එන්න. 


Java Break for loops


මතකනේ break use කලේ switch වලදී අදාල case එක බලලා ඒ condition එක true කරනව නම් program එකේ අවසානෙට jump වෙන්න අනික් කොටස් ලට නොයා. ඉතිම් loop වලදිත් ඒක ඒමම තමා loop එක අතරමැද්දාවෙන් break වෙලා program එක ඉවර කරන එක තමා break එකෙන් කරන්නේ. 


Break for, for loop


For loop එකට break දැම්මම මොකක්ද වෙන්නෙ කියලා උදාහරනෙකින් පැහැදිලි කරගමු,




උදාහරනේ සම්පූර්න්‍යෙන්ම පැහැදිලි කලොත් මෙතනදී දහවතාවක් run වෙන්න තියන loop එක හතර වතාවක් run වෙලා නතර වෙනවා, i==4 උනාම loop එක නතර කරන්න තමා අලුතෙන් add කරලා තිය්න code කෑලි දෙකේ තේරුම. 


දැන් වෙන්නෙ මොකක්ද කියල පැහැදිලීනේ, මං දන්නව දැන් කට්ටියට ආපු ඊලග ප්‍රශ්නෙ තමයි ඕකට තව ඕම code කෑල්ලක් දාගන program එක මොකට සංකීර්න කරගන්නවද, i<10 කියලා නොදා i<4 කියල දැම්ම නම් එක පාරම උත්තරේ ගන්න තිබුනා නේද කියලා, ඒකට උත්තරේ මම කලින්ම දුන්නා, මතක් නම් ඔයාලට. Break එකෙන් කරන්නේ program එකේ Execution time එක අඩු කරන එක. කී පාරක් loop උනත් for loop එක run වෙන්න යන කාලයේ වෙනසක් නෑ, ඒක එකම වෙලාව යන්නේ. ඒ කියන්නේ 10000 සැරයක් ලූප් උනත් 4 සැරයක් loop උනත් ඒ සඳහා ගත වෙන කාලය සමානයි, දැන් එතකොට ඔයාලට තේරෙන්න ඕන for loop එක මැදින් කඩන එකෙන් කාලය විශාල ලෙස ඉතුරු කරගන්න පුලුවන් වෙනවා කියන එක. හරි ඔන්න ඕක තමා For loop එකේ break වල කතාව.


Break for while loop


For loop එක විදියටම වාසිය run Time එක අඩු වෙන එකමයි Syntax එක එන් විදිය බලන්න පහල, 





Java Continue For loops


Continue statement එකෙන් කරන්නේ දීල තියන condition එකට අදාල කොටස loop එකෙන් අයින් කරල (break mentioned iteration from loop) ඊලග කොටසේ ඉදන් execute කරන එකමයි, ඒ කියන්නේ මෙතනදිත් වෙන්නේ break වීමක්ම තමයි, ඒත් ඒම break වෙන්නේ අපි mention කරන විශේශ එක කොටසක් විතරයි. Loop දෙකට එක එකකට් දීලා තියන් උදාහරණ ටික බලන්නකෝ. තේරෙයි ඔයාට,


Continue for, for loop




Continue for, while loop




ඔච්චරයි ඉතිම් Java Loops කියලා ඉගන ගන්න තියෙන්නේ, දැන් හරි ඒකත් එතකොට ඉවරයි. ඔයාල මේ ඉගන ගත්තේ java වල අතිශය වැදගත් කොටසක්.  ඊලග දවසේ අපි කතා කරනවා වගේම කතා කරලා ඉවර කරනව Java Array ගැන. මේකත් loop වගේම අති සුවිසල් අති වැදගත් කොටසක්. ඒක නිසා අනිවාරෙන්ම එන්න ඊලග කොටස බලන්න, array ත් ඉවර උනාම java Basics ඉවරයි, ඊට පස්සේ ඊලග ලොකු කොටසකට යන්නේ අපි java Methods 😁


අදට එහෙනම් මෙච්චරයි. Bye මගේ කොල්ලනේ කෙල්ලනේ 😁😽