ஜாவா செட் ஒரு இடைமுகமாக

ஒரு தொகுப்பு என்பது தனித்துவமான பொருட்களின் தொகுப்பாகும். தனித்துவமானது என்பது எந்த இரண்டு பொருட்களும் ஒரே மதிப்பைக் கொண்டிருக்க முடியாது. தொகுப்பின் செயல்படுத்தலைப் பொறுத்து, அது ஆர்டர் செய்யப்படலாம் அல்லது இல்லை. ஜாவா தொகுப்பு, ஒரு சுருக்க தரவு வகையாக (ADT), சில முக்கிய செயல்பாடுகளைக் கொண்டுள்ளது (இங்கு T என்பது எந்த தரவு வகையையும் குறிக்கிறது, எ.கா. int, String அல்லது எந்த வகுப்பு பொருள்):

• boolean add(T item): தொகுப்பில் உருப்படியை வெற்றிகரமாகச் சேர்த்தால் சரி என்றும், உருப்படி ஏற்கனவே தொகுப்பில் இருந்தால் தவறு என்றும் வழங்கும்.
• boolean remove(T item): தொகுப்பிலிருந்து உருப்படி வெற்றிகரமாக அகற்றப்பட்டால் சரி என்றும் இல்லையெனில் தவறு என்றும் (உருப்படி தொகுப்பில் இல்லை என்றால்) திரும்பும்.
• boolean contains(T item): உருப்படியானது தொகுப்பில் இருந்தால் சரி என்றும் இல்லையெனில் தவறு என்றும் வழங்கும்.
• boolean isEmpty(): செட் காலியாக இருந்தால் சரி என்றும் இல்லையெனில் பொய் என்றும் வழங்கும்.

ஜாவாவில் உள்ள தொகுப்புகள் அழகான சுய-விளக்க செயல்பாட்டு கையொப்பங்களைக் கொண்டுள்ளன (அவை வேண்டும் என). ஒரு தொகுப்பில் ஒரே மாதிரியான இரண்டு உருப்படிகளைச் சேர்த்தால், முதலில் சேர்க்கப்பட்ட உருப்படி மட்டுமே தொகுப்பில் இருக்கும். உருப்படியை முதலில் அகற்றும் வரை, அதே உருப்படியைச் சேர்ப்பதற்கான அனைத்து அடுத்தடுத்த முயற்சிகளும் புறக்கணிக்கப்படும். பொதுவாகப் பயன்படுத்தப்படும் செட் செயல்பாடுகளில் ஒன்று கொடுக்கப்பட்ட தொகுப்பிற்குள் ஒரு உருப்படி உள்ளதா எனச் சரிபார்ப்பது. செயல்பாடு இதற்கு ஒரு சிறந்த இயக்க நேரத்தை வழங்குகிறது: O(1) அல்லது O(log n) நேர சிக்கலானது பயன்படுத்தப்படும் செயலாக்கம் a அல்லது a contains()என்பதை பொறுத்துHashSetTreeSet, முறையே. எனவே ஒரு தொகுப்பு எதற்காகப் பயன்படுத்தப்படலாம்? ஐடிகள், பெயர்கள் அல்லது பிற தனிப்பட்ட அடையாளங்காட்டிகள் போன்ற பல தனித்துவமான பொருட்களை நீங்கள் எப்போதாவது கண்காணிக்க வேண்டும் என்றால், அத்தகைய சேகரிப்பில் ஏதேனும் உருப்படி இருக்கிறதா என்று அடிக்கடிச் சரிபார்க்கவும், ஒரு தொகுப்பு நல்ல தேர்வாக இருக்கும். ஒரு தொகுப்பின் உதாரணம் இங்கே உள்ளது: Studentகொடுக்கப்பட்ட வகுப்பில் உள்ள அனைத்து மாணவர்களையும் குறிக்கும் பொருள்களின் பட்டியல் உங்களிடம் இருப்பதாக கற்பனை செய்து பாருங்கள். இந்த வகுப்பிற்கு ஒவ்வொருவருக்கும் Studentஒரு தனிப்பட்ட பெயர் (சரம்) மற்றும் கிரேடு (int) இருக்கலாம். அனைத்து A மாணவர்களின் (தரம் >=90) பட்டியலை நீங்கள் அடிக்கடி குறிப்பிட விரும்பினால், இந்தப் பட்டியலைச் சுற்றிப் பார்த்து, ஒவ்வொரு மாணவரின் தரத்தையும் ஒவ்வொரு முறையும் சரிபார்ப்பது கடினமானதாக இருக்கும். HashSetஅதற்கு பதிலாக, வகுப்பில் உள்ள அனைத்து A மாணவர்களையும் கண்காணிக்கும் சரங்களை நீங்கள் பயன்படுத்தலாம் :

• ஒவ்வொரு முறையும் மாணவர்களின் கிரேடுகள் புதுப்பிக்கப்படும்போது, ​​மாணவர்களின் புதிய கிரேடு 90ஐ விட அதிகமாக உள்ளதா அல்லது அதற்கு சமமாக உள்ளதா இல்லையா என்பதை நீங்கள் சரிபார்க்கலாம்.
  • அப்படியானால், பயன்படுத்தும் A மாணவர்களின் தொகுப்பில் அவர்களைச் சேர்க்கவும்add()
    • அவர்கள் ஏற்கனவே A மாணவராக இருந்திருந்தால், இந்த செயல்பாடு வெறுமனே புறக்கணிக்கப்படுகிறது.
  • இல்லையெனில், A மாணவர்கள் பயன்படுத்தும் தொகுப்பிலிருந்து அவற்றை அகற்றவும்remove()
    • இந்த கட்டத்தில் அவர்கள் A மாணவராக இல்லாவிட்டால், இந்த செயல்பாடு வெறுமனே புறக்கணிக்கப்படுகிறது.

அத்தகைய அமைப்புடன், உங்கள் வகுப்பில் உள்ள அனைத்து 'A' மாணவர்களின் புதுப்பித்த தொகுப்பை எப்போதும் வைத்திருப்பீர்கள். ஜானி ஆப்பிள்சீட் உங்கள் வகுப்பில் சிறப்பாகச் செயல்படுகிறாரா என்பதைச் சரிபார்க்க விரும்பினால், contains(“Johnny Appleseed”)செட்டில் அழைப்பதன் மூலம் அதை எளிதாகச் செய்யலாம். நிச்சயமாக, இது ஒரு தொகுப்பிற்கான பயன்பாட்டு வழக்கின் ஒரு எடுத்துக்காட்டு மட்டுமே, மேலும் A மாணவர்களைக் கண்காணிப்பதில் உள்ள குறிப்பிட்ட சிக்கலை வேறு வழிகளில் தீர்க்க முடியும்.

செயலாக்கங்கள்: ஜாவாவில் ஹாஷ்செட் மற்றும் ஜாவா ட்ரீசெட் எடுத்துக்காட்டுகள்

HashSetஜாவாவிலும் ஜாவாவிலும் உள்ளவை இரண்டும் TreeSetவரும் java.utils package. நீங்கள் அவற்றை இவ்வாறு இறக்குமதி செய்யலாம்:

// imports everything from Java's util package, including HashSet and TreeSet
import java.util.*;

அல்லது

import java.util.HashSet; // imports only the Java HashSet
import java.util.TreeSet; // imports only the Java TreeSet

HashSetஜாவாவிற்கும் ஜாவாவிற்கும் உள்ள முக்கிய வேறுபாடு TreeSetஎன்னவென்றால், TreeSetவரிசைப்படுத்தப்பட்டுள்ளது, ஆனால் அது HashSetஇல்லை. இதனால்தான் TreeSetமுக்கிய செயல்பாடுகளுக்கு O(log n) நேர சிக்கலானது, HashSetO(1) அல்லது நிலையான நேர சிக்கலானது; TreeSetஎல்லா நேரங்களிலும் ஒழுங்கை பராமரிக்க வேண்டும் . முன்பு குறிப்பிடப்பட்ட முக்கிய செட் செயல்பாடுகளுக்கு கூடுதலாக, ஜாவா HashSetமற்றும் TreeSetஜாவா இரண்டும் சில பயனுள்ள செயல்பாடுகளைக் கொண்டுள்ளன:

• void clear(): அனைத்து பொருட்களின் தொகுப்பையும் அழிக்கிறது.
• int size(): தொகுப்பில் உள்ள பொருட்களின் எண்ணிக்கையை வழங்குகிறது.
• Object clone(): தொகுப்பின் ஆழமற்ற நகலை வழங்குகிறது.
• Iterator iterator(): முதல் பொருளில் தொடங்கி, ஒரு இட்டேட்டரைத் தொகுப்பிற்குத் தருகிறது.

size()"A மாணவர்களின் பட்டியல்" எடுத்துக்காட்டில் இந்த செயல்பாடுகளுக்கான பயன்பாடுகளை நீங்கள் கற்பனை செய்யலாம்: உங்களிடம் எத்தனை 'A' மாணவர்கள் உள்ளனர் என்பதைப் பார்க்க விரும்பினால் அல்லது clear()செமஸ்டர் முடிவில் பட்டியலை அழிக்க விரும்பினால் நீங்கள் அழைக்கலாம் . clone()இடைக்கால அறிக்கைகள் (இதன் மூலம் அசலைப் போலவே குளோன் புதுப்பித்த நிலையில் இருக்காது) போன்ற ஒரு குறிப்பிட்ட நேரத்தில், A மாணவர்களின் பட்டியலின் குளோனை உருவாக்கி வைத்திருக்கலாம் .

ஜாவா ஹாஷ்செட் எடுத்துக்காட்டு

ஜாவாவில் s பயன்படுத்தப்படுவதற்கான HashSetஒரு சிறிய எடுத்துக்காட்டு இங்கே :String

import java.util.HashSet;
class HashSetDemo {
    public static void main(String[] args)
    {
	  // create a HashSet of Strings
        HashSet<String> hs = new HashSet<String>();

        // Add elements using the add() method
        hs.add("Collin");
	  hs.add("Bob");
 	  hs.add("Abigail");

        // Duplicates will ignored; this statement is useless
        hs.add("Collin");


        System.out.println(hs);
	  System.out.println("Bob is in the set (T/F): " + hs.contains("Bob"));
  System.out.println("Max is in the set (T/F): " + hs.contains("Max"));


    }
}

வெளியீடு: ---------

[Collin, Bob, Abigail]
Bob is in the set (T/F): true
Max is in the set (T/F): false

ஜாவா ட்ரீசெட் உதாரணம்

ஜாவா செட் உதாரணம் கோட்பாட்டைப் புரிந்துகொள்ள உங்களுக்கு உதவும். ஜாவாவில் s பயன்படுத்தப்படுவதற்கான TreeSetசிறிய எடுத்துக்காட்டு இங்கே :String

import java.util.TreeSet;
class TreeSetDemo {
    public static void main(String[] args)
    {
	  // create a TreeSet of Strings
        TreeSet<String> ts = new TreeSet<String>();

        // Add elements using the add() method.
        ts.add("Collin");
	  ts.add("Bob");
 	  ts.add("Abigail");

        // Duplicates will ignored; this statement is useless
        ts.add("Collin");

        // printing the set prints the names in alphabetical order!
        System.out.println(ts);

	  System.out.println("Bob is in the set (T/F): " + ts.contains("Bob"));
  System.out.println("Max is in the set (T/F): " + ts.contains("Max"));
  System.out.println("Size of the set: " + ts.size());
 	  ts.clear();
	  System.out.println("Size of the set after clear(): " + ts.size());


    }
}

வெளியீடு: -------

[Abigail, Bob, Collin]
Bob is in the set (T/F): true
Max is in the set (T/F): false
Size of the set: 3
Size of the set after clear(): 0

அவ்வளவுதான்! இது உதவியது என்று நம்புகிறேன் 😊