Collection
│
├── List
│ ├── ArrayList
│ ├── LinkedList
│ └── Vector
│
├── Set
│ ├── HashSet
│ ├── LinkedHashSet
│ └── TreeSet
│
└── Queue
 ├── PriorityQueue
 └── Deque
 ├── ArrayDeque
 └── LinkedList

Map (separate hierarchy)
├── HashMap
├── LinkedHashMap
├── TreeMap
└── Hashtable

List<Integer> list = new ArrayList<>();

list.add(10);
list.add(20);
list.add(30);

System.out.println(list.get(1));

list.remove(1);

System.out.println(list.contains(10));

LinkedList<Integer> list = new LinkedList<>();

list.addFirst(10);
list.addLast(20);

System.out.println(list.getFirst());
System.out.println(list.getLast());

list.removeFirst();
list.removeLast();

Set<Integer> set = new HashSet<>();

set.add(10);
set.add(20);
set.add(10);

System.out.println(set);

Set<Integer> set = new LinkedHashSet<>();

TreeSet<Integer> set = new TreeSet<>();

set.add(30);
set.add(10);
set.add(20);

System.out.println(set);

set.first();
set.last();
set.ceiling(25);
set.floor(25);
set.higher(20);
set.lower(20);

Map<Integer, String> map = new HashMap<>();

map.put(1, "Apple");
map.put(2, "Banana");

System.out.println(map.get(1));

map.remove(2);

System.out.println(map.containsKey(1));

for(Map.Entry<Integer, String> entry : map.entrySet()) {
 System.out.println(entry.getKey() + " " + entry.getValue());
}

Map<Integer, String> map = new LinkedHashMap<>();

LinkedHashMap<Integer, Integer> map =
 new LinkedHashMap<>(16, 0.75f, true);

TreeMap<Integer, String> map = new TreeMap<>();

map.firstKey();
map.lastKey();
map.ceilingKey(10);
map.floorKey(10);
map.higherKey(10);
map.lowerKey(10);

Queue<Integer> q = new LinkedList<>();

q.offer(10);
q.offer(20);

System.out.println(q.peek());

q.poll();

PriorityQueue<Integer> pq = new PriorityQueue<>();

PriorityQueue<Integer> pq =
 new PriorityQueue<>((a, b) -> b - a);

PriorityQueue<Integer> pq =
 new PriorityQueue<>(Collections.reverseOrder());

Deque<Integer> dq = new ArrayDeque<>();

// Front

dq.addFirst(10);
dq.removeFirst();
dq.peekFirst();

// Back

dq.addLast(20);
dq.removeLast();
dq.peekLast();

Deque<Integer> stack = new ArrayDeque<>();

stack.push(10);
stack.push(20);

System.out.println(stack.peek());

stack.pop();

Collections.sort(list);
Collections.sort(list, Collections.reverseOrder());

Collections.reverse(list);

Collections.max(list);
Collections.min(list);

Collections.frequency(list, 10);

(a, b) -> a - b

(a, b) -> b - a

Integer.compare(a, b)
Integer.compare(b, a)

Map<Integer, Integer> freq = new HashMap<>();

for(int num : nums) {
 freq.put(num, freq.getOrDefault(num, 0) + 1);
}

PriorityQueue<Integer> pq = new PriorityQueue<>();

Queue<Integer> q = new LinkedList<>();

Deque<Integer> stack = new ArrayDeque<>();

Deque<Integer> dq = new ArrayDeque<>();

list.forEach(System.out::println);

list.stream().sorted().toList();

Collections.sort(list, (a, b) -> a.age - b.age);

list.remove(2);

list.remove(Integer.valueOf(2));

PriorityQueue<Integer> pq = new PriorityQueue<>();

LinkedHashMap