Java Notes
Learn Java Hashtable from scratch — what it is, how it differs from HashMap, why null keys and values are rejected, thread-safety explained, and why ConcurrentHashMap is the modern choice.
Hashtable Java ka sabse pehla key-value map tha — Java 1.0 mein aaya, tab Collections Framework bhi nahi tha (woh Java 1.2 mein aaya). Ye ek hash-based structure hai, bilkul HashMap ki tarah, lekin ek bada fark hai: Hashtable ka har method synchronized hai.
Synchronized matlab: ek time par sirf ek thread koi bhi method call kar sakti hai. Doosri thread ko wait karna padta hai. Yahi thread-safety deta hai, lekin isi wajah se ye slow bhi hai.
Aaj ke naye code mein Hashtable use karna galat maana jaata hai. Lekin tumhara kisi legacy codebase se kaam padega, aur interviews mein ye zaror poochha jaata hai. Isliye samajhna zaroori hai.
Hashtable ka Basic Use
Try it in WoHoCode
Edit the program, then run it here.
Run this example to see its output.
Ye sab kuch exactly HashMap jaisa dikhta hai — methods same hain, behavior same hai. Fark internally hai (synchronization).
Hashtable Iterate Karo
Try it in WoHoCode
Edit the program, then run it here.
Run this example to see its output.
Enumeration kya hai? Ye Iterator se bhi purana interface hai. Java 1.0 mein Iterator nahi tha — Enumeration tha. hasMoreElements() = hasNext(), nextElement() = next(). Naye code mein Iterator ya for-each prefer karo.
Sabse Bada Fark: null Keys aur Values Allowed Nahi
Try it in WoHoCode
Edit the program, then run it here.
Run this example to see its output.
Kyon null allowed nahi? Hashtable hashCode() call karta hai key pe aur equals() value pe compare karne ke liye. null pe koi bhi method call karo to NullPointerException aata hai. Isliye design level par hi null ko reject kar diya.
HashMap ne kaise null allow kiya? HashMap mein null key ke liye special case handle kiya gaya hai — internally null key ko index 0 pe store karta hai bina hashCode() call kiye.
Synchronization ka Matlab — Thread Safety
Ye concept samajhna important hai:
Try it in WoHoCode
Edit the program, then run it here.
Run this example to see its output.
Ye important lesson hai: Hashtable individual method calls ko thread-safe banata hai, lekin compound operations (get + put like above) ke beech doosri thread aa sakti hai. Isliye Hashtable ka synchronized hona real-world thread safety ke liye kaafi nahi hai.
Hashtable vs HashMap — Complete Comparison
// HashMap
HashMap<String, Integer> map = new HashMap<>();
// - Thread safe: NAHI
// - Null key: EK allowed
// - Null value: Multiple allowed
// - Performance: FAST
// - Introduced: Java 1.2
// Hashtable
Hashtable<String, Integer> table = new Hashtable<>();
// - Thread safe: HAAN (synchronized methods)
// - Null key: NAHI
// - Null value: NAHI
// - Performance: SLOW (lock overhead)
// - Introduced: Java 1.0| Feature | HashMap | Hashtable |
|---|---|---|
| Thread-safe | Nahi | Haan |
| Null key | Ek allowed | Nahi |
| Null value | Allowed | Nahi |
| Speed | Fast | Slow |
| Legacy | Nahi | Haan |
| Extends | AbstractMap | Dictionary |
| Implements | Map | Map |
Aaj Hashtable ki Jagah kya use karein?
Single-threaded code ke liye:
// HashMap use karo — faster, null allowed
Map<String, Integer> map = new HashMap<>();Multi-threaded code ke liye:
import java.util.concurrent.ConcurrentHashMap;
// ConcurrentHashMap use karo — properly thread-safe, fast
ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
map.put("key", 1);
// - Synchronized nahi (full lock nahi lagta)
// - Bucket-level locking use karta hai — sirf wahi bucket lock hoti hai jo use ho rahi hai
// - Multiple threads simultaneously alag buckets mein kaam kar sakti hain
// - Null key/value allowed NAHI (Hashtable ki tarah)Kyon ConcurrentHashMap better hai:
- Hashtable: ek kaam hote waqt poori map lock — sirf ek thread kuch kar sakti hai
- ConcurrentHashMap: sirf us bucket ko lock karo jahan kaam ho raha hai — baaki sab threads doosre buckets mein kaam kar sakti hain
Common Mistake: Hashtable Use Karna Naye Code Mein
// WRONG — legacy code ka pattern
Hashtable<String, Integer> scores = new Hashtable<>();
// CORRECT — naye code ke liye
Map<String, Integer> scores = new HashMap<>(); // single thread
// ya
ConcurrentHashMap<String, Integer> scores = new ConcurrentHashMap<>(); // multi-threadAgar koi purana code Hashtable use karta ho aur tumhe update karna ho, to pehle check karo ki:
- Code multi-threaded hai ya nahi?
- Null keys/values store hoti hain kya?
Uske hisaab se HashMap ya ConcurrentHashMap mein migrate karo.
Practice Task
Task: Ek Hashtable<String, String> banao jisme desh aur unki currency store karo (India-Rupee, USA-Dollar, Japan-Yen, UK-Pound). Phir:
- Saari entries print karo entrySet se
- "Japan" ki currency print karo
- "Euro" currency kisi key mein hai kya check karo (containsValue)
- Null key add karne ki koshish karo aur exception catch karo
- Same data HashMap mein banao aur null key successfully add karo
Solution:
Try it in WoHoCode
Edit the program, then run it here.
Run this example to see its output.
Kya observe karo: Hashtable aur HashMap dono same output denge currencies ke liye (except order). Lekin null key par behavior bilkul alag hai. new HashMap<>(currencies) Hashtable se directly HashMap bana leta hai — kyunki dono Map implement karte hain.
Continue the lesson path