Java Collections Framework: List, Set, Map හැඳින්වීම | SC Guide

හලෝ යාළුවනේ, කොහොමද ඉතින්? Java Programming වලට ආස කරන, නැත්නම් මේ දවස්වල Software Engineering ලෝකේ කරක් ගහන ඔයාලා හැමෝටම ගොඩක් වැදගත් වෙන මාතෘකාවක් ගැන තමයි අද අපි කතා කරන්න යන්නේ. ඒ තමයි Java Collections Framework. ඇත්තටම, මේක Java වල Data Management වලට තියෙන කොඳු නාරටිය වගේ. හරියට ඔයාගේ පොත් රාක්කේ, නැත්නම් එළවළු කඩේ ගොඩගහලා තියෙන එළවළු වගේ, දත්ත ගොඩක් එක විදිහකට, පිළිවෙලකට, නැත්නම් විශේෂ අවශ්‍යතාවක් අනුව ගබඩා කරලා තියාගන්න තමයි මේකෙන් පුළුවන් වෙන්නේ.

හිතන්න, ඔයා Software එකක් හදනවා. ඒකේ User Details ටිකක්, නැත්නම් Product List එකක්, නැත්නම් Student Marks වගේ ගොඩක් දත්ත තියෙනවා. මේ හැමදේම තනි තනි Variable වල දාගෙන ඉන්න පුළුවන්ද? බැහැනේ මචං! ඒක ප්‍රායෝගික නැහැ. එතකොට තමයි Collections Framework එක අපිට අත දෙන්නේ. මේකෙන් අපිට පුළුවන් දත්ත ටික එකතු කරලා, ඕන විදිහකට Organize කරලා, පහසුවෙන් ඒවාට Access කරන්න, Update කරන්න, Delete කරන්න වගේ දේවල් කරන්න. අද අපි මේ Framework එකේ තියෙන ප්‍රධාන කොටස් තුනක් ගැන කතා කරමු: List, Set, සහ Map.

Collections Framework එක මොකක්ද?

සරලවම කිව්වොත්, Java Collections Framework එක කියන්නේ java.util පැකේජ් එකේ තියෙන interfaces සහ classes ගොඩක් එකතුවක්. මේකෙන් අපිට Data Structures හසුරවන්න අවශ්‍ය සම්මත ක්‍රමවේදයක් සපයනවා. මේක පාවිච්චි කරන එකෙන් අපිට ලැබෙන වාසි ගොඩයි:

• වැඩ අඩු වෙනවා: දත්ත කළමනාකරණයට අවශ්‍ය algorithms අපිට අලුතෙන් ලියන්න ඕන නැහැ. මේ Framework එකේ ඒ හැමදේම තියෙනවා.
• Performance වැඩි වෙනවා: මේ Framework එකේ තියෙන implementations හදලා තියෙන්නේ උපරිම efficiency ලබාගන්න විදිහට.
• Interoperability: විවිධ APIs අතර දත්ත හුවමාරු කරගන්න පහසු වෙනවා.

මේ Framework එකේ මූලිකම Interface එක තමයි Collection. මේකෙන් තමයි අනිත් හැම Interface එකක්ම වගේ Extend වෙන්නේ. නමුත් අද අපි විශේෂයෙන් කතා කරන්නේ ඒ Collection Interface එකේ ප්‍රධානම Sub-interfaces තුනක් ගැනයි.

List - දත්ත අනුපිළිවෙලට තියාගන්න

List කියන්නේ ordered collection එකක්. ඒ කියන්නේ අපි දත්ත දාන පිළිවෙලටම තමයි ඒක ඇතුළෙත් දත්ත ගබඩා වෙන්නේ. මේකේ තවත් විශේෂත්වයක් තමයි duplicate elements දාන්න පුළුවන් වීම. හරියට පොත් රාක්කයක් වගේ, පොත් අංකෙට තියෙනවා. එකම පොත දෙපාරක් තිබ්බත් අවුලක් නැහැ.

List Interface එකේ ප්‍රධානම Implementations දෙක තමයි:

• ArrayList: මේක dynamic array එකක් වගේ. දත්ත index එකකින් ටක් ගාලා අල්ලගන්න පුළුවන්. ඒ කියන්නේ random access වලට මේක සුපිරි. හැබැයි, ලැයිස්තුවේ මැදට දත්තයක් දාන්න, නැත්නම් අයින් කරන්න ඕන නම් පොඩ්ඩක් Slow වෙන්න පුළුවන්, මොකද ඒ වෙලාවට අනිත් දත්ත ටික එහාට මෙහාට කරන්න වෙන නිසා. ගොඩක් වෙලාවට අපි වැඩියෙන් පාවිච්චි කරන්නේ මේක තමයි.
• LinkedList: මේක doubly-linked list එකක්. ArrayList එකට වඩා මේකේ වාසිය තමයි ලැයිස්තුවේ මැදට දත්ත දාන එකයි, අයින් කරන එකයි ගොඩක් වේගවත් වීම. හැබැයි random access වලට නම් ArrayList එක තරම්ම වේගවත් නැහැ. දත්ත මැද්දෙන් දාන්න, අයින් කරන්න ගොඩක් තියෙනවා නම් මේක තමයි ගොඩක් හොඳ.

මෙන්න ArrayList එකක් පාවිච්චි කරන පොඩි Code Example එකක්:

import java.util.ArrayList;
import java.util.List;

public class ListExample {
    public static void main(String[] args) {
        // String type list එකක් හදනවා
        List<String> studentNames = new ArrayList<>();

        // නම් List එකට එකතු කරනවා
        studentNames.add("කමල්");
        studentNames.add("සුනිල්");
        studentNames.add("අයෝමි");
        studentNames.add("කමල්"); // Duplicate එකක්, List එකට අවුලක් නැහැ!

        System.out.println("මුළු ශිෂ්‍ය සංඛ්‍යාව: " + studentNames.size());

        // පළවෙනි ශිෂ්‍යයා කවුද කියලා හොයනවා (index 0)
        System.out.println("පළවෙනි ශිෂ්‍යයා: " + studentNames.get(0));

        System.out.println("සියලුම ශිෂ්‍යයෝ:");
        // List එකේ තියෙන හැම නමක්ම Print කරනවා
        for (String name : studentNames) {
            System.out.println(name);
        }

        // "සුනිල්" කියන නම List එකෙන් අයින් කරනවා
        studentNames.remove("සුනිල්");
        System.out.println("සුනිල්ව අයින් කළාට පස්සේ: " + studentNames);
    }
}

Set - අද්විතීය දත්ත වලට

Set කියන්නේ unordered collection එකක්. ඒ කියන්නේ දත්ත තියෙන්නේ මොන පිළිවෙලටද කියලා කියන්න බැහැ (නමුත් සමහර Implementations වල පිළිවෙලක් තියෙනවා). මේකේ තියෙන ලොකුම වාසිය තමයි, එකම දත්තයක් දෙපාරක් දාන්න බැරි එක. ඒ කියන්නේ duplicate data බෑ බෑ... Unique වෙන්නම ඕන. ඉතින් duplicate data වලින් ගැලවෙන්න මේක සුපිරි. හරියට පාසලේ ක්‍රීඩා උළෙලකදී සහභාගී වෙන ළමයින්ගේ නම් ලැයිස්තුවක් වගේ. එක ළමයෙක් දෙපාරක් ලියාපදිංචි වෙන්න බැහැනේ.

Set Interface එකේ ප්‍රධානම Implementations තුනක් තමයි:

• HashSet: මේක තමයි වැඩියෙන්ම පාවිච්චි කරන Set Implementation එක. මේකේ performance සුපිරි, මොකද hashing mechanism එකක් පාවිච්චි කරන නිසා. හැබැයි දත්ත තියෙන්නේ unordered විදිහට. වැඩේ ඉක්මනට කරන්න ඕන නම් මේක තමයි පාර.
• LinkedHashSet: මේක HashSet එක වගේම තමයි, හැබැයි මේකේ insertion order එක Maintain කරනවා. ඒ කියන්නේ දත්ත දැම්ම විදිහටම තියාගන්න ඕන නම් මේක හොඳයි.
• TreeSet: මේක Set එකක් වුනත් දත්ත තියෙන්නේ sorted order එකට (නැචුරල් ඕඩර් එකට නැත්නම් අපි දෙන Comparator එකකට අනුව). HashSet තරම් වේගවත් නැහැ, මොකද Red-Black Tree එකක් පාවිච්චි කරන නිසා. ඔටෝමැටිකලි පිළිවෙලට තියෙන්න ඕන නම් මේක සුපිරි.

මෙන්න HashSet එකක් පාවිච්චි කරන Code Example එකක්:

import java.util.HashSet;
import java.util.Set;

public class SetExample {
    public static void main(String[] args) {
        // String type Set එකක් හදනවා
        Set<String> uniqueItems = new HashSet<>();

        // අයිතම Set එකට එකතු කරනවා
        uniqueItems.add("පෑන");
        uniqueItems.add("පොත");
        uniqueItems.add("පැන්සල");
        uniqueItems.add("පෑන"); // මේක Add වෙන්නේ නැහැ, මොකද duplicate එකක් නිසා!

        System.out.println("අද්විතීය භාණ්ඩ ගණන: " + uniqueItems.size());
        System.out.println("අද්විතීය භාණ්ඩ: " + uniqueItems); // Order එකක් නැතුව Print වෙන්න පුළුවන්

        // යම් අයිතමයක් Set එකේ තියෙනවද කියලා බලනවා
        System.out.println("පොත Set එකේ තියෙනවද? " + uniqueItems.contains("පොත"));

        // Set එකෙන් අයිතමයක් අයින් කරනවා
        uniqueItems.remove("පැන්සල");
        System.out.println("පැන්සල අයින් කළාට පස්සේ: " + uniqueItems);
    }
}

Map - Key-Value යුගල

Map කියන්නේ Collection Interface එක Extend කරන්නේ නැති වෙනම Interface එකක්. මේක ටිකක් අනිත් දෙකට වඩා වෙනස්. මෙතනදී අපි දත්ත ගබඩා කරන්නේ 'Key' එකකට 'Value' එකක් කියන විදිහට. හැම Key එකක්ම unique වෙන්න ඕන. හැබැයි Values duplicate වෙන්න පුළුවන්. අපි Dictionary එකක් වගේ හිතමු. වචනයක් (Key) එකේ තේරුම (Value) එක්ක තියෙනවා වගේ. එහෙමත් නැත්නම් දුරකථන නාමාවලියක් (Phone Book) වගේ.

Map Interface එකේ ප්‍රධානම Implementations තුනක් තමයි:

• HashMap: මේක තමයි Map Implementations අතරින් වේගවත්ම එක. Hashing පාවිච්චි කරන නිසා දත්ත ඉක්මනට හොයාගන්න, නැත්නම් දාන්න හොඳම විකල්පය. මේකේ දත්ත තියෙන්නේ unordered විදිහට. null Keys සහ Values පාවිච්චි කරන්න පුළුවන්.
• LinkedHashMap: මේක HashMap වගේම තමයි, හැබැයි මේකේ insertion order එක Maintain කරනවා. ඒ කියන්නේ Key-Value යුගල දැම්ම පිළිවෙලටම තමයි තියෙන්නේ.
• TreeMap: මේක Map එකක් වුනත් Keys වලට අනුව sorted order එකට තමයි දත්ත ගබඩා වෙන්නේ (නැචුරල් ඕඩර් එකට නැත්නම් අපි දෙන Comparator එකකට අනුව). HashMap තරම් වේගවත් නැහැ.

මෙන්න HashMap එකක් පාවිච්චි කරන Code Example එකක්:

import java.util.HashMap;
import java.util.Map;

public class MapExample {
    public static void main(String[] args) {
        // String Key එකක් සහ String Value එකක් තියෙන Map එකක් හදනවා
        Map<String, String> capitalCities = new HashMap<>();

        // Key-Value යුගල එකතු කරනවා
        capitalCities.put("ශ්‍රී ලංකාව", "කොළඹ");
        capitalCities.put("ඉන්දියාව", "නවදිල්ලිය");
        capitalCities.put("ජපානය", "ටෝකියෝ");
        capitalCities.put("ඕස්ට්‍රේලියාව", "කැන්බරා");

        // Key එකක් දීලා Value එක ගන්නවා
        System.out.println("ශ්‍රී ලංකාවේ අගනුවර: " + capitalCities.get("ශ්‍රී ලංකාව"));

        // යම් Key එකක් Map එකේ තියෙනවද කියලා බලනවා
        System.out.println("ජර්මනිය Map එකේ තියෙනවද? " + capitalCities.containsKey("ජර්මනිය"));

        System.out.println("සියලුම රටවල් සහ අගනුවර:");
        // Map එකේ තියෙන හැම Key-Value යුගලයක්ම Print කරනවා
        for (Map.Entry<String, String> entry : capitalCities.entrySet()) {
            System.out.println(entry.getKey() + " -> " + entry.getValue());
        }

        // Key එකක් දීලා යුගලයක් අයින් කරනවා
        capitalCities.remove("ජපානය");
        System.out.println("ජපානය අයින් කළාට පස්සේ: " + capitalCities);

        // Map එකේ Values විතරක් ගන්නවා
        System.out.println("සියලුම අගනුවර: " + capitalCities.values());
    }
}

අවසානය

ඉතින් යාළුවනේ, මේ තමයි Java Collections Framework එකේ ප්‍රධාන Interfaces තුන වන List, Set, Map සහ ඒවායේ ජනප්‍රිය Implementations ගැන කෙටි හැඳින්වීමක්. ඕනම Java Project එකකදී, විශේෂයෙන්ම Data Handling එකේදී මේවා නැතුවම බැහැ. හරියට Software Engineer කෙනෙක්ට Tools Box එකක් වගේ, මේ Collection Framework එකේ තියෙන Tools ගැන හොඳ අවබෝධයක් තියෙන එක ඔයාගේ Coding Life එකට ලොකු පහසුවක්.

මේවා ගැන තවත් ගැඹුරට ඉගෙන ගන්න පුළුවන්. ඒත් මුලින්ම මේ Basics ටික හොඳට අවබෝධ කරගන්න එක වැදගත්. පුළුවන් නම්, මේ Code Examples ටික ඔයාලගේ IDE එකේ Run කරලා බලන්න, Values ටික වෙනස් කරලා Experiment කරලා බලන්න. එතකොට තවත් හොඳට Concept එක තේරෙයි.

මොනවා හරි ප්‍රශ්න තියෙනවා නම්, නැත්නම් මේ ගැන ඔයාලගේ අදහස්, අත්දැකීම් බෙදාගන්න ඕන නම්, පහළින් Comment එකක් දාන්න අමතක කරන්න එපා. අපි ඊළඟ ලිපියෙන් තවත් වැදගත් මාතෘකාවක් අරගෙන එන්නම්. එතකන් හැමෝටම ජය වේවා! කෝඩිං වැඩ සාර්ථක වේවා!