Java වල ArrayList සහ LinkedList: කවදාද මොනවා පාවිච්චි කරන්නේ? SC ගයිඩ් එකක්!

හායි යාළුවනේ! කොහොමද ඉතින්? අද අපි කතා කරන්න යන්නේ Java වල ගොඩක්ම වැදගත් concepts දෙකක් ගැන. ඒ තමයි ArrayList සහ LinkedList.

ගොඩක් වෙලාවට අලුතින් programming පටන් ගන්න අයට වගේම, පොඩ්ඩක් ඉගෙන ගත්ත අයටත් මේ දෙක ගැන පොඩි ව්‍යාකූලත්වයක් තියෙනවා. කවදාද මොනවා පාවිච්චි කරන්නේ කියලා හරි තේරෙන්නේ නැහැ. ඉතින් අපි අද මේ දෙක හොඳටම compare කරලා, කවදාද මොනවා පාවිච්චි කරන්නේ කියලා practical විදියට බලමු.

කෝපි කෝප්පයක් හදාගෙන, හොඳට relax වෙලා, මේ ලිපිය කියවන්න පටන් ගන්න!

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

හරි, මුලින්ම බලමු ArrayList කියන්නේ මොකක්ද කියලා. සරලවම කිව්වොත්, ArrayList කියන්නේ dynamic array එකක්. "dynamic" කියන්නේ මොකක්ද? සාමාන්‍ය Array එකක size එක අපි මුලින්ම කියන්න ඕනේ. ඒත් ArrayList එකක එහෙම නෑ. අවශ්‍ය වුණාම ඕකේ size එක automate වෙනවා. මාරම පහසුයි නේද?

ArrayList එක වැඩ කරන්නේ කොහොමද?

ArrayList එක ඇතුළෙන් වැඩ කරන්නේ සාමාන්‍ය Array එකක් වගේමයි. නමුත් විශේෂත්වය තමයි, ඔයා item එකක් add කරනකොට Array එක පිරෙනවා නම්, ArrayList එක automate එකෙන් අලුත් ලොකු Array එකක් හදලා, පරණ Array එකේ තියෙන data ටික අලුත් එකට copy කරනවා. මේක ටිකක් වෙලා යන වැඩක්. හරිද?

ArrayList වල වාසි සහ අවාසි (Pros and Cons)

• වාසි (Pros):
  • ඉක්මන් ප්‍රවේශය (Fast Random Access): Index එකක් දීලා ඕනෑම item එකක් ඉක්මනින් ගන්න පුළුවන්. උදාහරණයක් විදියට, myArrayList.get(5) කිව්වොත් ක්ෂණිකව 5 වෙනි index එකේ තියෙන item එක ලැබෙනවා. මේක වෙන්නේ O(1) time complexity එකකින්.
  • Compact Memory: Memory එකේ එක ළඟ තියෙන නිසා cache locality හොඳයි.
• අවාසි (Cons):
  • මැදට දාන/අයින් කරනකොට මන්දගාමී වීම (Slow Insertions/Deletions in the Middle): ඔයා item එකක් ArrayList එකේ මැදට add කරනවා නම්, ඒ තැනින් පස්සේ තියෙන හැම item එකක්ම එක තැනක් පස්සට තල්ලු කරන්න වෙනවා. අයින් කරනකොටත් ඒ වගේමයි. මේක වෙන්නේ O(n) time complexity එකකින්.
  • Size Resizing Overhead: ArrayList එක පිරෙනකොට අලුත් Array එකක් හදලා data copy කරන එකට කාලයක් සහ resource යනවා.

ArrayList උදාහරණයක්

මෙන්න පොඩි code කෑල්ලක් ArrayList එකක් කොහොමද පාවිච්චි කරන්නේ කියලා.

import java.util.ArrayList;

public class ArrayListExample {
    public static void main(String[] args) {
        // ArrayList එකක් හදනවා String object save කරන්න
        ArrayList<String> fruitList = new ArrayList<>();

        // Items add කරනවා
        fruitList.add("Apple");
        fruitList.add("Banana");
        fruitList.add("Orange");
        fruitList.add(1, "Grape"); // 1 වෙනි index එකට Grape add කරනවා (Banana පස්සට යනවා)

        System.out.println("Fruit List: " + fruitList); // Output: [Apple, Grape, Banana, Orange]

        // Item එකක් ගන්නවා
        String firstFruit = fruitList.get(0);
        System.out.println("First Fruit: " + firstFruit); // Output: Apple

        // Item එකක් remove කරනවා
        fruitList.remove("Banana"); // Banana remove කරනවා
        System.out.println("Fruit List after removing Banana: " + fruitList); // Output: [Apple, Grape, Orange]

        // Size එක බලනවා
        System.out.println("Size of fruitList: " + fruitList.size()); // Output: 3
    }
}

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

දැන් බලමු LinkedList එක ගැන. LinkedList කියන්නේ doubly-linked list එකක්. අයියෝ, ඒ මොකක්ද දැන්? කලබල වෙන්න එපා. හරිම සරලයි.

LinkedList එක වැඩ කරන්නේ කොහොමද?

LinkedList එකේ data save කරන්නේ nodes විදියට. හැම node එකකම item එකක් සහ ඒ item එකට කලින් තියෙන node එකටයි, පස්සේ තියෙන node එකටයි pointer එකක් තියෙනවා. මේක දාමයක් වගේ. එක node එකක් තව node එකකට connect වෙලා තියෙන්නේ pointers වලින්. Memory එකේ එක ළඟ තියෙන්න ඕනේ කියලා නීතියක් නෑ.

LinkedList වල වාසි සහ අවාසි (Pros and Cons)

• වාසි (Pros):
  • ඉක්මන් Insertion/Deletion (Fast Insertions/Deletions): ඔයාට item එකක් ඕනෑම තැනකට add කරන්න හරි remove කරන්න හරි පුළුවන් ඉක්මනට. ඒකට කරන්න තියෙන්නේ අදාළ node එකේ pointers ටික විතරක් වෙනස් කරන එකයි. අනික ඒවා copy කරන්න අවශ්‍ය නෑ. මේක වෙන්නේ O(1) time complexity එකකින්.
• අවාසි (Cons):
  • මන්දගාමී ප්‍රවේශය (Slow Random Access): Index එකක් දීලා item එකක් ගන්න යනකොට LinkedList එක මුල ඉඳන්ම ඒ index එකට එනකම් ගමන් කරන්න ඕනේ. මේකට වෙලා යනවා. මේක O(n) time complexity එකක්.
  • වැඩි Memory පරිභෝජනය (More Memory Usage): හැම node එකකටම data එකයි, previous pointer එකයි, next pointer එකයි තියෙන නිසා ArrayList එකට වඩා වැඩි memory ප්‍රමාණයක් අවශ්‍ය වෙනවා.
  • Cache Performance: Memory එකේ එක ළඟ නැති නිසා cache locality එච්චර හොඳ නැහැ.

LinkedList උදාහරණයක්

මෙන්න LinkedList එකක් පාවිච්චි කරන විදිය.

import java.util.LinkedList;

public class LinkedListExample {
    public static void main(String[] args) {
        // LinkedList එකක් හදනවා String object save කරන්න
        LinkedList<String> studentNames = new LinkedList<>();

        // Items add කරනවා
        studentNames.add("Nimal");
        studentNames.add("Kamal");
        studentNames.add("Sunil");
        studentNames.addFirst("Amara"); // මුලට Amara add කරනවා
        studentNames.addLast("Saman");   // අගට Saman add කරනවා

        System.out.println("Student Names: " + studentNames); // Output: [Amara, Nimal, Kamal, Sunil, Saman]

        // Item එකක් ගන්නවා (මේක මන්දගාමී වෙන්න පුළුවන්)
        String thirdStudent = studentNames.get(2);
        System.out.println("Third Student: " + thirdStudent); // Output: Kamal

        // මුලින්ම තියෙන එක remove කරනවා
        studentNames.removeFirst();
        System.out.println("After removing first student: " + studentNames); // Output: [Nimal, Kamal, Sunil, Saman]

        // අගින්ම remove කරනවා
        studentNames.removeLast();
        System.out.println("After removing last student: " + studentNames); // Output: [Nimal, Kamal, Sunil]
    }
}

කවදාද මොනවා පාවිච්චි කරන්නේ? (When to Use Which?)

හරි, දැන් තමයි ප්‍රශ්නේ. මේ දෙකෙන් මොකක්ද පාවිච්චි කරන්නේ? තීරණය රඳා පවතින්නේ ඔයාගේ application එක කරන දේවල් අනුව.

• ArrayList පාවිච්චි කරන්න:
  • ඔයාට නිතරම item එකක් index එකකින් හොයන්න (get කරන්න) අවශ්‍ය නම්. උදාහරණයක් විදියට, students ලාගේ නම් list එකක, 5 වෙනි student ගේ නම ඕනේ වගේ අවස්ථාවක.
  • ArrayList එකට add කරන සහ remove කරන ගමන් මෙහෙයුම් ටිකක් අඩු නම්, ඒ කියන්නේ ගොඩක් වෙලාවට data කියවනවා (read කරනවා) නම්.
  • ඉහළ memory ප්‍රමාණයක් අවශ්‍ය නොවන අවස්ථාවල.
• LinkedList පාවිච්චි කරන්න:
  • ඔයාට නිතරම item එකක් මැදට add කරන්න හරි remove කරන්න හරි අවශ්‍ය නම්. උදාහරණයක් විදියට, music playlist එකක song එකක් මැදට දානවා, නැත්තම් අයින් කරනවා වගේ අවස්ථාවක.
  • ඔයාට Queue (පෝලිමක්) හෝ Deque (ද්වි-අන්ත පෝලිමක්) වගේ data structure එකක් විදියට පාවිච්චි කරන්න අවශ්‍ය නම් (addFirst(), removeFirst(), addLast(), removeLast() වගේ operations වලට LinkedList එක ගොඩක්ම කාර්යක්ෂමයි).
  • Memory usage එක ගැන එච්චරම ප්‍රශ්නයක් නැති අවස්ථාවල.

ප්‍රායෝගික උදාහරණ (Practical Scenarios)

උදාහරණය 1: Student Marks List එකක් (ArrayList is Good)

හිතන්න, ඔයාට සිසුන් පිරිසකගේ විභාග ලකුණු save කරන්න ඕනේ කියලා. නිතරම වෙන්නේ student කෙනෙක්ගේ index එක දීලා එයාගේ ලකුණු ගන්න එක. අලුතින් student ලා add කරනවා හරි remove කරනවා හරි කියන එක වෙන්නේ අඩුවෙන්.

// Student marks save කරන්න ArrayList එකක්
ArrayList<Integer> examMarks = new ArrayList<>();
examMarks.add(85); // Student 1
examMarks.add(72); // Student 2
examMarks.add(90); // Student 3

// 2 වෙනි student ගේ ලකුණු ගන්නවා - මේක ArrayList එකට හොඳයි
int student2Marks = examMarks.get(1); // O(1)
System.out.println("Student 2's Marks: " + student2Marks);

උදාහරණය 2: Music Playlist එකක් (LinkedList is Good)

හිතන්න, ඔයා music player එකක් හදනවා කියලා. Playlist එකකට songs add කරනවා, delete කරනවා, playlist එකේ මැදට songs rearrange කරනවා වගේ operations නිතරම කරනවා නම්.

// Music playlist එකක් LinkedList එකක් විදියට
LinkedList<String> myPlaylist = new LinkedList<>();
myPlaylist.add("Shape of You");
myPlaylist.add("Blinding Lights");
myPlaylist.add("Levitating");

// මැදට අලුත් song එකක් add කරනවා - LinkedList එකට හොඳයි
myPlaylist.add(1, "Old Town Road"); // O(1)
System.out.println("Updated Playlist: " + myPlaylist);

// මැදින් song එකක් remove කරනවා - Blinding Lights remove වෙනවා
myPlaylist.remove("Blinding Lights"); 
System.out.println("Playlist after removing song: " + myPlaylist);

අවසාන වශයෙන් (In Conclusion)

ඉතින් යාළුවනේ, ArrayList සහ LinkedList කියන්නේ Java වල Collection Framework එකේ තියෙන ගොඩක්ම ප්‍රයෝජනවත් data structures දෙකක්. මේ දෙකේම තියෙන වාසි සහ අවාසි තේරුම් අරගෙන, ඔයා හදන application එකට ගැලපෙන එක තෝරා ගන්න එක තමයි Smart Developer කෙනෙක්ගේ වැඩේ.

කිසිම වෙලාවක "මේක තමයි හොඳම එක" කියලා එකක් නෑ. තියෙන්නේ "මේ අවස්ථාවට ගැලපෙන හොඳම එක" කියන එක විතරයි. මේ article එකෙන් ඔයාලට ArrayList සහ LinkedList ගැන හොඳ අවබෝධයක් ලැබෙන්න ඇති කියලා හිතනවා.

මේ ගැන ඔයාලට තව මොනවා හරි දැනගන්න ඕනේ නම්, නැත්තම් මේ article එක ගැන ඔයාලගේ අදහස් පහළින් comment එකක් දාගෙන යන්න! අපි ඊළඟ article එකෙන් හමුවෙමු! Happy Coding!