Java Collections அப்படின்னா என்ன? ArrayList, HashMap, HashSet எப்போ Use பண்ணலாம்?

Java Collections அப்படின்னா என்ன?#

Java Collections-ன்னா பயமுறுத்தற பெரிய வார்த்தை இல்ல. எளிமையா சொன்னா, 'Data-வை வைக்க ready-made containers' - அவ்ளோ தான். நீங்க ஒரு array full ஆயிடுச்சுன்னா, manual-ஆ பெரிய array create செஞ்சு copy பண்ணணும்னு logic எழுத வேண்டாம். JDK team அந்த வேலையை ஏற்கனவே செஞ்சு வச்சிருக்காங்க. 90% நேரம் நீங்க Use பண்ண போற மூணு interface: List, Set, Map.

List - Order-ஐ வைச்சுக்கும், duplicate-வையும் allow பண்ணும். Jio recharge counter-ல queue மாதிரி, யார் முதல்ல வந்தாங்கன்னு order முக்கியம்.

Set - Duplicate-ஐ தானா தள்ளிடும். ஒரு PAN number list-ல unique entries மட்டும் வேணும்னா Set தான் சரியான choice.

Map - Key-value pair store பண்ணும். Phonebook மாதிரி - பேரு key, number value.

ArrayList, LinkedList, Vector - மூணும் List implement செய்யும். HashSet, LinkedHashSet, TreeSet - Set implement செய்யும். HashMap, LinkedHashMap, TreeMap - Map implement செய்யும். ஒரே family தான், ஆனா behind-the-scenes behaviour வேற. இந்த behaviour தான் interviewer கேட்கப் போறது.

ArrayList vs LinkedList - எப்படி பிக் பண்ணலாம்?#

ArrayList உள்ள array-வை வச்சு வேலை செய்யும். Array full ஆகும் போது, Java சைலன்ட்ஆ ஒரு பெரிய array create செஞ்சு எல்லா element-ஐயும் copy பண்ணிடும்.

list.get(5) எடுக்கணும்னா instant-ஆ கிடைக்கும் - அது வெறும் index math தான். ஆனா middle-ல insert பண்ணணும்னா, அதற்கு பின்னாடி இருக்கற எல்லா element-ஐயும் shift பண்ணணும், அதனால slow.

LinkedList ஒரு chain of nodes - ஒவ்வொரு node அடுத்த, முந்தின node-ஐ point பண்ணும். Front-ல, back-ல add/remove பண்ணணும்னா shift வேண்டாம், cheap.

ஆனா get(5) எடுக்கணும்னா, chain-ஐ start-ல இருந்து ஒவ்வொரு node-ஆ நடந்து தான் போகணும் - பெரிய list-ல இது slow.

Practical-ஆ பார்த்தா? Specific reason இல்லாம ArrayList தான் பிக் பண்ணுங்க. Flipkart-ல order-item list-ஆ இருந்தாலும், Zoho form-field list-ஆ இருந்தாலும், எல்லாமே default-ஆ ArrayList தான் Use ஆகுது. LinkedList theory-ல அதிகம் பேசப்படும், day-to-day code-ல அதிகம் காணமாட்டீங்க.

import java.util.*;

public class ListDemo {
    public static void main(String[] args) {
        List<String> arrayList = new ArrayList<>();
        arrayList.add("Chennai");
        arrayList.add("Coimbatore");
        arrayList.add(1, "Madurai"); // index 1-ல insert

        List<String> linkedList = new LinkedList<>();
        linkedList.add("Chennai");
        linkedList.addFirst("Trichy");

        System.out.println(arrayList);
        System.out.println(linkedList);
    }
}

HashMap internal-ஆ எப்படி வேலை செய்யும்?#

HashMap-ஐ ஒரு பெரிய almirah-ஆ நினைச்சுக்குங்க. ஒவ்வொரு key-க்கும் ஒரு 'bucket number' கொடுக்கும் - அது hashCode() method வச்சு decide ஆகுது.

இரண்டு key ஒரே bucket-ல விழுந்தாலும் (collision), Map exact key-ஐ கண்டுபிடிக்க equals() method-ஐ வச்சு check பண்ணும். hashCode() bucket-ஐ sort பண்ணும், equals() exact match-ஐ confirm பண்ணும் - இந்த இரண்டு வேலையும் சேர்ந்து தான் put() மற்றும் get() வேலை செய்யும்.

இங்க தான் பல developers தப்பு பண்றாங்க. Custom key class எழுதும் போது hashCode() மற்றும் equals() இரண்டையும் override பண்ணாம, அல்லது ஒன்றை மட்டும் override பண்ணி விட்டீங்கன்னா, Map silent-ஆ தப்பா behave செய்யும் - exception கூட தராது, ஆனா get() null திருப்பும்.

import java.util.*;

class Employee {
    String empId;
    Employee(String empId) { this.empId = empId; }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Employee)) return false;
        Employee e = (Employee) o;
        return empId.equals(e.empId);
    }

    @Override
    public int hashCode() {
        return empId.hashCode();
    }
}

public class HashMapDemo {
    public static void main(String[] args) {
        Map<Employee, String> salary = new HashMap<>();
        salary.put(new Employee("E101"), "45000");
        System.out.println(salary.get(new Employee("E101"))); // 45000 - equals/hashCode சரியா இருந்தா தான்
    }
}

Loop போடலாமா, Stream Use பண்ணலாமா?#

Collection-ஐ iterate பண்ண for-each loop, Iterator, Streams - மூணு வழியும் இருக்கு.

Streams ஒரு வரியில் filter, map, sort எல்லாம் readable-ஆ எழுத உதவும். உதாரணமா, 50 marks-க்கு மேல உள்ள students-ஐ எடுத்து sort பண்ணணும்னா:

import java.util.*;
import java.util.stream.*;

public class StreamDemo {
    public static void main(String[] args) {
        List<Integer> marks = Arrays.asList(78, 45, 92, 60, 38, 88);

        List<Integer> passed = marks.stream()
                .filter(m -> m >= 50)
                .sorted()
                .collect(Collectors.toList());

        System.out.println(passed); // [60, 78, 88, 92]
    }
}

ஆனா interview pressure-ல, குறிப்பா whiteboard round-ல, plain for-loop எளிதா, வேகமா, தப்பு இல்லாம எழுத முடியும். Stream syntax ஒரு சின்ன தப்பு பண்ணா compile ஆகாது. அதனால இரண்டையும் தெரிஞ்சுக்கிறது தான் safe.

யார் எந்த mistake பண்ணி trouble-ல மாட்டுறாங்க?#

முதல் mistake - ArrayList-ல middle-ல அதிகமா insert/delete பண்ணி performance பத்தி கவலைப்படாதது. 10-20 element list-ல problem இல்ல, ஆனா lakhs records-ஆ இருந்தா shift cost தெரியும்.

இரண்டாவது - custom object-ஐ HashMap key-ஆ வச்சு, hashCode()/equals() override பண்ணாதது. இதால் data 'காணாமல் போன' மாதிரி feel ஆகும்.

மூணாவது - iterate பண்ணும் போது list-ல directly element remove பண்ணுறது. இது ConcurrentModificationException தரும். Iterator.remove() அல்லது removeIf() Use பண்ணணும்.

நாலாவது - Set-ல duplicate இருக்காதுன்னு நினைச்சு, custom object-ஐ போட்டு equals() override செய்யாமலே duplicate வந்துடுது. Set duplicate தள்ளறதுக்கும் equals()/hashCode() தான் base.

Service company interview-ல எந்த Collections Questions கேட்பாங்க?#

TCS, Infosys, Cognizant (CTS), Zoho மாதிரி Chennai, Coimbatore IT companies-ல, Data Structures round-ல Collections கேள்வி கண்டிப்பா வரும். 'HashMap internal-ஆ எப்படி வேலை செய்யும்' - இது classic opening question.

அதுக்கு அடுத்து 'ArrayList vs LinkedList difference', 'HashMap vs TreeMap vs LinkedHashMap', 'Fail-fast vs Fail-safe Iterator', 'HashSet-ல duplicate எப்படி check ஆகுது' - இதெல்லாம் common follow-up. Product companies-ல Streams, Optional, Collectors.groupingBy() மாதிரி advanced topics கூட கேட்பாங்க.

இந்த topics theory-ஆ மட்டும் படிச்சா போதாது. சின்ன code எழுதி, run பண்ணி பார்த்தா தான் விளங்கும்.

Practice Task: ஒரு List<String>-ல Chennai, Coimbatore, Madurai, Chennai, Trichy போட்டு, அதை Set-ஆ convert பண்ணி duplicate போயிருக்கான்னு பாருங்க. அப்புறம் அதையே Stream வச்சு 'C' letter-ல start ஆகுற city-ஐ மட்டும் filter பண்ணி print பண்ணுங்க.

HashMap, LinkedHashMap, TreeMap - இதுல எது எப்போ Use பண்ணலாம்?#

Map family-ல HashMap ஒரு basic option தான், ஆனா LinkedHashMap, TreeMap-ஐ எப்போ பிக் பண்ணணும்னு பல developers confuse ஆவாங்க. HashMap order-ஐ guarantee பண்ணாது - நீங்க எந்த order-ல key போட்டாலும், get() பண்ணும்போது வேற order-ல வரலாம். உதாரணமா, நீங்க ஒரு Zoho CRM form-ல customer details key-value-ஆ store பண்ணி, அதை அதே order-ல காட்டணும்னா HashMap சரியான choice இல்ல.

LinkedHashMap insertion order-ஐ exact-ஆ வைச்சுக்கும். அதாவது, எந்த order-ல போட்டீங்களோ, அதே order-ல iterate பண்ணும்போது வரும். IRCTC booking history காட்ட வேண்டிய ஒரு feature-ஆ நினைச்சுக்குங்க - பயணி முதல்ல book செஞ்ச ticket முதல்ல தெரியணும்னா, இது தான் சரியான structure. TreeMap இன்னும் ஒரு Step மேல போய் key-ஐ natural sorted order-ல வைக்கும் - எடுத்துக்காட்டா, ஒரு college admission list-ல roll number key-ஆ வச்சு, automatic-ஆ ascending order-ல காட்டணும்னா TreeMap தேவைப்படும்.

Interview-ல இந்த மூணையும் ஒப்பிட்டு கேக்குறது common. 'Fast access வேணும், order பற்றி கவலை இல்ல'னா HashMap. 'Insertion order முக்கியம்'னா LinkedHashMap. 'Sorted output வேணும்'னா TreeMap - இந்த simple rule-ஐ வச்சு நீங்க எந்த கேள்விக்கும் confident-ஆ பதில் சொல்லலாம். Real project-ல Flipkart cart-ல product list order-ல காட்டணும்னா LinkedHashMap பயன்படுத்துறது உண்டு, ஆனா பல developers இந்த difference தெரியாம எல்லா இடத்துலையும் HashMap மட்டும் Use பண்ணி order பத்தி பின்னாடி confuse ஆவாங்க.