Aspect List Set Queue Map

Set<String> set = new Queue<String> queue = new Map<String, Integer> map = new
Syntax for Creation List<String> list = new ArrayList<>();
HashSet<>(); LinkedList<>(); HashMap<>();
HashMap, TreeMap,
ArrayList, LinkedList, Vector, HashSet, TreeSet,
Common Implementations PriorityQueue, ArrayDeque LinkedHashMap,
CopyOnWriteArrayList LinkedHashSet
ConcurrentHashMap
Ordering Ordered (by index) Unordered Depends on implementation Unordered (by key)
Not allowed (Duplicate keys are
Duplicates Allowed Not allowed Allowed
overwritten)
Allowed (Single null key, multiple
Null Values Allowed Doesn't affect uniqueness Allowed
null values)
add(element),
get(index), add(element), put(key, value), get(key),
Access Methods remove(element), offer(element), poll(), peek()
remove(index) remove(key)
contains(element)
Set<K> keySet(), Collection<V>
Iterator Iterator<E> iterator(), listIterator() Iterator<E> iterator() Iterator<E> iterator() values(), Set<Map.Entry<K, V>>
entrySet()
Synchronization Not synchronized Not synchronized Not synchronized Synchronized or lock striping
- Fast for retrieval (HashMap)<br>-
- Fast for basic - Efficient for adding/removing
- Fast for access by index<br>- Maintains order
Performance operations<br>- Slower for elements<br>- Slower for access
Slower for insertions/deletions (LinkedHashMap)<br>- Sorted by
TreeSet due to sorting by index
keys (TreeMap)
- When uniqueness of - Modeling real-world scenarios - Associating keys with values<br>-
- When the order of elements
elements is required<br>- like tasks, jobs, etc.<br>- Fast retrieval based on keys<br>-
Common Use Cases matters<br>- When frequent access
When order doesn't matter Implementing scheduling Maintaining sorted key-value pairs
by index is required
and faster lookup is needed algorithms (TreeMap)
set.add("element");<br>bool map.put("key", value);<br>String
queue.offer("element");<br>Strin
list.add("element");<br>String value ean contains = value =
Example Syntaxes g head = queue.peek();<br>String
= list.get(0);<br>list.remove(2); set.contains("element");<br> map.get("key");<br>map.remove("k
removed = queue.poll();
set.remove("element"); ey");
Lists:

Aspect ArrayList LinkedList Vector CopyOnWriteArrayList

List<String> list = new List<String> list = new
Syntax for Creation List<String> list = new ArrayList<>(); List<String> list = new Vector<>();
LinkedList<>(); CopyOnWriteArrayList<>();
add(element), get(index), add(element), get(index), add(element), get(index), add(element), get(index),
Common Operations
remove(index) remove(index) remove(index) remove(index)
Iterator<E> iterator(),
Iteration Iterator<E> iterator(), listIterator() Iterator<E> iterator() Iterator<E> iterator(), listIterator()
listIterator()
Synchronization Not synchronized Not synchronized Synchronized Synchronized
Fast for access by index, slower for Fast for insertions/deletions,
Performance Similar to ArrayList Slower for writes, fast for reads
insertions/deletions slower for access by index

list.add("element");<br> list.add("element");<br> String list.add("element");<br> String

list.add("element");<br> String value
Example Syntaxes String value = list.get(0);<br> value = list.get(0);<br> value = list.get(0);<br>
= list.get(0);<br> list.remove(2);
list.remove(2); list.remove(2); list.remove(2);
Sets:

Aspect HashSet TreeSet LinkedHashSet

Set<String> set = new Set<String> set = new
Syntax for Creation Set<String> set = new HashSet<>();
TreeSet<>(); LinkedHashSet<>();
add(element),
add(element), remove(element), add(element), remove(element),
Common Operations remove(element),
contains(element) contains(element)
contains(element)
Iterator<E> iterator(),
Iteration Iterator<E> iterator() Iterator<E> iterator()
descendingIterator()
Ordering Unordered Sorted Maintains insertion order
Fast for basic operations, no order Elements are sorted, slower Fast for basic operations,
Performance
guaranteed for operations maintains insertion order

set.add("element");<br> boolean set.add("element");<br> set.add("element");<br> boolean

contains = boolean contains = contains =
Example Syntaxes
set.contains("element");<br> set.contains("element");<br> set.contains("element");<br>
set.remove("element"); set.remove("element"); set.remove("element");
Queues:

Aspect PriorityQueue ArrayDeque

Queue<String> queue = new Queue<String> queue = new
Syntax for Creation
PriorityQueue<>(); ArrayDeque<>();
Common Operations offer(element), poll(), peek() offer(element), poll(), peek()
Iterator<E> iterator(),
Iteration Iterator<E> iterator()
descendingIterator()
Elements are ordered by a specified
Ordering Unordered
comparator
Efficient for adding/removing
Performance Efficient for basic operations
elements
queue.offer("element");<br>
queue.offer("element");<br> String
String head =
Example Syntaxes head = queue.peek();<br> String
queue.peek();<br> String
removed = queue.poll();
removed = queue.poll();
Maps:

Aspect HashMap TreeMap LinkedHashMap ConcurrentHashMap

Map<String, Integer> map = new Map<String, Integer> map = Map<String, Integer> map = new Map<String, Integer> map = new
Syntax for Creation
HashMap<>(); new TreeMap<>(); LinkedHashMap<>(); ConcurrentHashMap<>();
put(key, value), get(key), put(key, value), get(key), put(key, value), get(key), put(key, value), get(key),
Common Operations
remove(key) remove(key) remove(key) remove(key)
Set<K> keySet(),
Set<K> keySet(), Collection<V> Set<K> keySet(), Collection<V> Set<K> keySet(), Collection<V>
Collection<V> values(),
Iteration values(), Set<Map.Entry<K, V>> values(), Set<Map.Entry<K, V>> values(), Set<Map.Entry<K, V>>
Set<Map.Entry<K, V>>
entrySet() entrySet() entrySet()
entrySet()
Ordering Unordered Sorted by keys Maintains insertion order Unordered (Segment-based)
Elements are sorted based on Fast for iteration (maintains
Performance Fast for retrieval High concurrency, O(1) for updates
keys insertion order)
map.put("key", value);<br>
map.put("key", value);<br> String map.put("key", value);<br> String map.put("key", value);<br> String
String value =
Example Syntaxes value = map.get("key");<br> value = map.get("key");<br> value = map.get("key");<br>
map.get("key");<br>
map.remove("key"); map.remove("key"); map.remove("key");
map.remove("key");