ජාවා Arrays: මූලික සංකල්ප සහ භාවිතය | Java Array Basics SC Guide

කොහොමද යාලුවනේ! SC Guide එකට ආයෙත් ඔයාලා හැමෝම සාදරයෙන් පිළිගන්නවා. අද අපි කතා කරන්න යන්නේ Java Programming වලදී අත්‍යවශ්‍යම වගේම ගොඩක් වැදගත් Concepts එකක් ගැන - ඒ තමයි Arrays! Programming ලෝකේ මුලින්ම පියවර තියන ඔයාලට මේ Array කියන දේ පොඩ්ඩක් සංකීර්ණ වෙන්න පුළුවන්. ඒත් කරදර වෙන්න එපා, අද අපි මේ Array කියන දේ හරිම සරලව, ඔයාලට තේරෙන භාෂාවෙන්, ඒ වගේම අපේ සිංහල ක්‍රමයටම විස්තර කරමු. මේ ලිපිය කියවනකොට ඔයාලට Java Arrays ගැන හොඳ අවබෝධයක් ලැබෙයි කියලා මට විශ්වාසයි. එහෙනම් වැඩේට බහිමුද?

Array කියන්නේ මොකද්ද?

හරි, මුලින්ම බලමු මේ Array කියන්නේ මොකද්ද කියලා. අපි හිතමු ඔයාලට එකම වර්ගයේ දේවල් ගොඩක් Store කරගන්න ඕන කියලා. උදාහරණයක් විදියට, Class එකක ඉන්න ළමයි 50 දෙනෙකුගේ Marks Store කරන්න ඕන. සාමාන්‍ය විදියට නම් ඔයාලා වෙන වෙනම Variables 50ක් හදාගන්න වෙනවා නේද? int studentMark1 = 85; int studentMark2 = 92; වගේ. හිතන්නකෝ ළමයි 500ක් හිටියොත්? ඒක හරිම අපහසු වැඩක්. මේ වගේ අවස්ථාවලට තමයි Array කියන Data Structure එක එන්නේ.

සරලව කිව්වොත්, Array කියන්නේ එකම Data Type එකේ (වර්ගයේ) Data Values කිහිපයක් එකම Variable එකක Save කරගන්න පුළුවන් ක්‍රමයක්. මේවාට අපි 'Elements' කියලා කියනවා. Array එකක තියෙන විශේෂ ලක්ෂණ කිහිපයක් තමයි:

• Fixed Size: Array එකක් හැදුවට පස්සේ ඒකේ Size එක, ඒ කියන්නේ ඒක ඇතුළේ තියාගන්න පුළුවන් Element ගාන වෙනස් කරන්න බැහැ.
• Homogeneous Data: Array එකක් ඇතුළේ තියෙන්න පුළුවන් එකම වර්ගයේ (int, String, boolean වගේ) Data විතරයි. int Array එකක String එකක් දාන්න බැහැ.
• Contiguous Memory: සාමාන්‍යයෙන් Array Elements මතකයේ (Memory) එකට යාබදව (Sequentially) Save වෙනවා. මේ නිසා Data access කිරීම හරිම වේගවත්.

අපි මේක පොඩි උදාහරණයකින් තේරුම් ගමු. හිතන්න ඔයාලගේ ගෙදර පොඩි ලොකර් පේළියක් තියෙනවා කියලා. හැම ලොකර් එකක්ම එකම Size එකේ. ඒ වගේම හැම ලොකර් එකක්ම අංක දාලා තියෙනවා 0 ඉඳන්. ඔයාලට ඕන කරන බඩුව ලොකර් අංකේ කියලා කෙලින්ම ගිහින් ගන්න පුළුවන්. Array එකක් කියන්නෙත් ඒ වගේ දෙයක්. හැම Element එකකටම Index එකක් (අංකයක්) තියෙනවා, ඒක පටන් ගන්නේ 0 ඉඳන්.

Java වල Array හදන්නේ කොහොමද?

දැන් අපි බලමු Java වල Array එකක් හදන්නේ, ඒ කියන්නේ Declare කරලා Initialize කරන්නේ කොහොමද කියලා.

Array එකක් Declare කරන හැටි

මුලින්ම අපි Array එකක් තියෙනවා කියලා Java Compiler එකට කියන්න ඕන. මේකට අපි කියනවා Declaration කියලා. මේක කරන්න ක්‍රම දෙකක් තියෙනවා:

dataType[] arrayName;
// හෝ
dataType arrayName[];

උදාහරණයක් විදියට:

int[] numbers; // int වර්ගයේ Array එකක් declare කිරීම
String[] names; // String වර්ගයේ Array එකක් declare කිරීම

මෙහිදී dataType කියන්නේ Array එකේ තියෙන Elements වල වර්ගය (e.g., int, String, double). arrayName කියන්නේ ඔයාලා Array එකට දෙන නම. සාමාන්‍යයෙන් පළවෙනි ක්‍රමය (dataType[] arrayName;) තමයි ගොඩක් වෙලාවට භාවිතා කරන්නේ, මොකද ඒකෙන් Array එකේ Data Type එක පැහැදිලිව පේනවා.

Array එකක් Instantiate කරන හැටි (Creation)

Array එකක් Declare කරාට පස්සේ, ඒක තවම මතකයේ (Memory) හදලා නැහැ. Array එකකට මතකයේ ඉඩක් වෙන් කරන්න ඕන. මේකට අපි කියනවා Instantiation කියලා. මේක කරන්නේ new Keyword එක පාවිච්චි කරලා:

arrayName = new dataType[size];

මෙහිදී size කියන්නේ Array එකේ තියාගන්න පුළුවන් Elements ගාන. මේක ධන පූර්ණ සංඛ්‍යාවක් (Positive Integer) වෙන්න ඕන.

උදාහරණයක්:

int[] numbers; // Declaration
numbers = new int[5]; // Instantiation: int වර්ගයේ Elements 5ක් තියාගන්න පුළුවන් Array එකක් සෑදීම

මේ ක්‍රියාවලි දෙකම එකම පේලියකින් කරන්නත් පුළුවන්. ඒක තමයි ගොඩක්ම පාවිච්චි වෙන ක්‍රමය:

dataType[] arrayName = new dataType[size];

උදාහරණ:

int[] ages = new int[10]; // int වර්ගයේ Elements 10ක් තියාගන්න පුළුවන් Array එකක්
double[] prices = new double[7]; // double වර්ගයේ Elements 7ක් තියාගන්න පුළුවන් Array එකක්
String[] cities = new String[3]; // String වර්ගයේ Elements 3ක් තියාගන්න පුළුවන් Array එකක්

Array එකක් Initialize කරන හැටි (Assigning Values)

Array එකක් හැදුවට පස්සේ, ඒකේ Elements වලට Values දාන්න ඕන නේද? අපි මේකට කියනවා Initialization කියලා. Array එකක් හැදුවම ඒකේ Elements වලට Default Values ටිකක් Auto assign වෙනවා. ඒවා තමයි:

• int, byte, short, long - 0
• float, double - 0.0
• boolean - false
• char - '\u0000' (null character)
• Object types (like String) - null

ඒත් අපිට අපිට ඕන කරන Values දාන්න පුළුවන්. Array එකක තියෙන Element එකකට Value එකක් දාන්න අපි ඒකේ Index එක (අංකය) පාවිච්චි කරනවා. මතක තියාගන්න, Array වල Index එක පටන් ගන්නේ 0 ඉඳන්!

උදාහරණයක්:

int[] marks = new int[5]; // Elements 5ක Array එකක්. Indexes: 0, 1, 2, 3, 4

marks[0] = 75; // පළවෙනි Element එකට (Index 0) Value එකක් දීම
marks[1] = 80;
marks[2] = 90;
marks[3] = 65;
marks[4] = 95; // අන්තිම Element එකට (Index 4) Value එකක් දීම

// මේක තව විදියකටත් කරන්න පුළුවන්. Array එක Declare කරනකොටම Values ටික දාන්න:
int[] studentMarks = {75, 80, 90, 65, 95}; // Size එක auto adjust වෙනවා (Elements 5ක්)

// String Array එකකට උදාහරණයක්:
String[] fruits = {"Apple", "Banana", "Orange"};

දෙවෙනි ක්‍රමය (Curly braces {} ඇතුළේ Values දෙන එක) හරිම පහසුයි. මෙතනදී අපි Size එක කියන්න ඕන නැහැ, Java එකෙන් තියෙන Elements ගාන අනුව Size එක Auto assign කරනවා.

Array වල දත්ත Access කරන්නේ කොහොමද?

දැන් අපි Array එකක් හැදුවා, ඒකට Values දැම්මා. දැන් බලමු ඒ Values ටික ආයෙත් ගන්නෙයි, වෙනස් කරන්නෙයි කොහොමද කියලා.

Element එකක් Access කරන හැටි

Array එකක තියෙන ඕනෑම Element එකක් Access කරන්න අපිට ඒකේ Index එක (අංකය) පාවිච්චි කරන්න පුළුවන්. මතක තියාගන්න, Index එක 0 ඉඳන් තමයි පටන් ගන්නේ!

int[] numbers = {10, 20, 30, 40, 50};

int firstNumber = numbers[0]; // Index 0 හි ඇති Value එක ලබා ගැනීම (10)
int thirdNumber = numbers[2]; // Index 2 හි ඇති Value එක ලබා ගැනීම (30)

System.out.println("First number: " + firstNumber); // Output: First number: 10
System.out.println("Third number: " + thirdNumber); // Output: Third number: 30

Element එකක් Modify කරන හැටි

ඒ වගේම Array එකේ තියෙන Element එකක Value එකක් වෙනස් කරන්නත් පුළුවන්. ඒකටත් Index එක පාවිච්චි කරනවා.

int[] scores = {90, 85, 70, 95};
System.out.println("Original score at index 1: " + scores[1]); // Output: Original score at index 1: 85

scores[1] = 88; // Index 1 හි ඇති Value එක 88 ලෙස වෙනස් කිරීම
System.out.println("New score at index 1: " + scores[1]); // Output: New score at index 1: 88

Array එකේ Length එක

Array එකක Elements කීයක් තියෙනවද කියලා දැනගන්න .length කියන Property එක පාවිච්චි කරන්න පුළුවන්. මේක හරිම වැදගත්, මොකද Array එකක් Travers (Array එකේ හැම Element එකක්ම බලන එක) කරනකොට මේක අවශ්‍ය වෙනවා.

String[] cars = {"BMW", "Audi", "Mercedes", "Toyota"};
int numberOfCars = cars.length;

System.out.println("Number of cars: " + numberOfCars); // Output: Number of cars: 4

Common Error: ArrayIndexOutOfBoundsException

මේක තමයි Array පාවිච්චි කරනකොට beginner කෙනෙක්ට නිතරම වරදින තැනක්! අපි Array එකක Size එකට වඩා වැඩි හෝ අඩු (Negative) Index එකක් Access කරන්න හැදුවොත්, Java එකෙන් ArrayIndexOutOfBoundsException කියන Error එක දෙනවා.

int[] numbers = {10, 20, 30};
System.out.println(numbers[3]); // මේක Error එකක් දෙනවා, මොකද index 3ක් නැහැ (0, 1, 2 විතරයි තියෙන්නේ).

මේක වළක්වාගන්න හැමවිටම Index එක 0 ත් arrayName.length - 1 අතර තියෙනවද කියලා බලන්න ඕන.

Array එකක් Traverse කරන හැටි

Array එකක තියෙන හැම Element එකක්ම පෙන්වන්න, නැත්නම් ඒ හැම Element එකක්ම Process කරන්න අපිට Loop එකක් පාවිච්චි කරන්න පුළුවන්. Java වල Array එකක් Travers කරන්න ප්‍රධාන ක්‍රම දෙකක් තියෙනවා:

For Loop

මේක තමයි Array Travers කරන්න තියෙන standard ක්‍රමය. අපිට Index එක පාවිච්චි කරලා හැම Element එකක්ම Access කරන්න පුළුවන්.

int[] grades = {78, 92, 85, 60, 95};

System.out.println("Using a for loop:");
for (int i = 0; i < grades.length; i++) {
    System.out.println("Grade at index " + i + ": " + grades[i]);
}
/* Output:
Grade at index 0: 78
Grade at index 1: 92
Grade at index 2: 85
Grade at index 3: 60
Grade at index 4: 95
*/

මෙතනදී i කියන Variable එක 0 ඉඳන් Array එකේ Length එකට වඩා එකක් අඩුවෙනකම් (grades.length - 1) යනවා. මේ නිසා අපිට හැම Index එකක්ම Access කරන්න පුළුවන්.

Enhanced For Loop (For-each loop)

මේක Loop කරනකොට Index එක ගැන වැඩිය හිතන්නේ නැතුව, හැම Element එකක්ම එකින් එක ගන්න පුළුවන් පහසු ක්‍රමයක්. ඒත් මේකෙන් Element එකේ Index එක ගන්න බැහැ, ඒ වගේම Array එකේ Element එකක Value එක වෙනස් කරන්නත් බැහැ (ඒක වෙනම Variable එකකට copy වෙන නිසා).

String[] colors = {"Red", "Green", "Blue", "Yellow"};

System.out.println("Using an enhanced for loop (for-each loop):");
for (String color : colors) {
    System.out.println("Color: " + color);
}
/* Output:
Color: Red
Color: Green
Color: Blue
Color: Yellow
*/

මෙතනදී String color : colors කියන්නේ 'colors' Array එකේ තියෙන හැම String Element එකක්ම අරගෙන ඒක 'color' කියන Variable එකට දාන්න කියන එක. ගොඩක් වෙලාවට Read-only Operation වලට මේ For-each Loop එක හරිම පහසුයි.

Practical Use Cases & Tips (ප්‍රයෝගික භාවිතයන් සහ උපදෙස්)

Array කියන්නේ Programming වලදි හරිම වැදගත් Concept එකක්. මේවා පාවිච්චි වෙන තැන් ඕන තරම් තියෙනවා:

• Student Marks ටිකක් Store කරලා Average එක හොයන්න.
• Product List එකක් Maintain කරන්න.
• Game board එකක් (e.g., Tic-Tac-Toe, Chess) Design කරන්න (Multidimensional Arrays).
• සංඛ්‍යා පේළියක් Sort කරන්න (පෙළගස්වන්න).

ඔයාලට තව Tips ටිකක් දෙන්නම් මේ Array එක්ක වැඩ කරනකොට මතක තියාගන්න:

1. ArrayIndexOutOfBoundsException ගැන සැලකිලිමත් වෙන්න: Index එක 0 ඉඳන් array.length - 1 වෙනකම් විතරයි පාවිච්චි කරන්න පුළුවන්. මේකෙන් පරිස්සම් වෙන්න.
2. Fixed Size ගැන මතක තියාගන්න: Array එකක් හදපු ගමන් ඒකේ Size එක Fixed වෙනවා. ඔයාලට Elements Add කරන්න, Remove කරන්න ඕන නම් ArrayList වගේ Dynamic Data Structure එකක් ගැන හිතන්න. ඒ ගැන අපි වෙනම Article එකකින් කතා කරමු.
3. Arrays Class එක: Java වල java.util.Arrays කියන Utility Class එකක් තියෙනවා. මේකේ Array එක්ක වැඩ කරන්න පුළුවන් හරිම පහසු Methods ගොඩක් තියෙනවා. උදාහරණයක් විදියට:
   • Arrays.sort(array) - Array එකක තියෙන Elements Sort කරන්න.
   • Arrays.toString(array) - Array එකක තියෙන Elements String එකක් විදියට Print කරන්න. (මේක Debug කරනකොට හරිම ප්‍රයෝජනවත්!)

Arrays.toString() වලට පොඩි උදාහරණයක් බලමු:

import java.util.Arrays;

public class ArrayToStringExample {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};
        System.out.println(Arrays.toString(numbers)); // Output: [1, 2, 3, 4, 5]

        String[] fruits = {"Apple", "Banana", "Cherry"};
        System.out.println(Arrays.toString(fruits)); // Output: [Apple, Banana, Cherry]
    }
}

මේ Arrays class එක ගැනත් ඔයාලට තව ඉස්සරහට ඉගෙන ගන්න පුළුවන්.

Conclusion (අවසානය)

ඉතින් යාලුවනේ, අද අපි Java Arrays ගැන මූලිකම දේවල් ගොඩක් ඉගෙන ගත්තා. Array එකක් කියන්නේ මොකද්ද, ඒක Declare කරන්නේ, Instantiate කරන්නේ, Initialize කරන්නේ කොහොමද, ඒ වගේම Array එකක Elements Access කරලා Traverse කරන්නේ කොහොමද කියන දේවල් අපි විස්තරාත්මකව සාකච්ඡා කළා. මේ Concepts ටික ඔයාලට Programming වලදී ගොඩක් දුර යන්න උදව් වෙයි. මතක තියාගන්න, ඕනම Programming Concept එකක් තේරුම් ගන්න හොඳම දේ තමයි ඒක ප්‍රැක්ටිස් කරන එක. ඒ නිසා අදම ඔයාලගේ IDE එක ඇරගෙන මේවා අත්හදා බලන්න.

මේ ලිපිය ගැන ඔයාලගේ අදහස්, ප්‍රශ්න පහළින් comment එකක් දාගෙන යන්න. ඒ වගේම ඔයාලට ඉස්සරහට මොන වගේ Topics ගැනද දැනගන්න ඕන කියලත් කියන්න. තවත් මේ වගේ වැදගත් ලිපියකින් හමුවෙනකම්, ඔයාලා හැමෝටම සුභ දවසක්!