Collections aur Generics interview questions & answers

Ek kirane ki dukaan sochiye. Counter ke peechhe maalik teen alag cheezein rakhta hai, aur har ek ka shape uske kaam ke hisaab se hai.

Ek hai rozana ki bikri ka register — har bikri usi order me likhi hui jis order me hui, aur agar ek hi customer chaar baar aaya to chaar baar likha hua. Doosri hai gali ki dukaanon ki list — har dukaan ka naam sirf ek baar, kyunki "Sharma General Store" do baar likhne se koi nayi baat pata nahi chalti. Aur teesra hai rate card — usko aap shuru se aakhir tak padhte nahi, aap cheeni dhoondhte hain aur 48 mil jaata hai.

Kisi ne shauk me teen register nahi banaye. Har ek isliye hai kyunki usse alag sawaal poochha jaata hai.

In production wahi teen shapes Java ke teen collection parivaar hain. Bikri ka register ek List hai — order ke saath, duplicate allowed, position se pahunch. Gali ki list ek Set hai — koi duplicate nahi, aur order ka koi vaada nahi. Rate card ek Map hai — aapke paas ek key hoti hai aur aapko value milti hai.

🌍 Real-world example: ek food delivery app aapki order history List me rakhti hai, jin cuisines pe filter lag sakta hai wo Set me, aur restaurant-id se restaurant-details Map me. Data ek hi jagah se aata hai, shape teen, kyunki sawaal teen alag hain.

💡 Collection Framework = java.util me pehle se bani data structures (List, Set, Queue, Map aur unke implementations) ka set, aur wo interfaces jo inhe aapas me badalne laayak banate hain. 💡 Iterable = sabse upar wala interface. Jo bhi Iterable hai use for-each loop me daala ja sakta hai. 💡 Collection (bina s ke) = Iterable ke neeche wala interface, jise List, Set aur Queue extend karte hain. 💡 Collections (s ke saath) = bilkul alag ek utility class, jisme Collections.sort, Collections.max, Collections.unmodifiableList jaise static helper methods hain.

Hierarchy, usi order me jis order me kaam aati hai

Iterable
   └── Collection ......... add, remove, size, contains, iterator
         ├── List ......... order ke saath, duplicates OK, index access -> ArrayList, LinkedList, Vector
         ├── Set .......... koi duplicate nahi                          -> HashSet, LinkedHashSet, TreeSet
         └── Queue ........ processing ka order                         -> ArrayDeque, PriorityQueue

Map .................. key -> value, Collection ke NEECHE nahi          -> HashMap, LinkedHashMap, TreeMap

Is diagram me do cheezein baar-baar poochhi jaati hain.

Map kinare pe latka hua hai. Wo framework ka hissa hai par Collection ko extend nahi karta. Wajah mechanical hai, philosophical nahi: Collection add(E element) ka vaada karta hai — ek baar me ek cheez. Map jodiyan rakhta hai, isliye uska method put(K key, V value) hai. Jis shape ko do argument chahiye wo ek argument wale contract ko nibha hi nahi sakta. "Map ek Collection hai" bolna hierarchy ki sabse aam galti hai.

Collection aur Collections ka aapas me koi rishta nahi. Ek wo interface hai jise aapki ArrayList implement karti hai. Doosra ek toolbox class hai jiska object aap kabhi nahi banate. Naam me sirf ek akshar ka farq hai, aur isiliye interviewer ko ye sawaal pasand hai.

Framework aaya hi kyun — wo array jiski jagah isne li

Collections se pehle sirf array the, aur array ke teen kade kinare hain:

• Uski length banate waqt hi fix ho jaati hai. 3 length wale array pe arr[3] ArrayIndexOutOfBoundsException deta hai; usko badhane ka matlab hai bada array banao aur haath se copy karo.
• Uska apna koi behaviour nahi. Na contains, na remove, na apna sort — loop aapko likhna padta hai.
• Har array apne me ek jazeera hai. Jo method array leta hai wo List nahi le sakta; jo method List leta hai wo ArrayList, LinkedList, ya jo bhi use implement karta hai, sab le leta hai.

Aakhri baat hi asli inaam hai. List ek interface hai, isliye aap List<String> names = new ArrayList<>(); likhte hain aur aage ka har method interface pe tika rehta hai. Saal bhar baad LinkedList daal dijiye, baaki kuch nahi badlega.

Standard definition (interview me bolo): The Java Collection Framework is a unified architecture of interfaces (Collection, List, Set, Queue, Map) and their implementations that provides ready-made, resizable data structures along with algorithms such as sorting and searching, so that different collection types can be used interchangeably through a common API.

Kab use karein: lagbhag hamesha, jaise hi do-chaar se zyada values rakhni ho. List tab jab order maayne rakhta ho ya duplicate hona jaayaz ho, Set tab jab data asal me unique cheezon ka set ho aur aap baar-baar "ye pehle aa chuka hai kya" likh rahe hon, aur Map tab jab aap ek list me dhoondh kar doosri me kuch lookup kar rahe hon — wo dhoondhna khud ek Map hai jo likha jaana baaki hai.

Kab NAHI use karein: do tang jagahon pe aaj bhi seedha array jeet-ta hai. Primitives — Collection sirf object rakh sakta hai, isliye List<Integer> har int ko box karta hai aur wo memory kharch karta hai jo int[] nahi karta. Aur wo fixed-length buffer jahan size sach me constant ho aur code performance-critical ho, jaise image ya byte processing. Trade-off: collections thodi memory aur ek layer ka kharcha lete hain, aur badle me resizing, banaye-banaye algorithms aur aapas me badalne ki aazadi dete hain. Aam business code me ye sauda bilkul barabari ka nahi hai.

import java.util.*;

public class T1 {
    public static void main(String[] args) {
        String[] arr = {"Aarav", "Diya", "Aarav"};
        // arr[3] = "Kabir";  // ArrayIndexOutOfBoundsException - array ki length badalti nahi

        List<String> list = new ArrayList<>(Arrays.asList(arr));
        list.add("Kabir");                          // List badh gayi, duplicate bhi rakhti hai
        System.out.println("List  : " + list + "  size=" + list.size());

        Set<String> set = new HashSet<>(list);      // duplicate khud hat gaya
        System.out.println("Set   : " + set + "  size=" + set.size());

        Map<String, Integer> map = new HashMap<>(); // key se dhoondhna
        map.put("Aarav", 91);
        map.put("Diya", 78);
        map.put("Aarav", 95);                       // wahi key dobara = value replace
        System.out.println("Map   : " + map + "  Aarav=" + map.get("Aarav"));

        Collections.sort(list);                     // Collections = utility class, List nahi
        System.out.println("sorted: " + list);
        System.out.println("max   : " + Collections.max(list));
        System.out.println("List is a Collection? " + (list instanceof Collection));
        System.out.println("Map is a Collection?  " + (map instanceof Collection));
    }
}

Office me formon ka dher rakhne ke do tareeke.

Ek clerk unhe bound register me rakhta hai — har page pe number, har page apni jagah. Page 47 maangiye, uska angootha seedha wahin girta hai. Par 12 aur 13 ke beech naya page daaliye, to uske baad ke har page ka number badalna padta hai aur sab khisakte hain.

Doosra clerk khule kaagaz ek zanjeer me rakhta hai, har kaagaz pe likha hota hai agla us mez pe hai. Beech me naya kaagaz ghusaana bahut aasaan — do parchiyaan badal do. Par "kaagaz 47 do" ka matlab hai kaagaz 1 se shuru karke zanjeer ko santaalis baar follow karna.

Koi behtar nahi hai. Ye ulte sauday hain, aur Java dono deta hai.

In production register hai ArrayList — andar ek resizable array. Zanjeer hai LinkedList — nodes ki doubly linked kadi.

🌍 Real-world example: jo product listing aap page-dar-page dekhte hain aur jisme koodte hain wo ArrayList hai. Jis job queue me kaam sire pe jud-ta aur hat-ta rehta hai wo LinkedList ke kareeb hai — halaanki asal me wahan ArrayDeque jeet-ta hai, jo queue wale topic me hai.

💡 ArrayList = ek array pe tiki hui List; index se pahunch seedhi hai, beech me insert karne pe elements khisakte hain. 💡 LinkedList = nodes pe tiki hui List; har node me value ke saath pichhle aur agle node ka link hota hai. 💡 RandomAccess = ek khaali marker interface jo ArrayList implement karta hai aur LinkedList nahi, jiska matlab hai "yahan kisi bhi position tak pahunchna sasta hai". 💡 Vector = Java 1.0 ki asli synchronized List, jo sirf purane code ke liye bachi hui hai.

Naap, raay nahi

Neeche wala demo dono lists ko 1,00,000 elements se bharta hai aur do kaam ka waqt naapta hai. Ye ginti JDK 17 pe asli run se aayi hai:

Kaam	ArrayList	LinkedList
get(i) 1,00,000 baar	1 ms	5315 ms
add(0, x) 20,000 baar	458 ms	7 ms

Ek taraf paanch hazaar guna dheema, doosri taraf pinsath guna tez. Poora topic yahi hai, aur isiliye "kaunsa tez hai" ka jawab hamesha "kis kaam me?" hota hai.

Wo aadha jawab jo pakda jaata hai

Zyadatar candidate kehte hain "LinkedList insertion aur deletion me tez hai". Interviewer ka agla sawaal hota hai "list.add(5000, x) me bhi tez?" — aur wahan jawab palat jaata hai, kyunki LinkedList ko pehle position 5000 tak chal kar jaana padta hai. Uska sasta insert tabhi lagta hai jab aap us jagah pehle se khade hon: sire pe, ya Iterator haath me hote hue.

Theek se boliye: LinkedList us position pe insert karne me sasti hai jo aapke paas pehle se hai; position tak pahunchna uske liye mehnga hai. ArrayList me ulta hai.

ArrayList badhti kaise hai — aur wo number jo sabko aadha yaad hai

Mashhoor jawab hai "default capacity 10". JDK 17 pe chala kar dekhein to poori tasveer alag hai: new ArrayList<>() zero length ke array se shuru hoti hai, 10 ki capacity pehle add() pe aati hai, aur 10 bharne pe array aadha aur badhta hai — 15 tak, 20 tak nahi. Badhne ka matlab hai naya array banana aur copy karna, isiliye jab size pehle se pata ho to new ArrayList<>(50_000) likhna faaydemand hai.

Vector, aur wo jawab kyun nahi hai

Vector wahi ArrayList hai jiska har method synchronized hai. Wo legacy hai — Java 1.0 ka, framework se bhi pehle ka. Use na karne ki do wajah: single-threaded code me bhi har call pe locking ka kharcha lagta hai, aur wo per-method lock compound operations ko waise bhi safe nahi banata. if (!v.contains(x)) v.add(x); phir bhi race hai, kyunki doosra thread in do calls ke beech ghus sakta hai. Asli concurrent collections Ch6 ka mazmoon hain.

Standard definition (interview me bolo): ArrayList is a resizable-array implementation of the List interface offering constant-time positional access, while LinkedList is a doubly-linked-list implementation offering constant-time insertion and removal at a known position but linear-time positional access.

Kab use karein: default ArrayList rakhiye, aur poore yaqeen se — index se padhna, iterate karna aur aakhir me jodna hi lagbhag saara code karta hai, aur teenon me ArrayList ya sabse aage hai ya barabar. LinkedList tabhi uthaiye jab kaam sach me siron pe ho ya iterator ke zariye ho, jaise wo queue jisme ek taraf se daalte hain aur doosri taraf se nikaalte hain.

Kab NAHI use karein: LinkedList isliye mat chuniye ki kahin padha tha "insertion O(1) hai" — agar aap position tak index se pahunch rahe hain to us tak chalne ki keemat aap de chuke hain, aur bahut badi list ke alawa har jagah wo ArrayList ke khiskaane se mehngi padti hai. Trade-off: ArrayList kabhi-kabhi resize-and-copy aur beech me insert pe shifting ka kharcha leti hai; LinkedList har element ke liye do pointer wala ek object aur har indexed access pe ek chalna maangti hai. Aam business code me ArrayList memory aur speed dono me jeet-ti hai, isiliye wahi default hai.

import java.util.*;

public class T2 {
    public static void main(String[] args) {
        int N = 100_000;
        List<Integer> arrayList  = new ArrayList<>();
        List<Integer> linkedList = new LinkedList<>();
        for (int i = 0; i < N; i++) { arrayList.add(i); linkedList.add(i); }

        System.out.println("ArrayList  is RandomAccess? " + (arrayList  instanceof RandomAccess));
        System.out.println("LinkedList is RandomAccess? " + (linkedList instanceof RandomAccess));

        long t0 = System.nanoTime();
        long sum1 = 0;
        for (int i = 0; i < N; i++) sum1 += arrayList.get(i);      // seedha index
        long t1 = System.nanoTime();
        long sum2 = 0;
        for (int i = 0; i < N; i++) sum2 += linkedList.get(i);     // har baar chal kar dhoondhna
        long t2 = System.nanoTime();

        System.out.println("get(i) x " + N + "  ArrayList  : " + (t1 - t0) / 1_000_000 + " ms");
        System.out.println("get(i) x " + N + "  LinkedList : " + (t2 - t1) / 1_000_000 + " ms");

        long t3 = System.nanoTime();
        for (int i = 0; i < 20_000; i++) arrayList.add(0, i);      // shuruaat me insert
        long t4 = System.nanoTime();
        for (int i = 0; i < 20_000; i++) linkedList.add(0, i);
        long t5 = System.nanoTime();
        System.out.println("add(0, x) x 20000  ArrayList  : " + (t4 - t3) / 1_000_000 + " ms");
        System.out.println("add(0, x) x 20000  LinkedList : " + (t5 - t4) / 1_000_000 + " ms");
    }
}

Ek class teacher ek register rakhti hai. Har student ki ek line hai, aur wo line poore term me badhti jaati hai — unit test, mid-term, practical, final. Aakhir me use teen cheezein chahiye: har student ka average, ek rank list, aur distinction cutoff se upar wale naam.

Isi ek jumle me is chapter ke chaar faisle chhupe hain, aur is project me wo chaaron aap khud lenge.

Aap bana kya rahe hain

Ek Gradebook class, chaar kaamon ke saath:

• addMark(student, mark) — us student ka ek mark jodna jo ho bhi sakta hai aur nahi bhi
• average(student) — uska average, aur jo student hai hi nahi uspe koi crash nahi
• rankList() — saare students average ke hisaab se, sabse upar sabse zyada, barabari me naam se
• toppers(cutoff) — cutoff pe ya usse upar ke alag-alag naam

Step 1 — Ek line likhne se pehle shape chuniye

Teen sawaal chalaiye.

Duplicate ka koi matlab hai kya? Haan — Aarav ne sach me do baar 76 laaye, aur dono marks uske average me ginte hain. Isliye marks ek List hain, Set nahi.

Kya main kuch key se dhoondhta hoon? Lagataar, student ke naam se. Isliye container ek Map hai.

Kaunsa order chahiye? Kachcha register ek insaan ke liye chhapta hai, isliye insertion order — LinkedHashMap.

Isse banta hai Map<String, List<Integer>>. Ek key, kai values — asli code me Map ka sabse aam shape yahi hai.

Step 2 — computeIfAbsent, aur wo null check jo aap likhte hi nahi

Seedha-saada version har student ke pehle hi mark pe toot-ta hai:

marks.get(student).add(mark);            // pehli baar NullPointerException

Bhola fix chaar line ka null check hai. Idiom ek line ka hai:

marks.computeIfAbsent(student, s -> new ArrayList<>()).add(mark);

Key na ho to lambda khaali list banata hai, rakh deta hai, aur wapas de deta hai. Key ho to maujooda list bina chhede wapas mil jaati hai. Dono soorat me aapko list milti hai aur aap usme jod dete hain.

Ye shape yaad rakhiye. computeIfAbsent ke saath Map<K, List<V>> hi Java me grouping likhne ka tareeka hai, aur ye har doosre interview task me aata hai.

Step 3 — Khaali lautaiye, null nahi

List<Integer> list = marks.getOrDefault(student, List.of());
if (list.isEmpty()) return 0;

average("Neha") ne exception ki jagah 0.0 chhapa, kyunki anjaan student ke liye getOrDefault ne khaali list de di. Jo method null ki jagah khaali collection lautata hai, wo har bulane wale se ek null check hata deta hai — aur bulane wale null check bhoolte hain.

Step 4 — Rank list: Map ko value se sort nahi kiya ja sakta

Yahi wo kadam hai jahan log galti karte hain. Value se sorted koi Map hota hi nahi, aur TreeMap key se sort karta hai. Rows bahar nikaal kar List sort kijiye:

List<Map.Entry<String, Double>> rows = new ArrayList<>();
for (String s : marks.keySet()) rows.add(Map.entry(s, average(s)));
rows.sort(Map.Entry.<String, Double>comparingByValue().reversed()
                   .thenComparing(Map.Entry::getKey));

Zanjeer baayein se daayein padhiye: average se, ulta taaki sabse zyada upar aaye, aur barabari me naam se. Run me Aarav aur Ishaan dono ka average 76.0 hai aur Aarav pehle dikhta hai — tie-breaker apna kaam karta hua.

⚠️ Average pe keyed TreeMap<Double, String> ka lalach mat kijiye. Do students ka 76.0 hai, aur Map ki key unique hoti hai, isliye unme se ek chup-chaap gayab ho jaata. Wo galti ek student kam wali rank list deti hai aur koi error dikhta hi nahi.

Step 5 — Toppers ek Set

Naam ek hi baar aana chahiye, isliye Set, aur TreeSet bina kisi sort call ke alphabetical output deta hai. Chhapa hua [Aarav, Diya, Ishaan] sirf container ke chunaav ki wajah se sorted hai.

Khud karke dekhiye

1. subjects jodiye: value ko Map<String, Map<String, List<Integer>>> bana kar har student ke subject-wise marks rakhiye aur har subject ka topper nikaaliye.
2. dropLowest(student) jodiye — average nikaalne se pehle sabse kam ek mark hataiye. Collections.min lijiye aur yaad rakhiye ki hataana kisi chalte hue iteration ko chhedna nahi chahiye.
3. Rank list ko barabari ke saath theek rank ke saath chhapiye: 76.0 wale dono students rank 2 hain, aur uske baad wala rank 4.
4. LinkedHashMap ko HashMap kar ke dobara chalaiye. Averages aur rank list bilkul wahi rahenge; sirf kachche dump ka order badlega. Ye samajhna ki wo kyun mehfooz hai, isi exercise ka maqsad hai.

import java.util.*;

public class Gradebook {
    private final Map<String, List<Integer>> marks = new LinkedHashMap<>();

    void addMark(String student, int mark) {
        marks.computeIfAbsent(student, s -> new ArrayList<>()).add(mark);
    }
    double average(String student) {
        List<Integer> list = marks.getOrDefault(student, List.of());
        if (list.isEmpty()) return 0;
        int total = 0;
        for (int m : list) total += m;
        return Math.round(total * 100.0 / list.size()) / 100.0;
    }
    List<Map.Entry<String, Double>> rankList() {
        List<Map.Entry<String, Double>> rows = new ArrayList<>();
        for (String s : marks.keySet()) rows.add(Map.entry(s, average(s)));
        rows.sort(Map.Entry.<String, Double>comparingByValue().reversed()
                           .thenComparing(Map.Entry::getKey));
        return rows;
    }
    Set<String> toppers(double cutoff) {
        Set<String> out = new TreeSet<>();
        for (String s : marks.keySet()) if (average(s) >= cutoff) out.add(s);
        return out;
    }

    public static void main(String[] args) {
        Gradebook gb = new Gradebook();
        gb.addMark("Ishaan", 72); gb.addMark("Ishaan", 80);
        gb.addMark("Diya", 91);   gb.addMark("Diya", 89);
        gb.addMark("Aarav", 76);  gb.addMark("Aarav", 76);
        gb.addMark("Kabir", 65);

        System.out.println("raw marks     : " + gb.marks);
        System.out.println("Diya average  : " + gb.average("Diya"));
        System.out.println("Neha average  : " + gb.average("Neha"));   // koi crash nahi

        System.out.println("--- rank list ---");
        int rank = 1;
        for (Map.Entry<String, Double> row : gb.rankList()) {
            System.out.println("  " + rank++ + ". " + row.getKey() + "  " + row.getValue());
        }
        System.out.println("toppers(>=76) : " + gb.toppers(76));
    }
}