జావా హాష్ మ్యాప్‌లను అర్థం చేసుకోవడం

జావా అంటే ఏమిటిహాష్ మ్యాప్స్?

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

హాష్ మ్యాప్‌లను ఉపయోగిస్తున్నప్పుడు, విలువలు హాష్ మ్యాప్‌లో ఉంచబడతాయి మరియు వినియోగదారు విలువను తిరిగి పొందినప్పుడల్లా, విలువను ఉపయోగించడానికి కీ ఉపయోగించబడుతుంది.

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

హాష్ మ్యాప్‌లో అనేక పద్ధతులు అందుబాటులో ఉన్నాయి

• ఆబ్జెక్ట్ పుట్ (ఆబ్జెక్ట్ కీ, ఆబ్జెక్ట్ విలువ)
• గణన కీలు () - ఇది కీలను పొందుతుంది
• గణన అంశాలు () - ఇది మూలకాలను పొందుతుంది
• ఆబ్జెక్ట్ గెట్ (ఆబ్జెక్ట్ కీలు) - కీని పాస్ చేసి దానితో అనుబంధించబడిన విలువను పొందండి
• బూలియన్ కీ (ఆబ్జెక్ట్ కీ) ను కలిగి ఉంది - హాష్ మ్యాప్‌లో కీ ఉందో లేదో తనిఖీ చేయడానికి ఉపయోగిస్తారు
• బూలియన్ విలువ (ఆబ్జెక్ట్ కీ) ను కలిగి ఉంది - కీని పాస్ చేయండి
• ఆబ్జెక్ట్ రిమూవ్ (ఆబ్జెక్ట్ కీ) - కీని పాస్ చేసి ఆబ్జెక్ట్ ను తొలగించండి
• Int పరిమాణం () - పరిమాణాన్ని ఉపయోగించడం కోసం
• స్ట్రింగ్ టు స్ట్రింగ్ () - స్ట్రింగ్ గా మార్చడానికి

ప్రతి కీకి సంబంధిత విలువలు ఉన్నాయి, ఇక్కడ విలువలు హాష్ మ్యాప్‌లో కూడా శూన్యంగా ఉంటాయి.

హాష్ మ్యాప్ యొక్క సృష్టి.

హాష్ మ్యాప్ హాష్ మ్యాప్ = కొత్త హాష్ మ్యాప్ ()

అంశాలను ఉంచడం

ఈ రోజు వరకు జావా పార్స్ స్ట్రింగ్

hashmap.put (“అంకిత”, 9634.58)

hashmap.put (“విశాల్”, 1283.48)

hashmap.put (“గురిందర్”, 1478.10)

hashmap.put (“కృష్ణ”, 199.11)

జావా అల్గోరిథంలు మరియు డేటా నిర్మాణాలు

ఇక్కడ, మేము కీ మరియు విలువను పాస్ చేస్తాము.

విలువను ప్రదర్శిస్తోంది - మళ్ళిని పొందండి

ఇటిరేటర్ iterator = hashmap.entrySet (). ఇటిరేటర్ ()

ఇక్కడ, విలువలు సెట్‌లో ఉన్నాయి కాబట్టి మేము ఎంట్రీసెట్‌ని ఉపయోగిస్తాము.

పంక్తితో పాటు:

(Iterator.hasNext ()) while అయితే

మ్యాప్.ఎంట్రీ ఎంట్రీ = (మ్యాప్.ఎంట్రీ) iterator.next ()

System.out.print (entry.getKey () + ”:”)

System.out.printIn (entry.getValue ())

}

మాకు ప్రశ్న ఉందా? వ్యాఖ్యల విభాగంలో వాటిని ప్రస్తావించండి మరియు మేము మిమ్మల్ని సంప్రదిస్తాము.

సంబంధిత పోస్ట్లు:

ఉదాహరణలతో జావా 9 లక్షణాలు