Collections Framework என்பது பொருட்களின் குழுக்களை சேமிக்கவும் கையாளவும் Java-ன் ஒருங்கிணைந்த இடைமுகங்கள் மற்றும் வகுப்புகளின் தொகுப்பாகும் — List, Set, Map, Queue மற்றும் அவற்றின் பழங்கள். இது தயாரிக்கப்பட்ட, நன்கு சோதிக்கப்பட்ட தரவு கட்டமைப்புகளை வழங்குகிறது, எனவே நீங்கள் அரிதாகவே உங்கள் சொந்தம் கட்ட வேண்டும்.
Collection
├── List — ordered, allows duplicates, indexed access
├── Set — no duplicates, models uniqueness
└── Queue — FIFO/priority ordering for processing
Map (separate hierarchy) — key→value pairs
List<String> list = new ArrayList<>(); // backed by an array — fast random access
list.add("a");
list.get(0); // index access — O(1)
list.contains("a"); // O(n) search
// LinkedList — fast insert/remove at ends, O(n) random access
ArrayList (வரிசை-ஆதரவு, வேகமான குறிப்பு) என்பது இயல்புநிலை; LinkedList அடிக்கடி இறுதி செருகலுக்கு பொருத்தமாக உள்ளது।
Set<String> set = new HashSet<>(); // O(1) add/contains, NO order
set.add("a");
set.add("a"); // ignored — duplicates not allowed
set.contains("a"); // O(1) — great for membership tests
// TreeSet — sorted order; LinkedHashSet — insertion order
HashSet O(1) தনிமை சோதனை வழங்குகிறது; TreeSet கூறுகளை வரிசைப்படுத்தி வைத்திருக்கிறது।
Map<String, Integer> map = new HashMap<>(); // O(1) get/put, no order
map.put("age", 30);
map.get("age"); // 30
map.getOrDefault("x", 0); // safe access with default
map.computeIfAbsent("list", k -> new ArrayList<>()); // handy for grouping
// TreeMap — sorted by key; LinkedHashMap — insertion order
HashMap என்பது O(1) முக-அடிப்படையிலான தேடலுக்கான பணிக்காரன்.
Need ordered + indexed + duplicates → ArrayList
Need uniqueness, fast lookup → HashSet
Need key→value, fast lookup → HashMap
Need sorted order → TreeSet / TreeMap
Need FIFO processing → ArrayDeque / LinkedList (Queue)
Need thread-safety → ConcurrentHashMap, etc.
ArrayList: get O(1), add-end O(1), contains/remove O(n)
HashMap/HashSet: get/put/contains O(1) average
TreeMap/TreeSet: O(log n) (sorted)
LinkedList: add/remove-ends O(1), get O(n)
Collections Framework என்பது Java-ன் அதிகம் பயன்படுத்தப்படும் பகுதிகளில் ஒன்றாகும் — ஏறக்குறைய ஒவ்வொரு நிரல்களும் அதன் மூலம் தரவு குழுக்களை சேமித்து செயல்படுத்துகின்றன।
சரியான சேகரണத்தைத் தேர்ந்தெடுப்பது என்பது நேரடியாக சரியான செயல்பாடு மற்றும் செயல்திறனை பாதிக்கும் ஒரு முக்கிய திறமையாகும்: வரிசைப்படுத்தப்பட்ட குறியிட்ட தரவுக்கு ArrayList, தனிமைக்கு HashSet, வேகமான முக-தேடலுக்கு HashMap மற்றும் தேவைப்படும் போது வரிசைப்படுத்தப்பட்ட/நேரச்சேரணை மாறுபாடுகள்।
இடைமுகங்களை (List/Set/Map/Queue), அவற்றின் செயல்படுத்தல்கள் மற்றும் குறிப்பாக செயல்திறன் பண்புக்கூறுகளை (O(1) HashMap தேடல் vs O(n) பட்டியல் தேடல்) புரிந்துகொள்வது உங்களைப் பொருத்தமான கட்டமைப்பைத் தேர்ந்தெடுக்க அனுமதிக்கிறது, தவறான கட்டமைப்பைப் பயன்படுத்துவதற்குப் பதிலாக (மெதுவான குறியப்பின் பொதுவான காரணம்)।
இது Java-ன் தினசரி வளர்ச்சிக்கான நிலையான, நடைமுறை அறிவாகும்।