Master Cheat Sheet

// --- 1. ARRAY ---
int[] arr = new int[5];
int len = arr.length;       // field, NOT method
int val = arr[0];

// --- 2. ARRAYLIST ---
List<Integer> list = new ArrayList<>();
list.add(10);               // boolean
list.add(0, 20);            // void
list.get(0);                // E
list.set(0, 99);            // returns previous E
list.remove(0);             // removes at index -> returns E
list.remove(Integer.valueOf(99)); // removes value -> returns boolean
list.size();                // int

// --- 3. QUEUE & DEQUE ---
Queue<Integer> q = new ArrayDeque<>();
q.offer(10);                // boolean (safe)
q.poll();                   // returns E (null if empty)
q.peek();                   // returns E (null if empty)

Deque<Integer> stack = new ArrayDeque<>();
stack.push(10);             // void (inserts at front)
stack.pop();                // returns E (throws if empty)
stack.peek();               // returns E (null if empty)

// --- 4. PRIORITY QUEUE ---
PriorityQueue<Integer> minHeap = new PriorityQueue<>();
PriorityQueue<Integer> maxHeap = new PriorityQueue<>(Collections.reverseOrder());
minHeap.offer(10);          // O(log n)
minHeap.poll();             // O(log n) -> returns minimum

// --- 5. SET ---
Set<Integer> set = new HashSet<>();
set.add(10);                // boolean (false if duplicate)
set.contains(10);           // boolean

// --- 6. MAP ---
Map<String, Integer> map = new HashMap<>();
map.put("A", 1);            // returns previous V
map.get("A");               // returns V (null if missing)
map.getOrDefault("A", 0);   // safe read
map.merge("A", 1, Integer::sum); // frequency counting
map.keySet();               // Set<K>
map.values();               // Collection<V>
map.entrySet();             // Set<Map.Entry<K, V>>

// --- 7. TREE BOUNDS ---
TreeSet<Integer> ts = new TreeSet<>();
ts.lower(10);               // strictly < 10
ts.floor(10);               // <= 10
ts.ceiling(10);             // >= 10
ts.higher(10);              // strictly > 10

TreeMap<Integer, String> tm = new TreeMap<>();
tm.lowerKey(10);            // strictly < 10
tm.floorKey(10);            // <= 10
tm.ceilingKey(10);          // >= 10
tm.higherKey(10);           // strictly > 10

// 1. ArrayList
List<Integer> a1 = new ArrayList<>();
List<Integer> a2 = new ArrayList<>(50); // Pre-allocates buffer (size is still 0)
List<Integer> a3 = new ArrayList<>(List.of(1, 2, 3)); // Populated mutable copy

// 2. LinkedList
LinkedList<Integer> l1 = new LinkedList<>();
LinkedList<Integer> l2 = new LinkedList<>(List.of(1, 2, 3));

// 3. Set Family
Set<Integer> h1 = new HashSet<>();
Set<Integer> h2 = new HashSet<>(List.of(1, 2, 3));
Set<Integer> lhs = new LinkedHashSet<>(); // Preserves insertion order
NavigableSet<Integer> t1 = new TreeSet<>();
NavigableSet<Integer> t2 = new TreeSet<>(Comparator.reverseOrder()); // Reverse sorted

// 4. Heap / PriorityQueue
PriorityQueue<Integer> pqMin = new PriorityQueue<>(); // Default Min-heap
PriorityQueue<Integer> pqMax = new PriorityQueue<>(Comparator.reverseOrder()); // Max-heap

// 5. Map Family
Map<Integer, String> m1 = new HashMap<>();
Map<Integer, String> m2 = new HashMap<>(Map.of(1, "A", 2, "B"));
NavigableMap<Integer, String> tm1 = new TreeMap<>();
NavigableMap<Integer, String> tm2 = new TreeMap<>(Comparator.reverseOrder());