హాష్ మ్యాప్ పద్ధతులు జావా



హాష్ మ్యాప్ జావా జావా మ్యాప్

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

జావా హాష్ మ్యాప్ సోపానక్రమం

జావాలోని హాష్ మ్యాప్ తరగతి విస్తరించింది వియుక్త తరగతి వియుక్త మ్యాప్ మరియు అమలు చేస్తుంది మ్యాప్ క్రింద చూపిన విధంగా ఇంటర్ఫేస్.

జావాలో హాష్ మ్యాప్

హాష్ మ్యాప్ నిర్మాణం మరియు పని సూత్రం

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

జావాలో హాష్ మ్యాప్

హాష్ మ్యాప్ పనితీరు

జావాలో హాష్ మ్యాప్ యొక్క పనితీరు క్రింది పారామితులపై ఆధారపడి ఉంటుంది:

  • ప్రారంభ సామర్థ్యం - ఇది ప్రారంభించినప్పుడు హాష్ మ్యాప్ ఎన్ని బకెట్లను నిల్వ చేయగలదో సూచిస్తుంది. అప్రమేయంగా, ఇది 16 కీ-విలువ జతలు
  • లోడ్ కారకం - ఇది సామర్థ్యం శాతం పెంచాల్సిన అవసరం ఉంది. అప్రమేయంగా, ఇది 0.75
  • థ్రెషోల్డ్ - ఇది లోడ్ కారకం మరియు సామర్థ్యం యొక్క ఉత్పత్తి, దీని డిఫాల్ట్ విలువ 12 (16 * 0.75)
  • రీహాషింగ్ - ఇది ప్రవేశ విలువను చేరుకున్న తర్వాత సామర్థ్యాన్ని రెట్టింపు చేసే ప్రక్రియ.

జావా హాష్ మ్యాప్ డిక్లరేషన్

జావాలో హాష్ మ్యాప్ ఉపయోగించడానికి, మేము దిగుమతి చేసుకోవాలి java.util.HashMap ప్యాకేజీ. వాక్యనిర్మాణం క్రింద ఇవ్వబడింది:

HashMap<KeyType,ValueType> map = new HashMap<>();

కీటైప్ - ఇది కీ డేటా రకం.ఎగ్: స్ట్రింగ్ లేదా ఇంటీజర్

వాల్యూటైప్ - ఇది విలువ డేటా రకం. ఉదా: స్ట్రింగ్ లేదా పూర్ణాంకం

హాష్ మ్యాప్ ఫీచర్స్

జావాలోని హాష్ మ్యాప్ యొక్క లక్షణాలు క్రింద ఉన్నాయి:

  • ప్రతి కీకి సంబంధించిన విలువలను నిల్వ చేస్తుంది
  • ప్రత్యేకమైన కీలను మాత్రమే కలిగి ఉంటుంది
  • నకిలీ కీలను అనుమతించదు కాని నకిలీ విలువలను కలిగి ఉంటుంది
  • ఇది ఏ క్రమాన్ని నిర్వహించదు అంటే డేటా చొప్పించిన క్రమం అది తిరిగి పొందబడిన క్రమానికి సమానం కాదు.
  • ఇది సమకాలీకరించబడదు

జావా హాష్ మ్యాప్ క్లాస్ కన్స్ట్రక్టర్స్

దిగువ పట్టికలో మీరు చూడగలిగినట్లుగా హాష్ మ్యాప్ 4 వేర్వేరు కన్స్ట్రక్టర్లకు మద్దతు ఇస్తుంది:

నమూనా రచయిత<span style="font-family: Mandali; "> టెండర్‌ వివరణ</span>
హాష్ మ్యాప్ ()డిఫాల్ట్ హాష్ మ్యాప్‌ను ప్రారంభిస్తుంది
హాష్ మ్యాప్ (మ్యాప్)మ్యాప్ m యొక్క అంశాలతో హాష్‌మ్యాప్‌ను ప్రారంభిస్తుంది
హాష్ మ్యాప్ (పూర్ణాంక సామర్థ్యం)పేర్కొన్న సామర్థ్యం పూర్ణాంక విలువతో హ్యాష్‌మ్యాప్‌ను ప్రారంభిస్తుంది
హాష్ మ్యాప్ (పూర్ణాంక సామర్థ్యం, ​​ఫ్లోట్ లోడ్‌ఫ్యాక్టర్)పేర్కొన్న సామర్థ్యం మరియు లోడ్‌ఫ్యాక్టర్‌తో హ్యాష్‌మ్యాప్‌ను ప్రారంభిస్తుంది

హాష్ మ్యాప్ పద్ధతులు

దిగువ పట్టికలో పేర్కొన్న పద్ధతులతో పాటు మ్యాప్ ఇంటర్‌ఫేస్‌కు చెందిన అన్ని పద్ధతులకు జావా హాష్ మ్యాప్ మద్దతు ఇస్తుంది

విధానం<span style="font-family: Mandali; "> టెండర్‌ వివరణ</span>పరామితి
void clear ()ఈ మ్యాప్‌లోని అన్ని మ్యాపింగ్‌లను తొలగిస్తుంది అంటే మ్యాప్ ఖాళీగా ఉంటుంది
ఆబ్జెక్ట్ క్లోన్ ()ఈ హాష్ మ్యాప్ ఉదాహరణ యొక్క నిస్సార కాపీని అందిస్తుంది. కీ మరియు విలువలు క్లోన్ చేయబడవు
బూలియన్ కే (ఆబ్జెక్ట్ కీ) కలిగి ఉందిపేర్కొన్న కీ కోసం మ్యాపింగ్ విలువ ఉంటే నిజం అవుతుందికీ - మనం విలువను తిరిగి పొందవలసిన కీ
బూలియన్ విలువ (ఆబ్జెక్ట్ విలువ) కలిగి ఉందిపేర్కొన్న విలువ కోసం కీ మ్యాపింగ్ ఉంటే నిజం అవుతుందివిలువ - పేర్కొన్న కీ మ్యాప్ చేయబడిన విలువ
సెట్ ఎంట్రీసెట్ ()మ్యాప్ యొక్క మ్యాపింగ్ యొక్క సమితి వీక్షణను అందిస్తుంది
బూలియన్ సమానం (ఆబ్జెక్ట్ ఓ)వస్తువు యొక్క మ్యాపింగ్ యొక్క అదే మ్యాపింగ్ ఉంటే నిజం అవుతుందిo - పోల్చవలసిన వస్తువు
పూర్ణాంకం పొందండి (ఆబ్జెక్ట్ కీ)మ్యాప్‌లో పేర్కొన్న కీ విలువను అందిస్తుంది. మ్యాపింగ్ లేకపోతే ఇది శూన్యంగా వస్తుందికీ - విలువ మ్యాపింగ్ కోసం తిరిగి పొందవలసిన కీ
పూర్ణాంక getOrDefault (ఆబ్జెక్ట్ కీ, పూర్ణాంక డిఫాల్ట్ విలువ)మ్యాప్ చేయబడితే పేర్కొన్న కీ విలువను అందిస్తుంది, లేకపోతే మ్యాపింగ్ లేకపోతే డిఫాల్ట్ విలువను తిరిగి ఇస్తుందికీ - మనం విలువైన కీని తిరిగి ఇవ్వాలి
defaultvalue - మ్యాపింగ్ లేనప్పుడు తిరిగి ఇవ్వవలసిన డిఫాల్ట్ విలువ
int హాష్ కోడ్ ()మ్యాప్ యొక్క హాష్‌కోడ్ విలువను చూపుతుంది
బూలియన్ isEmpty ()హాష్ మ్యాప్‌లో కీ-విలువ జతలు లేవు
కీసెట్ () ను సెట్ చేయండిమ్యాప్‌లో ఉన్న కీల సెట్ సెట్ వీక్షణను అందిస్తుంది
పూర్ణాంక పుట్ (స్ట్రింగ్ కీ, పూర్ణాంక విలువ)కీని విలువతో అనుబంధిస్తుంది. కీ ఇప్పటికే ఉంటే, అది పాత విలువను కొత్త విలువతో భర్తీ చేస్తుందికీ - మ్యాపింగ్ కోసం కీ
విలువ - పేర్కొన్న కీ కోసం విలువ
శూన్యమైన పుట్అల్ (మ్యాప్ m)M యొక్క అన్ని కీ-విలువ మ్యాపింగ్‌లను ప్రస్తుత మ్యాప్‌కు అనుబంధిస్తుందిm - ప్రస్తుత మ్యాప్‌కు జోడించాల్సిన మ్యాపింగ్ కాపీలు
పూర్ణాంక putIfAbsent (స్ట్రింగ్ కీ, పూర్ణాంక విలువ)ఇప్పటికే కీకి మ్యాప్ చేయకపోతే విలువను అనుబంధిస్తుందికీ - మ్యాపింగ్ కోసం కీ
విలువ - అనుబంధించాల్సిన విలువ
పూర్ణాంక తొలగింపు (ఆబ్జెక్ట్ కీ)మ్యాప్‌లో పేర్కొన్న కీ కోసం మ్యాపింగ్‌ను తొలగిస్తుందికీ - మ్యాపింగ్ తొలగించాల్సిన మ్యాప్‌లోని కీ
బూలియన్ తొలగింపు (ఆబ్జెక్ట్ కీ, ఆబ్జెక్ట్ విలువ)పేర్కొన్న విలువతో మ్యాప్ చేయబడితే మాత్రమే పేర్కొన్న కీ యొక్క ఎంట్రీని తొలగిస్తుందికీ - మ్యాప్‌లో కీ
విలువ - విలువ కీకి మ్యాప్ చేయబడింది
పూర్ణాంక పున replace స్థాపన (స్ట్రింగ్ కీ, పూర్ణాంక విలువ)పేర్కొన్న కీ విలువను ప్రస్తుతం కొంత విలువతో మ్యాప్ చేస్తేనే దాన్ని విలువతో భర్తీ చేస్తుందికీ - మ్యాప్‌లో కీ
విలువ - భర్తీ చేయవలసిన విలువ
బూలియన్ పున replace స్థాపన (స్ట్రింగ్ కీ, పూర్ణాంక పాత విలువ, పూర్ణాంక క్రొత్త విలువ)పేర్కొన్న కీ యొక్క ఎంట్రీని ఇప్పటికే పేర్కొన్న పాత విలువతో మ్యాప్ చేస్తేనే క్రొత్త విలువతో భర్తీ చేస్తుందికీ - మ్యాప్‌లో కీ
oldvalue - పాత విలువ కీకి మ్యాప్ చేయబడింది
newvalue - కీకి మ్యాప్ చేయవలసిన క్రొత్త విలువ
పూర్ణాంక పరిమాణం ()మ్యాప్ యొక్క పరిమాణాన్ని అందిస్తుంది
స్ట్రింగ్ toString ()మ్యాప్ యొక్క స్ట్రింగ్ ప్రాతినిధ్యాన్ని అందిస్తుంది
సేకరణ విలువలు ()మ్యాప్‌లో ఉన్న విలువల సేకరణ వీక్షణను అందిస్తుంది

హాష్ మ్యాప్ మినహాయింపులు

ఇది జావాలో క్రింది మినహాయింపులను విసురుతుంది:

  • ఏకకాలిక మోడిఫికేషన్ ఎక్సెప్షన్
  • IllelgalMonitorStateException
  • NullPointerException
  • అంతరాయం కలిగించిన మినహాయింపు
  • చట్టవిరుద్ధ ఆర్గ్యుమెంట్ ఎక్సెప్షన్

హాష్ మ్యాప్‌కు ఎలిమెంట్స్‌ను కలుపుతోంది

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

తరువాత, మేము 'స్టూ' అనే రెండవ హాష్ మ్యాప్‌ను సృష్టించి, ఆపై 2 కీ-విలువ జతలను జోడిస్తాము. ఇది మేము ఉపయోగించి 'విద్యార్థి' మ్యాప్‌కు జోడిస్తాము putAll పద్ధతి.

import java.util.HashMap;
public class HashMapAdd {

  public static void main(String[] args) {
    HashMap<String,Integer> student = new HashMap<>();
    student.put("Arthi", 100);
    student.put("Dev", 105);
    student.put("Banu",102);
    student.put("Rishi", 108);
    System.out.println("Elements in student map:");
    System.out.println(student);
    
    HashMap<String,Integer> stu = new HashMap<>();
    stu.put("Ravi",110);
    stu.put("Tejas", 112);
    System.out.println("Elements in stu map:");
    System.out.println(stu);
    
    student.putAll(stu);
    
    System.out.println("Elements in student map after invoking putAll method:");
    System.out.println(student);
  }

}
Elements in student map:
{Dev=105, Banu=102, Rishi=108, Arthi=100}
Elements in stu map:
{Ravi=110, Tejas=112}
Elements in student map after invoking putAll method:
{Dev=105, Ravi=110, Tejas=112, Banu=102, Rishi=108, Arthi=100}

మ్యాప్‌లో నిర్దిష్ట కీ లేదా విలువ ఉందో లేదో తనిఖీ చేయండి

మేము ఉపయోగిస్తాము కే కలిగి ఉంది మ్యాప్‌లో నిర్దిష్ట కీ ఉందో లేదో తనిఖీ చేసే పద్ధతి. ఈ సందర్భంలో, దేవ్ ఉన్నాడు మరియు అందువల్ల ఇది నిజం అవుతుంది మరియు రవి లేడు మరియు అందువల్ల తప్పుడు తిరిగి వస్తుంది.

అదేవిధంగా, విలువను కలిగి ఉంది ఒక నిర్దిష్ట విలువ ఉంటే పద్ధతి తనిఖీ చేస్తుంది. ఇక్కడ, 102 ఉంది, కానీ 110 లేదు మరియు అందువల్ల తప్పుడు తిరిగి వస్తుంది.

import java.util.HashMap;
public class HashMapAdd {

  public static void main(String[] args) {
    HashMap<String,Integer> student = new HashMap<>();
    student.put("Arthi", 100);
    student.put("Dev", 105);
    student.put("Banu",102);
    student.put("Rishi", 108);
    System.out.println("Elements in student map:");
    System.out.println(student);
    
    System.out.println(student.containsKey("Dev"));
    System.out.println(student.containsKey("Ravi"));
    
    System.out.println(student.containsValue(102));
    System.out.println(student.containsValue(110));
  }

}
Elements in student map:
{Dev=105, Banu=102, Rishi=108, Arthi=100}
true
false
true
false

కీ-విలువ జతను తీసివేసి, భర్తీ చేయండి

ఇక్కడ, మేము జావా ఆఫ్ ఇంటీజర్‌లో హ్యాష్‌మ్యాప్‌ను సృష్టిస్తాము మరియు స్ట్రింగ్ భాషలను నిల్వ చేయడానికి టైప్ చేయండి. మేము 2 వ విలువను క్రొత్త డేటాతో భర్తీ చేస్తాము మరియు 3 వ విలువను నిర్దిష్ట కీ-విలువ జత ఉపయోగించి మ్యాప్‌లో ఉంటే భర్తీ చేస్తాము భర్తీ () పద్ధతి.

అప్పుడు, మేము కీని ఉపయోగించి 3 వ మూలకాన్ని తీసివేస్తాము మరియు ఉపయోగించి కీ-విలువను ఉపయోగించి 1 వ మూలకాన్ని తీసివేస్తాము తొలగించు () పద్ధతి.

import java.util.HashMap;
public class RemoveHashMap {

  public static void main(String[] args) {
    HashMap<Integer,String> lang = new HashMap<>();
    lang.put(1, "Java");
    lang.put(2, "C");
    lang.putIfAbsent(3, "C++");
    System.out.println(lang);
    
    lang.replace(2, "PHP");
    System.out.println(lang);
    
    lang.replace(3, "C++", "JavaScript");
    System.out.println(lang);
    
    lang.remove(3);
    System.out.println(lang);
    
    lang.remove(1, "Java");		
    System.out.println(lang);
    
    
  }

}
{1=Java, 2=C, 3=C++}
{1=Java, 2=PHP, 3=C++}
{1=Java, 2=PHP, 3=JavaScript}
{1=Java, 2=PHP}
{2=PHP}

స్పష్టమైన మరియు ఖాళీ పద్ధతుల ఉదాహరణ

జావాలోని హాష్ మ్యాప్ ఉపయోగిస్తుంది క్లియర్ () మ్యాప్‌లోని కీ-విలువ జతల మ్యాపింగ్‌ను క్లియర్ చేసే పద్ధతి మరియు isEmpty మ్యాప్ ఖాళీగా ఉంటే పద్ధతి తనిఖీ చేస్తుంది. మ్యాపింగ్ ఉన్నందున 1 వ అవుట్పుట్ తప్పు మరియు స్పష్టమైన () పద్ధతిని ప్రారంభించిన తర్వాత మ్యాప్‌లో కీ-విలువ జతలు లేనందున 2 వ అవుట్పుట్ నిజం.

import java.util.HashMap;
public class RemoveHashMap {

  public static void main(String[] args) {
    HashMap<Integer,String> lang = new HashMap<>();
    lang.put(1, "Java");
    lang.put(2, "C");
    
    System.out.println(lang.isEmpty());
    lang.clear();
    
    System.out.println(lang.isEmpty());
    
  }

}
false
true

ఎంట్రీసెట్ ఉపయోగించి హాష్ మ్యాప్ ఎలిమెంట్స్ ద్వారా మళ్ళించడం

జావాలోని హాష్ మ్యాప్ యొక్క వ్యక్తిగత కీ-విలువ జతలను తిరిగి పొందడానికి, మేము దీనిని ఉపయోగించవచ్చు ఎంట్రీసెట్ హాష్ మ్యాప్ యొక్క పద్ధతి ఎంట్రీ a ఉపయోగించి మ్యాప్ ఇంటర్ఫేస్ యొక్క పద్ధతి ప్రతి లూప్ కోసం. మ్యాప్ ఇంటర్ఫేస్ యొక్క ఎంట్రీ పద్ధతి అంతర్నిర్మిత పద్ధతులను కలిగి ఉంది geyKey () కీని పొందడానికి మరియు getValue () సంబంధిత విలువను పొందడానికి. మేము ఉపయోగించవచ్చు పరిమాణం () మ్యాప్ యొక్క పరిమాణాన్ని పొందడానికి పద్ధతి.

import java.util.HashMap;
import java.util.Map;
public class IterateHashMap {

  public static void main(String[] args) {
    HashMap<String,String> cityState = new HashMap<>();
    cityState.put("Bangalore", "Karnataka");
    cityState.put("Chennai", "TamilNadu");
    cityState.put("Madurai", "TamilNadu");
    cityState.put("Mumbai", "Maharashtra");
    
    System.out.println("Size of map is : " + cityState.size());
    
    for(Map.Entry<String,String> m : cityState.entrySet())
    {
      System.out.println(m.getKey() + " : " + m.getValue());
    }

  }

}
Size of map is : 4
Chennai : TamilNadu
Madurai : TamilNadu
Mumbai : Maharashtra
Bangalore : Karnataka

కీసెట్ () మరియు విలువలు () ఉపయోగించి మూలకాల ద్వారా లూప్ చేయండి

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

కీసెట్‌ను ఉపయోగించి, మనం ఉపయోగించడం ద్వారా లూప్ కోసం మళ్ళించడం ద్వారా కీ-విలువ జతలను కూడా ముద్రించవచ్చు పొందండి () సంబంధిత విలువలను పొందే పద్ధతి.

import java.util.HashMap;
import java.util.Map;
public class IterateHashMap {

  public static void main(String[] args) {
    HashMap<String,String> cityState = new HashMap<>();
    cityState.put("Bangalore", "Karnataka");
    cityState.put("Chennai", "TamilNadu");
    cityState.put("Madurai", "TamilNadu");
    cityState.put("Mumbai", "Maharashtra");
    
    System.out.println("Printing only keys:");
    for(String s : cityState.keySet())
    {
      System.out.println(s);
    }
    System.out.println();
    System.out.println("Printing only values: ");
    for(String c : cityState.values())
    {
      System.out.println(c);
    }
    System.out.println();
    System.out.println("Printing both key-value pairs:");
    for(String v : cityState.keySet())
    {
      System.out.println("Key: " + v + " | value: " + cityState.get(v));
    }
  }

}
Printing only keys:
Chennai
Madurai
Mumbai
Bangalore

Printing only values: 
TamilNadu
TamilNadu
Maharashtra
Karnataka

Printing both key-value pairs:
Key: Chennai | value: TamilNadu
Key: Madurai | value: TamilNadu
Key: Mumbai | value: Maharashtra
Key: Bangalore | value: Karnataka

ముగింపు

ఈ ట్యుటోరియల్‌లో, మీరు వివిధ ఉదాహరణలతో పాటు హాష్ మ్యాప్ మరియు దాని విభిన్న పద్ధతుల గురించి నేర్చుకున్నారు.

సూచన