HashSet అంటే ఏమిటి?
HashSet అనేది జావాలో అంతర్నిర్మిత డేటాటైప్, మరియు సాధారణ పరంగా మీరు "HashSet అనేది ప్రత్యేకమైన అంశాల యొక్క క్రమం లేని సేకరణ" అని చెప్పవచ్చు. ఒక ప్రాథమిక ఉదాహరణను పరిశీలించండి:
- ఇది నిల్వ కోసం హాష్ పట్టికను ఉపయోగించే సేకరణను ( సేకరణ అంటే వస్తువుల యొక్క ఒకే యూనిట్ ఉదా: అర్రేలిస్ట్, లింక్డ్‌లిస్ట్, వెక్టర్ మొదలైనవి) సృష్టిస్తుంది.
- HashSetలో నకిలీ విలువలు అనుమతించబడవు.
- మీరు HashSetలో "శూన్య" విలువలను చేర్చవచ్చు.
- చొప్పించే క్రమం నిర్వహించబడదు. కాబట్టి మీరు అంశాలను క్రమంలో చొప్పించాలని చూస్తున్నట్లయితే, మీ అవసరాలకు HashSet చెడు ఎంపిక అవుతుంది.
- మీరు స్థిరమైన సమయంలో (O(1)) ఒక మూలకాన్ని పొందాలనుకుంటే/తిరిగి పొందాలనుకుంటే, మీరు తీసుకోగల ఉత్తమ విధానాలలో HashSet ఒకటి.
HashSet.contains() పద్ధతి అంటే ఏమిటి?
HashSet.contains() అనేది HashSet యొక్క సందర్భంలో ఒక అంశం ఉందో లేదో తనిఖీ చేయడానికి ఒక boolean పద్ధతి. సరళంగా చెప్పాలంటే, సెట్‌లో కావలసిన మూలకం ఉందా. Java.util.HashSet దాని కోసం సమర్థవంతమైన అమలును అందిస్తుంది. మీ ప్రశ్నలను పరిష్కరించడానికి మీరు దీన్ని ఎలా సమర్థవంతంగా ఉపయోగించవచ్చో మేము మీకు చూపుతాము.పూర్ణాంకాలతో ()ని కలిగి ఉంటుంది
import java.util.HashSet;
public class HashSetDemo {
public static void main(String[] args) {
// Declare your hash set
HashSet digits = new HashSet();
digits.add(0);
digits.add(1);
digits.add(2);
digits.add(3);
digits.add(4);
digits.add(5);
digits.add(null);
System.out.println("All elements in hashset:\t" + digits);
// Try adding duplicates
digits.add(5);
digits.add(2);
System.out.println("After adding duplicates: \t" + digits);
System.out.println("\n-------Using Contains Method-------");
// Check out if the following digits exist in the hashset
System.out.println("digits.contains(0) : " + digits.contains(0));
System.out.println("digits.contains(2) : " + digits.contains(2));
System.out.println("digits.contains(3) : " + digits.contains(7));
System.out.println("digits.contains(null) : " + digits.contains(null));
}
}
హ్యాష్‌సెట్‌లోని అన్ని మూలకాలు: [0, శూన్య, 1, 2, 3, 4, 5] నకిలీలను జోడించిన తర్వాత: [0, శూన్య, 1, 2, 3, 4, 5] -------ఉపయోగించే పద్ధతి- ------ digits.contains(0) : true digits.contains(2) : true digits.contains(3) : false digits.contains(null) : true
స్ట్రింగ్‌లతో ()ని కలిగి ఉంటుంది
స్ట్రింగ్స్‌తో కలిగి ఉన్న() పద్ధతికి మరొక ఉదాహరణను చూడండి .import java.util.HashSet;
public class HashSetDemo {
public static void main(String[] args) {
// Try working with another hash set of String type
HashSet rainbow = new HashSet();
// Adding elements into HashSet using add()
rainbow.add("Red");
rainbow.add("Orange");
rainbow.add("Yellow");
rainbow.add("Green");
rainbow.add("Blue");
rainbow.add("Indigo");
rainbow.add("Violet");
// Let's traverse the hashset
System.out.println("Traversing the rainbow:");
for (String i : rainbow){
System.out.println(i);
}
// Check out if rainbow contains this color or not
System.out.println("\n-------Using Contains Method-------");
System.out.println("rainbow.contains(\"Yellow\"): \t" + rainbow.contains("Yellow"));
System.out.println("rainbow.contains(\"White\"): \t" + rainbow.contains("White"));
System.out.println("rainbow.contains(\"Lavender\"): \t" + rainbow.contains("Lavender"));
System.out.println("rainbow.contains(\"Red\"): \t" + rainbow.contains("Red"));
// Remove a color from rainbow using remove()
rainbow.remove("Red");
// Now consume set contains() method again to check if it's still present
System.out.println("rainbow.contains(\"Red\"): \t" + rainbow.contains("Red"));
System.out.println("\nAfter removing Red: " + rainbow);
}
}
ఇంద్రధనస్సును దాటడం: రెడ్ వైలెట్ ఎల్లో బ్లూ ఇండిగో ఆరెంజ్ గ్రీన్ -------ఉపయోగించే విధానం------- రెయిన్‌బో.contains("పసుపు"): true rainbow.contains("White"): false rainbow. కలిగి ("లావెండర్"): తప్పుడు రెయిన్‌బో. కలిగి ఉంటుంది("ఎరుపు"): నిజమైన రెయిన్‌బో. కలిగి ఉంటుంది("ఎరుపు"): తప్పు ఎరుపును తొలగించిన తర్వాత: [వైలెట్, పసుపు, నీలం, నీలిమందు, నారింజ, ఆకుపచ్చ]
మీరు చూడగలిగినట్లుగా, అవుట్‌పుట్ క్రమం మరియు మూలకాలను హ్యాష్‌సెట్‌లో ఉంచే క్రమం నుండి భిన్నంగా ఉంటుంది.