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 මගේ කොල්ලනේ කෙල්ලනේ 😁😽