Set আর Map — HashMap, TreeMap আর দ্রুত খোঁজার কৌশল

১ · দুটি প্রশ্ন — “আছে কি?” আর “এর মান কী?”

পর্ব ৩০-এ List দেখেছেন: উপাদানগুলো সারিতে থাকে, প্রতিটির একটি index. কিন্তু বাস্তব প্রোগ্রামের অনেক প্রশ্নের সাথে index-এর কোনো সম্পর্ক নেই। “এই মোবাইল নম্বর থেকে আজ কি আগে কেউ লগইন করেছে?” “রোল ১৪২-এর ছাত্রের ফল কী?” “এই বাক্যে ‘ঢাকা’ শব্দটি কতবার এসেছে?” এমন প্রশ্নে List দিয়ে উত্তর দিতে হলে প্রতিটি উপাদান একে একে মেলাতে হয়। দশ লাখ উপাদানে, সবচেয়ে খারাপ ক্ষেত্রে, দশ লাখবার।

Java-র Collections Framework-এ এই দুই ধরনের প্রশ্নের জন্য দুটি আলাদা interface আছে:

পার্থক্যটা কতটা বড়, একটি বাস্তব কাজে দেখুন। একটি অনলাইন দোকানের দুটি তালিকা: গত মাসের ১ লাখ ক্রেতার ফোন নম্বর, আর এই মাসের ১ লাখ। “কারা দুই মাসেই কিনেছেন?” — nested loop দিয়ে লিখলে প্রতিটি নম্বরকে অন্য তালিকার প্রতিটির সাথে মেলাতে হয়: ১ লাখ × ১ লাখ = ১,০০০ কোটি তুলনা। একটি তালিকাকে HashSet-এ রাখলে কাজ হয় প্রায় ২ লাখ ধাপ — প্রথম তালিকা set-এ ঢোকাতে ১ লাখ, দ্বিতীয় তালিকার প্রতিটির জন্য একটি contains. যে কাজে কয়েক মিনিট লাগত, তা নেমে আসে এক সেকেন্ডের নিচে। এই পর্বের মূল বার্তা এটাই: সঠিক কাঠামো বাছাই অনেক সময় সবচেয়ে বড় optimization.

সব সময় variable-এর টাইপ লিখুন interface দিয়ে — Set<String> s = new HashSet<>();, Map<Integer, String> m = new TreeMap<>();. পরে implementation বদলাতে হলে শুধু ডান পাশটি বদলান (পর্ব ২১-এর “program to an interface”). আর মনে রাখুন, collection-এ primitive রাখা যায় না: Map<int, String> লিখলে javac থামিয়ে দেয় —

Main.java:4: error: unexpected type
        Map<int, String> m = new HashMap<>();
            ^
  required: reference
  found:    int
1 error

লিখতে হবে Map<Integer, String>. তারপর m.put(142, "A+") লিখলে 142 নিজে থেকেই Integer হয়ে যায় — পর্ব ০৬-এর autoboxing.

২ · Set — HashSet, LinkedHashSet আর TreeSet

তিনটি Set-এর কাজ এক — ডুপ্লিকেট বাদ দেওয়া — কিন্তু উপাদানগুলো কোন ক্রমে দেখাবে, আর কত দ্রুত, সেখানে পার্থক্য। একই ইনপুট 5, 1, 9, 1, 3 তিনটিতে দিলে:

এখানে O(1) আর O(log n) হলো Big-O notation: ডেটা বাড়লে কাজ কীভাবে বাড়ে। O(1) মানে উপাদান দশটি হোক বা দশ লাখ, খরচ মোটামুটি একই। O(log n) মানে দশ লাখ উপাদানেও মাত্র ২০টির মতো ধাপ (২-এর ২০ ঘাত প্রায় দশ লাখ)। দুটিই List-এর contains-এর O(n)-এর চেয়ে অনেক অনেক ভালো।

add একটি boolean ফেরত দেয়: নতুন হলে true, আগে থেকে থাকলে false — কোনো exception নয়। তাই “প্রথমবার দেখলে কিছু করো” লেখা যায় এক লাইনে: if (seen.add(phone)) sendWelcomeSms(phone);. HashSet ভেতরে আসলে একটি HashMap, যার key-গুলোই set-এর উপাদান আর value একটি খালি স্থানধারী object. তাই পর্ব ২৩-এ দেখা সব নিয়ম — hashCode আর equals একসাথে, একই field দিয়ে — Set-এর উপাদানের জন্যও খাটে।

TreeSet — সাজানো, আর “কাছাকাছি” খোঁজা

TreeSet শুধু সাজিয়ে রাখে না, সে একটি NavigableSet: সাজানো ক্রম ব্যবহার করে এমন প্রশ্নের উত্তর দেয়, যা HashSet পারে না। ধরুন একটি বাস কাউন্টারে আজকের ছাড়ার সময় (মিনিটে) রাখা আছে {10, 25, 40, 55, 70}:

সব মান OpenJDK 21-এ চালিয়ে যাচাই করা। খেয়াল করুন: headSet শেষের মানটি বাদ দেয়, tailSet শুরুর মানটি রাখে। আর কিছু না পেলে floor/ceiling null দেয় — সেটা int-এ রাখতে গেলে NullPointerException. TreeSet উপাদান তুলনা করে Comparable-এর compareTo দিয়ে (পর্ব ২৩), তাই যে class Comparable নয়, তার object TreeSet-এ ঢোকাতে গেলে ClassCastException আসে — অথবা আপনি একটি Comparator দিন (পর্ব ৩৩)।

Set-গণিত — union, intersection, difference

স্কুলের ভেন চিত্র মনে আছে? Java-তে তিনটি set operation-ই তৈরি আছে, কিন্তু একটি সতর্কতা: এই method-গুলো যে set-এর ওপর ডাকেন, সেটাকেই বদলে দেয়। তাই আগে একটি কপি বানান:

Set<String> rina  = new TreeSet<>(List.of("C", "Java", "Python"));
Set<String> karim = new TreeSet<>(List.of("Java", "Kotlin", "Python", "Go"));

Set<String> union = new TreeSet<>(rina);  union.addAll(karim);     // দুজনের যেকোনো একজন জানে
Set<String> both  = new TreeSet<>(rina);  both.retainAll(karim);    // দুজনেই জানে
Set<String> only  = new TreeSet<>(rina);  only.removeAll(karim);    // শুধু রিনা জানে
// union = [C, Go, Java, Kotlin, Python]   both = [Java, Python]   only = [C]

এখানে TreeSet নেওয়া হয়েছে যাতে ছাপা ফল প্রতিবার একই ক্রমে আসে। HashSet হলে ফলের উপাদান একই থাকত, কিন্তু ক্রম অনির্দিষ্ট। rina.containsAll(karim) জানায় karim কি rina-র subset. আর দুটি set-এর equals উপাদান মেলায়, ক্রম নয় — একটি HashSet আর একটি TreeSet-এ একই উপাদান থাকলে equals true.

৩ · Map-এর মৌলিক কাজ — put, get আর null-এর নিয়ম

একটি ফোনবুক দিয়ে শুরু করা যাক: নাম → নম্বর। Map-এর প্রতিটি জোড়াকে বলে একটি entry, আর Java-তে তার টাইপ Map.Entry.

Map<String, String> phone = new HashMap<>();
phone.put("Rina", "01711-000001");             // নতুন key → null ফেরত
phone.put("Karim", "01811-000002");
String old = phone.put("Rina", "01911-000003"); // key আছে → মান বদলায়, পুরোনোটি ফেরত
phone.get("Rina");                    // "01911-000003"
phone.get("Nabil");                   // null — key নেই
phone.getOrDefault("Nabil", "নেই");   // "নেই"
phone.containsKey("Karim");           // true
phone.remove("Karim");                // মুছে দেয়, মুছে যাওয়া মান ফেরত দেয়
phone.size();                         // 1

লক্ষ করুন, put একই key-তে দ্বিতীয়বার দিলে নতুন entry তৈরি হয় না — পুরোনো মানটি বদলে যায়, আর পুরোনোটি ফেরত আসে। Map-এ একটি key একবারই থাকে, ঠিক Set-এর মতো। আসলে Map-এর key-গুলোর দল নিজেই একটি Set (keySet())।

null — কোথায় চলে, কোথায় চলে না

HashMap null মান রাখতে দেয় বলে একটি সূক্ষ্ম অস্পষ্টতা তৈরি হয়: get(k) null দিলে দুটি মানে হতে পারে — key নেই, অথবা key আছে আর তার মানই null. আরও সূক্ষ্ম: key আছে কিন্তু মান null হলে getOrDefault(k, 9)-ও null দেয়, 9 নয় — কারণ default দেওয়া হয় শুধু key না থাকলে (OpenJDK 21-এ যাচাই করা)। এই কারণে অভিজ্ঞ প্রোগ্রামাররা Map-এ null মান রাখেন না। “মান নেই” বোঝাতে key-টাই রাখবেন না।

Map ঘোরানো — entrySet, keySet, values

Map-এর তিনটি “জানালা” আছে: keySet() — সব key, values() — সব মান, আর entrySet() — সব জোড়া। key আর মান দুটিই দরকার হলে entrySet ঘোরান। keySet ঘুরিয়ে প্রতিবার get(k) ডাকলে প্রতিটি key-এর জন্য বাড়তি একটি খোঁজ হয়।

Map<Integer, String> result = new TreeMap<>(Map.of(142, "A+", 107, "B", 125, "A"));
for (var e : result.entrySet()) {
    System.out.println("রোল " + e.getKey() + " → " + e.getValue());
}
// রোল 107 → B
// রোল 125 → A
// রোল 142 → A+

ঘোরানোর সময় Map থেকে কিছু মুছবেন না। for-each লুপের ভেতরে map.remove(k) ডাকলে সাধারণত পরের ধাপে ConcurrentModificationException আসে — পর্ব ১১-এ List-এ যা দেখেছেন। শর্ত মেনে মুছতে লিখুন map.entrySet().removeIf(e -> e.getValue() < 33); — নিরাপদ, আর এক লাইনে।

৪ · আধুনিক Map method — merge, computeIfAbsent, putIfAbsent, compute

একটি বাক্যের প্রতিটি শব্দ কতবার এসেছে, গুনতে হবে। Java 8-এর আগে সবাই এভাবে লিখত — আর আজও AI প্রায়ই এভাবেই লেখে:

if (count.containsKey(w)) {
    count.put(w, count.get(w) + 1);   // তিনবার খোঁজা: containsKey, get, put
} else {
    count.put(w, 1);
}

কাজ করে, কিন্তু একই key তিনবার খোঁজা হয়, লেখা লম্বা, আর ভুলের জায়গা বেশি। Java 8 Map interface-এ কয়েকটি default method যোগ করেছে, যারা “খোঁজো, তারপর সিদ্ধান্ত নাও” কাজটি এক ডাকে সারে:

একটি বাড়তি নিয়ম: merge বা compute-এর function যদি null ফেরত দেয়, key-টি Map থেকে মুছে যায় (চালিয়ে যাচাই করা)। এভাবে “গোনা শূন্যে নামলে key সরাও” লেখা যায়। শব্দ গোনার কাজটি merge দিয়ে কীভাবে চলে, ধাপে ধাপে দেখুন — শব্দগুলো “ট্রেন বাস ট্রেন লঞ্চ ট্রেন”:

1Map<String, Integer> c = new TreeMap<>();2for (String w : words)3    c.merge(w, 1, Integer::sum);4System.out.println(c);

এবার একটি পূর্ণ প্রোগ্রাম: একটি বাংলা বাক্যের শব্দ গোনা (merge), তারপর একই সংখ্যার শব্দগুলোকে দলে ভাগ করা (computeIfAbsent দিয়ে একটি Map of List), আর একটি ওয়েবসাইটের লগ থেকে অনন্য ভিজিটর বের করা (Set):

import java.util.*;

class Main {
    public static void main(String[] args) {
        String text = "ঢাকা থেকে চট্টগ্রাম ট্রেন ঢাকা থেকে সিলেট বাস ঢাকা থেকে খুলনা ট্রেন";
        Map<String, Integer> count = new TreeMap<>();          // key সাজানো থাকে
        for (String w : text.split(" ")) {
            count.merge(w, 1, Integer::sum);                   // নেই → 1, আছে → পুরোনো + 1
        }
        System.out.println(count);

        Map<Integer, List<String>> byCount = new TreeMap<>();  // কতবার → কোন শব্দগুলো
        for (Map.Entry<String, Integer> e : count.entrySet()) {
            byCount.computeIfAbsent(e.getValue(), k -> new ArrayList<>()).add(e.getKey());
        }
        System.out.println(byCount);

        List<String> log = List.of("rina", "karim", "rina", "sumi", "karim", "rina");
        Set<String> visitors = new LinkedHashSet<>(log);       // ডুপ্লিকেট বাদ, প্রথম আসার ক্রম
        System.out.println(visitors.size() + " visitors: " + visitors);
        System.out.println(visitors.contains("sumi") + " " + visitors.contains("nabil"));
    }
}

এই “গোনা” আর “দলে ভাগ করা” দুটি প্যাটার্ন এত সাধারণ যে পর্ব ৩৫-এ Stream API এগুলোর জন্য তৈরি collector দেবে — Collectors.groupingBy আর Collectors.counting. ভেতরে তারা মূলত এই একই ধরনের কাজ করে (groupingBy নিজেও computeIfAbsent ব্যবহার করে)। লুপ দিয়ে একবার নিজে বুঝে নিলে Stream-এর কোড পড়া সহজ হবে।

৫ · HashMap-এর ভেতরে — bucket, load factor, resize আর treeification

পর্ব ২৩-এ দেখেছেন, HashSet/HashMap object-এর hashCode দিয়ে একটি bucket বাছে, আর সেই bucket-এর ভেতরে equals দিয়ে মিল নিশ্চিত করে। এবার আরও এক ধাপ ভেতরে যাই: টেবিলটি দেখতে কেমন, ভরে গেলে কী হয়, আর খারাপ ক্ষেত্রে HashMap নিজেকে কীভাবে রক্ষা করে।

• টেবিল একটি array. ডিফল্টে প্রথম put-এর সময় ১৬টি ঘরের array তৈরি হয়। ঘরের সংখ্যা সবসময় ২-এর ঘাত (১৬, ৩২, ৬৪…)।
• ঘর বাছাই। HashMap key-এর hashCode নেয়, উঁচু বিটগুলো নিচের বিটের সাথে মিশিয়ে দেয় (h ^ (h >>> 16)), তারপর ঘর = hash & (n - 1). n যেহেতু ২-এর ঘাত, এটা ভাগশেষ নেওয়ার একটি দ্রুত উপায় — শুধু নিচের কয়েকটি বিট রাখা।
• Collision হলে তালিকা। একই ঘরে একাধিক key পড়লে তারা একটি ছোট linked list হয়ে থাকে।
• Load factor ০.৭৫. উপাদানের সংখ্যা যখন ঘরের সংখ্যা × ০.৭৫ ছাড়ায় (১৬ ঘরে ১২টির বেশি), HashMap নতুন একটি দ্বিগুণ আকারের array বানায় আর সব entry নতুন ঘরে সরায় — একে বলে resize বা rehash.

ঘটনাগুলো ধাপে ধাপে দেখুন। বোঝার সুবিধার জন্য টেবিলটি ছোট — new HashMap<>(4) লিখলে আসলেই ৪টি ঘর হয়, আর সীমা ৪ × ০.৭৫ = ৩। hash-এর সংখ্যাগুলো বানানো, আসল মান নয়:

hash("rina") = 13     (ধরা যাক)
ঘর = 13 & (4 - 1) = 13 & 3 = 1

ঘর 0 │ ·
ঘর 1 │ rina=80
ঘর 2 │ ·
ঘর 3 │ ·          size = 1, সীমা = 3

hash("karim") = 6  →  6 & 3 = 2

ঘর 0 │ ·
ঘর 1 │ rina=80
ঘর 2 │ karim=65
ঘর 3 │ ·          size = 2

hash("sumi") = 9  →  9 & 3 = 1   ← rina-র ঘর!

ঘর 1-এ: rina — hash 13 ≠ 9, তাই আলাদা key
        তালিকার শেষে জুড়ে দাও

ঘর 1 │ rina=80 → sumi=72
ঘর 2 │ karim=65    size = 3

hash = 13 → ঘর 1
rina: hash মেলে, equals → true
→ শুধু মান বদলাও: 80 → 85, put ফেরত দেয় 80

ঘর 1 │ rina=85 → sumi=72
size বাড়েনি — নতুন entry নয়

hash = 20 → 20 & 3 = 0 → ঘর 0-এ বসল
size = 4  >  সীমা 3   → resize!

নতুন array: ৮টি ঘর, নতুন সীমা 6
প্রতিটি entry নতুন ঘর পাবে: hash & 7

sumi  9 & 7 = 1     ঘর 1 │ sumi=72
nabil 20 & 7 = 4    ঘর 4 │ nabil=90
rina  13 & 7 = 5    ঘর 5 │ rina=85
karim 6 & 7 = 6     ঘর 6 │ karim=65

rina আর sumi এখন আলাদা ঘরে — collision নেই।
ক্রমও বদলে গেছে: HashMap-এর ক্রমে ভরসা নয়!

Treeification — খারাপ দিনের বিমা

ভালো hashCode থাকলে প্রতিটি ঘরে গড়ে ১টিরও কম entry থাকে। কিন্তু hashCode খারাপ হলে (সব key একই hash দেয়), বা কেউ ইচ্ছা করে একই hash-এর হাজারো key পাঠায় (পর্ব ২৩-এর hash flooding), একটি ঘরের তালিকা লম্বা হয়ে যায় আর খোঁজা হয়ে যায় O(n). Java 8 থেকে HashMap এর একটি প্রতিকার রেখেছে, যাকে বলে treeification: কোনো ঘরে ৮টির বেশি entry হলে, আর টেবিলে অন্তত ৬৪টি ঘর থাকলে, সেই ঘরের তালিকাটি একটি red-black tree-তে বদলে যায়। তখন key-গুলো Comparable হলে (যেমন String) সবচেয়ে খারাপ খোঁজাও O(log n) — বিস্তারিত ভাবনার প্রশ্ন ৩-এ। (টেবিল ৬৪-এর ছোট হলে HashMap tree না বানিয়ে আগে resize করে।) সাধারণ প্রোগ্রামে এটা প্রায় কখনো ঘটে না — এটা দুর্ঘটনার বিমা, রোজকার পথ নয়।

key কেন immutable হতে হবে

পুরো ব্যবস্থাটা একটি অনুমানের ওপর দাঁড়িয়ে: কোনো key একবার একটি ঘরে বসার পর তার hash বদলাবে না। পর্ব ২৩-এর অংশ ৬-এ দেখেছেন, Set-এ রাখার পর object-এর নাম বদলালে সে পুরোনো ঘরে আটকে থাকে — contains false দেয়, আর আবার add করলে একই object দুবার থাকে। Map-এর key-এর বেলায় আরও খারাপ: put করা মান get দিয়ে আর পাওয়াই যায় না। তাই key হিসেবে নিন immutable টাইপ — String, Integer, enum, record (সব field নিজেও immutable হলে)। String-এর একটি বাড়তি সুবিধা: সে নিজের hashCode প্রথমবার হিসাব করে মনে রাখে, তাই একই String key বারবার খুঁজলে hash আবার হিসাব করতে হয় না।

৬ · TreeMap আর LinkedHashMap — সাজানো ক্রম আর ঢোকানোর ক্রম

TreeMap — সাজানো key, আর floorKey

TreeMap ভেতরে একটি red-black tree — নিজে নিজে ভারসাম্য রাখা একটি binary search tree. প্রতিটি node-এর বাঁয়ে ছোট key, ডানে বড়। ভারসাম্য থাকায় tree-এর উচ্চতা সবসময় O(log n), তাই put, get, remove — সব O(log n). HashMap-এর চেয়ে একটু ধীর, কিন্তু বিনিময়ে key-গুলো সবসময় সাজানো, আর সে একটি NavigableMap: firstKey, lastKey, floorKey, ceilingKey, headMap, tailMap, descendingMap.

এর সবচেয়ে কাজের ব্যবহার হলো “পরিসর থেকে মান”। SSC/HSC-র গ্রেড: ৮০ বা বেশি A+, ৭০–৭৯ A, ৬০–৬৯ A-, ৫০–৫৯ B, ৪০–৪৯ C, ৩৩–৩৯ D, ৩৩-এর নিচে F. if-else-এর লম্বা সিঁড়ি না লিখে প্রতিটি সীমার শুরুটা key হিসেবে রাখুন। তারপর নম্বর দিলে floorKey(marks) বলে দেয় “এই নম্বর বা তার নিচের সবচেয়ে বড় সীমা কোনটি”। আয়কর বা বিদ্যুৎ বিলের ধাপ, কুরিয়ারের ওজন অনুযায়ী চার্জ, বয়স অনুযায়ী টিকিটের দাম — সব একই ছাঁচ। ৬৭ নম্বর দিয়ে খোঁজাটা ধাপে ধাপে দেখুন (tree-এর আকার সরল করে দেখানো):

                50:B
            /          \
        33:D            70:A
       /    \          /    \
     0:F   40:C     60:A-   80:A+

floorKey(67) = ?   উত্তর এখনো নেই

67 ≥ 50  →  50 একটি সম্ভাব্য উত্তর
           আরও বড় সম্ভাব্য উত্তর থাকতে পারে → ডানে যাও

সেরা এখন পর্যন্ত: 50
বাঁয়ের পুরো অংশ (0, 33, 40) আর দেখার দরকার নেই

67 < 70  →  70 উত্তর হতে পারে না (67-এর বেশি)
           বাঁয়ে যাও

সেরা এখন পর্যন্ত: 50
80 বাদ পড়ল

67 ≥ 60  →  60, 50-এর চেয়ে ভালো সম্ভাব্য উত্তর
           ডানে যাও … ডানে কিছু নেই

সেরা: 60

floorKey(67)   → 60
get(60)        → "A-"
floorEntry(67) → 60=A-   (key আর value একসাথে)

ceilingKey(67) → 70
floorKey(-5)   → null  ← সাবধান!

LinkedHashMap — ক্রম মনে রাখা HashMap, আর LRU cache

LinkedHashMap হলো HashMap, যার সব entry পাশাপাশি একটি দুই-দিকের linked list দিয়েও জোড়া। খোঁজা HashMap-এর মতোই O(1), কিন্তু ঘোরালে আসে ঢোকানোর ক্রমে। খরচ: প্রতিটি entry-তে দুটি বাড়তি reference. একটি মজার বিকল্প আছে — constructor-এর তৃতীয় argument true দিলে ক্রম হয় ব্যবহারের ক্রম (access order): get বা put করা entry তালিকার শেষে চলে যায়। আর removeEldestEntry override করলে প্রতিটি put-এর পর সে জিজ্ঞেস করে “সবচেয়ে পুরোনোটি সরাব?”। এই দুটি মিলিয়ে কয়েক লাইনে একটি LRU cache হয় — যে cache জায়গা ফুরালে “সবচেয়ে বেশি দিন ব্যবহার হয়নি” এমন জিনিস ফেলে দেয়।

import java.util.*;

class Main {
    public static void main(String[] args) {
        TreeMap<Integer, String> grade = new TreeMap<>(Map.of(
            80, "A+", 70, "A", 60, "A-", 50, "B", 40, "C", 33, "D", 0, "F"));
        for (int marks : new int[] {95, 80, 67, 33, 12}) {
            System.out.println(marks + " -> " + grade.floorEntry(marks).getValue());
        }

        Map<String, String> cache = new LinkedHashMap<>(16, 0.75f, true) {  // true = access order
            @Override
            protected boolean removeEldestEntry(Map.Entry<String, String> eldest) {
                return size() > 3;                       // ৩টির বেশি হলে সবচেয়ে পুরোনোটি বাদ
            }
        };
        cache.put("/home", "Home"); cache.put("/about", "About"); cache.put("/blog", "Blog");
        cache.get("/home");                              // /home এখন সবচেয়ে সাম্প্রতিক
        cache.put("/shop", "Shop");                      // ৪টি হলো → সবচেয়ে পুরোনো বাদ
        System.out.println(cache.keySet());
    }
}

1put /home, /about, /blog2cache.get("/home");3cache.put("/shop", "Shop");4System.out.println(cache.keySet());

Java 21 LinkedHashMap আর TreeMap-কে একটি নতুন interface দিয়েছে — SequencedMap (JEP 431). এখন যেকোনো ক্রম-ওয়ালা Map-এ একই নামে লেখা যায় firstEntry(), lastEntry(), pollFirstEntry(), আর reversed(). HashMap এই interface implement করে না — কারণ তার কোনো “প্রথম” নেই।

EnumMap — key যখন enum

পর্ব ২৪-এ দেখেছেন, key যদি একটি enum হয় — সপ্তাহের দিন, অর্ডারের অবস্থা — তাহলে EnumMap নিন। ভেতরে সে একটি সাধারণ array, যার index হলো enum-এর ordinal: hash নেই, collision নেই, ঘোরালে enum ঘোষণার ক্রম। HashMap-এর চেয়ে দ্রুত আর কম মেমরির। Set-এর জন্য একই রকম EnumSet, যা ভেতরে বিট দিয়ে কাজ করে।

৭ · অপরিবর্তনীয় Map — Map.of, Map.entry আর Map.copyOf

অনেক Map একবার বানিয়ে আর কখনো বদলানো হয় না — জেলার কোড, ভ্যাটের হার, মেনুর দাম। এদের জন্য Java 9 এনেছে Map.of, আর Java 10 এনেছে Map.copyOf. এগুলো unmodifiable: put বা remove ডাকলে UnsupportedOperationException.

Map<String, Integer> code = Map.of("Dhaka", 1, "Chattogram", 2, "Khulna", 3);
Map<String, Integer> big  = Map.ofEntries(              // ১০ জোড়ার বেশি হলে
        Map.entry("Rajshahi", 4), Map.entry("Sylhet", 5));
Map<String, Integer> snap = Map.copyOf(someHashMap);    // অপরিবর্তনীয় কপি

Map.of সর্বোচ্চ ১০ জোড়া নেয়; বেশি হলে Map.ofEntries আর Map.entry. তিনটি কঠোর নিয়ম আছে, আর প্রতিটি OpenJDK 21-এ চালিয়ে যাচাই করা:

• একই key দুবার — সাথে সাথে exception. HashMap-এ একই key দুবার put করলে নীরবে পুরোনো মান মুছে যায়। Map.of একে ভুল হিসেবে ধরে: Map.of("a", 1, "a", 2) দেয় java.lang.IllegalArgumentException: duplicate key: a. (Set.of-এ একই উপাদান দুবার দিলে: duplicate element: a.) কপি-পেস্ট করা কনফিগারেশনে ভুলটা চলার শুরুতেই ধরা পড়ে।
• null কোথাও নয়। key বা value null দিলে NullPointerException. যে HashMap-এ null key আছে, তার Map.copyOf-ও একই কারণে ব্যর্থ হয়।
• ঘোরানোর ক্রম ইচ্ছা করে এলোমেলো। OpenJDK-র বর্তমান implementation প্রতিবার JVM চালু হওয়ার সময় একটি এলোমেলো “salt” বেছে নেয়, আর Map.of/Set.of-এর ঘোরানোর ক্রম তার ওপর নির্ভর করে। তাই একই প্রোগ্রাম দুবার চালালে ক্রম আলাদা হতে পারে (ভাবনার প্রশ্ন ৪)।

Map.copyOf আর Collections.unmodifiableMap(m)-এর পার্থক্য মনে রাখুন। প্রথমটি একটি স্বাধীন কপি; মূল Map পরে বদলালে কপি বদলায় না। দ্বিতীয়টি শুধু একটি “পড়ার জানালা” — নিজে বদলানো যায় না, কিন্তু মূল Map বদলালে জানালা দিয়ে সেই বদল দেখা যায়। আর মনে রাখুন, unmodifiable মানে শুধু Map-এর কাঠামো স্থির; ভেতরের value যদি একটি mutable list হয়, সেই list বদলানো যায় (পর্ব ২৫-এর shallow immutability).

৮ · কোনটি কখন — খরচের টেবিল আর সিদ্ধান্তের নিয়ম

তিনটি প্যাটার্ন, যা বারবার লাগবে

• গোনা (frequency count): count.merge(x, 1, Integer::sum) — শব্দ, ভোট, প্রতিটি পণ্যের বিক্রি, প্রতিটি IP-র request.
• দলে ভাগ করা (grouping): groups.computeIfAbsent(key, k -> new ArrayList<>()).add(x) — বিভাগ অনুযায়ী ছাত্র, জেলা অনুযায়ী অর্ডার, একই অক্ষরের শব্দ। পর্ব ৩৫-এ Collectors.groupingBy একই কাজ এক লাইনে করবে।
• দেখা হয়েছে কি (seen set): if (!seen.add(x)) { /* ডুপ্লিকেট! */ } — ডুপ্লিকেট ফর্ম, একই OTP দুবার, গ্রাফে একই node দুবার না ঘোরা। দুই তালিকার মিল খুঁজতে একটিকে Set বানান, অন্যটি ঘুরে contains — nested loop-এর O(n × m) নেমে আসে O(n + m)-এ।

৯ · AI-এর যুগে — Map-এর কোড যাচাই করা

“একটি লগ ফাইল থেকে প্রতিটি ব্যবহারকারীর লগইন সংখ্যা বের করো” — AI এমন কাজে কয়েক সেকেন্ডে কোড দেয়, আর বেশিরভাগ সময় সেটা চলে। কিন্তু Set আর Map-এর সবচেয়ে বিপজ্জনক ভুলগুলো compile error দেয় না: ক্রম আজ ঠিক আসে কাল আসে না, ছোট ডেটায় দ্রুত চলে বড় ডেটায় ঘণ্টা লাগে। এগুলো আপনাকেই ধরতে হবে।

AI-এর লেখা Set/Map কোড হাতে পেলে — যাচাইয়ের চেকলিস্ট

• প্রশ্নের সাথে কাঠামো মেলে: “আছে কি?” → Set, “এর মান কী?” → Map, সাজানো/পরিসর → Tree
• কোনো আউটপুট, ফাইল বা টেস্ট HashMap/HashSet-এর ঘোরানোর ক্রমের ওপর নির্ভর করে না
• containsKey + get + put-এর জায়গায় merge / computeIfAbsent / getOrDefault
• কোনো nested loop বা list.contains দিয়ে বড় ডেটায় খোঁজা নেই
• key immutable; নিজের class হলে equals আর hashCode দুটোই আছে, একই field দিয়ে
• লুপের ভেতরে map.remove নেই; floorKey/floorEntry/get-এর null ফল সামলানো হয়েছে
• Map.of-এ ডুপ্লিকেট key বা null নেই; বদলাতে হবে এমন Map-এ Map.of ব্যবহার হয়নি