ஜாவாவில் HashMap மற்றும் Hashtable ஆகியவற்றை ஒப்பிடுதல்: முக்கிய வேறுபாடுகள் மற்றும் செயல்திறன்

ஜாவாவில் HashMap மற்றும் Hashtable ஐப் புரிந்துகொள்வது

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

இந்தக் கட்டுரை HashMap மற்றும் Hashtable ஆகியவற்றுக்கு இடையேயான முக்கிய வேறுபாடுகளை ஆராய்கிறது, அவற்றின் செயல்பாடுகள், செயல்திறன் மற்றும் திரிக்கப்படாத பயன்பாடுகளுக்கான பொருத்தம் ஆகியவற்றை ஆராய்கிறது. முடிவில், உங்கள் குறிப்பிட்ட பயன்பாட்டு வழக்கில் எந்த தரவு கட்டமைப்பைப் பயன்படுத்துவது என்பது பற்றிய தெளிவான யோசனை உங்களுக்கு இருக்கும்.

கட்டளை	விளக்கம்
HashMap.put()	ஹாஷ்மேப்பில் ஒரு முக்கிய மதிப்பு ஜோடியைச் செருகுகிறது. பூஜ்ய விசைகள் மற்றும் மதிப்புகளை அனுமதிக்கிறது.
Hashtable.put()	ஹேஷ்டேபிளில் விசை-மதிப்பு ஜோடியைச் செருகுகிறது. பூஜ்ய விசைகள் அல்லது மதிப்புகளை அனுமதிக்காது.
System.nanoTime()	இயங்கும் Java Virtual Machine இன் உயர் தெளிவுத்திறன் கொண்ட நேர மூலத்தின் தற்போதைய மதிப்பை நானோ வினாடிகளில் வழங்கும்.
try { ... } catch (NullPointerException e)	குறியீட்டைச் செயல்படுத்த முயற்சிக்கிறது மற்றும் எந்த NullPointerExceptions ஐப் பிடிக்கிறது, Hashtable.put() பூஜ்ய மதிப்புகளுடன் அழைக்கப்படும் நிகழ்வுகளைக் கையாளுகிறது.
HashMap.get()	HashMap இலிருந்து குறிப்பிட்ட விசையுடன் தொடர்புடைய மதிப்பை மீட்டெடுக்கிறது.
Hashtable.get()	Hashtable இலிருந்து குறிப்பிட்ட விசையுடன் தொடர்புடைய மதிப்பை மீட்டெடுக்கிறது.

HashMap மற்றும் Hashtable அமலாக்கத்தில் ஆழ்ந்து விடுங்கள்

முதல் ஸ்கிரிப்ட் நேரடி ஒப்பீட்டை வழங்குகிறது மற்றும் ஜாவாவில். தேவையான வகுப்புகளை இறக்குமதி செய்வதன் மூலம் ஸ்கிரிப்ட் தொடங்குகிறது மற்றும் இரண்டு தரவு கட்டமைப்புகளின் நிகழ்வுகளை உருவாக்குகிறது. ஏ முக்கிய-மதிப்பு ஜோடிகளுடன் உடனடி மற்றும் மக்கள்தொகை கொண்டது. இதேபோல், ஏ Hashtable உருவாக்கப்பட்டு மக்கள்தொகை கொண்டது. இந்த ஸ்கிரிப்ட் பின்னர் பூஜ்ய மதிப்புகளைக் கையாள்வதில் உள்ள அடிப்படை வேறுபாட்டைக் காட்டுகிறது. சிக்கல்கள் இல்லாமல் பூஜ்ய மதிப்புகளைச் செருக அனுமதிக்கிறது, அதேசமயம் வீசுகிறார் ஒரு பூஜ்ய விசைகள் அல்லது மதிப்புகள் சேர்க்க முயற்சித்தால். தி try { ... } catch (NullPointerException e) இந்த நடத்தையை விளக்குவதற்கு தொகுதிகள் பயன்படுத்தப்படுகின்றன. ஸ்கிரிப்ட் டெவலப்பர்கள் இந்த இரண்டு தரவு கட்டமைப்புகளுக்கு இடையே தேர்ந்தெடுக்கும் போது எப்போது மற்றும் ஏன் பூஜ்ய மதிப்புகள் கருத்தில் கொள்ள வேண்டும் என்பதை புரிந்து கொள்ள உதவுகிறது.

இரண்டாவது ஸ்கிரிப்ட் செயல்திறன் சோதனையில் கவனம் செலுத்துகிறது மற்றும் ஒரு அல்லாத திரிக்கப்பட்ட சூழலில். இரண்டு வரைபடங்களையும் துவக்கி, ஒரு மில்லியன் முக்கிய மதிப்பு ஜோடிகளைச் செருகுவதற்கு எடுத்துக் கொள்ளும் நேரத்தை அளவிடுவதன் மூலம் இது தொடங்குகிறது. . இந்த உயர்-தெளிவுத்திறன் நேர அளவீடு, செயல்பாடுகளுக்கு எடுக்கப்பட்ட துல்லியமான நேரத்தைப் பிடிக்க உதவுகிறது. முடிவுகள் கன்சோலில் அச்சிடப்பட்டு, தொடர்புடைய செயல்திறனைக் காட்டுகிறது. ஸ்கிரிப்ட் இரண்டு தரவு கட்டமைப்புகளிலிருந்தும் ஒரே மாதிரியான விசைகளுக்கான மீட்டெடுப்பு நேரத்தையும் அளவிடுகிறது. இந்த நேரங்களை ஒப்பிடுவதன் மூலம், த்ரெட் அல்லாத பயன்பாடுகளில் எந்த தரவு அமைப்பு சிறப்பாக செயல்படுகிறது என்பதை டெவலப்பர்கள் அளவிட முடியும். இந்த ஸ்கிரிப்ட் செயல்திறன் டியூனிங் மற்றும் தொடர்புடைய மேல்நிலை புரிந்து கொள்ள குறிப்பாக பயனுள்ளதாக இருக்கும் Hashtable அதன் ஒத்திசைக்கப்பட்ட முறைகள் காரணமாக.

HashMap மற்றும் Hashtable ஆகியவற்றை ஒப்பிடுதல்: முக்கிய வேறுபாடுகள் மற்றும் பயன்பாட்டு வழக்குகள்

ஒப்பிடுவதற்கான ஜாவா செயல்படுத்தல்

import java.util.HashMap;
import java.util.Hashtable;

public class MapComparison {
    public static void main(String[] args) {
        // Creating a HashMap
        HashMap<String, String> hashMap = new HashMap<>();
        hashMap.put("1", "One");
        hashMap.put("2", "Two");
        hashMap.put("3", "Three");

        // Creating a Hashtable
        Hashtable<String, String> hashtable = new Hashtable<>();
        hashtable.put("A", "Apple");
        hashtable.put("B", "Banana");
        hashtable.put("C", "Cherry");

        // Displaying the HashMap
        System.out.println("HashMap: " + hashMap);

        // Displaying the Hashtable
        System.out.println("Hashtable: " + hashtable);

        // Checking for null values
        try {
            hashMap.put(null, "NullValue");
            System.out.println("HashMap allows null values: " + hashMap);
        } catch (NullPointerException e) {
            System.out.println("HashMap does not allow null values");
        }
        try {
            hashtable.put(null, "NullValue");
            System.out.println("Hashtable allows null values: " + hashtable);
        } catch (NullPointerException e) {
            System.out.println("Hashtable does not allow null values");
        }
    }
}

HashMap vs. Hashtable: ஒற்றை-திரிக்கப்பட்ட சூழலில் செயல்திறன்

திரிக்கப்படாத பயன்பாடுகளுக்கான ஜாவா செயல்திறன் சோதனை

import java.util.HashMap;
import java.util.Hashtable;

public class PerformanceTest {
    public static void main(String[] args) {
        // Initializing the maps
        HashMap<Integer, Integer> hashMap = new HashMap<>();
        Hashtable<Integer, Integer> hashtable = new Hashtable<>();

        // Adding elements to HashMap
        long startTime = System.nanoTime();
        for (int i = 0; i < 1000000; i++) {
            hashMap.put(i, i);
        }
        long endTime = System.nanoTime();
        System.out.println("HashMap time: " + (endTime - startTime) + " ns");

        // Adding elements to Hashtable
        startTime = System.nanoTime();
        for (int i = 0; i < 1000000; i++) {
            hashtable.put(i, i);
        }
        endTime = System.nanoTime();
        System.out.println("Hashtable time: " + (endTime - startTime) + " ns");

        // Retrieving elements from HashMap
        startTime = System.nanoTime();
        for (int i = 0; i < 1000000; i++) {
            hashMap.get(i);
        }
        endTime = System.nanoTime();
        System.out.println("HashMap retrieval time: " + (endTime - startTime) + " ns");

        // Retrieving elements from Hashtable
        startTime = System.nanoTime();
        for (int i = 0; i < 1000000; i++) {
            hashtable.get(i);
        }
        endTime = System.nanoTime();
        System.out.println("Hashtable retrieval time: " + (endTime - startTime) + " ns");
    }
}

HashMap மற்றும் Hashtable: ஒத்திசைவு மற்றும் நூல் பாதுகாப்பு

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

மாறாக, ஒத்திசைக்கப்படவில்லை, எனவே நூல்-பாதுகாப்பானது அல்ல. ஒரு என்றால் ஒரே நேரத்தில் பல த்ரெட்கள் மூலம் அணுகப்படுகிறது, தரவு சீரற்ற தன்மை மற்றும் ரேஸ் நிலைமைகளின் ஆபத்து உள்ளது. ஒரு செய்ய நூல் பாதுகாப்பானது, டெவலப்பர்கள் பயன்படுத்தலாம் Collections.synchronizedMap() ஒத்திசைக்கப்பட்ட வரைபடத்தில் அதை மடிக்க அல்லது அவர்கள் பயன்படுத்தலாம் ஜாவா 1.5 இல் வகுப்பு அறிமுகப்படுத்தப்பட்டது, இது வரைபடத்தின் வெவ்வேறு பகுதிகளுக்கு ஒரே நேரத்தில் அணுகலை அனுமதிப்பதன் மூலம் சிறந்த செயல்திறனை வழங்குகிறது. இது செய்கிறது ஒரே நேரத்தில் பயன்பாடுகளுக்கு மிகவும் திறமையான தேர்வு.

1. HashMap மற்றும் Hashtable இடையே உள்ள முக்கிய வேறுபாடு என்ன?
2. ஒத்திசைக்கப்படவில்லை மற்றும் பூஜ்ய விசைகள் மற்றும் மதிப்புகளை அனுமதிக்கிறது ஒத்திசைக்கப்பட்டது மற்றும் பூஜ்ய விசைகள் அல்லது மதிப்புகளை அனுமதிக்காது.
3. ஒற்றை-திரிக்கப்பட்ட சூழலில் எது வேகமானது?
4. ஒத்திசைவு ஓவர்ஹெட் இல்லாததால், ஒற்றை-திரிக்கப்பட்ட சூழலில் பொதுவாக வேகமாக இருக்கும்.
5. HashMap நூலை எவ்வாறு பாதுகாப்பானதாக்குவது?
6. பயன்படுத்தி மடிக்க அல்லது பயன்படுத்துவதன் மூலம் .
7. Hashtable ஆனது பூஜ்ய விசைகள் அல்லது மதிப்புகளை சேமிக்க முடியுமா?
8. இல்லை, பூஜ்ய விசைகள் அல்லது மதிப்புகளை அனுமதிக்காது மற்றும் ஒரு முயற்சித்தால்.
9. HashMap இல் Hashtable ஐ எப்போது பயன்படுத்த வேண்டும்?
10. பயன்படுத்தவும் நூல் பாதுகாப்பு தேவைப்படும் போது மற்றும் ஒத்திசைவின் செயல்திறன் மேல்நிலை பற்றி நீங்கள் கவலைப்படவில்லை.
11. Hashtable க்கு ConcurrentHashMap சிறந்த மாற்றாக உள்ளதா?
12. ஆம், ஒப்பிடும்போது சிறந்த ஒத்திசைவு மற்றும் செயல்திறனை வழங்குகிறது .
13. HashMap ஏன் நூல்-பாதுகாப்பாக இல்லை?
14. ஒற்றை-திரிக்கப்பட்ட காட்சிகளுக்காக வடிவமைக்கப்பட்டுள்ளது மற்றும் ஒத்திசைவு வழிமுறைகள் இல்லை.
15. HashMap மற்றும் Hashtable மோதல்களை எவ்வாறு கையாளுகிறது?
16. இரண்டும் மற்றும் சங்கிலியைப் பயன்படுத்தி மோதல்களைக் கையாளவும், ஒவ்வொரு வாளியும் இணைக்கப்பட்ட உள்ளீடுகளின் பட்டியலைக் கொண்டிருக்கும்.

HashMap மற்றும் Hashtable ஆகியவை முக்கிய-மதிப்பு ஜோடிகளை சேமிப்பதில் ஒரே மாதிரியான நோக்கங்களைச் செய்கின்றன, ஆனால் ஒத்திசைவு மற்றும் செயல்திறனுக்கான அணுகுமுறையில் கணிசமாக வேறுபடுகின்றன. ஹாஷ்மேப் அதன் வேகம் மற்றும் பூஜ்ய மதிப்புகளுடன் கூடிய நெகிழ்வுத்தன்மை காரணமாக த்ரெட் அல்லாத பயன்பாடுகளுக்கு முன்னுரிமை அளிக்கப்படுகிறது. மாறாக, Hashtable நூல்-பாதுகாப்பான செயல்பாடுகளுக்கு ஏற்றது ஆனால் செயல்திறன் செலவில். இந்த வேறுபாடுகளைப் புரிந்துகொள்வதன் மூலம், டெவலப்பர்கள் தங்களின் குறிப்பிட்ட தேவைகளின் அடிப்படையில் எந்தத் தரவுக் கட்டமைப்பைப் பயன்படுத்த வேண்டும் என்பது பற்றிய தகவலறிந்த முடிவுகளை எடுக்க முடியும்.