Java Set පැහැදිලි කිරීම: අද්විතීය එකතු කිරීම්, HashSet, LinkedHashSet, සහ TreeSet සඳහා සම්පූර්ණ මාර්ගෝපදේශය

1. Set එකක් කියන්නේ මොනවාද?

Java වැඩසටහන්කරණයේ, Set යනු අතිශය වැදගත් එකතු කිරීමේ වර්ගයන්ගෙන් එකකි. “Set” යන වචනය ගණිතයෙහි සිට පැමිණේ, සහ ගණිත Set එකක් මෙන්ම, එයට ප්‍රධාන ලක්ෂණයක් වන එය අනුපිළිවෙල නැති අංගයන් අඩංගු නොකරයි.
ඔබට අද්විතීය අගයන් පමණක් කළමනාකරණය කිරීමට අවශ්‍ය වන විට Set එක භාවිතා කරයි, දත්ත වර්ගය සංඛ්‍යා, 문자열, හෝ වස්තු වශයෙන් කුමක් වුවත්.

Set සහ List අතර වෙනස කුමක්ද?

Java Collections Framework එක List සහ Map වැනි විවිධ දත්ත ව්‍යුහයන් ලබා දේ. ඒ අතර, Set සහ List බොහෝ විට සසඳනු ලැබේ. ඒවායේ ප්‍රධාන වෙනස්කම් පහත පරිදි වේ:

• List : අනුපිළිවෙල නැති අගයන් ඉඩ දෙයි සහ අංග අනුපිළිවෙල (ඉන්ඩෙක්ස්-අධාරිත) රැකගනී.
• Set : අනුපිළිවෙල නැති අගයන් ඉඩ නොදෙයි, සහ අංග අනුපිළිවෙල සහතික නොවේ (කොටසක් ක්‍රියාත්මක කිරීම හැර).

සාරාංශයෙන්, List එක “අනුපිළිවෙල ඇති එකතු කිරීම” වන අතර Set එක “අද්විතීය අංගයන්ගේ එකතු කිරීම” වේ.
උදාහරණයක් ලෙස, පරිශීලක ID ගණනාව අනුපිළිවෙල නැතිව කළමනාකරණය කිරීමට අවශ්‍ය නම්, Set එක ඉතා සුදුසු තේරීමකි.

Set භාවිතා කිරීමේ වාසි

• ස්වයංක්‍රීය අනුපිළිවෙල ඉවත් කිරීම පරිශීලකයන්ගෙන් විශාල ප්‍රමාණයේ දත්ත ලැබුණත්, Set එකට අංග එකතු කිරීම පමණක් කරන්නේ නම් අනුපිළිවෙල එකවර පමණක් ගබඩා වේ. මෙය අත්පොතේ අනුපිළිවෙල පරීක්ෂා කිරීමේ අවශ්‍යතාවය ඉවත් කරයි සහ ක්‍රියාත්මක කිරීම සරල කරයි.
• කාර්යක්ෂම සෙවීම සහ ඉවත් කිරීම Set ගොඩනැගීම් වේගවත් පවතින බව පරීක්ෂා කිරීම සහ ඉවත් කිරීමේ මෙහෙයුම් සිදු කිරීමට, එහි ක්‍රියාකාරිත්වය ක්‍රියාත්මක කිරීම (HashSet හෝ TreeSet වැනි) අනුව වෙනස් වේ.

Set එක කවදා භාවිතා කළ යුතුද?

• පරිශීලක ඊමේල් ලිපින හෝ ID වැනි අනුපිළිවෙල නොහැකි තොරතුරු කළමනාකරණය කරන විට
• දත්ත අද්විතීය බව සහතික කළ යුතු විට
• විශාල දත්ත කට්ටලයකින් අද්විතීය අගයන්ගේ ලැයිස්තුව කාර්යක්ෂමව සෑදීමට අවශ්‍ය විට

ඉහත පෙන්වා ඇති පරිදි, Set යනු Java හි අනුපිළිවෙල නොලැබෙන එකතු කිරීම් නියමිතව කළමනාකරණය කිරීමේ ප්‍රමිතියකි.
ඊළඟ කොටස්වල, අපි Set නියමයන්, භාවිතා රටා, සහ නිරූපිත කේත උදාහරණ විස්තරාත්මකව පරීක්ෂා කරමු.

2. Set හි මූලික නියමයන් සහ වාසි

Java හි, Set එක java.util.Set අතුරුමුහුණත මගින් නිර්වචනය කරයි. මෙම අතුරුමුහුණත ක්‍රියාත්මක කිරීමෙන්, ඔබට අනුපිළිවෙල නොමැති අද්විතීය අංගයන්ගෙන් සමන්විත එකතු කිරීමක් නියෝජනය කළ හැක. Set හි මූලික නියමයන් සහ වාසි ගැන සමීපව බලමු.

Set අතුරුමුහුණතේ මූලික ලක්ෂණ

Set එකට පහත ලක්ෂණ ඇත:

• අනුපිළිවෙල නැති අංග ඔබ දැනටමත් පවතින අංගයක් එකතු කිරීමට උත්සාහ කළහොත්, එය එකතු නොවේ. උදාහරණයක් ලෙස, set.add("apple") දෙවරක් ක්‍රියාත්මක කළත්, “apple” එකක් පමණක් ගබඩා වේ.
• අනුපිළිවෙල සහතික නොවේ (ක්‍රියාත්මක කිරීමේ පදනම) Set එක සාමාන්‍යයෙන් අංග අනුපිළිවෙල සහතික නොකරයි. එහෙත්, LinkedHashSet සහ TreeSet වැනි විශේෂ ක්‍රියාත්මක කිරීම් අංග අනුපිළිවෙලක් පාලනය කරයි.
• null අංගයන්ගේ සැකසීම null අංගයන් ඉඩ දීම ක්‍රියාත්මක කිරීමේ පදනම මත පදනම් වේ. උදාහරණයක් ලෙස, HashSet එකට null අංගයක් එකක් ඉඩ දේ, නමුත් TreeSet එකට එය ඉඩ නොදේ.

equals සහ hashCode හි වැදගත්කම

Set එකේ අංග දෙකක් අනුපිළිවෙල ලෙස සැලකේද යන්න equals සහ hashCode ක්‍රමයන් මගින් තීරණය වේ.
Set අංග ලෙස අභිරුචි පන්තීන් භාවිතා කරන විට, මෙම ක්‍රමයන් නිසි ලෙස අතිරේක නොකළහොත්, අනපේක්ෂිත අනුපිළිවෙල හෝ වැරදි ගබඩා හැසිරීමක් සිදුවිය හැක.

• equals : වස්තු දෙකක් තාර්කිකව සමානද යන්න තීරණය කරයි
• hashCode : කාර්යක්ෂම හැඳුනුම් සඳහා භාවිතා වන සංඛ්‍යාත්මක අගයක් ලබා දෙයි

Set භාවිතා කිරීමේ වාසි

Set ගොඩනැගීම් ප්‍රායෝගික වාසි කිහිපයක් ලබා දේ:

• අනුපිළිවෙල ඉවත් කිරීම පහසුයි Set එකට අගයන් එකතු කිරීම පමණක් කරන්නේ නම්, අනුපිළිවෙල ස්වයංක්‍රීයව ඉවත් වේ, අත්පොතේ පරීක්ෂා කිරීමේ අවශ්‍යතාවය ඉවත් කරයි.
• කාර්යක්ෂම සෙවීම සහ ඉවත් කිරීම HashSet වැනි ක්‍රියාත්මක කිරීම් වේගවත් සොයා ගැනීම සහ ඉවත් කිරීමේ මෙහෙයුම් ලබා දේ, බොහෝ විට List වලට වඩා ඉහළ වේ.
• සරල සහ අවබෝධය සලසන API add, remove, contains වැනි මූලික ක්‍රමයන් Set භාවිතය පහසු කරයි.

අභ්‍යන්තර ක්‍රියාත්මක කිරීම සහ කාර්යක්ෂමතාව

One of the most common Set implementations, HashSet, internally uses a HashMap to manage elements. This allows element addition, removal, and lookup to be performed with average O(1) time complexity.
If ordering or sorting is required, you can choose implementations such as LinkedHashSet or TreeSet depending on your needs.

3. ප්‍රධාන ක්‍රියාත්මක පන්තීන් සහ ඒවායේ ලක්ෂණ

Java, Set අතුරුමුහුර්තයේ කිහිපයක් ප්‍රධාන ක්‍රියාත්මක කිරීම් ලබා දේ. එක් එක් එකට වෙනස් ලක්ෂණ ඇත, එබැවින් ඔබේ භාවිතය සඳහා නිවැරදි එක තෝරා ගැනීම වැදගත් වේ. මෙහි, අපි ත්‍රිත්වයෙන් වැඩිම වාරිකව භාවිතා වන ක්‍රියාත්මක කිරීම්: HashSet, LinkedHashSet, සහ TreeSet පැහැදිලි කරමු.

HashSet

HashSet යනු Set අතුරුමුහුර්තයේ අතිශය පොදුව භාවිතා වන ක්‍රියාත්මක කිරීමයි.

• ලක්ෂණ
• අංග අනුක්‍රමය රැකගත නොකරයි (ඇතුළත් කිරීමේ අනුක්‍රමය සහ පරික්‍ෂණ අනුක්‍රමය වෙනස් විය හැක).
• අභ්‍යන්තරයෙන් HashMap භාවිතා කර, වේගවත් එකතු කිරීම, සෙවීම, සහ ඉවත් කිරීම මෙහෙයුම් ලබා දේ.
• null අංගයක් එකක් ඉඩ දේ.
• සාමාන්‍ය භාවිතා අවස්ථා
• අනුපිළිවෙල වැදගත් නොවන විට, අනුපිළිවෙල ඉවත් කිරීමට අවශ්‍ය නම් සුදුසුය.
• උදාහරණ කේතය

  Set<String> set = new HashSet<>();
  set.add("apple");
  set.add("banana");
  set.add("apple"); // Duplicate is ignored
  
  for (String s : set) {
      System.out.println(s); // Only "apple" and "banana" are printed
  }
  

LinkedHashSet

LinkedHashSet යනු HashSet හි කාර්ය සාධනය ඇතුළත් කිරීමේ අනුක්‍රමය රැකගනිමින් විස්තාර කරයි.

• ලක්ෂණ
• අංගයන් ඇතුළත් කරන ලද අනුක්‍රමය අනුව පරික්‍ෂණය කරයි.
• අභ්‍යන්තරයෙන් හෑෂ් වගුවක් සහ සම්බන්ධ ලැයිස්තුවක් එකතු කර කළමනාකරණය කරයි.
• HashSet ට වඩා ටිකක් මන්දගාමී වේ, නමුත් අනුපිළිවෙල වැදගත් වන විට ප්‍රයෝජනවත් වේ.
• සාමාන්‍ය භාවිතා අවස්ථා
• අනුපිළිවෙල රැකගෙන අනුපිළිවෙල ඉවත් කිරීමට අවශ්‍ය විට හොඳයි.
• උදාහරණ කේතය

  Set<String> set = new LinkedHashSet<>();
  set.add("apple");
  set.add("banana");
  set.add("orange");
  
  for (String s : set) {
      System.out.println(s); // Printed in order: apple, banana, orange
  }
  

TreeSet

TreeSet යනු Set ක්‍රියාත්මක කිරීමක් වන අතර එය ස්වයංක්‍රීයව අංගයන් වර්ගීකරණය කරයි.

• ලක්ෂණ
• අභ්‍යන්තරයෙන් රෙඩ්-බ්ලැක් ගස (සමතුලිත ගස ව්‍යුහයක්) භාවිතා කරයි.
• අංගයන් ස්වයංක්‍රීයව ඉහළින් පහලට වර්ගීකරණය කරයි.
• Comparable හෝ Comparator භාවිතා කර අභිරුචි අනුක්‍රමයක් සකස් කළ හැක.
• null අගයන් ඉඩ නොදේ.
• සාමාන්‍ය භාවිතා අවස්ථා
• අනන්‍යතාව සහ ස්වයංක්‍රීය වර්ගීකරණය දෙකම අවශ්‍ය වන විට ප්‍රයෝජනවත්.
• උදාහරණ කේතය

  Set<Integer> set = new TreeSet<>();
  set.add(30);
  set.add(10);
  set.add(20);
  
  for (Integer n : set) {
      System.out.println(n); // Printed in order: 10, 20, 30
  }
  

සාරාංශය

• HashSet : අනුපිළිවෙල අවශ්‍ය නොවන විට ඉහළ කාර්ය සාධනය සඳහා හොඳයි
• LinkedHashSet : ඇතුළත් කිරීමේ අනුක්‍රමය වැදගත් වන විට භාවිතා කරන්න
• TreeSet : ස්වයංක්‍රීය වර්ගීකරණය අවශ්‍ය වන විට භාවිතා කරන්න

නිවැරදි Set ක්‍රියාත්මක කිරීම තෝරා ගැනීම ඔබේ විශේෂ අවශ්‍යතා මත පදනම් වේ. සුදුසුම එක තෝරා ගෙන, එය ප්‍රභාවශාලීව භාවිතා කරන්න.

4. පොදු ක්‍රම සහ ඒවා භාවිතා කරන ආකාරය

Set අතුරුමුහුර්තය එකතු කිරීමේ මෙහෙයුම් සඳහා විවිධ ක්‍රම ලබා දේ. පහත දැක්වෙන්නේ අතිශය පොදුව භාවිතා වන ක්‍රම, උදාහරණ සමඟ පැහැදිලි කර ඇත.

ප්‍රධාන ක්‍රම

• add(E e) Set එකට අංගයක් එකතු කරයි. අංගය දැනටමත් පවතිනවා නම්, එය එකතු නොවේ.
• remove(Object o) Set එකෙන් නියමිත අංගය ඉවත් කරයි. සාර්ථක නම් true ලබා දේ.
• contains(Object o) Set එක නියමිත අංගය අඩංගුදැයි පරීක්ෂා කරයි.
• size() Set එකේ අංග ගණන ලබා දේ.
• clear() Set එකේ සියලු අංග ඉවත් කරයි.
• isEmpty() Set එක හිස්දැයි පරීක්ෂා කරයි.
• iterator() අංග පරික්‍ෂණය සඳහා Iterator එකක් ලබා දේ.
• toArray() Set එක අරේ එකකට පරිවර්තනය කරයි.

මූලික භාවිතා උදාහරණය

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

// Add elements
set.add("apple");
set.add("banana");
set.add("apple"); // Duplicate ignored

// Get size
System.out.println(set.size()); // 2

// Check existence
System.out.println(set.contains("banana")); // true

// Remove element
set.remove("banana");
System.out.println(set.contains("banana")); // false

// Clear all elements
set.clear();
System.out.println(set.isEmpty()); // true

Iterating Over a Set

Since Set does not support index-based access (e.g., set.get(0)), use an Iterator or enhanced for-loop.

// Enhanced for-loop
Set<String> set = new HashSet<>();
set.add("A");
set.add("B");
set.add("C");

for (String s : set) {
    System.out.println(s);
}

// Using Iterator
Iterator<String> it = set.iterator();
while (it.hasNext()) {
    String s = it.next();
    System.out.println(s);
}

Important Notes

• Adding an existing element using add does not change the Set.
• Element order depends on the implementation (HashSet: unordered, LinkedHashSet: insertion order, TreeSet: sorted).

5. Common Use Cases and Typical Scenarios

Java Sets are widely used in many situations where duplicate values must be avoided. Below are some of the most common and practical use cases encountered in real-world development.

Creating a Unique List (Duplicate Removal)

When you want to extract only unique values from a large dataset, Set is extremely useful.
For example, it can automatically remove duplicates from user input or existing collections.

Example: Creating a Set from a List to Remove Duplicates

List<String> list = Arrays.asList("apple", "banana", "apple", "orange");
Set<String> set = new HashSet<>(list);

System.out.println(set); // [apple, banana, orange]

Ensuring Input Uniqueness

Sets are ideal for scenarios where duplicate values must not be registered, such as user IDs or email addresses.
You can immediately determine whether a value already exists by checking the return value of add.

Set<String> emailSet = new HashSet<>();
boolean added = emailSet.add("user@example.com");
if (!added) {
    System.out.println("This value is already registered");
}

Storing Custom Classes and Implementing equals/hashCode

When storing custom objects in a Set, proper implementation of equals and hashCode is essential.
Without them, objects with the same logical content may be treated as different elements.

Example: Ensuring Uniqueness in a Person Class

class Person {
    String name;

    Person(String name) {
        this.name = name;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Person person = (Person) obj;
        return Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name);
    }
}

// Example usage
Set<Person> people = new HashSet<>();
people.add(new Person("Taro"));
people.add(new Person("Taro")); // Without proper implementation, duplicates may occur
System.out.println(people.size()); // 1

Fast Lookup and Data Filtering

Because Set provides fast lookups via contains, it is often used for filtering and comparison tasks.
Converting a List to a Set can significantly improve performance when repeatedly checking for existence.

Example: Fast Keyword Lookup

Set<String> keywordSet = new HashSet<>(Arrays.asList("java", "python", "c"));
boolean found = keywordSet.contains("python"); // true

6. Performance Considerations and Pitfalls

While Set is a powerful collection for managing unique elements, improper usage can lead to unexpected behavior or performance issues. This section explains key performance characteristics and common pitfalls.

Performance Differences by Implementation

• HashSet අභ්‍යන්තරව හෑෂ් වගුවක් භාවිතා කරයි, සාමාන්‍ය O(1) කාර්ය සාධනය ලබා දේ ඇතුළත් කිරීම, ඉවත් කිරීම සහ සොයා ගැනීමේ මෙහෙයුම් සඳහා. අංග සංඛ්‍යාව ඉතා විශාල වීම හෝ හෑෂ් ගැටුම් බහුලව සිදුවීමේදී කාර්ය සාධනය අඩුවිය හැක.
• LinkedHashSet HashSet සමඟ සමාන කාර්ය සාධනයක් ඇත, නමුත් අතිරේක පිරිවැය එකතු කිරීමේ අනුක්‍රමය රැක ගැනීම නිසා. බොහෝ අවස්ථා වල, වෙනස අලූත් නොවේ, විශාල දත්ත කට්ටලයන් හසුරුවන තුරු.
• TreeSet අභ්‍යන්තරව රෙඩ්-බ්ලැක් ගසක් (Red-Black Tree) භාවිතා කරයි, එය O(log n) කාර්ය සාධනය ලබා දේ ඇතුළත් කිරීම, ඉවත් කිරීම සහ සොයා ගැනීමේ මෙහෙයුම් සඳහා. HashSet ට වඩා මන්දගාමී වන නමුත් ස්වයංක්‍රීය වර්ගීකරණය ලබා දේ.

මාරු කළ හැකි වස්තු Set අංග ලෙස භාවිතා කිරීම

Extra caution is required when storing mutable objects in a Set.
HashSet and TreeSet rely on hashCode or compareTo values to manage elements.
If these values change after insertion, lookup and removal may fail.

උදාහරණය: මාරු කළ හැකි වස්තු සමඟ ඇති ගැටලුව

Set<Person> people = new HashSet<>();
Person p = new Person("Taro");
people.add(p);

p.name = "Jiro"; // Modifying after insertion
people.contains(p); // May return false unexpectedly

To avoid such issues, it is strongly recommended to use immutable objects as Set elements whenever possible.

null අගයන් හසුරවීම

• HashSet / LinkedHashSet : එක් null අංගයක් ඉඩ දේ
• TreeSet : null අගයන් ඉඩ නොදේ (NullPointerException දෝෂයක් දමයි)

අනෙකුත් වැදගත් සටහන්

• අනුක්‍රමණය කිරීමේදී වෙනස් කිරීම Set එකක් අනුක්‍රමණය කරන අතරතුර වෙනස් කිරීම ConcurrentModificationException එකක් ඇති කරවිය හැක. Set එක සෘජුවම වෙනස් කිරීම වෙනුවට Iterator.remove() භාවිතා කරන්න.
• නිවැරදි ක්‍රියාත්මක කිරීම තේරීම අනුක්‍රමය වැදගත් වන විට LinkedHashSet හෝ TreeSet භාවිතා කරන්න. HashSet අනුක්‍රමය සහතික නොකරයි.

7. සසඳුම් සටහන (දර්ශනය)

පහත සටහන ප්‍රධාන Set ක්‍රියාත්මක කිරීම් අතර වෙනස්කම් සරලව සාරාංශ කරයි.

ප්‍රධාන ග්‍රහණයන්

• HashSet : අනුක්‍රමය අත්‍යවශ්‍ය නොවන අතර කාර්ය සාධනය ප්‍රමුඛ වන විට පෙරනිමි තේරීම.
• LinkedHashSet : ඇතුළත් කිරීමේ අනුක්‍රමය රැක ගැනීම අවශ්‍ය වන විට හොඳම.
• TreeSet : ස්වයංක්‍රීය වර්ගීකරණය අවශ්‍ය වන විට සුදුසු.

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

Q1. මූලික වර්ග (int, char, ආදිය) Set එකක භාවිතා කළ හැකිද?

A1. නැත. ඒ වෙනුවට Integer හෝ Character වැනි wrapper පන්තීන් භාවිතා කරන්න.

Q2. එකම අගය බහු වාරයක් එක් කළහොත් කුමක් වේද?

A2. පළමු ඇතුළත් කිරීම පමණක් සුරැකේ. අංගය දැනටමත් පවතිනවා නම් add ක්‍රමය false පසුලත් කරයි.

Q3. List සහ Set අතර කවදා භාවිතා කළ යුතුද?

A3. අනුක්‍රමය හෝ පිළිවෙල වැදගත් නම් List භාවිතා කරන්න, ඒත් ඒකකත්වය අවශ්‍ය නම් Set භාවිතා කරන්න.

Q4. අභිරුචි වස්තු Set එකක ගබඩා කිරීමට කුමක් අවශ්‍යද?

A4. equals සහ hashCode නිවැරදිව අතිරේක (override) කරන්න.

Q5. ඇතුළත් කිරීමේ අනුක්‍රමය රැක ගැනීමට කෙසේද?

A5. LinkedHashSet භාවිතා කරන්න.

Q6. අංග ස්වයංක්‍රීයව වර්ගීකරණය කිරීමට කෙසේද?

A6. TreeSet භාවිතා කරන්න.

Q7. Set එකක් null අගයන් අඩංගු කළ හැදියිද?

A7. HashSet සහ LinkedHashSet එක් null අගයක් ඉඩ දේ; TreeSet එය ඉඩ නොදේ.

Q8. Set එකේ ප්‍රමාණය ලබා ගැනීමට කෙසේද?

A8. size() භාවිතා කරන්න.

Q9. Set එකක් List හෝ array එකකට පරිවර්තනය කිරීමට කෙසේද?

A9.

• array එකකට: toArray()
• List එකකට: new ArrayList<>(set)

Q10. අනුක්‍රමණය කරන අතරතුර අංග ඉවත් කළ හැදියිද?

A10. ඔව්, නමුත් Iterator.remove() භාවිතා කිරීම පමණක්.

9. නිගමනය

මෙම ලිපිය Java Set එකේ එකතුකිරීම් මූලික කරුණු සිට උසස් භාවිතය දක්වා ආවරණය කරයි. ප්‍රධාන කරුණු මෙසේය:

• Set එක අද්විතීය අංග එකතුකිරීම් කළමනාකරණය කිරීම සඳහා නිර්මාණය කර ඇත, එය පිළිවෙල ඉවත් කිරීම සඳහා සුදුසුය.
• ප්‍රධාන ක්‍රියාත්මක කිරීම් HashSet (වේගවත්, අනුක්‍රම රහිත), LinkedHashSet (ඇතුළත් කිරීමේ අනුක්‍රම), සහ TreeSet (වර්ගීකරණය) ඇතුළත් වේ.
• සාමාන්‍ය භාවිතයන් අතර පිළිවෙල ඉවත් කිරීම, අද්විතීය පරීක්ෂණ, අභිරුචි වස්තු කළමනාකරණය, සහ වේගවත් සොයා ගැනීම් වේ.
• කාර්ය සාධන ලක්ෂණ සහ මාරු කළ හැකි වස්තු, අනුක්‍රමණ නීති වැනි ගැටළු අවබෝධ කර ගැනීම අත්‍යවශ්‍යය.
• සසඳුම් සටහන සහ FAQ වාස්තුකාරී මාර්ගෝපදේශ ලබා දේ වාස්තුකාරී සංවර්ධනය සඳහා.

Set එකතු කිරීමේ පරිපාලනය Java වැඩසටහන් ලේසි, ආරක්ෂිත, සහ වැඩි කාර්යක්ෂම කරයි.
ඊළඟට, Set සමඟ List හෝ Map එකතු කරමින්, වැඩි දියුණු දත්ත ව්‍යුහ සහ විසඳුම් ගොඩනඟා ගැනීමට සැලකිල්ලට ගන්න.