HashMap: ఇది ఎలాంటి మ్యాప్?

హాయ్! ఈ పాఠంలో, మేము జావా హాష్‌మ్యాప్‌లో నిశితంగా సమీక్షిస్తాము . ఇంతకుముందు, మూలకాలు వాటికవే నిల్వ చేయబడిన డేటా నిర్మాణాలను మేము అధ్యయనం చేసాము. శ్రేణి లేదా అర్రేలిస్ట్ / లింక్డ్‌లిస్ట్‌లో , మేము కొన్ని మూలకాల సంఖ్యను నిల్వ చేస్తాము. కానీ మన పని కొద్దిగా మారితే? కింది పనిని ఊహించండి: ప్రతి వ్యక్తి పేరు మరియు పాస్‌పోర్ట్ నంబర్‌ను నిల్వ చేసే 100 మంది వ్యక్తుల జాబితాను సృష్టించండి. సూత్రప్రాయంగా, ఇది అంత కష్టం కాదు. ఉదాహరణకు, మీరు రెండింటినీ స్ట్రింగ్‌లో నింపి, ఆపై ఈ స్ట్రింగ్‌ల జాబితాను సృష్టించవచ్చు: "అమేలియా అగ్యిలర్, 4211 717171". కానీ ఈ పరిష్కారం రెండు లోపాలను కలిగి ఉంది. ముందుగా, పాస్‌పోర్ట్ నంబర్ ద్వారా శోధించే సామర్థ్యం మనకు అవసరం కావచ్చు. మరియు ఈ సమాచార నిల్వ ఆకృతిని బట్టి ఇది సమస్యాత్మకంగా ఉంటుంది. రెండవది, ఒకే పాస్‌పోర్ట్ నంబర్‌తో ఇద్దరు వేర్వేరు వ్యక్తులను సృష్టించకుండా మనల్ని ఏదీ ఆపదు. మరియు ఇది మా పరిష్కారం యొక్క అత్యంత తీవ్రమైన లోపం. దీన్ని ఎప్పటికీ అనుమతించకూడదు: ఇద్దరు వ్యక్తులు ఒకే పాస్‌పోర్ట్ నంబర్‌ని కలిగి ఉండరు. కొత్త డేటా నిర్మాణం మా సహాయానికి వస్తుంది: మ్యాప్. దీనిని "అసోసియేటివ్ అర్రే" అని కూడా అంటారు, కానీ ఈ పదం చాలా అరుదుగా ఉపయోగించబడుతుంది. చాలా సాధారణంగా, దీనిని "నిఘంటువు" లేదా "మ్యాప్" అని పిలుస్తారు. :) మేము ఇంతకుముందు పరిగణించిన డేటా స్ట్రక్చర్‌ల కంటే ఇది ప్రాథమికంగా ఎలా భిన్నంగా ఉంటుంది? అన్నింటికంటే ముఖ్యంగా, మ్యాప్‌లోని డేటా కీ-విలువ జతలుగా నిల్వ చేయబడుతుంది. ఏదైనా కీలు మరియు విలువలుగా ఉపయోగపడుతుంది: సంఖ్యలు, స్ట్రింగ్‌లు లేదా ఇతర తరగతుల వస్తువులు. ఈ రోజు మనం మ్యాప్ క్లాస్ యొక్క అత్యంత సాధారణ అమలును అధ్యయనం చేస్తాము : Java HashMap .

కాబట్టి, జావాలో HashMap గురించి మనం ఏమి తెలుసుకోవాలి?

దీన్ని సృష్టించడం చాలా సులభం:

public static void main(String[] args) {
   HashMap<Integer, String> passportsAndNames = new HashMap<>();
}

ఇక్కడ మేము మూలకాలను "number-string" జతలగా నిల్వ చేసే నిఘంటువుని సృష్టిస్తాము. సంఖ్య కీగా మరియు స్ట్రింగ్ విలువగా పని చేస్తుంది. మేము కీ రకం (పూర్ణాంకం) మరియు విలువ రకాన్ని (స్ట్రింగ్) కూడా పేర్కొంటాము. ఎందుకు? ముందుగా, HashMap కీ ఎల్లప్పుడూ ప్రత్యేకంగా ఉంటుంది. మేము పాస్‌పోర్ట్ నంబర్‌ను కీగా ఉపయోగించుకోవచ్చు మరియు నకిలీలను నివారించవచ్చు కాబట్టి ఇది మాకు సరిగ్గా సరిపోతుంది. విలువ పూర్తి పేరుతో స్ట్రింగ్ అవుతుంది (వేర్వేరు వ్యక్తులు ఒకే పేరుని కలిగి ఉండవచ్చు; దాని గురించి మనం చింతించాల్సిన పని లేదు). HashMap కి కొత్త జతని జోడించడం ఇలా కనిపిస్తుంది:

public class Main {

   public static void main(String[] args) {
       HashMap<Integer, String> passportsAndNames = new HashMap<>();

       passportsAndNames.put (212133, "Bridget Logan");
       passportsAndNames.put (162348, "Ivan the Great");
       passportsAndNames.put(8082771, "Donald John Trump");
       System.out.println(passportsAndNames);
   }
}

మేము దీని కోసం పుట్ () పద్ధతిని ఉపయోగిస్తాము . అదనంగా, HashMap toString() పద్ధతిని భర్తీ చేస్తుంది , కనుక ఇది కన్సోల్‌లో ప్రదర్శించబడుతుంది. అవుట్‌పుట్ ఇలా ఉంటుంది: {212133=బ్రిడ్జేట్ లోగాన్, 8082771=డోనాల్డ్ జాన్ ట్రంప్, 162348=ఇవాన్ ది గ్రేట్} ఇప్పుడు కీలు నిజంగా ప్రత్యేకమైనవో కాదో వెరిఫై చేద్దాం? మ్యాప్‌లో ఇప్పటికే ఉపయోగించిన కీతో కొత్త మూలకాన్ని జోడించడాన్ని ప్రయత్నిద్దాం :

public static void main(String[] args) {
   HashMap<Integer, String> passportsAndNames = new HashMap<>();

   passportsAndNames.put (212133, "Bridget Logan");
   passportsAndNames.put (162348, "Ivan the Great");
   passportsAndNames.put(8082771, "Donald John Trump");
   passportsAndNames.put(162348, "Albert Kent");// This key has already been used
   System.out.println(passportsAndNames);
}

అవుట్‌పుట్: {212133=బ్రిడ్జేట్ లోగాన్, 8082771=డోనాల్డ్ జాన్ ట్రంప్, 162348=ఆల్బర్ట్ కెంట్} మీరు చూడగలిగినట్లుగా, కీ 162348 తో అనుబంధించబడిన మునుపటి విలువ భర్తీ చేయబడింది. మేము "కీ" అనే పదాన్ని ఒక కారణం కోసం ఉపయోగిస్తాము. హ్యాష్‌మ్యాప్‌లోని విలువలు కీని ఉపయోగించి యాక్సెస్ చేయబడతాయి, కానీ ఇతర మార్గం కాదు. విలువలు ప్రత్యేకంగా ఉండకపోవచ్చు కాబట్టి, విలువను ఉపయోగించి కీని పొందడం సాధ్యం కాదు. HashMap నుండి మూలకాన్ని పొందేటప్పుడు లేదా తీసివేయేటప్పుడు ఇది స్పష్టంగా చూడవచ్చు :

public static void main(String[] args) {
   HashMap<Integer, String> passportsAndNames = new HashMap<>();

   passportsAndNames.put (212133, "Bridget Logan");
   passportsAndNames.put (162348, "Ivan the Great");
   passportsAndNames.put(8082771, "Donald John Trump");

   String lidiaName = passportsAndNames.get(212133);
   System.out.println(lidiaName);

   passportsAndNames.remove(162348);
   System.out.println(passportsAndNames);
}

విలువను పొందడానికి లేదా నిఘంటువు నుండి ఒక జతని తీసివేయడానికి, మనం తప్పనిసరిగా గెట్( )కి పాస్ చేయాలి మరియు విలువకు అనుగుణంగా ఉండే ప్రత్యేక కీని తీసివేయాలి . శ్రేణులు మరియు జాబితాల వలె కాకుండా, జావాలోని హాష్‌మ్యాప్‌లో సంఖ్యా సూచికలు లేవు: విలువలు కీని ఉపయోగించి యాక్సెస్ చేయబడతాయి. కన్సోల్ అవుట్‌పుట్: బ్రిడ్జేట్ లోగాన్ {212133= బ్రిడ్జేట్ లోగాన్, 8082771=డోనాల్డ్ జాన్ ట్రంప్} అర్రేలిస్ట్ మరియు లింక్డ్‌లిస్ట్ తరగతులు జాబితాలో ఏదైనా నిర్దిష్ట మూలకం ఉందో లేదో తనిఖీ చేద్దాం. Java HashMap దీన్ని అనుమతిస్తుంది. ఇంకా ఏమిటంటే, మేము ఈ జంటలోని ఇద్దరు సభ్యుల కోసం దీన్ని చేయవచ్చు: ఇది కలిగి ఉన్న కీ() (కీ కోసం తనిఖీ చేస్తుంది) మరియు కలిగి ఉన్న విలువ()(విలువ కోసం తనిఖీలు) పద్ధతులు.

public static void main(String[] args) {
   HashMap<Integer, String> passportsAndNames = new HashMap<>();

   passportsAndNames.put (212133, "Bridget Logan");
   passportsAndNames.put (162348, "Ivan the Great");
   passportsAndNames.put(8082771, "Donald John Trump");

   System.out.println(passportsAndNames.containsKey(11111));
   System.out.println(passportsAndNames.containsValue("Donald John Trump"));
}

అవుట్‌పుట్: తప్పు నిజం Javaలో HashMap యొక్క మరొక అనుకూలమైన లక్షణం ఏమిటంటే, మీరు అన్ని కీలు మరియు అన్ని విలువల యొక్క ప్రత్యేక జాబితాలను పొందవచ్చు. ఇది కీసెట్() మరియు విలువలు() పద్ధతులతో సాధించబడుతుంది :

public class Main {

   public static void main(String[] args) {
       HashMap<Integer, String> passportsAndNames = new HashMap<>();

       passportsAndNames.put (212133, "Bridget Logan");
       passportsAndNames.put (162348, "Ivan the Great");
       passportsAndNames.put(8082771, "Donald John Trump");

       Set keys = passportsAndNames.keySet();
       System.out.println("Keys: " + keys);

       ArrayList<String> values = new ArrayList<>(passportsAndNames.values());
       System.out.println("Values: " + values);
   }
}

కీలు మేము ఇంకా కవర్ చేయని సెట్‌లోకి సంగ్రహించబడ్డాయి . ఇందులో రిపీటింగ్ ఎలిమెంట్స్ ఉండకపోవడం విశేషం. ఇప్పుడు ప్రధాన విషయం ఏమిటంటే, అన్ని కీల జాబితాను HashMap నుండి ప్రత్యేక సేకరణలోకి తిరిగి పొందవచ్చని గుర్తుంచుకోండి . ఉదాహరణలో, మేము విలువలను సాధారణ అర్రేలిస్ట్‌లో సేవ్ చేసాము . కన్సోల్ అవుట్‌పుట్: కీలు: [212133, 8082771, 162348] విలువలు: [బ్రిడ్జేట్ లోగాన్, డోనాల్డ్ జాన్ ట్రంప్, ఇవాన్ ది గ్రేట్] పరిమాణం () మరియు స్పష్టమైన() పద్ధతులు మనం చర్చించిన మునుపటి నిర్మాణాల మాదిరిగానే చేస్తాయి: మొదటిది ప్రస్తుతం నిఘంటువులో ఉన్న మూలకాల సంఖ్యను అందిస్తుంది, రెండవది అన్ని మూలకాలను తొలగిస్తుంది.

public static void main(String[] args) {
   HashMap<Integer, String> passportsAndNames = new HashMap<>();

   passportsAndNames.put (212133, "Bridget Logan");
   passportsAndNames.put (162348, "Ivan the Great");
   passportsAndNames.put(8082771, "Donald John Trump");

   System.out.println(passportsAndNames.size());
   passportsAndNames.clear();
   System.out.println(passportsAndNames);
}

అవుట్‌పుట్: 3 {} మా HashMap లో కనీసం ఒక మూలకం ఉందో లేదో తనిఖీ చేయడానికి , మేము isEmpty() పద్ధతిని ఉపయోగించవచ్చు :

public static void main(String[] args) {
   HashMap<Integer, String> passportsAndNames = new HashMap<>();

   passportsAndNames.put (212133, "Bridget Logan");
   passportsAndNames.put (162348, "Ivan the Great");
   passportsAndNames.put(8082771, "Donald John Trump");

   if (!passportsAndNames.isEmpty()) {

       System.out.println(passportsAndNames);
   }
}

అవుట్‌పుట్: {212133=బ్రిడ్జేట్ లోగాన్, 8082771=డోనాల్డ్ జాన్ ట్రంప్, 162348=ఇవాన్ ది గ్రేట్} ఇప్పుడు మేము ప్రాథమిక తనిఖీ తర్వాత మాత్రమే కన్సోల్‌కి అవుట్‌పుట్ చేస్తాము. :) మరో ఆసక్తికరమైన అంశం ఏమిటంటే, రెండు మ్యాప్‌లను ఒకటిగా కలపవచ్చు. ఇది putAll() పద్ధతిని ఉపయోగించి సాధించబడింది. మేము దానిని మొదటి హాష్‌మ్యాప్‌లో పిలుస్తాము , రెండవదాన్ని ఆర్గ్యుమెంట్‌గా పాస్ చేస్తాము మరియు రెండవ దానిలోని మూలకాలు మొదటిదానికి జోడించబడతాయి:

public static void main(String[] args) {
   HashMap<Integer, String> passportsAndNames = new HashMap<>();
   HashMap<Integer, String> passportsAndNames2 = new HashMap<>();

   passportsAndNames.put (212133, "Bridget Logan");
   passportsAndNames.put (162348, "Ivan the Great");
   passportsAndNames.put(8082771, "Donald John Trump");

   passportsAndNames2.put(917352, "Clifford Patrick");
   passportsAndNames2.put(925648, "Mitchell Salgado");

   passportsAndNames.putAll(passportsAndNames2);
   System.out.println(passportsAndNames);
}

అవుట్‌పుట్: {917352=క్లిఫోర్డ్ పాట్రిక్, 212133=బ్రిడ్జేట్ లోగాన్, 8082771=డోనాల్డ్ జాన్ ట్రంప్, 925648=మిచెల్ సల్గాడో, 162348=ఇవాన్ ది గ్రేట్} పాస్‌పోర్ట్‌లుAndNames2లోని అన్ని జతల పాస్‌పోర్ట్‌లకు కాపీ చేయబడ్డాయి . ఇప్పుడు మరింత సంక్లిష్టమైన ఉదాహరణను పరిగణించండి. ప్రత్యేకంగా, లూప్‌లో హాష్‌మ్యాప్‌పై మళ్లించడం .

for (Map.Entry<Integer, String> entry: passportsAndNames.entrySet()) {
   System.out.println(entry);
}

Map.Entry తరగతి నిఘంటువు లోపల కీ-విలువ జతను సూచిస్తుంది . entrySet () పద్ధతి మా HashMap లోని అన్ని జతల జాబితాను అందిస్తుంది . మా మ్యాప్‌లో ఈ Map.Entry జతలను కలిగి ఉన్నందున, మేము వేర్వేరు కీలు లేదా విలువలను కాకుండా జతలపై పునరావృతం చేస్తున్నాము. అవుట్‌పుట్: 212133=బ్రిడ్జేట్ లోగాన్ 8082771=డోనాల్డ్ జాన్ ట్రంప్ 162348=ఇవాన్ ది గ్రేట్ అలాగే, HashMap కోసం అధికారిక ఒరాకిల్ డాక్యుమెంటేషన్‌ను అధ్యయనం చేయడం మర్చిపోవద్దు .