අද අපි කතා කරමු Data collections ගැන.

Data Collections ගැන කතා කරන්න කලින් අපි කතා කරමු Data Arrays ගැන. Data Array එකක් කියන්නෙ එකම වර්ගයේ Data අනුපිළිවෙලකට ගබඩා කරන්න පුලුවන් දාත්ත ව්‍යූහයක්(Data Structure). Array එකේ Type එක String නම් ඒකෙ තියෙන්න පුලුවන් String Data විතරයි. Array එකක් නිර්මාණය කරද්දි ඒකට අදාලව Fixed Size එකක් දෙන්න ඕනි. Array එකක් හැදුවට පස්සෙ අපට Array එක වෙනස් කරන්න බෑ.

ex:-  int[] array = new int[5];
        array[0] = 1;
                array[1] = 2;
                array[2] = 3;
                array[3] = 4;
                array[4] = 5;

එතකොට මොනාද මේ Array වල තියෙන ප්‍රශ්න?

    මම මුලින් කිව්වා වගේ Array එකක් හදනකොට අපි ඒකට Fixed Size එකක් දෙන්න ඕනි. දැන් ඔයාලා හිතන්නකො අපි Size එක 5ක් වෙන Array එකක් හදනවා integer වලින්. එතකොට අපිට ඒ Array එකට ඇඩ් කරන්න පුලුවන් වෙන්නෙ Element 5ක් විතරයි.

අපිට Array එකකට අලුතින් Element එක ඇඩ් කරන්න ඕනි උනොත් මොකක්ද අපි කරන්න ඕනි?

අපිට Array එකකට අලුතින් Element එකක් ඇඩ් කරන්න ඕනි උනොත් අපිට  කලින් Array Size එකට වඩා size එකෙන් වැඩි අලුත් Array එකක් හදන්න වෙනව. ඊට පස්සෙ කලින් Array එකේ තිබ්බ Element අලුතින් හදපු Array එකට ඇඩ් කරාට පස්සෙ තමයි අපිට අලුතින් Element ඇඩ් කරන්න වෙන්නෙ. ඒතකොට මේ විදිහට අලුතින් elements ඇඩ් කරන සෑම වතාවකදිම අපට සිද්දවෙනවා නැවත නැවත කෝඩ් කරන්න.එහෙම උනාම අපට විශාල කාලයක් ගතවෙනවා.

ex:-  int[] array = new int[5];
      array[0] = 1;
              array[1] = 2;
              array[2] = 3;
              array[3] = 4;
              array[4] = 5;

      int newElement = 6;

             // Create a new array with size larger by 1
             int[] newArray = new int[array.length + 1];

             // Copy elements from the old array to the new array
             for (int i = 0; i < array.length; i++) {
             newArray[i] = array[i];
             }

             // Add the new element to the new array
             newArray[newArray.length - 1] = newElement;
 

දැන් ඔයාලට හිතෙන්න පුලුවන් Array එක හදනකොටම වැඩි size එකක් දීලා  Array එක හදන්න පුළුවන්නේ කියලා.  ඔව් අපිට එහෙම හදන්න පුළුවන්. හැබැයි එතකොට අපේ memory එකේ වැඩි ඉඩ ප්‍රමාණයක් නාස්ති වෙනවා පොඩි ඩේටා ප්‍රමාණයක් store කරද්දි උනත්.

එතකොට මේ ප්‍රශ්න වලට අපිවට විසඳුමක් නැද්ද?

විසඳුමක් තියනවා.. ඒ තමයි Java Collections.අපි Java Collections භාවිතා කරනවා නම් අපට මුලින් කතා කරපු ප්‍රශ්න ටික නැති කරගන්න පුලුවන්.Collection එකක් කියන්නෙ object/ elements වල එකතුවක් කියලා අපට සරලව කියන්න පුලුවන්. 

එතකොට මොනාද මේ Data Collections වලට උදාහරණ?

දැන් අපි ඒ උදාහරණ වලින් කීපයක් ගැන සාකච්චා කරමු.

1)Array List

Array List වලට Arrays වලට වගේ fixed size එකක් ඕනි වෙන්නෙ නෑ. අපි අලුතින් element ඇඩ් කරනකොට List එකේ size එක automatically වැඩි වෙනවා. element අයින් කරොත් size එක automatically අඩු වෙනවා. එතකොට අපට Array වල වගේ නැවත නැවත කෝඩ් කරන්න ඕනි නෑ. අපේ වෙලාව ඉතිරි කරගන්න පුළුවන්.

ex:- List<String> arrayList = new ArrayList<>();
arrayList.add("A");
arrayList.add("C");
arrayList.add("D");
arrayList.remove("D");

දැන් අපිට මේ list එකේ A සහ C අතරට අලුතින් B කියන element එක ඇඩ් කරන්න ඕනි නම්, අපට අලුතින් list එකක් හදන්න ඕනි නෑ. අපට අවශ්‍ය index එක දාලා element එක ඇඩ් කරන්න පුළුවන්.

arrayList.add(1,"B");

එතකොට කොහොමද Array List එකේ තියෙන ඩේටා print කරගන්නෙ?

අපට Array List එකේ තියන ඩේටා print කරගන්න forEach කියන method එකක් හදුන්වලා දීලා තියෙනවා.අපට එම method එක භාවිතා කරලා ඉතා පහසුවෙන් ඩේටා ටික print කරගන්න පුළුවන්

ex:-    List<String> arrayList = new ArrayList<>();

        // Add elements to the ArrayList
                arrayList.add("A");
        arrayList.add("C");
        arrayList.add("D");

        // Print the ArrayList before removal using forEach
        System.out.print("ArrayList before removal: ");
        arrayList.forEach(element -> System.out.print(element + " "));
        System.out.println();

        // Remove an element from the ArrayList
        arrayList.remove("D");

        // Print the ArrayList after removal using forEach
        System.out.print("ArrayList after removal: ");
        arrayList.forEach(element -> System.out.print(element + " "));
        System.out.println();

Output:-ArrayList before removal: A C D 
ArrayList after removal: A C 

2)Linked List

Linked List කියන්නෙ Array List වලට වඩා සාර්තක වේගවත් ක්‍රමයක්.

ex:- List<Integer> linkedList = new LinkedList();

එතකොට linked list එක ආරම්භයේම අපට values ඇඩ් කරන්න පුළුවන් ද?

ඔව් පුළුවන්.හැබැයි අපි ඒකට List.of කියන method එක use කරන්න ඕනි. ඒ වගේම අපි List කියන class එක import කරගන්න ඕනි.

ex:-  List<String> multipleElementsList = List.of("one", "two", "three");

අපට Linked List එකේ ඩේටා Array list එක ආකාරයටම print කරගන්න පුළුවන්.

ex:-linkedList.forEach(element -> System.out.print(element + " "));

2)Set

අපට set වලදි list වල වගේ duplicate ඩේටා තියාගන්න බෑ. set වල hashSet, linkedHashSet, treeSet කියලා කොටස් 3 ක් තියෙනවා. අපට set වල තියාගන්න පුළුවන් උපරිම null value සංඛ්‍යාව 1කි.

a)hashSet:-

Set<Integer> set = new HashSet<>();

        // Add elements to the HashSet
        set.add(1);
        set.add(3);
        set.add(4);

// Remove an element from the HashSet
        set.remove(4);

b)linkedHashSet:-

Set<Integer> set = new LinkedHashSet<>();

        // Add elements to the LinkedHashSet
        set.add(1);
        set.add(3);
        set.add(4);

// Remove an element from the LinkedHashSet
        set.remove(4);

c)treeSet

Set<Integer> treeSet = new TreeSet<>();

       // Add elements to the TreeSet
        treeSet.add(1);
        treeSet.add(3);
        treeSet.add(4);

    // Remove an element from the TreeSet
        treeSet.remove(4);

#Collection   #Java