జావా సెట్ ఉదాహరణ  



జావా జావా సెట్ సెట్

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

సెట్ ఇంటర్ఫేస్ యొక్క లక్షణాలు  

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

జావా సెట్ మరియు జావా జాబితా మధ్య వ్యత్యాసం  

  • జావా సెట్ అనేది క్రమం లేని మూలకాల సేకరణ అయితే <span style="font-family: Mandali; "> జాబితా</span> మూలకాల యొక్క ఆర్డర్ సేకరణ.
  • సెట్‌కు ఇండెక్స్-ఆధారిత ప్రాప్యత లేదు, కాని జాబితాలో మనం అంశాలను యాక్సెస్ చేయగల సూచిక ఉంది.
  • సెట్లో, మేము నకిలీ విలువలను జోడించలేము, అయితే నకిలీ విలువలను జోడించడానికి జాబితా అనుమతిస్తుంది.

అమలు సెట్  

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

  • హాష్‌సెట్ - సమితి గుండా ప్రయాణించేటప్పుడు మూలకాల క్రమం లేదా క్రమం లేదు.
  • ట్రీసెట్ - ఇది సార్టింగ్‌తో పాటు మూలకాల క్రమాన్ని సంరక్షిస్తుంది
  • లింక్డ్ హాష్‌సెట్ - ఇది చొప్పించడం వలె మూలకాల క్రమాన్ని సంరక్షిస్తుంది
ఇది కూడ చూడు
స్కానర్ క్లాస్ జావా మరియు స్కానర్ జావాను దిగుమతి చేయండి

జావా సెట్ చేయండి

జావా సెట్ ఉదాహరణ  

సెట్ ఇంటర్‌ఫేస్‌ను అమలు చేయడానికి, మేము java.util ను దిగుమతి చేసుకోవాలి. * ప్యాకేజీ వేరే తరగతి ప్యాకేజీలను విడిగా దిగుమతి చేస్తుంది.

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

public class SetExample {

  public static void main(String[] args) {
    Set set1 = new HashSet();
    Set set2 = new TreeSet();
    Set set3 = new LinkedHashSet();

  }

}

క్రింద చూపిన విధంగా మేము సాధారణ సెట్లను కూడా సృష్టించవచ్చు. ఇక్కడ మేము హాష్‌సెట్‌ను స్ట్రింగ్ రకంగా మరియు ట్రీసెట్‌ను పూర్ణాంక రకంగా పేర్కొన్నాము. అందువల్ల ఈ వస్తువులు ఈ నిర్దిష్ట రకాల విలువలను మాత్రమే అంగీకరిస్తాయి.

import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;

public class SetExample {

  public static void main(String[] args) {
    Set<String> setstring = new HashSet<String>();
    Set<Integer> setint = new TreeSet<Integer>();
  }
}

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

సెట్లో క్రింద పేర్కొన్న పద్ధతులతో పాటు కలెక్షన్ ఇంటర్ఫేస్ యొక్క అన్ని పద్ధతులు ఉన్నాయి.

విధానం<span style="font-family: Mandali; "> టెండర్‌ వివరణ</span>పరామితి
బూలియన్ యాడ్ (స్ట్రింగ్ ఇ)సెట్ ఇప్పటికే లేనట్లయితే దానికి మూలకాన్ని జోడిస్తుంది. సెట్‌లో మూలకం ఇప్పటికే ఉండి, కాల్‌ను విస్మరిస్తే అది తప్పు అవుతుందిe - సెట్‌కు జోడించాల్సిన మూలకం
బూలియన్ యాడ్అల్ (కలెక్షన్)సేకరణలో ఉన్న అన్ని అంశాలను సమితిలో చేర్చకపోతే అది జోడిస్తుందిసి - జోడించాల్సిన అంశాల సేకరణ
void clear ()సెట్ నుండి అన్ని అంశాలను తొలగిస్తుంది మరియు సెట్ ఖాళీగా ఉంటుంది
బూలియన్ కలిగి ఉంది (ఆబ్జెక్ట్ ఓ)సెట్‌లో మూలకం ఉందో లేదో తనిఖీ చేస్తుంది మరియు ఉన్నట్లయితే నిజమైనదిo - సెట్‌లో శోధించాల్సిన మూలకం
బూలియన్ అన్ని కలిగి ఉంది (సేకరణ సి)సేకరణ సమితి యొక్క ఉపసమితి కాదా అని తనిఖీ చేస్తుంది మరియు ఉన్నట్లయితే నిజమైనదిసి - మూలకాల సేకరణ
బూలియన్ సమానం (ఆబ్జెక్ట్ ఓ)ఆమోదించిన వస్తువుతో సెట్ యొక్క సమానత్వాన్ని తనిఖీ చేస్తుంది. రెండూ సెట్లు మరియు ఒకే అంశాలు మరియు పరిమాణాన్ని కలిగి ఉంటే ఇది నిజం అవుతుందిo - పోల్చవలసిన వస్తువు
బూలియన్ isEmpty ()సెట్ ఖాళీగా ఉందో లేదో తనిఖీ చేస్తుంది మరియు ఖాళీగా ఉంటే నిజం అవుతుంది
ఇటిరేటర్ ఇరేటర్ ()సెట్‌లోని మూలకాల ద్వారా నావిగేట్ చెయ్యడానికి ఇటరేటర్‌ను చూపుతుంది
బూలియన్ తొలగించు (ఆబ్జెక్ట్ ఓ)సెట్ నుండి నిర్దిష్ట మూలకాన్ని తీసివేస్తుంది మరియు మూలకం తొలగించబడితే నిజమైనదిo - తొలగించాల్సిన మూలకం
బూలియన్ రిమూవల్అల్ (కలెక్షన్ సి)సేకరణలో ఉన్న అన్ని అంశాలను సెట్ నుండి తొలగిస్తుందిసి - తొలగించాల్సిన మూలకాల సేకరణ
బూలియన్ నిలుపుదల అన్ని (సేకరణ సి)సెట్‌లోని సేకరణలోని మూలకాలను మాత్రమే కలిగి ఉంటుంది, అంటే సేకరణలో భాగం కాని అన్ని ఇతర అంశాలను ఇది తొలగిస్తుందిసి - నిలుపుకోవలసిన మూలకాల సేకరణ
పూర్ణాంక పరిమాణం ()సెట్‌లోని మూలకాల సంఖ్యను చూపుతుంది
SplitIterator splititerator ()సెట్‌లోని అంశాలపై స్ప్లిట్ ఇరేటర్‌ను సృష్టిస్తుంది
ఆబ్జెక్ట్ [] toArray ()సెట్‌లోని అన్ని అంశాలను శ్రేణికి మారుస్తుంది
స్ట్రింగ్ toString ()వస్తువు యొక్క స్ట్రింగ్ ప్రాతినిధ్యాన్ని అందిస్తుంది
ఇది కూడ చూడు
జావాలో డేటాఇన్‌పుట్ స్ట్రీమ్

మినహాయింపులను సెట్ చేయండి  

జావా సెట్ త్రోలు దిగువ మినహాయింపులు

  • మద్దతు లేని ఆపరేషన్ ఎక్సెప్షన్
  • NullPointerException
  • క్లాస్‌కాస్ట్ ఎక్సెప్షన్
  • చట్టవిరుద్ధ ఆర్గ్యుమెంట్ ఎక్సెప్షన్

సమితి నుండి మూలకాలను జోడించి తొలగించండి  

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

తొలగింపు ఉదాహరణలో, మేము మొదట 1 వ సెట్ నుండి ఒక మూలకాన్ని తీసివేసి, ఆపై రెండవ సెట్ నుండి అన్ని అంశాలను తీసివేస్తాము.

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

public class SetExample {

  public static void main(String[] args) {

    Set<String> setstring = new HashSet<String>();
    setstring.add("Java");
    setstring.add("Javascript");
    System.out.println(setstring);
    
    Set<String> string2 = new HashSet<String>();
    string2.add("C");
    string2.add("C++");
    
    setstring.addAll(string2);
    System.out.println("Elements in set after addAll operation");
    System.out.println(setstring);
    
    setstring.remove("Javascript");
    System.out.println("Elements in the set after remove opertaion");
    System.out.println(setstring);
    
    setstring.removeAll(string2);
    System.out.println("Elements in the set after removeAll opertaion");
    System.out.println(setstring);
    
  }
  

}
Output:
[Java, Javascript]
Elements in set after addAll operation
[Java, C++, C, Javascript]
Elements in the set after remove opertaion
[Java, C++, C]
Elements in the set after removeAll opertaion
[Java]

ట్రీసెట్ ఉపయోగించి మూలకాలను క్రమబద్ధీకరించడం  

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

import java.util.*;

public class SetSort {

  public static void main(String[] args) {
    Set<Integer> numbers = new HashSet<Integer>();
    int[] a = {34,78,12,67,45,23,12,89};
    for(int i=0;i<a.length;i++) {
      numbers.add(a[i]);
    }
    System.out.println("Elements in HashSet");
    System.out.println(numbers);
    
    Set<Integer> treeset = new TreeSet<Integer>(numbers);
    System.out.println("Elements in treeset after sort");
    System.out.println(treeset);
  }

}
Output:
Elements in HashSet
[34, 67, 23, 89, 12, 45, 78]
Elements in treeset after sort
[12, 23, 34, 45, 67, 78, 89]

జావా సెట్‌ను శ్రేణికి మార్చండి  

మేము సెట్‌ను ఒకగా మార్చవచ్చు అమరిక క్రింద వివరించిన విధంగా toArray పద్ధతిని ఉపయోగించే మూలకాల.

import java.util.*;

public class SetArray {

  public static void main(String[] args) {
    Set<String> names = new HashSet<String>();
    names.add("Roshan");
    names.add("Kiran");
    names.add("Tejas");
    names.add("Karthik");
    
    String[] strnames = names.toArray(new String[names.size()]);
    for(String strvalues: strnames) {
      System.out.println(strvalues);
    }

  }

}
Output:
Roshan
Kiran
Tejas
Karthik

సెట్ కార్యకలాపాల జావా ప్రోగ్రామ్ ఉదాహరణ (యూనియన్, ఖండన మరియు వ్యత్యాసం)  

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

import java.util.*;

public class SetOperations {

  public static void main(String[] args) {
    Set<Integer> set1 = new HashSet<Integer>();
    set1.add(3);
    set1.add(7);
    set1.add(5);
    set1.add(1);
    System.out.println("Set 1 : " + set1);
    
    Set<Integer> set2 = new HashSet<Integer>();
    set2.add(3);
    set2.add(4);
    set2.add(9);
    set2.add(5);
    
    System.out.println("Set 2 : " + set2);
    
    Set<Integer> a = new HashSet<Integer>(set1);
    a.addAll(set2);
    
    System.out.println("Union of Set 1 and Set 2 : " + a);
    
    Set<Integer> b = new HashSet<Integer>(set1);
    b.retainAll(set2);
    System.out.println("Intersection of Set 1 and Set 2 : " + b);
    
    Set<Integer> c = new HashSet<Integer>(set1);
    c.removeAll(set2);
    System.out.println("Difference between Set 1 and Set 2 : " + c);
  }

}
Output:
Set 1 : [1, 3, 5, 7]
Set 2 : [3, 4, 5, 9]
Union of Set 1 and Set 2 : [1, 3, 4, 5, 7, 9]
Intersection of set 1 and set 2 : [3, 5]
Difference between 2 sets : [1, 7]

ముగింపు  

ఈ ట్యుటోరియల్‌లో, మీరు జావాలో సెట్ గురించి మరియు విభిన్న అవకతవకల కోసం సెట్‌ను ఎలా సృష్టించాలో మరియు ఎలా ఉపయోగించాలో నేర్చుకున్నారు.

ఇది కూడ చూడు
జావాలో గణనలు

సూచన