Java ලැයිස්තු ආරම්භ කිරීමේ මාර්ගෝපදේශය: හොඳම ක්‍රම, උදාහරණ, සහ කාර්ය සාධන උපදෙස්

1 1. හැඳින්වීම
2 2. Lists හි මූලික සංකල්ප සහ Initialization හි වැදගත්කම
3 3. List එකක් Initialize කිරීමේ පහක් Ways
4 4. එක් එක් ආරම්භක ක්‍රමය සසඳීම
5 5. ප්‍රායෝගික භාවිත උදාහරණ
6 6. සාරාංශය
7 7. නිතර අසන ප්‍රශ්න (FAQ)

1. හැඳින්වීම

ජාවාහි ප්‍රොග්‍රෑම් කිරීමේදී, “List initialization” යනු මූලික සහ වැදගත් සංකල්පවලින් එකකි. Arrays වලට වඩා වෙනස්ව, Lists dynamic resizing ඉඩදෙන අතර ArrayList සහ LinkedList වැනි විවිධ implementations සඳහා සහාය දෙයි, එමඟින් ඒවා දෛනික development කාර්යයන්හි බහුලව භාවිතා වේ. කෙසේ වෙතත්, බොහෝ developers “මම කුමන initialization method භාවිතා කළ යුතුද?” හෝ “එක් එක් approach අතර වෙනස්කම් මොනවාද?” වැනි ප්‍රශ්න සමඟ අරගල කරති.

මෙම ලිපිය ජාවාහි Lists හි අත්‍යවශ්‍ය ලක්ෂණ, initialization හි අරමුණ සහ ලබාගත හැකි විවිධ initialization methods—විශේෂයෙන්ම ආරම්භකයින් සඳහා—පැහැදිලිව පැහැදිලි කරයි. අපි තවද real projects හි සාමාන්‍යයෙන් භාවිතා වන practical examples, සාමාන්‍ය pitfalls සහ ඔබේ use case අනුව නිවැරදි method තෝරාගැනීම ගැනද සාකච්ඡා කරමු. Lists initialize කිරීමේ optimal way ඉගෙන ගැනීමට හෝ competing articles මත වාසියක් ලබාගැනීමට අපේක්ෂා කරන්නේ නම්, මෙම මාර්ගෝපදේශය ඉතා වැදගත් වේ.

2. Lists හි මූලික සංකල්ප සහ Initialization හි වැදගත්කම

ජාවාහි Lists යනු ordered, variable-length data store කළ හැකි collection වර්ගයකි. වඩාත්ම භාවිතා වන implementation එක වන්නේ ArrayList යි, නමුත් LinkedList සහ Vector ඇතුළු වෙනත් කිහිපයක් ඇත. Arrays වලට සාපේක්ෂව, Lists flexible resizing සහ elements add කිරීම හෝ remove කිරීම වැනි සරල operations ලබාදෙයි.

【Lists හි ලක්ෂණ】

ඇතුළත් කළ order ආරක්ෂා වේ : Elements ඇතුළත් කළ order තුළම තබාගනී.
Duplicates ඉඩදෙයි : එකම values බහුවිධයෙන් store කළ හැක.
Dynamic size : Size ඉදිරියට specify කිරීම අවශ්‍ය නැත; elements freely add හෝ remove කළ හැක.

කෙසේ වෙතත්, විවිධ initialization methods වෙනස්ව හැසිරෙන බැවින්, objective අනුව නිවැරදි approach තෝරාගැනීම වැදගත් වේ.

【Initialization හි වැදගත්කම】
නිවැරදි List initialization technique තෝරාගැනීම ඔබේ use case මත බරපතලව රඳා පවතී. උදාහරණයක් ලෙස:

Empty List එකක් create කිරීම සඳහා සරල method එකක් අවශ්‍ය වේ.
Initial values සහිත List එකක් create කිරීම වෙනත් approach එකක් අවශ්‍ය විය හැක.
Immutable List එකක් අවශ්‍ය නම්, නිශ්චිත methods වඩාත් සුදුසුය. ඊට අමතරව, modern Java versions improved efficiency සඳහා නව syntax ලබාදෙයි. මෙම options තේරුම් ගැනීම productivity බෙහෙවින් වැඩිදියුණු කරයි.

【Lists සහ arrays අතර වෙනස】
ජාවාහි Arrays fixed-length වන අතර, ඒවායේ size declaration වෙලාවේදීම තීරණය කළ යුතුය. Lists, එහෙත්, dynamic resizing සඳහා සහාය දෙන බැවින් practical use cases හි preferred වේ. කෙසේ වෙතත්, initialization technique සහ internal implementation අනුව, performance differences හෝ functional restrictions ඇති විය හැකි බැවින්, proper usage වැදගත් වේ.

3. List එකක් Initialize කිරීමේ පහක් Ways

ජාවා Lists initialize කිරීම සඳහා කිහිපයක් methods ලබාදෙයි. Ideal method ඔබේ use case, Java version සහ පසුව elements add හෝ remove කිරීම අවශ්‍යද යන්න මත රඳා පවතී. මෙම කොටසේ ලක්ෂණ සහ best use cases සමඟ පොදුවේ භාවිතා වන පහක් initialization techniques පැහැදිලි කර ඇත.

3.1 Empty List එකක් Create කිරීම

මෙය මූලිකම initialization approach එකකි. Empty List එකකින් ආරම්භ කර values පසුව add කිරීමට අපේක්ෂා කරන විට භාවිතා වේ.

List<String> list = new ArrayList<>();

Use case : Elements පසුව add කිරීමේදී.
Key point : මුලින් empty වුවද, add() භාවිතයෙන් elements freely add කළ හැක. ඔබේ needs අනුව LinkedList වැනි වෙනත් implementations තෝරාගත හැක.

3.2 Arrays.asList භාවිතය

කිහිපයක් values හෝ array එකකින් List එකක් quickly create කිරීමට අපේක්ෂා කරන විට, Arrays.asList() සුදුසුය. එය single line එකකින් initial values සහිත List එකක් create කිරීමට ඉඩදෙයි.

List<String> list = Arrays.asList("A", "B", "C");

Use case : Multiple fixed values වලින් List එකක් create කිරීමේදී.
Note : මෙම method එකෙන් create කළ Lists fixed size එකක් ඇති බැවින්, add() හෝ remove() භාවිතයෙන් elements add හෝ remove කිරීමට ඉඩ නැත. කෙසේ වෙතත්, set() භාවිතයෙන් existing values modify කළ හැක.
Modification අවශ්‍ය නම් : පහත පරිදි නව ArrayList එකක් create කරන්න:

List<String> list = new ArrayList<>(Arrays.asList("A", "B", "C"));

3.3 List.of භාවිතය (Java 9+)

Java 9 සිට, List.of() මගින් අප්‍රතිවර්තන ලැයිස්තු (immutable Lists) පහසුවෙන් නිර්මාණය කළ හැක.

List<String> list = List.of("A", "B", "C");

භාවිත අවස්ථාව : අන්තර්ගතය ස්ථාවර වන අතර වෙනස් කිරීමට අවශ්‍ය නොවන විට.
විශේෂත්වයන් : මෙම ක්‍රමය භාවිතා කර නිර්මාණය කරන ලද ලැයිස්තු සම්පූර්ණයෙන්ම අක්‍රිය වේ. add(), remove(), හෝ set() වැනි වෙනස්කම් කිසිවක් ඉඩ නොදේ. මෙය ස්ථිර අගයන් සහ ආරක්ෂා-අත්‍යවශ්‍ය දත්ත සඳහා සුදුසුය.

3.4 Instance Initializer එකක් භාවිතා කිරීම

මෙම අඩු ප්‍රචලිත තාක්ෂණය අනාමික පන්තියක් තුළ instance initializer එකක් භාවිතා කරයි. එය එක් ප්‍රකාශයක් තුළ බහු-පේළි හෝ සංකීර්ණ ආරම්භක කිරීම සලස්වයි.

List<String> list = new ArrayList<>() {{
    add("A");
    add("B");
    add("C");
}};

භාවිත අවස්ථාව : බොහෝ අංග හෝ සංකීර්ණ ආරම්භක තර්කයක් අවශ්‍ය වන විට.
අවධානය : එය අනාමික පන්තියක් නිර්මාණය කරන බැවින්, මතක හා නඩත්තු ගැටළු හේතුවෙන් විශාල ව්‍යාපෘති හෝ කාර්ය සාධන-අත්‍යවශ්‍ය පරිසර සඳහා නිර්දේශ නොකෙරේ.

3.5 ආරම්භක ධාරිතාවයක් සමඟ ArrayList එකක් නිර්මාණය කිරීම

List<String> list = new ArrayList<>(100);

භාවිත අවස්ථාව : ඔබ බොහෝ අංග ඇතුළත් කිරීමට බලාපොරොත්තු වන අතර, අනුමාන ප්‍රමාණය දැන සිටින විට.
ලාභය : අභ්‍යන්තර ප්‍රතිමානයේ (resizing) ක්‍රියාකාරකම් අඩු කර කාර්ය සාධනය වැඩි කරයි.

මෙම විවිධ ආරම්භක ක්‍රමයන් Java සංවර්ධකයන්ට එක් එක් අවස්ථාව සඳහා අතිශය කාර්යක්ෂම ක්‍රමය තෝරා ගැනීමට ඉඩ සලසයි.

4. එක් එක් ආරම්භක ක්‍රමය සසඳීම

මෙම කොටස පෙර හඳුන්වා දුන් පස් ආරම්භක තාක්ෂණයන් සසඳයි. මෙම සංවිධානය කළ සාරාංශය ඔබට අවශ්‍ය ක්‍රමය තීරණය කිරීමට උපකාරී වේ.

【ප්‍රධාන සසඳන ලක්ෂණ】

Initialization Method	Add/Remove	Modify Values	Immutability	Recommended Use Case
new ArrayList<>()	Yes	Yes	No	General List operations
Arrays.asList(…)	No	Yes	Partial (fixed size)	When converting an array to a List and only modifying existing values
new ArrayList<>(Arrays.asList(…))	Yes	Yes	No	When you need both initial values and modifiable size
List.of(…)	No	No	Excellent	When a fully immutable constant List is required
Instance initializer	Yes	Yes	No	When initializing complex or multi-line values at once
new ArrayList<>(initial capacity)	Yes	Yes	No	When handling many elements and optimizing performance

【ප්‍රධාන තේරීම් මාර්ගෝපදේශ】

ඔබට පසුකාලීනව අංග එකතු කිරීම හෝ ඉවත් කිරීම අවශ්‍ය නම් ⇒ new ArrayList<>() හෝ new ArrayList<>(Arrays.asList(...))
ස්ථාවර අගයන්ගෙන් ලැයිස්තුවක් අවශ්‍ය නම්, එකතු/ඉවත් කිරීම නොකර ⇒ Arrays.asList(...)
සම්පූර්ණයෙන්ම අක්‍රිය ලැයිස්තුවක් (ආරක්ෂා-අත්‍යවශ්‍ය) අවශ්‍ය නම් ⇒ List.of(...) (Java 9+)
බහු-පේළි හෝ සංකීර්ණ ආරම්භක තර්කයක් අවශ්‍ය නම් ⇒ Instance initializer
බොහෝ අංග බලාපොරොත්තු වන අතර වැඩි කාර්ය සාධනය අවශ්‍ය නම් ⇒ new ArrayList<>(initial capacity)

【සටහන්】

Arrays.asList භාවිතයෙන් නිර්මාණය කරන ලද ලැයිස්තු ස්ථාවර ප්‍රමාණයක් ඇත—අංග එකතු කිරීම හෝ ඉවත් කිරීම UnsupportedOperationException එකක් ඇති කරයි.
List.of ශුන්‍ය හෝ බහු අංග සහය දක්වයි, නමුත් එය අක්‍රිය වේ— add, remove, සහ set භාවිතා කළ නොහැක.
Instance initializer ගණනාවක් ශක්තිමත් වුවද, ඒවා අනාමික පන්තියන් නිර්මාණය කරයි, එය කියවීමේ පහසුව සහ කාර්ය සාධනයට අඩුපාඩු ඇති කරයි.

අරමුණු, ආරක්ෂාව, සහ කාර්ය සාධනය මත පදනම්ව නිවැරදි ආරම්භක ක්‍රමය තේරීම Java සංවර්ධනයේ ප්‍රභාවී වීමට අත්‍යවශ්‍ය වේ.

5. ප්‍රායෝගික භාවිත උදාහරණ

මෙම කොටස පෙර හඳුන්වා දුන් එක් එක් List ආරම්භක ක්‍රම සඳහා ප්‍රායෝගික උදාහරණ ලබා දෙයි. නිරූපිත අවස්ථා සමාලෝචනය කිරීමෙන්, ඔබේ අවශ්‍යතාවයට සුදුසු ක්‍රමය හොඳින් තේරුම් ගත හැක.

5.1 හිස් List එකක් නිර්මාණය කර පසුව අගයන් එකතු කිරීම

List<String> names = new ArrayList<>();
names.add("Satou");
names.add("Suzuki");
names.add("Takahashi");
System.out.println(names); // Output: [Satou, Suzuki, Takahashi]

විස්තරය:
මෙය මූලික භාවිතයයි. ඔබට පෙර හිස් List එකක් සකස් කර පසුව, පරිශීලක ඇතුළත් කිරීම හෝ ලූපයන් මගින් අගයන් එකතු කිරීමට අවශ්‍ය විට මෙය ප්‍රයෝජනවත් වේ.

5.2 Arrays.asList සමඟ ස්ථාවර-ප්‍රමාණ List එකක් නිර්මාණය කිරීම

List<String> fruits = Arrays.asList("Apple", "Banana", "Mikan");
System.out.println(fruits); // Output: [Apple, Banana, Mikan]
// fruits.add("Grape"); // ← This will cause an error
fruits.set(0, "Pineapple"); // This is allowed
System.out.println(fruits); // Output: [Pineapple, Banana, Mikan]

විස්තරය:
මෙම ක්‍රමය ස්ථාවර දත්ත කට්ටලයක් හසුරවීමට හෝ අගයන් වහාම සැකසීමට ප්‍රයෝජනවත් වේ. නමුත්, අංග එකතු කිරීම හෝ ඉවත් කිරීම ඉඩ නොදෙන බැවින් අවධානයෙන් සිටිය යුතුය.

5.3 List.of භාවිතයෙන් අවිනිශ්චිත ලැයිستුවක් නිර්මාණය කිරීම (Java 9+)

List<String> colors = List.of("Red", "Blue", "Green");
System.out.println(colors); // Output: [Red, Blue, Green]
// colors.add("Yellow"); // ← Will throw an exception

විස්තරය:
මෙය ස්ථිර ලැයිස්තු හෝ වෙනස් නොකළ යුතු වටිනාකම් සඳහා ආදර්ශීය වන අතර, විශේෂයෙන් ආරක්ෂාව සහ අවිනිශ්චිතභාවය වැදගත් වන විට.

5.4 ආකෘතිගත මුල් වටිනාකම් සකස් කිරීම සඳහා ආකෘතිගත මුල්ගත කරන්නා භාවිතය

List<Integer> numbers = new ArrayList<>() {{
    for (int i = 1; i <= 5; i++) {
        add(i * i); // 1, 4, 9, 16, 25
    }
}};
System.out.println(numbers); // Output: [1, 4, 9, 16, 25]

විස්තරය:
මුල්ගත කිරීම සඳහා වල්ලි, තත්ත්වයන් හෝ සංකීර්ණ තර්ක අවශ්‍ය වන විට එය උපකාරී වේ. එය බලවත් වුවද, නිරුපකරණ පන්තියේ අධික බර තුළින් ලොකු පරිමාණ සංකීර්ණතාවලදී එය නිර්දේශ නොකෙරේ.

5.5 මුල් ධාරිතාවය සමඟ විශාල දත්ත ප්‍රමාණයක් එකතු කිරීම

List<Integer> bigList = new ArrayList<>(1000);
for (int i = 0; i < 1000; i++) {
    bigList.add(i);
}
System.out.println(bigList.size()); // Output: 1000

විස්තරය:
විශාල දත්ත සෙට් පවත්වාගෙන යන විට, මුල් ධාරිතාවයක් විශේෂ කිරීම ආකෘතිගත කිරීම් ක්‍රියාකාරකම් අඩු කරන අතර කාර්ය සාධනය වැඩි දියුණු කරයි.

වාස්තවික තත්ත්වය මත ගැලපෙන මුල්ගත කිරීම් ක්‍රමය තෝරාගැනීම පාඨකීයභාවය, කාර්ය සාධනය සහ නඩත්තු කිරීමේ හැකියාව වැඩි දියුණු කරයි.

6. සාරාංශය

මෙම ලිපියෙන් අපි Java හි ලැයිස්තු මුල්ගත කිරීම සඳහා බහුවිධ ප්‍රවේශයන් ගවේෂණය කළෙමු—මූලික සංකල්ප සහ ප්‍රායෝගික උදාහරණ සිට සංසන්දන සහ හොඳම පුරුදු දක්වා. ලැයිස්තු මුල්ගත කිරීම මුලින් බැලූ විට සරල ලෙස පෙනුනත්, ඔප්ටිමල් ක්‍රමය භාවිත තත්ත්වයන් සහ අවශ්‍යතා මත සැලකිය යුතු ලෙස වෙනස් වේ.

ප්‍රධාන කරුණු සාරාංශය:

ලැයිස්තු ක්‍රමානුකූල වේ, ආවර්තනයන්ට ඉඩ දෙයි, සහ ගතික ආකෘතිගත කිරීමට සහාය දෙයි, එබැවින් ඒවා වර්ගීකරණවලට වඩා නම්‍යශීලී වේ.
Java විවිධ මුල්ගත කිරීම් ක්‍රම සපයයි: හිස් ලැයිස්තු, මුල් වටිනාකම් සහිත ලැයිස්තු, අවිනිශ්චිත ලැයිස්තු, විශේෂිත මුල් ධාරිතාවය සහිත ලැයිස්තු, සහ තවත්.
නිවැරදි ක්‍රමය තෝරාගැනීම ඔබට සාධන/ඉවත් කිරීම් අවශ්‍ය ද, ස්ථිර දත්ත පවත්වාගෙන යන්නේ ද, අවිනිශ්චිතභාවය සහතික කරන්නේ ද, හෝ විශාල දත්ත සෙට් කාර්යක්ෂමව පවත්වාගෙන යන්නේ ද යන්න මත රඳා පවතී.
Arrays.asList සහ List.of වල විශේෂිත සීමාවන් ඇත (ස්ථිර ප්‍රමාණය හෝ සම්පූර්ණ අවිනිශ්චිතභාවය), එබැවින් ඒවායේ හැසිරීම තේරුම් ගැනීම අත්‍යවශ්‍ය වේ.

ඔබ ලැයිස්තු මුල්ගත කිරීමට මුහුණ දෙන විට සැබෑ සංවර්ධනයේ හෝ අධ්‍යයනයේදී, වඩාත් ගැලපෙන ක්‍රමය තෝරාගැනීම සඳහා මෙම මාර්ගෝපදේශයට ආපසු බලන්න. අපි බලාපොරොත්තු වන්නේ මෙම ලිපිය ඔබට ආරක්ෂිත සහ කාර්යක්ෂම Java කේත ලිවීමට උපකාරී වේ යැයි.

7. නිතර අසන ප්‍රශ්න (FAQ)

ප්‍රශ්න 1: Arrays.asList භාවිතයෙන් නිර්මාණය කළ ලැයිස්තුවකට සාධන එකතු කළ හැකිද?

පිළිතුර 1: නැහැ, ඔබට නොහැකිය. Arrays.asList භාවිතයෙන් නිර්මාණය කළ ලැයිස්තුවක ස්ථිර ප්‍රමාණයක් ඇත, එබැවින් add() හෝ remove() කැඳවීම UnsupportedOperationException විසින් දමනය වේ.
කෙසේ වෙතත්, ඔබට set() භාවිතයෙන් පවතින වටිනාකම් ලියා පළ කළ හැකිය.
ඔබට වෙනස් කළ හැකි ලැයිස්තුවක් අවශ්‍ය නම්, එය පහත පරිදි පරිවර්තනය කරන්න:
new ArrayList<>(Arrays.asList(...))

ප්‍රශ්න 2: List.of සහ Arrays.asList අතර වෙනස කුමක්ද?

පිළිතුර 2:

List.of (Java 9+) සම්පූර්ණ අවිනිශ්චිත ලැයිස්තුවක් නිර්මාණය කරයි. කිසිදු වෙනස්කම් ඉඩ නැහැ—set() පවා නොවේ.
Arrays.asList ස්ථිර-ප්‍රමාණය ලැයිස්තුවක් නිර්මාණය කරයි. ඔබට සාධන එකතු හෝ ඉවත් කළ නොහැකි වුවත්, set() භාවිතයෙන් වටිනාකම් ලියා පළ කිරීමට ඉඩ ඇත.

අනෙකුත් බොහෝමයක් add() සහ remove() අවසර නොදෙන වුවත්, List.of ශක්තිමත් අවිනිශ්චිතභාවය සපයයි.
ආරක්ෂාව සහ අවිනිශ්චිතභාවය ප්‍රමුඛ වන විට, List.of නිර්දේශ කෙරේ.

ප්‍රශ්න 3: ලැයිස්තුවක් මුල්ගත කිරීමේදී මුල් ධාරිතාවයක් විශේෂ කිරීමේ වාසි මොනවාද?

පිළිතුර 3:
ArrayList භාවිතා කරන විට, ඔබට බොහෝ සාධන එකතු කිරීමක් අපේක්ෂා කරන විට මුල් ධාරිතාවයක් විශේෂ කිරීම වාසිදායක වේ. එය අභ්‍යන්තර වර්ගීකරණ ආකෘතිගත කිරීම් ක්‍රියාකාරකම් අඩු කරන අතර, කාර්ය සාධනය වැඩි දියුණු කරයි.
ඔබට සාධන ප්‍රමාණයේ ආසන්න වශයෙන් දන්නා නම්, මුල් ධාරිතාවයක් සකස් කිරීම අනවශ්‍ය මතක පුනර්ව්‍යවස්ථාපන වළක්වයි.

ප්‍රශ්න 4: මුල්ගත කිරීම සඳහා ආකෘතිගත මුල්ගත කරන්නා භාවිතා කිරීමේදී මම සැලකිලිමත් විය යුතුයි ඇයි?

පිළිතුර 4:
ආකෘතිගත මුල්ගත කරන්නා පිටුපසදී නිරුපකරණ පන්තියක් නිර්මාණය කරයි.
මෙය තුළින් ඇති විය හැකි:

වැඩි මතක භාවිතය
අඩු නඩත්තුකම
Serialization වේලාවේදී සම්භාව්‍ය ගැටලු

කෙටි සහ සංකීර්ණ ආරම්භකරණය සඳහා පහසු වුවද, මෙය විශාල පරිමාණයේ හෝ කාර්ය සාධනයට සංවේදී පරිසර සඳහා යෝග්‍ය නොවේ.

ප්‍රශ්න 5: LinkedList එකක් කෙසේ ආරම්භ කළ යුතුද?

පිළිතුර 5:
LinkedList ආරම්භකරණය ArrayList වලට සමානව ක්‍රියා කරයි. උදාහරණයක් ලෙස:
List<String> list = new LinkedList<>();
ඔබට වෙනත් ක්‍රම භාවිතයෙන් LinkedList එකක් ආරම්භ කළ හැකිය:

new LinkedList<>(existingList)
Arrays.asList හෝ List.of භාවිතයෙන් පරිවර්තනය සමග

අපි බලාපොරොත්තු වන්නේ මෙම FAQ කොටස ඔබගේ ප්‍රශ්නවලට පිළිතුරු ලබා දීමට උපකාරී වේවි.
List ආරම්භකරණය තේරුම් ගැනීම cleaner, safer, සහ වඩා කාර්යක්ෂම Java සංවර්ධනයට සහාය වනු ඇත.