ఇంటర్‌ఫేస్‌గా జావా సెట్

సమితి అనేది కేవలం ప్రత్యేకమైన వస్తువుల సమాహారం. విశిష్టత అంటే ఏ రెండు వస్తువులు ఒకే విలువ(లు) కలిగి ఉండకూడదు. సెట్ అమలుపై ఆధారపడి, అది ఆదేశించబడవచ్చు లేదా చేయకపోవచ్చు. జావా సెట్, అబ్‌స్ట్రాక్ట్ డేటా టైప్ (ADT)గా, కొన్ని కీలక కార్యకలాపాలను కలిగి ఉంటుంది (ఇక్కడ T ఏదైనా డేటా రకాన్ని సూచిస్తుంది ఉదా. int, String లేదా ఏదైనా తరగతి వస్తువు):

• boolean add(T item): అంశం సెట్‌కు విజయవంతంగా జోడించబడితే ఒప్పు మరియు అంశం ఇప్పటికే సెట్‌లో ఉంటే తప్పు అని చూపుతుంది.
• boolean remove(T item): సెట్ నుండి ఐటెమ్ విజయవంతంగా తీసివేయబడితే ఒప్పు మరియు లేకపోతే తప్పు (అంశం సెట్‌లో లేకుంటే) చూపుతుంది.
• boolean contains(T item): అంశం సెట్‌లో ఉంటే ఒప్పు మరియు లేకపోతే తప్పు అని చూపుతుంది.
• boolean isEmpty(): సెట్ ఖాళీగా ఉంటే ఒప్పు మరియు లేకపోతే తప్పు అని చూపుతుంది.

జావాలోని సెట్‌లు చాలా స్వీయ-వివరణాత్మక ఫంక్షన్ సంతకాలను కలిగి ఉంటాయి (అవి తప్పక). మీరు ఒక సెట్‌కి రెండు సారూప్య అంశాలను జోడిస్తే, మొదట జోడించిన అంశం మాత్రమే సెట్‌లో ఉంటుంది. ఐటెమ్‌ను మొదట తీసివేయకపోతే, అదే అంశాన్ని జోడించడానికి అన్ని తదుపరి ప్రయత్నాలు విస్మరించబడతాయి. ఒక అంశం ఇచ్చిన సెట్‌లో ఉందో లేదో తనిఖీ చేయడం అనేది సాధారణంగా ఉపయోగించే సెట్ ఆపరేషన్‌లలో ఒకటి. ఫంక్షన్ contains()దీని కోసం గొప్ప రన్‌టైమ్‌ను ఇస్తుంది: O(1) లేదా O(log n) సమయ సంక్లిష్టత ఉపయోగించిన అమలు a HashSetలేదా a అనే దానిపై ఆధారపడి ఉంటుందిTreeSet, వరుసగా. కాబట్టి సెట్ దేనికి ఉపయోగించవచ్చు? సరే, మీరు ఎప్పుడైనా అనేక విభిన్న ఆబ్జెక్ట్‌లను ట్రాక్ చేయవలసి వస్తే - IDలు, పేర్లు లేదా ఇతర ప్రత్యేక ఐడెంటిఫైయర్‌లు వంటివి - మరియు అటువంటి సేకరణలో ఏదైనా వస్తువు ఉందో లేదో తరచుగా తనిఖీ చేయండి, అప్పుడు ఒక సెట్ మంచి ఎంపిక కావచ్చు. సెట్ యొక్క ఉదాహరణ వినియోగ సందర్భం ఇక్కడ ఉంది: మీరు Studentఇచ్చిన తరగతిలోని విద్యార్థులందరికీ ప్రాతినిధ్యం వహించే వస్తువుల జాబితాను కలిగి ఉన్నారని ఊహించుకోండి. ఈ తరగతికి ప్రతి ఒక్కటి Studentప్రత్యేక పేరు (స్ట్రింగ్) మరియు గ్రేడ్ (పూర్ణాంక) కలిగి ఉండవచ్చు. మీరు 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(): మొదటి ఆబ్జెక్ట్ నుండి ప్రారంభించి, సెట్‌కి ఇటరేటర్‌ను తిరిగి అందిస్తుంది.

"A విద్యార్థుల జాబితా" ఉదాహరణలో ఈ ఫంక్షన్‌ల కోసం ఉపయోగాలను కనుగొనడాన్ని మీరు ఊహించవచ్చు: size()మీరు ఎంత మంది '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

అంతే! ఇది సహాయపడిందని ఆశిస్తున్నాను 😊