1. හැඳින්වීම
Java හි වැඩසටහන් ලියන විට, List යනු බොහෝමයක් භාවිතා කරන සහ වැදගත් දත්ත ව්යුහයන්ගෙන් එකකි. List එකක් භාවිතා කිරීමෙන් ඔබට අයිතම බහුලව අනුක්රමයෙන් ගබඩා කර, අවශ්ය පරිදි අයිතම එකතු කිරීම, ඉවත් කිරීම, සහ අංග සොයා ගැනීම වැනි ක්රියාකාරකම් පහසුවෙන් සිදු කළ හැක.
කෙසේ වෙතත්, List ගොඩනැගීම ප්රභාවී ලෙස භාවිතා කිරීමට, ආරම්භක ක්රම සම්පූර්ණයෙන් අවබෝධ කර ගැනීම අත්යවශ්යය. වැරදි ආරම්භක කිරීම අනපේක්ෂිත දෝෂ හෝ බග්ස් ඇති කරමින්, කියවීමට සහ නඩත්තු කිරීමට ඇති හැකියාවට වැදගත් බලපෑම් සිදු කරයි.
මෙම ලිපියේ, අපි “Java List ආරම්භක කිරීම” යන මාතෘකාවට අවධානය යොමු කර, ආරම්භක-හිතකාමී මූලික ආරම්භක ක්රමවලින් පටන් ගනිමින්, ප්රායෝගික තාක්ෂණ සහ පොදු වැරදි පිළිබඳ සියල්ල පැහැදිලි කරමු. Java සංස්කරණ අතර වෙනස්කම් සහ සැබෑ ලෝක කේතන අවස්ථා මත පදනම් වූ හොඳම ක්රියාමාර්ගද අපි ආවරණය කරමු.
ඔබ Java ඉගෙන ගැනීමට නවකයෙක් වුවත්, හෝ List ගොඩනැගීම නිතර භාවිතා කරන කෙනෙක් වුවත්, මෙම ලිපිය විවිධ ආරම්භක රටාවන් සමාලෝචනය කර සංවිධානය කිරීමට හොඳ අවස්ථාවකි.
අවසන් වශයෙන්, සාමාන්ය ප්රශ්න සහ ගැටළු විසඳීමට FAQ කොටසක් සපයනු ලැබේ.
2. මූලික List ආරම්භක ක්රම
Java හි List භාවිතා කිරීම ආරම්භ කරන විට, පළමු පියවර “හිස් List” එකක් සෑදීමයි, එනම් List එක ආරම්භ කිරීම. මෙහි, අපි සාමාන්යතම ක්රියාත්මක කිරීම වන ArrayList භාවිතා කර මූලික ආරම්භක ක්රම පැහැදිලි කරමු.
2.1 new ArrayList<>() භාවිතා කර හිස් List එකක් සෑදීම
new ArrayList<>() භාවිතා කරමින් කරන ලද ආරම්භක කිරීම වඩාත්ම සාමාන්යය වන අතර, පහත පරිදි ලියයි:
List<String> list = new ArrayList<>();
මෙය අංග කිසිවක් නොමැති හිස් List එකක් සෑදේ.
ප්රධාන කරුණු:
Listයනු අතුරුමුහුණතක් වන අතර, ඔබටArrayListහෝLinkedListවැනි නිරුපිත පන්තියක් උදාහරණයක් ලෙස නිර්මාණය කළ හැක.- ආකාරශීලීත්වය සඳහා, වෙනස්කම
Listලෙස ප්රකාශ කිරීම සාමාන්යයෙන් නිර්දේශ කරයි.
2.2 නියමිත ආරම්භක ධාරිතාව සමඟ ආරම්භක කිරීම
ඔබට විශාල දත්ත ගබඩා කිරීමට හෝ අංග ගණන දැනටමත් දැන සිටින විට, ආරම්භක ධාරිතාව නියම කිරීම කාර්යක්ෂමතාව වැඩි කරයි.
උදාහරණය:
List<Integer> numbers = new ArrayList<>(100);
මෙය අභ්යන්තරයෙන් 100 අංග සඳහා ඉඩ වෙන් කරයි, අයිතම එකතු කිරීමේදී ප්රතිසංස්කරණ වියදම් අඩු කර, කාර්යක්ෂමතාව වැඩි කරයි.
2.3 LinkedList ආරම්භක කිරීම
ඔබගේ අවශ්යතා අනුව LinkedList භාවිතා කළ හැක. භාවිතය සමාන වේ:
List<String> linkedList = new LinkedList<>();
LinkedList අංග නිතර එකතු කිරීම හෝ ඉවත් කිරීම සිදුවන අවස්ථා වල විශේෂයෙන් ප්රයෝජනවත් වේ.
Java හි new ArrayList<>() හෝ new LinkedList<>() භාවිතා කර හිස් List ආරම්භ කිරීම පහසු කරයි.
3. ආරම්භක අගයන් සමඟ List සෑදීම
බොහෝ අවස්ථාවල, ඔබට ආරම්භක අගයන් සමඟ List එකක් සෑදීමට අවශ්ය විය හැක. පහත මූලික ආරම්භක රටාවන් සහ ඒවායේ ලක්ෂණ දැක්වේ.
3.1 Arrays.asList() භාවිතා කිරීම
Java හි බොහෝමයක් භාවිතා කරන ක්රමයක් වන Arrays.asList() වේ.
උදාහරණය:
List<String> list = Arrays.asList("A", "B", "C");
මෙය ආරම්භක අගයන් සමඟ List එකක් සෑදේ.
වැදගත් සටහන්:
- ආපසු ලැබෙන List එක ස්ථාවර-ප්රමාණ වන අතර, එහි දිග වෙනස් කළ නොහැක.
add()හෝremove()ඇමතුම් කිරීමUnsupportedOperationExceptionනාමික දෝෂයක් ඇති කරයි. - අංග වෙනස් කිරීම (
set()භාවිතා කිරීම) ඉඩ ඇත.
3.2 List.of() භාවිතා කිරීම (Java 9+)
Java 9 සිට, List.of() භාවිතා කර අවලංගු List (immutable) පහසුවෙන් සෑදිය හැක:
List<String> list = List.of("A", "B", "C");
ලක්ෂණ:
- සම්පූර්ණයෙන්ම අවලංගු List—
add(),set(), සහremove()සියල්ල තහනම් වේ. - ඉතා කියවීමට පහසු සහ ස්ථාවර අගයන් සඳහා සුදුසු.
3.3 Arrays.asList() වෙතින් Mutable List එකක් සෑදීම
ඔබට ආරම්භක අගයන් සමඟ List එකක් අවශ්ය වන අතර, පසුකාලීනව එය වෙනස් කිරීමට අවශ්ය නම්, මෙම ක්රමය ප්රයෝජනවත් වේ:
List<String> list = new ArrayList<>(Arrays.asList("A", "B", "C"));
මෙය mutable List එකක් සෑදේ.
add()සහremove()සාමාන්ය ලෙස ක්රියා කරයි.
3.4 Double-Brace ආරම්භක කිරීම
අනොනීම් පන්තියක් භාවිතා කරන උසස් තාක්ෂණයක්:
List<String> list = new ArrayList<>() {{
add("A");
add("B");
add("C");
}};
විශේෂත්වයන් සහ අනතුරු ඇඟවීම්:
- සංකුචිත කේතයක් නිර්මාණය කරයි, නමුත් අනාමික පන්තියක් හේතුවෙන් අතිරේක පරිභාරයක් සහ මතක ලීක් එකක් ඇති විය හැක.
- ඉක්මන් ප්රදර්ශන හෝ පරීක්ෂණ කේත සඳහා පමණක් භාවිතා කරන්න; නිෂ්පාදනය සඳහා නිර්දේශ නොකෙරේ.
මෙය Java ඔබේ අවශ්යතා අනුව ආරම්භක අගයන් සමඟ List ගොඩනැගීමට විවිධ ක්රම ලබා දෙන බව පෙන්වයි.
5. සසඳුම් සහ තේරීම් මාර්ගෝපදේශය
Java විවිධ List ආරම්භක ක්රම ලබා දේ, සහ හොඳම තේරීම භාවිතා නිරූපණය මත පදනම් වේ. මෙම කොටස එක් එක් ක්රමය සාරාංශ කරයි සහ කවදා කුමන ක්රමය තෝරා ගත යුතුද යන්න පැහැදිලි කරයි.
5.1 වෙනස් කළ හැකි List සහ වෙනස් කළ නොහැකි List
- වෙනස් කළ හැකි List
- අංග එකතු කිරීම, ඉවත් කිරීම, හෝ වෙනස් කිරීම කළ හැක.
- උදාහරණ:
new ArrayList<>(),new ArrayList<>(Arrays.asList(...)) - ලූප් තුළ අයිතම එකතු කිරීම වැනි ගතික මෙහෙයුම් සඳහා හොඳයි.
- වෙනස් කළ නොහැකි List
- එකතු කිරීම, මකා දැමීම, හෝ වෙනස් කිරීම නොහැක.
- උදාහරණ:
List.of(...),Collections.singletonList(...),Collections.nCopies(...) - ස්ථිර අගයන් හෝ ආරක්ෂිත අගයන් පාරිභෝගික කිරීම සඳහා සුදුසුයි.
5.2 පොදු ක්රමවල සසඳුම් වගුව
| Method | Mutability | Java Version | Characteristics / Use Cases |
|---|---|---|---|
new ArrayList<>() | Mutable | All Versions | Empty List; add elements freely |
Arrays.asList(...) | Fixed Size | All Versions | Has initial values but size cannot change |
new ArrayList<>(Arrays.asList(...)) | Mutable | All Versions | Initial values + fully mutable; widely used |
List.of(...) | Immutable | Java 9+ | Clean immutable List; no modifications allowed |
Collections.singletonList(...) | Immutable | All Versions | Immutable List with a single value |
Collections.nCopies(n, obj) | Immutable | All Versions | Initialize with n identical values; useful for testing |
Stream.generate(...).limit(n) | Mutable | Java 8+ | Flexible pattern generation; good for random or sequential data |
5.3 භාවිත නිරූපණය අනුව නිර්දේශිත ආරම්භක රටා
- ඔබට හිස් List එකක් අවශ්ය වන විට
new ArrayList<>()- ආරම්භක අගයන් අවශ්ය වන අතර පසුකාලීනව වෙනස් කිරීමට අවශ්ය නම්
new ArrayList<>(Arrays.asList(...))- එය ස්ථිර අගයක් ලෙස භාවිතා කර, වෙනස් නොකිරීමට අවශ්ය නම්
List.of(...)(Java 9+)Collections.singletonList(...)- එකම අගයක් සමඟ නියමිත සංඛ්යාවක් අවශ්ය නම්
Collections.nCopies(n, value)- අගයන් ගතිකව ජනනය කළ යුතු නම්
Stream.generate(...).limit(n).collect(Collectors.toList())
5.4 වැදගත් සටහන්
- වෙනස් කළ නොහැකි හෝ නියම-ප්රමාණ List එකක් වෙනස් කිරීමට උත්සාහ කිරීමෙන් දෝෂ (exception) සිදුවේ.
- ඔබේ අවශ්ය වෙනස්කම් සහ Java අනුවාදය අනුව සුදුසු ක්රමය තෝරන්න.
නිවැරදි ආරම්භක ක්රමය තේරීම අනපේක්ෂිත දෝෂ වැළැක්වීමට සහ කියවීමට පහසුකම, ආරක්ෂාව වැඩි කිරීමට උපකාරී වේ.
6. පොදු දෝෂ සහ ඒවා සකස් කිරීමේ ක්රම
List ආරම්භ කිරීම හෝ භාවිත කිරීමේදී නිතර සිදුවන දෝෂ ඇත. මෙන්න පොදු උදාහරණ සහ ඒවාගේ විසඳුම්.
6.1 UnsupportedOperationException
සාමාන්ය අවස්ථා:
Arrays.asList(...)මගින් සාදන ලද List එකකටadd()හෝremove()කැඳවීමList.of(...),Collections.singletonList(...),Collections.nCopies(...)මගින් සාදන ලද List එක වෙනස් කිරීම
උදාහරණ:
List<String> list = Arrays.asList("A", "B", "C");
list.add("D"); // Throws UnsupportedOperationException
කාරණය:
- මෙම ක්රමයන් මගින් ප්රමාණය වෙනස් කළ නොහැකි හෝ සම්පූර්ණයෙන්ම වෙනස් කළ නොහැකි List ගොඩනැගේ.
විසඳුම:
- වෙනස් කළ හැකි List එකක් ලෙස වැටුප් කරන්න:
new ArrayList<>(Arrays.asList(...))
6.2 NullPointerException
සාමාන්ය අවස්ථාව:
- කිසිදා ආරම්භ නොකළ List එකක් ප්රවේශ කිරීම
උදාහරණ:
List<String> list = null;
list.add("A"); // NullPointerException
කාරණය:
nullයොමුකිරීමකට මත ක්රමයක් කැඳවීම.
විසඳුම:
- භාවිතයට පෙර සෑම විටම ආරම්භ කරන්න:
List<String> list = new ArrayList<>();
6.3 වර්ග-සම්බන්ධ ගැටළු
- Generics නොමැති List එකක් සාදීමෙන් රන්ටයිම් වර්ග දෝෂයන්ගේ අවදානම වැඩි වේ.
උදාහරණ:
List list = Arrays.asList("A", "B", "C");
Integer i = (Integer) list.get(0); // ClassCastException
විසඳුම:
- හැකි තරම් Generics භාවිතා කරන්න.
මෙම පොදු දෝෂ අවබෝධ කර ගැනීමෙන් List ආරම්භ කිරීම හෝ භාවිත කිරීමේදී ගැටළු වැළැක්වීමට ඔබට උපකාරී වේ.
7. සාරාංශය
මෙම ලිපිය Java හි විවිධ List ආරම්භක ක්රම සහ නිවැරදි ක්රම තේරීම පිළිබඳ විස්තර කරයි.
අපි ආවරණය කළේ:
- මූලික හිස් List නිර්මාණය
new ArrayList<>()සහnew LinkedList<>()භාවිතා කරමින් - ආරම්භක අගයන් සමඟ List
Arrays.asList(),List.of(), සහnew ArrayList<>(Arrays.asList(...))භාවිතා කරමින් - විශේෂ ආරම්භක රටා
Collections.singletonList(),Collections.nCopies(), සහStream.generate()වැනි - වෙනස් කළ හැකි සහ වෙනස් කළ නොහැකි List අතර ප්රධාන වෙනස්කම්
- සාමාන්ය වැරදි සහ දෝෂ හසුරුවීම
ලැයිස්තු ආරම්භක කිරීම සරල බව පෙනේදත්, මෙම වෙනස්කම් තේරුම් ගැනීම සහ නිවැරදි ක්රමය තේරීම ආරක්ෂිත සහ කාර්යක්ෂම කේත ලිවීම සඳහා අත්යවශ්ය වේ.
8. FAQ (නිතර අසන ප්රශ්න)
Q1: Arrays.asList() භාවිතයෙන් සාදන ලද List එකකට අංග එකතු කළ හැදියිද?
A1: නැත. Arrays.asList() ස්ථාවර-ප්රමාණ List එකක් ලබා දෙයි. add() හෝ remove() කැඳවීම UnsupportedOperationException එකක් නිකුත් කරයි. වෙනස් කළ හැකි List එකක් සඳහා new ArrayList<>(Arrays.asList(...)) භාවිතා කරන්න.
Q2: List.of() සහ Arrays.asList() අතර වෙනස මොනවාද?
List.of()(Java 9+) → සම්පූර්ණයෙන්ම වෙනස් කළ නොහැකි;set()ද භාවිතා කළ නොහැක.Arrays.asList()→ ස්ථාවර-ප්රමාණ, නමුත්set()භාවිතා කළ හැක.
Q3: Double‑Brace ආරම්භක කිරීම භාවිතා කළ යුතුද?
A3: එය නිර්දේශ නොකෙරේ, මන්ද එය අනාමික පන්තියක් නිර්මාණය කර මතක රැස්වීම් (memory leaks) ඇති විය හැකි බැවින්. ඒ වෙනුවට සාමාන්ය ආරම්භක කිරීම භාවිතා කරන්න.
Q4: ආරම්භක ධාරිතාවක් නියම කිරීමේ ප්රතිලාභ මොනවාද?
A4: බොහෝ අංග එකතු කරන විට අභ්යන්තර ප්රති‑ප්රමාණය (resizing) අඩු කරයි, එමඟින් කාර්යක්ෂමතාව වැඩි වේ.
Q5: List ආරම්භක කිරීමේදී සෑම විටම ජනරූප (generics) භාවිතා කළ යුතුද?
A5: නියමයෙන්. ජනරූප භාවිතා කිරීම වර්ග ආරක්ෂාව වැඩි කරයි සහ ක්රියාකාලීන දෝෂ වලින් වැළැක්වෙයි.
Q6: ආරම්භක නොකළ List එකක් භාවිතා කළහොත් කුමක් වේද?
A6: එය මතකයේ NullPointerException එකක් ඇති කරයි. පළමුව ආරම්භක කිරීම අනිවාර්යයි.
Q7: List ආරම්භක කිරීමේ සංස්කරණ වෙනස්කම් තිබේද?
A7: ඔව්. List.of() Java 9 සහ ඊට පසු සංස්කරණ වල පමණක් ලබා ගත හැක.
