జావా హ్యాష్టబుల్

జావా హ్యాష్టబుల్ క్లాస్ అనేది జావా కలెక్షన్ ఫ్రేమ్‌వర్క్‌లోని పురాతన సభ్యులలో ఒకటి. ఇది గణిత హాష్ పట్టిక డేటా నిర్మాణం యొక్క అమలు. జావాలో హ్యాష్‌టేబుల్ అంతర్గతంగా కీ/విలువ జతలు నిల్వ చేయబడిన బకెట్‌లను కలిగి ఉంటుంది. Hashtable అనేది HashMap ని పోలి ఉంటుంది . వాటి మధ్య అత్యంత ముఖ్యమైన వ్యత్యాసం: HashMap సమకాలీకరించబడనప్పుడు Hashtable సమకాలీకరించబడింది .

డేటా నిర్మాణంగా హ్యాష్‌టేబుల్

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

• నిర్దిష్ట వస్తువుకు నిర్దిష్ట హాష్ కోడ్ ఉంటుంది.
• రెండు సమాన వస్తువులు ఒకే హాష్ కోడ్‌లను కలిగి ఉంటాయి. రివర్స్ నిజం కాదు.
• రెండు హాష్ కోడ్‌లు వేర్వేరుగా ఉంటే, వస్తువులు ఖచ్చితంగా సమానంగా ఉండవు.
• వేర్వేరు వస్తువులు ఒకే హాష్ కోడ్‌ని కలిగి ఉండవచ్చు. ఈ చాలా అరుదైన సంఘటన తాకిడిని పిలుస్తుంది. మంచి హాష్ ఫంక్షన్ ఘర్షణల సంభావ్యతను తగ్గిస్తుంది.

ఆబ్జెక్ట్‌కి హాష్ ఫంక్షన్‌ని వర్తింపజేయడం వల్ల వచ్చే ఫలితం హ్యాష్‌కోడ్‌ని పిలుస్తుంది .

జావాలో హ్యాష్‌టేబుల్

Hashtable క్లాస్ అనేది హాష్ టేబుల్ డేటా స్ట్రక్చర్ యొక్క అమలు. ఈ సేకరణ జావా కలెక్షన్ ఫ్రేమ్‌వర్క్ కంటే ముందుగా సృష్టించబడింది, కానీ తర్వాత దానిలో చేర్చబడింది. అన్ని "ప్రారంభ" సేకరణల వలె (జావా 1.0 నుండి), హ్యాష్‌టేబుల్ సమకాలీకరించబడింది (దాదాపు అన్ని పద్ధతులు సమకాలీకరించబడినట్లుగా గుర్తించబడ్డాయి). ఈ అంశం కారణంగా, హ్యాష్‌టేబుల్ గణనీయమైన పనితీరు సమస్యలను కలిగి ఉంది. అందువల్ల, జావా 1.2 నుండి ప్రారంభించి, చాలా సందర్భాలలో మ్యాప్ ఇంటర్‌ఫేస్ యొక్క ఇతర ఇంప్లిమెంటేషన్‌లను వాటి సమకాలీకరణ లేకపోవడం వల్ల ఉపయోగించమని సిఫార్సు చేయబడింది . సాధారణంగా HashMap అత్యంత సరైన ప్రత్యామ్నాయం. కాబట్టి క్లాస్ హ్యాష్‌టేబుల్<K,V>కీలు మరియు విలువలను కలిగి ఉంటుంది. ఇది హ్యాషింగ్ సూత్రంపై కీలను నిల్వ చేస్తుంది. కీ-విలువ జతలు "బకెట్లు"లో నిల్వ చేయబడతాయి. బకెట్లు కలిసి ఒక "టేబుల్", ఒక రకమైన అంతర్గత శ్రేణిని నిర్మిస్తాయి. కీ/విలువ జత మ్యాప్ చేయాల్సిన బకెట్‌ను గుర్తించడానికి హ్యాష్‌టేబుల్ కీ యొక్క హ్యాష్‌కోడ్‌ను ఉపయోగిస్తుంది. హాష్ ఫంక్షన్ కీ యొక్క హ్యాష్‌కోడ్ నుండి బకెట్ స్థానాన్ని పొందడానికి అనుమతిస్తుంది. ఈ ఫంక్షన్ ఒక వస్తువు కోసం పూర్ణాంక సంఖ్యను అందిస్తుంది. మేము పైన చెప్పినట్లుగా రెండు సమానమైన వస్తువులు ఒకే హ్యాష్‌కోడ్‌ను కలిగి ఉంటాయి, అయితే రెండు అసమాన వస్తువులు ఎల్లప్పుడూ వేర్వేరు హ్యాష్‌కోడ్‌లను కలిగి ఉండకపోవచ్చు. హ్యాష్‌టేబుల్‌లో ఉంచబడిన విభిన్న వస్తువులు ఒకే హాష్ కోడ్‌ని కలిగి ఉండవచ్చు. ఈ సమస్యను పరిష్కరించడానికి (తాకిడి) జాబితాల శ్రేణి హ్యాష్‌టేబుల్‌లో ఉపయోగించబడుతుంది. ఒకే బకెట్‌కు మ్యాప్ చేయబడిన జతలు జాబితాలో నిల్వ చేయబడతాయి మరియు ఈ జాబితా సూచన శ్రేణి సూచికలో నిల్వ చేయబడుతుంది.

హ్యాష్టేబుల్ జావా కన్స్ట్రక్టర్స్

• Hashtable() , డిఫాల్ట్ కన్స్ట్రక్టర్. ఇది ఖాళీ హ్యాష్‌టేబుల్‌ని సృష్టిస్తుంది. (డిఫాల్ట్ ప్రారంభ సామర్థ్యం = 11, లోడ్ ఫ్యాక్టర్ =0.75).
• హ్యాష్ టేబుల్ (పూర్ణాంక పరిమాణం) పేర్కొన్న పరిమాణం యొక్క హ్యాష్ టేబుల్‌ను నిర్మిస్తుంది.
• హ్యాష్ టేబుల్ (పూర్ణాంక పరిమాణం, ఫ్లోట్ ఫిల్ రేషియో) పేర్కొన్న పరిమాణం మరియు పూరక నిష్పత్తి యొక్క హాష్ పట్టికను సృష్టిస్తుంది.
• Hashtable(Map m) ఇచ్చిన మ్యాప్‌ల మాదిరిగానే మ్యాపింగ్‌లతో హ్యాష్‌టేబుల్‌ను సృష్టిస్తుంది.

హ్యాష్ టేబుల్ డిక్లరేషన్

హ్యాష్‌టేబుల్ జావా క్లాస్ మ్యాప్ , క్లోన్ చేయదగిన మరియు సీరియలైజ్ చేయగల ఇంటర్‌ఫేస్‌లను అమలు చేస్తుంది . ఇది నిఘంటువు తరగతిని విస్తరించింది .

Hashtable.java
public class Hashtable<K,V>
    extends Dictionary<K,V>
    implements Map<K,V>, Cloneable, java.io.Serializable

K అనేది మ్యాప్ ద్వారా నిర్వహించబడే కీల రకం. V అనేది మ్యాప్ చేయబడిన విలువల రకం. ఉదాహరణ:

Hashtable<Student, Integer> myHTable = new Hashtable<>();

హ్యాష్ టేబుల్ జావాను ఎలా దిగుమతి చేయాలి

Java Hashtable java.util ప్యాకేజీలో ఉంది . కాబట్టి దిగుమతి java.util.Hashtable ఉపయోగించండి; మీ కోడ్‌లో. సాధారణంగా మీరు దీని గురించి మీ IDE నుండి సూచనను పొందుతారు.

హ్యాష్ టేబుల్ ప్రధాన కార్యకలాపాలు

Hashtable యొక్క ప్రధాన కార్యకలాపాలు పొందడం, సేకరణకు చొప్పించడం మరియు అక్కడ నుండి తీసివేయడం. ఇక్కడ ఈ మూడు ఆపరేషన్లు ఉన్నాయి:

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

ఇతర ముఖ్యమైన కార్యకలాపాలు:

• int size() హాష్ పట్టికలోని ఎంట్రీల పరిమాణాన్ని అందిస్తుంది.
• బూలియన్ పేర్కొన్న విలువ హాష్ పట్టికలో ఉంటే (ఆబ్జెక్ట్ విలువ) తనిఖీ చేస్తుంది. అలా అయితే, పద్ధతి ఒప్పు అని తిరిగి వస్తుంది, లేకపోతే తప్పు అని చూపుతుంది.
• బూలియన్ పేర్కొన్న విలువ హాష్ పట్టికలో ఉంటే విలువ (ఆబ్జెక్ట్ విలువ) తనిఖీ చేస్తుంది. అలా అయితే, పద్ధతి ఒప్పు అని తిరిగి వస్తుంది, లేకపోతే తప్పు అని చూపుతుంది.
• void clear() హ్యాష్ టేబుల్ నుండి అన్ని ఎంట్రీలను తొలగిస్తుంది.
• బూలియన్ కలిగి ఉన్న కీ (ఆబ్జెక్ట్ కీ) హాష్ పట్టికలో పేర్కొన్న కీ ఉంటే ఒప్పు అని తిరిగి ఇవ్వబడుతుంది, లేకపోతే తప్పుని తిరిగి ఇవ్వండి.
• బూలియన్ isEmpty() హ్యాష్‌టేబుల్ ఖాళీగా ఉంటే ఒప్పు లేదా కనీసం ఒక కీని కలిగి ఉంటే తప్పు అని చూపుతుంది.
• void rehash() హ్యాష్ టేబుల్ పరిమాణాన్ని పెంచుతుంది మరియు దాని అన్ని కీలను రీహాష్ చేస్తుంది.

హాష్ టేబుల్ అమలు, జావా కోడ్:

విద్యార్థి తరగతిని సృష్టిద్దాం :

import java.util.Date;
public class Student {
   String surname;
   String name;
   String secondName;
   Long birthday; // Long instead of long is used by Gson/Jackson json parsers and various orm databases

   public Student(String surname, String name, String secondName, Date birthday ){
       this.surname = surname;
       this.name = name;
       this.secondName = secondName;
       this.birthday = birthday == null ? 0 : birthday.getTime();
   }

   @Override
   public int hashCode(){
       //TODO: check for nulls
       return (surname + name + secondName + birthday).hashCode();
   }
   @Override
   public boolean equals(Object other_) {
       Student other = (Student)other_;
       return (surname == null || surname.equals(other.surname) )
               && (name == null || name.equals(other.name))
               && (secondName == null || secondName.equals(other.secondName))
               && (birthday == null || birthday.equals(other.birthday));
   }
}

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

public class HashTableExample {
   public static void main(String[] args) {
 
       Hashtable<Student, Integer> myHTable = new Hashtable<>();
       Student sarah1 = new Student("Sarah","Connor", "Jane", null);
       Student john = new Student("John","Connor", "Kyle", new Date(1985, 02-1, 28)); // date not exists
       myHTable.put(john,1);
       myHTable.put(sarah1,0);
       System.out.println(myHTable.get(john));
       System.out.println(myHTable.isEmpty());
       System.out.println(myHTable.size());
       System.out.println(myHTable.contains(1));
       myHTable.remove(john);
       System.out.println(myHTable.contains(0));
       System.out.println(myHTable.contains(1));
       System.out.println(myHTable.containsKey(sarah1));
   }
}

రన్నింగ్ ప్రోగ్రామ్ యొక్క ఫలితం:

1
false
2
true
true
false
true

HashMap vs Hashtable

• Hashtable జావాలోని HashMap వలె ఉంటుంది. అత్యంత ముఖ్యమైన వ్యత్యాసం ఏమిటంటే, HashMap సమకాలీకరించబడినప్పుడు Hashtable సమకాలీకరించబడింది. అందువల్ల, సింక్రొనైజేషన్ కారణంగా HashMap కంటే Hashtable నెమ్మదిగా ఉంటుంది.
• సమకాలీకరణ సమస్య మినహా, Hashtable శూన్యతను విలువ లేదా కీగా ఉపయోగించడానికి అనుమతించదు. HashMap ఒక శూన్య కీ మరియు బహుళ శూన్య విలువలను అనుమతిస్తుంది.
• హ్యాష్‌టేబుల్ డిక్షనరీ క్లాస్‌ను పొందుతుంది, అయితే హాష్‌మ్యాప్ అబ్‌స్ట్రాక్ట్ మ్యాప్ క్లాస్‌ను పొందుతుంది.
• HashMap ఇటరేటర్ ద్వారా ప్రయాణించబడుతుంది. హ్యాష్‌టేబుల్‌ని ఇటరేటర్ ద్వారా మాత్రమే కాకుండా ఎన్యూమరేటర్ ద్వారా కూడా ప్రయాణించవచ్చు.

జావా హ్యాష్‌టేబుల్ ఉదాహరణ (హ్యాష్‌టేబుల్ vs హాష్‌మ్యాప్ శూన్య కీ)

HashMap మరియు Hashtable లో కీ మరియు విలువగా ఉపయోగించిన శూన్యతను ప్రదర్శించడానికి ఇక్కడ ఒక ఫ్రాగ్మెంట్ కోడ్ ఉంది

// Null key Java hashtable example and hashmap example  

try{
      System.out.println("Hashtable");
      Hashtable hashTable = new Hashtable();
      hashTable.put(null, new Object());
    }catch(Exception ex){
      ex.printStackTrace();
    }
    System.out.println("HashMap");
    HashMap hashMap = new HashMap();
    hashMap.put(null, new Object());
    System.out.println("as you see no exceptions with null key in HashMap");
  }

ఈ భాగాన్ని కలిగి ఉన్న ప్రోగ్రామ్‌ను అమలు చేయడం వల్ల వచ్చే ఫలితం:

java.lang.NullPointerException
	at java.base/java.util.Hashtable.put(Hashtable.java:480)
	at Character.main(Character.java:58)
HashMap
as you see no exceptions with null key in HashMap

ముగింపు

మీరు నిజమైన ప్రాజెక్ట్‌లలో Hashtableని తరచుగా ఉపయోగించరు, కానీ పాత ప్రాజెక్ట్‌లలో ఈ డేటా స్ట్రక్చర్‌ను చేరుకోవడం సులభం. ఏది ఏమైనప్పటికీ, జావాలో ఏ డేటా స్ట్రక్చర్‌లు ఉన్నాయి మరియు అవి ఎలా పని చేస్తాయో అర్థం చేసుకోవడం ముఖ్యం, కనీసం మీ ఇంటర్వ్యూల కోసం. సాధారణంగా హాష్‌మ్యాప్ వస్తువులు వాటి సారూప్యత కారణంగా హ్యాష్‌టేబుల్‌కు బదులుగా ఉపయోగించబడతాయి. HashMap మరింత ప్రభావవంతంగా ఉంటుంది (ఇది సమకాలీకరించబడలేదు) మరియు ఒక కీ వలె శూన్యతను కలిగి ఉంటుంది.