ஜாவா ஹேஷ்டபிள்

Java Hashtable வகுப்பு ஜாவா சேகரிப்பு கட்டமைப்பின் பழமையான உறுப்பினர்களில் ஒன்றாகும். இது கணித ஹாஷ் அட்டவணை தரவு கட்டமைப்பின் செயல்படுத்தல் ஆகும். ஜாவாவில் ஹேஷ்டேபிளில் உள்ளகமாக விசை/மதிப்பு ஜோடிகள் சேமிக்கப்படும் பக்கெட்டுகள் உள்ளன. Hashtable ஆனது HashMap ஐப் போலவே உள்ளது . அவற்றுக்கிடையேயான மிக முக்கியமான வேறுபாடு: HashMap இல்லாவிட்டாலும் ஹேஷ்டேபிள் ஒத்திசைக்கப்படுகிறது .

தரவு கட்டமைப்பாக ஹேஷ்டபிள்

ஹேஷ்டேபிள் என்பது ஒரு தரவு கட்டமைப்பாகும், அங்கு தரவு வரிசை வடிவத்தில் சேமிக்கப்படுகிறது. ஒவ்வொரு தரவு மதிப்புக்கும் ஒரு தனிப்பட்ட முக்கிய மதிப்பு உள்ளது. விசை தெரிந்தால், தேவையான தரவுக்கான அணுகல் மிக வேகமாக இருக்கும். எனவே, செருகல் மற்றும் தேடல் செயல்பாடுகள் தரவு அளவில் சுயாதீனமாக வேகமாக இருக்கும். ஹாஷ் அட்டவணையானது தரவை வைத்திருப்பதற்கான ஒரு வரிசையைக் கொண்டுள்ளது மற்றும் ஒரு உறுப்பு இருக்க வேண்டிய குறியீட்டை தலைமுறைக்கு ஹாஷிங் செய்கிறது. ஹாஷிங் என்றால் என்ன? பொருளை எழுத்துகளின் தொகுப்பாக (குறியீடு) வரைபடமாக்குவது ஒரு விதி. பொதுவாக அந்த வகையான செயல்பாடு ஒரு பெரிய அளவிலான தரவை சிறிய முழு எண் மதிப்பாக மாற்றுகிறது. ஹாஷ் செயல்பாடுகள் வேறுபட்டிருக்கலாம், ஆனால் அவை அனைத்தும் சில பண்புகளை சமர்ப்பிக்கின்றன:

• ஒரு குறிப்பிட்ட பொருளுக்கு குறிப்பிட்ட ஹாஷ் குறியீடு உள்ளது.
• இரண்டு சமமான பொருள்கள் ஒரே ஹாஷ் குறியீடுகளைக் கொண்டுள்ளன. தலைகீழ் உண்மை இல்லை.
• இரண்டு ஹாஷ் குறியீடுகள் வேறுபட்டால், பொருள்கள் நிச்சயமாக சமமாக இருக்காது.
• வெவ்வேறு பொருள்கள் ஒரே ஹாஷ் குறியீட்டைக் கொண்டிருக்கலாம். இந்த மிக அரிதான நிகழ்வு மோதலை அழைக்கிறது. நல்ல ஹாஷ் செயல்பாடு மோதல்களின் நிகழ்தகவைக் குறைக்கிறது.

ஒரு பொருளுக்கு ஹாஷ் செயல்பாட்டைப் பயன்படுத்துவதன் விளைவாக ஹாஷ்கோடு அழைக்கிறது .

ஜாவாவில் ஹேஷ்டபிள்

ஹாஷ்டேபிள் கிளாஸ் என்பது ஹாஷ் டேபிள் டேட்டா கட்டமைப்பை செயல்படுத்துவதாகும். இந்த தொகுப்பு ஜாவா சேகரிப்பு கட்டமைப்பை விட முன்னதாக உருவாக்கப்பட்டது, ஆனால் பின்னர் அதில் சேர்க்கப்பட்டது. அனைத்து "ஆரம்ப" சேகரிப்புகளைப் போலவே (ஜாவா 1.0 இலிருந்து), ஒரு ஹாஷ்டேபிள் ஒத்திசைக்கப்படுகிறது (கிட்டத்தட்ட அனைத்து முறைகளும் ஒத்திசைக்கப்பட்டதாகக் குறிக்கப்படுகின்றன). இந்த காரணி காரணமாக, ஹேஷ்டேபிள் குறிப்பிடத்தக்க செயல்திறன் சிக்கல்களைக் கொண்டுள்ளது. எனவே, ஜாவா 1.2 இலிருந்து தொடங்கி, பெரும்பாலான சந்தர்ப்பங்களில் அவற்றின் ஒத்திசைவு இல்லாததால் வரைபட இடைமுகத்தின் பிற செயலாக்கங்களைப் பயன்படுத்த பரிந்துரைக்கப்படுகிறது . பொதுவாக HashMap மிகவும் பொருத்தமான மாற்றாகும். எனவே Class Hashtable<K,V>விசைகள் மற்றும் மதிப்புகளைக் கொண்டுள்ளது. இது ஹாஷிங் கொள்கையில் விசைகளை சேமிக்கிறது. முக்கிய மதிப்பு ஜோடிகள் "வாளிகளில்" சேமிக்கப்படுகின்றன. வாளிகள் ஒன்றாக ஒரு "டேபிள்", ஒரு வகையான உள் வரிசையை உருவாக்குகின்றன. விசை/மதிப்பு ஜோடியை வரைபடமாக்க வேண்டிய பக்கெட்டைத் தீர்மானிக்க ஹேஷ்டேபிள் விசையின் ஹாஷ்கோடைப் பயன்படுத்துகிறது. ஹாஷ் செயல்பாடு, கீயின் ஹாஷ்கோடில் இருந்து பக்கெட் இருப்பிடத்தைப் பெற உதவுகிறது. இந்தச் செயல்பாடு ஒரு பொருளுக்கான முழு எண் எண்ணை வழங்குகிறது. நாம் மேலே கூறியது போல் இரண்டு சமமான பொருள்களுக்கு ஒரே ஹாஷ்கோடு இருக்கும், அதே சமயம் இரண்டு சமமற்ற பொருள்கள் எப்போதும் வெவ்வேறு ஹாஷ்கோடுகளைக் கொண்டிருக்காது. ஹேஷ்டேபிளில் வைக்கப்படும் வெவ்வேறு பொருள்கள் ஒரே ஹாஷ் குறியீட்டைக் கொண்டிருக்கலாம். இந்தச் சிக்கலைத் தீர்க்க (மோதல்) பட்டியல்களின் வரிசை ஹேஷ்டேபிளில் பயன்படுத்தப்படுகிறது. ஒற்றை வாளியில் பொருத்தப்பட்ட ஜோடிகள் பட்டியலில் சேமிக்கப்படும் மற்றும் இந்த பட்டியல் குறிப்பு வரிசை அட்டவணையில் சேமிக்கப்படும்.

ஹேஸ்டேபிள் ஜாவா கன்ஸ்ட்ரக்டர்ஸ்

• Hashtable() , இயல்புநிலை கட்டமைப்பாளர். இது ஒரு வெற்று ஹேஷ்டேபிளை உருவாக்குகிறது. (இயல்புநிலை ஆரம்ப திறன் = 11, சுமை காரணி =0.75).
• Hashtable(int size) ஆனது குறிப்பிட்ட அளவிலான ஹாஷ்டேபிளை உருவாக்குகிறது.
• Hashtable(int size, float fillRatio) குறிப்பிட்ட அளவு மற்றும் நிரப்பு விகிதத்தின் ஹாஷ் அட்டவணையை உருவாக்குகிறது.
• Hashtable(வரைபடம் m) கொடுக்கப்பட்ட வரைபடத்தின் அதே மேப்பிங்களுடன் ஹேஷ்டேபிளை உருவாக்குகிறது.

ஹேஷ்டபிள் பிரகடனம்

Hashtable Java வகுப்பு வரைபடம் , குளோன் செய்யக்கூடிய மற்றும் வரிசைப்படுத்தக்கூடிய இடைமுகங்களை செயல்படுத்துகிறது . இது அகராதி வகுப்பை நீட்டிக்கிறது .

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() ஆனது ஹாஷ் அட்டவணையில் உள்ளீடுகளின் அளவை வழங்குகிறது.
• குறிப்பிட்ட மதிப்பு ஹாஷ் அட்டவணையில் உள்ளதா என்பதை boolean கொண்டுள்ளது(பொருள் மதிப்பு) சரிபார்க்கிறது. அப்படியானால், முறை உண்மை என்று திரும்பும், இல்லையெனில் தவறானது.
• குறிப்பிட்ட மதிப்பு ஹாஷ் அட்டவணையில் உள்ளதா என்பதை boolean கொண்டுள்ளது மதிப்பு(பொருள் மதிப்பு) சரிபார்க்கிறது. அப்படியானால், முறை உண்மை என்று திரும்பும், இல்லையெனில் தவறானது.
• void clear() ஹேஷ்டேபிளில் இருந்து அனைத்து உள்ளீடுகளையும் நீக்குகிறது.
• boolean containsKey(ஆப்ஜெக்ட் கீ) என்பது ஹாஷ் டேபிளில் குறிப்பிடப்பட்ட விசை இருந்தால் true என்பதைத் தரும்.
• boolean 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

• ஹேஷ்டேபிள் என்பது ஜாவாவில் உள்ள ஹாஷ்மேப்பைப் போன்றது. மிகவும் குறிப்பிடத்தக்க வித்தியாசம் என்னவென்றால், HashMap ஒத்திசைக்கப்படாத போது Hashtable ஒத்திசைக்கப்பட்டுள்ளது. எனவே, ஒத்திசைவு காரணமாக HashMap ஐ விட Hashtable மெதுவாக உள்ளது.
• ஒத்திசைவுச் சிக்கலைத் தவிர, ஹேஷ்டேபிள் பூஜ்யத்தை மதிப்பு அல்லது விசையாகப் பயன்படுத்த அனுமதிக்காது. HashMap ஒரு பூஜ்ய விசையையும் பல பூஜ்ய மதிப்புகளையும் அனுமதிக்கிறது.
• Hashtable அகராதி வகுப்பைப் பெறுகிறது, அதே சமயம் HashMap AbstractMap வகுப்பைப் பெறுகிறது.
• HashMap ஐ இட்டரேட்டரால் கடக்கப்படுகிறது. ஹேஷ்டேபிளை இட்டரேட்டரால் மட்டுமின்றி எண்யூமரேட்டராலும் கடந்து செல்ல முடியும்.

ஜாவா ஹேஷ்டேபிள் உதாரணம் (Hashtable vs HashMap null key)

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 பொருள்கள் அவற்றின் ஒற்றுமை காரணமாக Hashtable க்குப் பதிலாகப் பயன்படுத்தப்படுகின்றன. HashMap மிகவும் பயனுள்ளதாக இருக்கும் (இது ஒத்திசைக்கப்படவில்லை) மேலும் பூஜ்யத்தை ஒரு விசையாகக் கொண்டிருக்கலாம்.