1. ආරම්භය
ඇරේස් (Arrays) යනු ජාවා (Java) වැඩසටහන් කිරීමේදී එකම වර්ගයේ බහු අගයන් එකට කළමනාකරණය කිරීමට අවශ්ය මූලික දත්ත ව්යුහයකි. උදාහරණයක් ලෙස, වෙන්වූ විචල්ය (variables) භාවිතා කර 10 වෙනස් ලකුණු හෝ විශාල දත්ත කට්ටලයක් කළමනාකරණය කිරීම ප්රායෝගික නොවේ. මෙහිදී ඇරේස් උපකාරී වේ.
මෙම ලිපිය ජාවා හි ඇරේස් ආරම්භ කිරීම (initialize) පිළිබඳව පැහැදිලි හා ආරම්භක-හිතකාමී ආකාරයෙන් විස්තර කරයි. “ඇරේ එකක් කියන්නේ මොනවාද?” හෝ “මට ඇරේ එකක් ආරම්භ කරගන්නේ කෙසේද?” යන ප්රශ්න ඔබට ඇති නම්, මෙම මාර්ගෝපදේශය මූලික කරුණු සිට උසස් තාක්ෂණයන් දක්වා සියල්ල ආවරණය කරයි. අවසානය දක්වා කියවන්න.
මෙම ලිපිය කියවීමෙන් ඔබට පහත ලාභ ලබා ගත හැක:
- ඇරේස් ප්රකාශ කිරීම සහ ආරම්භ කිරීමේ සම්පූර්ණ ක්රියාවලිය අවබෝධ කර ගැනීම
- සාමාන්ය දෝෂ සහ සාමාන්ය ආරම්භක දෝෂ වලින් වැළැක්වීම
- සැබෑ සංවර්ධනයේ ප්රයෝජනවත් ප්රායෝගික කේත උදාහරණ ඉගෙන ගැනීම
මෙම අන්තර්ගතය වැඩසටහන් ආරම්භකයන්ට පමණක් නොව, ජාවා මූලික කරුණු නැවත සමාලෝචනය කිරීමට කැමති අය සඳහාද සුදුසුය.
දැන්, ජාවා හි ඇරේස් මූලික කරුණු ඉගෙන ගැනීමට ආරම්භ කරමු.
2. ජාවා හි ඇරේස් මූලික කරුණු
ඇරේස් ප්රකාශ කිරීම සහ මූලික වාක්ය රචනය
ජාවා හි ඇරේස් භාවිතා කිරීමට පළමු පියවර වන්නේ ඇරේ ප්රකාශ කිරීමයි. ප්රකාශ කිරීම වැඩසටහනට “මෙම විචල්යය බහු අගයන් ගබඩා කරන ඇරේ ලෙස භාවිතා කරනු ඇත” යනුවෙන් කියයි. ඇරේස් ප්රකාශ කිරීමට විවිධ ක්රම ඇත, නමුත් සාමාන්යතම දෙක මෙසේය:
int[] numbers; // Recommended style
int numbers[]; // C-style syntax
ජාවා හි ප්රියතම ශෛලිය int[] numbers; ලෙසයි, මෙහි [] වර්ග නාමය පසුබැසී ඇත. මෙම සංකේතය “int වර්ගයේ ඇරේ” බව පැහැදිලිව පෙන්වයි.
ඇරේ ප්රමාණය සහ ආරම්භක කිරීමේ වැදගත්කම
ඇරේ ප්රකාශ කිරීමෙන් පසු එය තත්කාලිකව භාවිතා කළ නොහැක. ඇරේ භාවිතා කිරීමට, එයට කොපමණ අංග (හෝ “ස්ලොට්”) තිබිය යුතුදැයි නියම කර ආරම්භක කිරීම (initialize) කළ යුතුය.
ආරම්භක කිරීම නියමිත අංග ගණන සඳහා මතකය වෙන් කර ඇරේ භාවිතා කළ හැකි කරයි.
උදාහරණයක් ලෙස, පන්දු ඉන්ටීජර් (integer) ඇරේ එකක් ආරම්භක කිරීම:
int[] scores = new int[5];
මෙම කේතය පන්දු අනුක්රමික ඉන්ටීජර් අංග පන්දුක් වෙන් කර scores[0] සිට scores[4] දක්වා ප්රවේශ විය හැක.
ජාවා හි, ඇරේ ප්රමාණය ආරම්භක කිරීමේදී නියම කළ යුතු අතර පසුකාලීනව වෙනස් කළ නොහැක. මෙය ආරම්භකයන්ට සාමාන්ය දෝෂ මූලයක් වේ.
ඇරේ වර්ග සහ පෙරනිමි අගයන්
ඇරේ වර්ගය එක් එක් අංගයේ වර්ගය තීරණය කරයි. උදාහරණයක් ලෙස, int[] යනු ඉන්ටීජර් ඇරේ එකක්, String[] යනු 문자열 (string) ඇරේ එකක්.
ජාවා හි, ඇරේ ආරම්භක කිරීමේදී, එහි එක් අංගයක් එහි වර්ගය අනුව ස්වයංක්රීයව පෙරනිමි අගයක් ලබා ගනී:
පෙරනිමි අගයන් උදාහරණ:
- int → 0
- double → 0.0
- boolean → false
- යොමු වර්ග (උදා: String) → null
ඒ අනුව, ජාවා හි ඇරේස් සඳහා පියවර දෙකක් අවශ්ය වේ: “ප්රකාශ කිරීම” සහ “ආරම්භක කිරීම”, දෙකම ඔබේ වැඩසටහන් ගමනේ මුලදී අවබෝධ කර ගැනීම අත්යවශ්ය වේ.
3. ඇරේස් ආරම්භක කිරීමේ ක්රම
ජාවා ඇරේස් ආරම්භක කිරීම සඳහා විවිධ ක්රම ලබා දේ. ඔබේ වැඩසටහනේ අවශ්යතා අනුව සුදුසුම ක්රමය වෙනස් වන බැවින්, සෑම ක්රමයක් කෙසේ ක්රියා කරන්නේදැයි දැන ගැනීම වැදගත් වේ.
3.1 ප්රකාශ කිරීමේ සමයේ ඇරේ ආරම්භක කිරීම
සුලභතම සහ අවබෝධයට පහසුම ක්රමය වන්නේ ඇරේ ප්රකාශ කිරීමේදී සෘජුවම ආරම්භක අගයන් ලබා දීම ය. මෙය අගයන් ස්ථිරව සහ පෙරනිමිව දැන සිටින විට විශේෂයෙන් ප්රයෝජනවත් වේ.
int[] numbers = {1, 2, 3, 4, 5};
String[] fruits = {"apple", "banana", "orange"};
new යතුර හෝ ප්රමාණ නියම කිරීම අවශ්ය නොවේ. ජාවා ස්වයංක්රීයව ලබා දුන් අංග ගණනට සමාන ඇරේ එකක් සාදයි.
3.2 new යතුර භාවිතා කර ඇරේ ආරම්භක කිරීම
ඊළඟ සාමාන්ය ක්රමය වන්නේ ඇරේ ප්රමාණය නියම කිරීමට new යතුර භාවිතා කිරීම ය.
int[] scores = new int[5]; // Five integers (default value: 0)
String[] names = new String[3]; // Three Strings (default value: null)
මෙම ආරම්භක රටාව තුළ, සියලු අංග ස්වයංක්රීයව පෙරනිමි අගයන් ලබා ගනී.
- සංඛ්යාත්මක වර්ග: 0 හෝ 0.0
- boolean: false
- යොමු වර්ග: null
This method is ideal when the array size is known but the values will be assigned later.
ඇරේ ප්රමාණය දැනටමත් දැනගෙන ඇති නමුත් අගයන් පසුව නියම කරන අවස්ථාවල මෙම ක්රමය ඉතා සුදුසුය.
3.3 Arrays.fill() භාවිතයෙන් ඇරේ ආරම්භ කිරීම
If you want to initialize all array elements to the same value, the Arrays.fill() method is very useful.
For example, to fill an array with the value 7:
ඔබට සියලු ඇරේ අංගයන් එකම අගයට ආරම්භ කිරීමට අවශ්ය නම්, Arrays.fill() ක්රමය ඉතා ප්රයෝජනවත් වේ. උදාහරණයක් ලෙස, ඇරේ එක 7 අගයෙන් පිරවීමට:
import java.util.Arrays;
int[] data = new int[5];
Arrays.fill(data, 7); // All elements become 7
This method is more efficient than looping and assigning the same value manually.
මෙම ක්රමය ලූප් කර එකම අගය අතින් නියම කිරීමේ වඩා කාර්යක්ෂම වේ.
3.4 ලූප් භාවිතයෙන් ඇරේ ආරම්භ කිරීම
When each array element needs a different value or follows a certain pattern, using a for loop is the standard approach.
ඇරේ එක් එක් අංගයට විවිධ අගයක් අවශ්ය වන විට හෝ නියමිත රටාවක් පවත්නා විට, for ලූප් භාවිතය සාමාන්ය ක්රමවේදය වේ.
int[] squares = new int[5];
for (int i = 0; i < squares.length; i++) {
squares[i] = i * i; // 0, 1, 4, 9, 16
}
Note that the enhanced for-loop (for-each) is suitable for reading values but not for assigning values by index.
උත්කෘෂ්ට for-loop (for-each) අගයන් කියවීමට සුදුසු වන අතර, අගයන් ඉන්ඩෙක්ස් අනුව නියම කිරීමට නොහැක.
As you can see, Java provides multiple initialization techniques—choose the method that best suits your particular scenario.
ඔබට දැකගත හැකි පරිදි, Java බහු ආරම්භක තාක්ෂණ ලබා දේ—ඔබගේ විශේෂ අවස්ථාවට සුදුසු ක්රමය තෝරන්න.
4. ඇරේ ආරම්භ කිරීම පිළිබඳ වැදගත් සටහන්
When working with arrays, it’s crucial to understand not just the initialization methods but also the common pitfalls and typical mistakes. Knowing these can help prevent bugs and unexpected behavior.
ඇරේ සමඟ වැඩ කරන විට, ආරම්භක ක්රම පමණක් නොව සාමාන්ය වැරදි සහ පොදු දෝෂ ගැනද අවබෝධය ඇති වීම අත්යවශ්යයි. මෙවැනි දේ දැන ගැනීම දෝෂ සහ අනපේක්ෂිත හැසිරීම් වැළැක්වීමට උපකාරී වේ.
අඛණ්ඩිත ඇරේ භාවිතයෙන් සිදුවන දෝෂ
An array cannot be used until it is properly initialized. Attempting to use an array that was only declared but not initialized will result in a NullPointerException.
ඇරේ නිසි ලෙස ආරම්භ කරන තුරු එය භාවිතා කළ නොහැක. ප්රකාශනය පමණක් කර ඇරේ ආරම්භ නොකළහොත් NullPointerException එකක් ඇති වේ.
int[] numbers;
System.out.println(numbers[0]); // Error: numbers is not initialized
To avoid this mistake, always remember that “declaration” and “initialization” must be done together.
මෙම වැරදි වැළැක්වීමට, “ප්රකාශනය” සහ “ආරම්භකරණය” එකට කළ යුතු බව සැමවිටම මතක තබා ගන්න.
ArrayIndexOutOfBoundsException වැළැක්වීම
If you attempt to access an index that is outside the valid range of the array, Java throws an ArrayIndexOutOfBoundsException.
Array indexes always begin at 0 and go up to array length – 1.
ඔබ ඇරේ වල වලංගු පරාසය පිටත ඉන්ඩෙක්ස් එකක් ප්රවේශ වීමට උත්සාහ කළහොත්, Java ArrayIndexOutOfBoundsException එකක් දෝෂයක් ලෙස දක්වයි.
ඇරේ ඉන්ඩෙක්ස් සෑමවිටම 0 සිට ආරම්භ කර ඇරේ දිග – 1 දක්වා යයි.
int[] data = new int[3];
data[3] = 10; // Error: index 3 does not exist (valid: 0, 1, 2)
When looping through an array, always use arrayName.length to ensure safe access.
ඇරේ එකක් ලූප් කරමින් සිටින විට, ආරක්ෂිත ප්රවේශය සඳහා සෑමවිටම arrayName.length භාවිතා කරන්න.
for (int i = 0; i < data.length; i++) {
// Safe access
}
ආරම්භක ලැයිස්තු ({}) භාවිතයේ සීමා
The initializer list {} can only be used at the time of declaration.
It cannot be used for an already declared array:
ආරම්භක ලැයිස්තුව {} ප්රකාශන කාලයේ පමණක් භාවිතා කළ හැක.
පෙර ප්රකාශිත ඇරේ එකකට එය භාවිතා කළ නොහැක:
int[] numbers;
numbers = {1, 2, 3}; // Error: initializer list cannot be used here
Instead, combine it with the new keyword:
එහි වෙනුවට, new යතුර සමඟ ඒක එකතු කරන්න:
numbers = new int[]{1, 2, 3}; // Correct usage
ඇරේ ප්රමාණය වෙනස් කළ නොහැක
Once initialized, the size of a Java array cannot be changed.
To increase the number of elements, you must create a new array and copy the values over.
ආරම්භ කිරීමෙන් පසු, Java ඇරේ එකේ ප්රමාණය වෙනස් කළ නොහැක.
අංග ගණන වැඩි කිරීමට, නව ඇරේ එකක් සාදා අගයන් පිටපත් කළ යුතුය.
Understanding these limitations helps prevent common array-related errors.
මෙම සීමා තේරුම් ගැනීම ඇරේ-සම්බන්ධ සාමාන්ය දෝෂ වැළැක්වීමට උපකාරී වේ.
5. උසස් විෂය: බහු-මාන ඇරේ ආරම්භ කිරීම
Arrays in Java can be more than one-dimensional. Two-dimensional arrays are especially useful for matrix-like or table-based data. Here, we explain how to initialize multi-dimensional arrays, focusing mainly on two-dimensional arrays.
Java හි ඇරේ එකක් එකම මානයකට වඩා වැඩි විය හැක. දෙමාන ඇරේ මැට්රික්ස්-සමාන හෝ වගුව-අධාරිත දත්ත සඳහා විශේෂයෙන් ප්රයෝජනවත් වේ. මෙහි, බහු-මාන ඇරේ ආරම්භ කිරීමේ ක්රමය පැහැදිලි කරමු, ප්රධාන වශයෙන් දෙමාන ඇරේ මත අවධානය යොමු කරමින්.
දෙමාන ඇරේ ප්රකාශනය සහ ආරම්භ කිරීම
A two-dimensional array is essentially an “array of arrays.” You can initialize one at declaration time or using the new keyword.
දෙමාන ඇරේ යනු මූලිකව “ඇරේ එකක් ඇරේ තුළ” ය. ඔබට එය ප්රකාශන කාලයේ හෝ new යතුර භාවිතා කර ආරම්භ කළ හැක.
ප්රකාශන කාලයේ ආරම්භ කිරීම
int[][] matrix = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
This creates a 3×3 two-dimensional array of integers.
මෙය පූර්ණ සංඛ්යා 3×3 දෙමාන ඇරේ එකක් නිර්මාණය කරයි.
new සමඟ ආරම්භ කිරීම
int[][] table = new int[2][3]; // Creates a 2×3 array
All elements are initialized to 0 by default.
You can also set values later:
සියලු අංගයන් පෙරනිමි ලෙස 0 වෙත ආරම්භ වේ.
ඔබට පසුව අගයන් සකස් කළ හැක:
table[0][0] = 10;
table[0][1] = 20;
table[1][2] = 30;
ජැග්ඩ් (අසමත්) ඇරේ නිර්මාණය
Java “ජැග්ඩ් අරේ” (jagged arrays) සලස්වයි, එහි එක් පේළියකට වෙනස් ගණනක තීරුවලින් සමන්විත විය හැක.
int[][] jagged = new int[3][];
jagged[0] = new int[2]; // Row 1 has 2 columns
jagged[1] = new int[4]; // Row 2 has 4 columns
jagged[2] = new int[1]; // Row 3 has 1 column
බහු-මාන අරේ ආරම්භ කිරීම පිළිබඳ සටහන්
- දෙමාන අරේවලටත් එහි අංග වර්ගයන් අනුව පෙරනිමි අගයන් ලබා දේ (උදා: int → 0, String → null).
new int[rows][columns]භාවිතා කරන විට, පළමු මානය (පේළි) නියම කළ යුතුය.- ආරම්භ නොකළ පේළියක් භාවිතා කිරීම
NullPointerExceptionඑකක් ඇති කරයි.
Java ඔබට අවශ්ය ව්යුහය අනුව, බහු-මාන අරේ ආරම්භ කිරීමේදී සලසන ලද සවිස්තරාත්මක විකල්ප ඇත.
6. සාරාංශය
Java හි අරේ ආරම්භ කිරීමේ මූලික සිට උසස් තාක්ෂණයන් දක්වා අපි සියල්ල ආවරණය කර ඇත. දැන් ප්රධාන කරුණු සමාලෝචනය කරමු.
අරේ ආරම්භ කිරීමේ ප්රධාන කරුණු
- භාවිතා කිරීමට පෙර අරේවල ප්රකාශනය සහ ආරම්භ කිරීම සෑමවිටම කරන්න
- ආරම්භ නොකළ අරේවලට NullPointerException වැනි දෝෂ ඇති වේ.
- අවස්ථාව අනුව සුදුසු ආරම්භ කිරීමේ ක්රමය තෝරන්න
- අගයන් ස්ථිර නම් initializer ලැයිස්තු භාවිතා කරන්න, ප්රමාණය පමණක් දැන සිටින විට
newභාවිතා කරන්න, ඒකරාශී අගයන් සකස් කිරීමටArrays.fill()භාවිතා කරන්න, සහ වෙනස් අගයන් සඳහා ලූප භාවිතා කරන්න. - ඉන්ඩෙක්ස් සීමා පිළිබඳ අවධානයෙන් සිටින්න
- අරේ ඉන්ඩෙක්ස් 0 සිට ආරම්භ වේ, සීමා ඉක්මවා ප්රවේශ වීම දෝෂ ඇති කරයි.
- බහු-මාන අරේවලට එක-මාන අරේවල මූලික නීති එකසේ පවතී
- ජැග්ඩ් අරේවලින් එක් පේළියකට වෙනස් දිග ලබා දිය හැක.
ආරම්භකයන් සඳහා උපදෙස් සහ ඊළඟ පියවර
අරේ ආරම්භ කිරීමේ අවබෝධය Java වැඩසටහන් කිරීමේ ශක්තිමත් පදනමක් ගොඩනැගීමට අත්යවශ්ය කොටසකි. සරල එක-මාන අරේවලින් ආරම්භ කර, සුවිශේෂී වීමෙන් පසු බහු-මාන අරේ සහ අරේ-අධාරිත තර්කයන් වෙත ගමන් කරන්න.
තවද, Java ArrayList වැනි ශක්තිමත් “ගතික අරේ” (dynamic arrays) ලබා දේ. මූලික අරේවල පරිපූර්ණ කරගත් පසු, Java හි සංග්රහ (collection) රාමුව ඉගෙන ගැනීම ස්වභාවික ඊළඟ පියවර වේ.
ඊළඟ අධ්යයනය අරේ ආරම්භ කිරීම පිළිබඳ නිතර අසන ප්රශ්න (FAQ) සාරාංශ කරයි. ඔබට සැකයක් ඇත්නම්, අදාල ප්රශ්න-පිළිතුරු (Q&A) නැවත සලකා බලන්න.
7. නිතර අසන ප්රශ්න (FAQ)
මෙහි, Java හි අරේ ආරම්භ කිරීම පිළිබඳ සාමාන්ය ප්රශ්න සහ ගැටළු පැහැදිලි කරමු.
Q1. මට පසුකාලීනව අරේවල ප්රමාණය වෙනස් කළ හැකිද?
A. නැත. එක් වරක් ආරම්භ කළ පසු, Java අරේවල ප්රමාණය වෙනස් කළ නොහැක. වෙනත් ප්රමාණයක් අවශ්ය නම්, නව අරේක් සාදමින් පවතින අගයන් පිටපත් කළ යුතුය. වෙනස් ප්රමාණයේ ව්යුහ සඳහා ArrayList භාවිතා කිරීම සලකා බලන්න.
Q2. අරේවක් ආරම්භ නොකළ තත්ත්වයේ එය භාවිතා කළහොත් කුමක් වේ?
A. ප්රකාශනය කළ නමුත් ආරම්භ නොකළ අරේවක් භාවිතා කිරීම NullPointerException එකක් ඇති කරයි. භාවිතා කිරීමට පෙර new හෝ initializer ලැයිස්තුවක් සමඟ අරේ ආරම්භ කරන්න.
Q3. Arrays.fill() සහ for ලූපය අතර වෙනස කුමක්ද?
A. Arrays.fill() සියලු අංගයන්ට එකම අගයක් සකසයි, whereas for ලූපයක් භාවිතා කරන්නේ එක් එක් අංගයට වෙනස් අගයන් ලබා දීමට.
Q4. අරේවල පෙරනිමි අගයන් කෙසේ නියම වේ?
A. new භාවිතා කරන විට පෙරනිමි අගයන් ස්වයංක්රීයව නියම වේ: int → 0, double → 0.0, boolean → false, යොමු වර්ග → null.
Q5. දෙමාන අරේවක පේළිවල දිග වෙනස් විය හැදියිද?
A. හැක. Java ජැග්ඩ් අරේවලට සහය දේ, එහි එක් පේළියකට වෙනස් තීරු ගණනක් තිබිය හැක, නමුත් පේළිය ආරම්භ කර නොමැතිව භාවිතා කළ නොහැක.
Q6. අරේවල පිටපත් කිරීම කෙසේද?
A. System.arraycopy() හෝ Arrays.copyOf() වැනි ක්රම භාවිතා කරන්න. ලූපයක් සමඟ අතින් පිටපත් කිරීම කළ හැකි නමුත්, නිර්මාණය කළ ක්රම වඩා සරල හා ආරක්ෂිත වේ.
Q7. අරේ සහ ArrayList අතර වෙනස කුමක්ද?
A. අරේවල ප්රමාණය ස්ථිර වන අතර එක වර්ගයක් පමණක් ගබඩා කරයි, එයට විරුද්ධව ArrayList ගතික ප්රමාණය සහිතව, වඩාත් ස flexibilty සහිත ක්රියාකාරකම් ලබා දේ.
