Collections: List, Set, Map
ArrayList ordered list है, duplicates allowed, index से access होता है।
HashSet सिर्फ़ unique values रखता है, order guarantee नहीं करता। HashMap key-value pairs store करता है — key से तुरंत value ढूँढ सकते हो, जैसे नाम से locker।
List<String> names = new ArrayList<>();
Set<Integer> ids = new HashSet<>();
Map<String, Integer> ages = new HashMap<>();
ages.put("Aarav", 10);- List = ordered, duplicates OK
- Set = सिर्फ़ unique values
- Map = key-value pairs
सबसे ऊपर "Collection" interface है, जिसे List, Set, और Queue extend करते हैं। Map इस hierarchy का हिस्सा नहीं है (क्योंकि वो key-value pairs store करता है, single elements नहीं) — वो अपना अलग interface (Map<K,V>) है जो Collection extend नहीं करता।
हर type एक अलग problem solve करता है: List order + duplicates allow करता है (जैसे एक shopping list — order matter करता है और same item दो बार हो सकता है)। Set सिर्फ uniqueness की guarantee देता है (जैसे एक class के roll numbers — कोई repeat नहीं हो सकता)। Queue processing order define करता है (जैसे एक ticket line — पहले आओ, पहले जाओ)। Map key-based fast lookup देता है (जैसे एक phonebook — नाम से number ढूंढो)।
ArrayList, List interface की सबसे commonly used implementation है — internally एक resizable array होती है। add() element जोड़ता है (end में by default, या specific index पर), get(index) retrieve करता है (O(1) — बहुत fast, direct array access जैसा), remove() index या value से हटा सकता है, size() बताता है कितने elements हैं।
contains() check करता है value है या नहीं (O(n) — linear search, क्योंकि ArrayList को पता नहीं कहाँ ढूंढे), isEmpty() बताता है खाली है या नहीं, indexOf() value का position ढूंढता है।
List<String> names = new ArrayList<>();
names.add("Aarav");
names.add("Riya");
System.out.println(names.get(0)); // Aarav
System.out.println(names.contains("Riya")); // true
names.remove("Aarav");HashSet सबसे fast है (add/remove/contains सब average O(1)) लेकिन कोई order guarantee नहीं (hash-based storage, elements "random" order में दिखते हैं जब print करो)। ज़्यादातर समय यही best choice है जब order matter न करे।
LinkedHashSet insertion order maintain करता है (जिस order में add किया, उसी order में iterate होगा) — थोड़ा slower than HashSet (extra linked-list overhead), लेकिन predictable order चाहिए तो यह चुनो।
TreeSet elements को हमेशा sorted (natural या custom Comparator) order में रखता है — internally एक balanced tree (Red-Black Tree) use करता है, इसलिए operations O(log n) समय लेते हैं (HashSet से slower, लेकिन sorted order मिलता है automatically)।
| HashSet | LinkedHashSet | TreeSet | |
|---|---|---|---|
| Order | कोई guarantee नहीं | Insertion order | Sorted order |
| Speed (add/contains) | O(1) average | O(1) average | O(log n) |
| कब use करें | बस uniqueness चाहिए | Uniqueness + insertion order | Uniqueness + sorted |
HashMap हर key का hashCode() calculate करता है, और उस hash के आधार पर decide करता है value कहाँ store होगी ("bucket" — internally एक array of buckets होती है)। यही वजह है key से value ढूंढना average O(1) (बहुत fast) होता है — array index जैसा direct jump, linear search नहीं।
अगर दो keys का hash same आ जाए ("collision"), वो एक ही bucket में linked list (या Java 8+ में अगर बहुत ज़्यादा collisions हों, एक balanced tree) की तरह store होती हैं — worst case थोड़ा slow हो सकता है, लेकिन अच्छे hashCode() implementation से यह rare होता है।
HashMap null key allow करता है (सिर्फ एक), और multiple null values। इससे Hashtable (पुरानी, legacy class) अलग है जो कोई null allow नहीं करती।
Order चाहिए + duplicates OK → ArrayList। सिर्फ unique values, order matter नहीं → HashSet। Unique + insertion order चाहिए → LinkedHashSet। Unique + sorted चाहिए → TreeSet। Key से fast lookup चाहिए → HashMap। Key से lookup + sorted keys चाहिए → TreeMap।
| ज़रूरत | Best Choice |
|---|---|
| Ordered list, duplicates OK | ArrayList |
| बीच में frequent insert/delete | LinkedList |
| सिर्फ unique values | HashSet |
| Unique + insertion order | LinkedHashSet |
| Unique + sorted | TreeSet |
| Key-value, fast lookup | HashMap |
| Key-value, sorted keys | TreeMap |
| FIFO processing | LinkedList (as Queue) / ArrayDeque |