జావా సెట్

సెట్ అనేది జావా కలెక్షన్ ఫ్రేమ్‌వర్క్‌లోని ఇంటర్‌ఫేస్. ప్రత్యేకమైన అంశాలతో క్రమం లేని సేకరణలను అమలు చేయడానికి మీరు జావా సెట్‌ని ఉపయోగించవచ్చు . ఈ వ్యాసంలో, మేము ఈ ఇంటర్‌ఫేస్ మరియు జావా భాషలో దాని అమలులు, సెట్‌తో పని చేసే పద్ధతులు మరియు కొన్ని ఉదాహరణలను కూడా ఇవ్వబోతున్నాము.

జావా సెట్ అంటే ఏమిటి

సెట్ అనేది జావా కలెక్షన్ ఫ్రేమ్‌వర్క్ నుండి ఇంటర్‌ఫేస్, కానీ సెట్ అనేది జాబితా వలె కాకుండా ఆర్డర్ చేసిన సేకరణ కాదు . అంటే జావా సెట్ మూలకాలు నిర్దిష్ట క్రమం లేకుండా ఉంచబడతాయి. కాబట్టి మీరు ఒక మూలకాన్ని చొప్పించగల స్థానంపై నియంత్రణ లేదు. అలాగే మీరు ఎలిమెంట్‌లను వాటి ఇండెక్స్ ద్వారా యాక్సెస్ చేయలేరు. గణితశాస్త్రపరంగా, సెట్ అనేది ప్రత్యేకమైన అంశాల సమాహారం. వాస్తవానికి, ఇది క్రమం లేని సేకరణ (క్రమం లేని సేకరణ), దీనిలో ఒకే విధమైన మూలకాలు నిల్వ చేయబడవు. మీరు ఉద్దేశపూర్వకంగా సెట్‌కి నకిలీ మూలకాన్ని జోడిస్తే , ఈ చర్య విస్మరించబడుతుంది మరియు సెట్ మారదు. అయితే అందులో ఒక శూన్య మూలకాన్ని నిల్వ చేయడానికి అనుమతి ఉంది.

అమలులను సెట్ చేయండి

జావా సెట్ అనేది ఇంటర్‌ఫేస్, కాబట్టి మీరు ఆబ్జెక్ట్‌లను రూపొందించడానికి దాని అమలులలో ఒకదాన్ని ఉపయోగించాలి. అవి HashSet , TreeSet మరియు LinkedHashSet . సెట్లలో , ప్రతి మూలకం ఒకే సందర్భంలో నిల్వ చేయబడుతుంది మరియు సెట్ యొక్క వివిధ అమలులు మూలకాలను నిల్వ చేయడానికి వేరే క్రమాన్ని ఉపయోగిస్తాయి . HashSet లో , మూలకాల క్రమం సంక్లిష్టమైన అల్గారిథమ్ ద్వారా నిర్ణయించబడుతుంది. మీకు స్టోరేజ్ ఆర్డర్ ముఖ్యమైనది అయితే, TreeSet కంటైనర్‌ను ఉపయోగించండి, ఇది ఆరోహణ క్రమంలో క్రమబద్ధీకరించబడిన వస్తువులను పోలిక క్రమంలో లేదా లింక్డ్‌హాష్‌సెట్‌ను నిల్వ చేస్తుంది., ఇది అదనపు క్రమంలో మూలకాలను నిల్వ చేస్తుంది. మెంబర్‌షిప్ టెస్టింగ్ కోసం సెట్‌లు తరచుగా ఉపయోగించబడతాయి, తద్వారా ఆబ్జెక్ట్ ఇచ్చిన సెట్‌కు చెందినదా అని మీరు సులభంగా తనిఖీ చేయవచ్చు, కాబట్టి ఆచరణలో ఫాస్ట్ లుకప్ కోసం ఆప్టిమైజ్ చేయబడిన హాష్‌సెట్ అమలు సాధారణంగా ఎంపిక చేయబడుతుంది. హాష్‌సెట్ అనేది ఎలిమెంట్‌లను అంతర్గతంగా నిల్వ చేయడానికి హాష్‌కోడ్() పద్ధతి ద్వారా అందించబడిన హాష్ విలువలను ఉపయోగించే ఒక సేకరణ . అంటే, HashSet<E> లోపల , HashMap<E, Object> ఆబ్జెక్ట్ నిల్వ చేయబడుతుంది, ఇది HashSet విలువలను కీలుగా నిల్వ చేస్తుంది. హాష్ కోడ్‌లను ఉపయోగించడం వలన సెట్ నుండి ఎలిమెంట్‌లను త్వరగా శోధించడానికి, జోడించడానికి మరియు తీసివేయడానికి మిమ్మల్ని అనుమతిస్తుంది . LinkedHashSet ఒక HashSetఇది లింక్ చేయబడిన జాబితాలో మూలకాలను కూడా నిల్వ చేస్తుంది. ఒక సాధారణ HashSet మూలకం క్రమాన్ని నిర్వహించదు. మొదట, అధికారికంగా ఇది ఉనికిలో లేదు మరియు రెండవది, కేవలం ఒక మూలకం జోడించబడినప్పుడు అంతర్గత క్రమం కూడా నాటకీయంగా మారుతుంది. మరియు మీరు లింక్డ్‌హాష్‌సెట్ నుండి ఇటరేటర్‌ను పొందవచ్చు మరియు లింక్డ్‌హాష్‌సెట్‌కి జోడించబడిన ఖచ్చితమైన క్రమంలో అన్ని మూలకాల ద్వారా వెళ్లడానికి దాన్ని ఉపయోగించవచ్చు . తరచుగా కాదు, కానీ కొన్నిసార్లు ఇది చాలా అవసరం కావచ్చు. ట్రీసెట్ అనేది మూలకాలను విలువ-ఆర్డర్ చేసిన చెట్టుగా నిల్వ చేసే సేకరణ. TreeSet<E> లోపల ఈ అన్ని విలువలను నిల్వ చేసే TreeMap<E, Object> ఉంది . మరియు ఈ ట్రీమ్యాప్మూలకాలను నిల్వ చేయడానికి ఎరుపు-నలుపు సమతుల్య బైనరీ చెట్టును ఉపయోగిస్తుంది. కాబట్టి, ఇది చాలా వేగవంతమైన యాడ్() , తొలగించు() , కలిగి() కార్యకలాపాలను కలిగి ఉంటుంది.

సెట్ ఆబ్జెక్ట్‌ను సృష్టించండి

సెట్ ఆబ్జెక్ట్‌ని సృష్టించడానికి మీరు తదుపరి ఫారమ్‌లో ఒకదాన్ని ఉపయోగించవచ్చు:

Set<Integer> intSet = new HashSet<>();
Set<String> vSet = new HashSet<>();
Set mySet = new LinkedHashSet();
HashSet<String> myHashset = new HashSet<>();

ఇక్కడ ఒక సరళమైన ఉదాహరణ ఉంది, ఇక్కడ మనం 2 సెట్లు , HashSet మరియు LinkedHashSet లను సృష్టించి , ఒక్కొక్కటి 5 మూలకాల కోసం జోడిస్తాము. దీని కోసం మనం add() పద్ధతిని ఉపయోగించవచ్చు .

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

public class HashSetTest {
    public static void main(String[] args) {
        Set mySet = new HashSet();
        Set mySet2 = new LinkedHashSet();
//adding some string elements
        mySet.add("Stuart");
        mySet.add("Alex");
        mySet.add("Johnny");
        mySet.add("Igor");
        mySet.add("Bel");
        System.out.println(mySet);
        mySet2.add("Stuart");
        mySet2.add("Alex");
        mySet2.add("Johnny");
        mySet2.add("Igor");
        mySet2.add("Bel");
        System.out.println(mySet2);
    }
}

ప్రోగ్రామ్ యొక్క అవుట్‌పుట్ ఇక్కడ ఉంది: మేము పైన చెప్పినట్లుగా, HashSet మూలకాల క్రమాన్ని నిర్వహించదు, కానీ LinkedHashSet చేస్తుంది. మేము వాటిని సెట్‌కి వ్రాసిన క్రమంలో మూలకాలను అందించిన లింక్డ్‌హాష్‌సెట్ ఇది .

జావా సెట్ పద్ధతులు

జావా సెట్‌లో కొన్ని ముఖ్యమైన పద్ధతులు ఇక్కడ ఉన్నాయి:

• బూలియన్ యాడ్(ఇ ఇ) . పేర్కొన్న మూలకం ఇప్పటికే లేకుంటే సెట్‌కి జోడిస్తుంది (ఐచ్ఛిక ఆపరేషన్).

• బూలియన్ తొలగించు (వస్తువు o) . పేర్కొన్న మూలకం ఈ సెట్‌లో ఉన్నట్లయితే దాని నుండి తొలగిస్తుంది (ఐచ్ఛిక ఆపరేషన్).

• బూలియన్ రిమూవ్ ఆల్(కలెక్షన్ సి) . పేర్కొన్న సేకరణ (ఐచ్ఛిక ఆపరేషన్)లో ఉన్న అన్ని అంశాలని ఈ సెట్ నుండి తొలగిస్తుంది.

• బూలియన్ retainAll(కలెక్షన్ సి) . పేర్కొన్న సేకరణ (ఐచ్ఛిక ఆపరేషన్)లో ఉన్న ఈ సెట్‌లోని మూలకాలను మాత్రమే కలిగి ఉంటుంది.

• శూన్యం స్పష్టమైన () . సెట్ నుండి అన్ని అంశాలను తొలగిస్తుంది.

• ఇటరేటర్ ఇటరేటర్() . ఈ సెట్‌లోని మూలకాలపై ఒక ఇటరేటర్‌ను అందిస్తుంది.

• పూర్ణాంక పరిమాణం () . ఇది సెట్‌లోని మూలకాల సంఖ్యను పొందడానికి ఉపయోగించబడుతుంది.

• boolean isEmpty() . సెట్ ఖాళీగా ఉందో లేదో తనిఖీ చేయడానికి.

• బూలియన్ కలిగి (వస్తువు o) . ఈ సెట్‌లో పేర్కొన్న మూలకం ఉంటే ఒప్పు అని చూపుతుంది.

• ఇటరేటర్ ఇటరేటర్() . ఈ సెట్‌లోని మూలకాలపై ఒక ఇటరేటర్‌ను అందిస్తుంది. మూలకాలు నిర్దిష్ట క్రమంలో తిరిగి ఇవ్వబడవు.

• ఆబ్జెక్ట్[] toArray() . ఈ సెట్‌లోని అన్ని మూలకాలను కలిగి ఉన్న శ్రేణిని అందిస్తుంది. ఈ సెట్ దాని ఎలిమెంట్‌లను దాని ఇటరేటర్ ద్వారా ఏ క్రమంలో అందించబడుతుందనే దానిపై ఏదైనా హామీని ఇస్తే, ఈ పద్ధతి తప్పనిసరిగా మూలకాలను అదే క్రమంలో అందించాలి.

పద్ధతులు అర్రేలిస్ట్ మాదిరిగానే ఉంటాయి , యాడ్ (ఆబ్జెక్ట్ o) పద్ధతిలో ఆబ్జెక్ట్ ఇప్పటికే లేకపోతే సెట్‌కి మాత్రమే జోడిస్తుంది. ఆబ్జెక్ట్ జోడించబడితే పద్ధతి యొక్క రిటర్న్ విలువ నిజం మరియు లేకపోతే తప్పు. సేకరణ<> ఇంటర్‌ఫేస్ నుండి వారసత్వంగా పొందిన కొన్ని పద్ధతులు కూడా ఉన్నాయి : parallelStream() , removeIf() , stream() మరియు forEach() పద్ధతి java.lang.Iterable ఇంటర్‌ఫేస్ నుండి వారసత్వంగా పొందబడింది.

జావా సెట్ ప్రధాన కార్యకలాపాల ఉదాహరణ

ఈ ఉదాహరణలో, మేము స్ట్రింగ్‌ల శ్రేణిని సృష్టించాము మరియు Arrays.asList ఆపరేషన్‌ని ఉపయోగించి దానిని mySet కి పంపుతాము . అప్పుడు మేము మరికొన్ని మూలకాలను తీసివేసి, మరో జంటను జోడిస్తాము. ఈ సందర్భంలో, సెట్‌లోని మూలకాలలో ఒకటి ఇప్పటికే ఉంది: ఇది జోడించబడదు. మేము శూన్యత కోసం తనిఖీ చేసే కార్యకలాపాలను కూడా ప్రయత్నిస్తాము isEmpty() , సెట్ పరిమాణం () యొక్క పరిమాణాన్ని నిర్ణయించడం మరియు అన్ని మూలకాల సెట్‌ను క్లియర్ చేయడం () .

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

public class HashSetTest2 {
   public static void main(String[] args) {
       //creating a string Array with some names
       String [] friends =  {"Stuart", "Ivy", "Johnny", "Alex", "Igor", "Tanya"};
       //creating a new set and adding elements from string array into it
       Set<String> mySet = new HashSet<>(Arrays.asList(friends));
       System.out.println(mySet);
       //removing two elements from the set
       mySet.remove("Igor");
       mySet.remove("Stuart");

       System.out.println(mySet);

       //adding 2 new Elements into set
       mySet.add("Dasha");
       mySet.add("Alex"); //it's second Alex, can't be added
       System.out.println(mySet);
       //cheking the size of mySet
       int size = mySet.size();
       System.out.println("The quantity of set's elements = " + size);
       //Checking if the set is empty
       System.out.println("Is mySet empty? " + mySet.isEmpty());
       //checking if some elements are in set
       System.out.println("Is Igor in set? " + mySet.contains("Igor"));
       System.out.println("Is Johnny in set? "+ mySet.contains("Johnny"));
       //deleting all elements from the set
       mySet.clear();
       System.out.println("Is mySet empty now? " + mySet.isEmpty());

   }
}

ప్రోగ్రామ్ యొక్క అవుట్‌పుట్ ఇక్కడ ఉంది:

లింక్డ్‌హాష్‌సెట్‌తో ఉదాహరణ మరియు అర్రేకి సెట్ చేయబడింది

ఇంకో ప్రోగ్రాం రాద్దాం. అందులో, మేము లింక్డ్‌హాష్‌సెట్ ఆధారంగా సెట్‌ను సృష్టిస్తాము , దానికి ఎలిమెంట్‌లను జోడించి, ఆపై సెట్‌ను అర్రేగా మారుస్తాము.

import java.util.Arrays;
import java.util.LinkedHashSet;
import java.util.Set;
   public class LinkedHashSet3 {
       public static void main(String[] args) {
           Set<String> set = new LinkedHashSet<>();
           set.add("C");
           set.add("D");
           set.add("E");
           set.add("F");
           set.add("G");
           set.add("A");
           set.add("B");
           System.out.println(set);
           set.remove("F");// removing an element from our set
           set.remove("C sharp");//trying to remove element that isn't in set
           System.out.println(set.remove("C sharp"));
           System.out.println("Print our set with elements removed: ");
           System.out.println(set);

//set to array
           String strArray[] = set.toArray(new String[set.size()]);
           System.out.println("New Array from set: ");
           System.out.println(Arrays.toString(strArray));
           System.out.println(strArray[0]);

       }
   }

ప్రోగ్రామ్ యొక్క అవుట్‌పుట్ ఇక్కడ ఉంది:

ఇటరేటర్‌తో ఉదాహరణను సెట్ చేయండి

ఒక సెట్‌ని క్రియేట్ చేద్దాం, ఆపై దాన్ని ఇటరేటర్‌ని ఉపయోగించి ప్రింట్ అవుట్ చేసి, ఆపై ఇటరేటర్‌ని ఉపయోగించి దాని నుండి అన్ని సరి సంఖ్యలను తీసివేద్దాం.

import java.util.*;

public class SetTest5
{
   public static void main(String[] args)
   {

       Set<Integer> mySet = new HashSe<>();
       for(int i = 0; i < 10; i++)
           mySet.add(i);

       Iterator iterator = mySet.iterator();

       //simple iteration
       while(iterator.hasNext()){
           int i = (int) iterator.next();
       }
       System.out.println(" " + mySet);

       //modification of mySet using iterator - removing all even numbers
       iterator = mySet.iterator();
       while(iterator.hasNext()){
           int x = (int) iterator.next();
           if(x%2 == 0) iterator.remove();
       }
       System.out.println(mySet);

       }
}

ప్రోగ్రామ్ యొక్క అవుట్‌పుట్ ఇక్కడ ఉంది:

ట్రీసెట్‌తో ఉదాహరణ

క్రమబద్ధీకరణ మీకు ముఖ్యమైతే, TreeSet అమలును ఉపయోగించండి. ఈ చిన్న ఉదాహరణలో, మేము మునుపటి ఉదాహరణలలో వలె స్నేహితుల పేర్లతో సెట్‌లో నింపుతాము. అయినప్పటికీ, క్రమబద్ధీకరించబడిన ట్రీసెట్‌లో , మూలకాలు వెంటనే క్రమబద్ధీకరించబడిన క్రమంలో వ్రాయబడతాయి. ఈ సందర్భంలో, పేర్లు అక్షరక్రమంలో ప్రదర్శించబడతాయి.

import java.util.Set;
import java.util.TreeSet;
public class TreeSetTest {

   public static void main(String[] args) {

       Set mySet = new TreeSet<>();
       mySet.add("Stuart");
       mySet.add("Alex");
       mySet.add("Johnny");
       mySet.add("Igor");
       mySet.add("Bel");
       System.out.println(mySet);

   }

అవుట్‌పుట్:

సంక్షిప్త ముగింపులు

• జావా సెట్ ఇంటర్‌ఫేస్ జావా కలెక్షన్స్ ఫ్రేమ్‌వర్క్‌లో భాగం.

• అమలు చేయబడిన తరగతులు: AbstractSet , ConcurrentHashMap.KeySetView , ConcurrentSkipListSet , CopyOnWriteArraySet , EnumSet , HashSet , JobStateReasons , LinkedHashSet , TreeSet .

• అత్యంత ప్రజాదరణ పొందిన సెట్ అమలులు HashSet , LinkedHashSet మరియు TreeSet .

• HashSet మూలకం క్రమం సంక్లిష్ట అల్గోరిథం ద్వారా నిర్ణయించబడుతుంది. స్టోరేజ్ ఆర్డర్ మీకు ముఖ్యమైనది అయితే, TreeSet కంటైనర్‌ను ఉపయోగించండి, ఇది ఆరోహణ క్రమంలో క్రమబద్ధీకరించబడిన వస్తువులను పోలిక క్రమంలో నిల్వ చేస్తుంది లేదా అదనపు క్రమంలో మూలకాలను నిల్వ చేసే LinkedHashSet .

• చాలా తరచుగా, సభ్యత్వాన్ని పరీక్షించడానికి సెట్లు ఉపయోగించబడతాయి. అంటే, ఒక వస్తువు గణిత కోణంలో ఇచ్చిన సమితికి చెందినదా అని తనిఖీ చేయడం. కాబట్టి చాలా తరచుగా ఆచరణలో ఉన్న అన్ని సెట్ అమలులలో, HashSet సాధారణంగా ఎంపిక చేయబడుతుంది. వేగవంతమైన శోధన కోసం ఈ అమలు ఆప్టిమైజ్ చేయబడింది.

• మీరు సెట్‌కు నకిలీ మూలకాలను జోడించలేరు, కాబట్టి మీరు ప్రత్యేక అంశాలను నిల్వ చేయడానికి సెట్ ఇంటర్‌ఫేస్ అమలులను ఉపయోగించవచ్చు .

• ఒక శూన్య మూలకాన్ని మాత్రమే జోడించడానికి సెట్ మిమ్మల్ని అనుమతిస్తుంది.

• సెట్ అనేది జాబితా కాదు మరియు దాని మూలకాల సూచికలు లేదా స్థానాలకు మద్దతు ఇవ్వదు.