int[] arr = new int[5];           // fixed size, all 0s
int[] arr = {1, 2, 3, 4, 5};      // inline init
arr.length                          // NOT .length() — no parens

// Iterate
for (int i = 0; i < arr.length; i++) { }
for (int num : arr) { }             // enhanced for — use when no index needed

// 2D array
int[][] grid = new int[3][4];       // 3 rows, 4 cols
grid.length                         // rows
grid[0].length                      // cols

// Fill
Arrays.fill(arr, -1);              // fill all with -1
Arrays.fill(grid[0], 0);           // fill one row

// Sort
Arrays.sort(arr);                   // ascending
Arrays.sort(arr, 0, 5);            // sort subarray [0,5)

// Copy
int[] copy = Arrays.copyOf(arr, arr.length);
int[] sub  = Arrays.copyOfRange(arr, 1, 4); // [1,4)

// Convert to list (read-only!)
List<Integer> list = Arrays.asList(1, 2, 3);

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

// Add
list.add(5);                         // append to end — O(1) amortized
list.add(0, 99);                    // insert at index 0 — O(n), SLOW

// Access
list.get(0);                         // O(1)
list.set(0, 10);                    // update at index — O(1)
list.size();                         // NOT .length

// Remove
list.remove(0);                     // remove by INDEX — O(n)
list.remove(Integer.valueOf(5));   // remove by VALUE — wrap int!

// Search
list.contains(5);                  // O(n)
list.indexOf(5);                   // -1 if not found

// Iterate — 3 ways
for (int x : list) { }              // enhanced for — cleanest
for (int i = 0; i < list.size(); i++) { list.get(i); }
list.forEach(x -> System.out.println(x));

// Sort
Collections.sort(list);             // ascending
list.sort(Comparator.reverseOrder()); // descending
list.sort((a, b) -> b - a);         // same — descending with lambda

// Useful ops
Collections.reverse(list);
Collections.max(list);
Collections.min(list);
Collections.frequency(list, 5);    // count of 5

// Convert to array
int[] arr = list.stream().mapToInt(Integer::intValue).toArray();

// Sublist (view, not copy)
List<Integer> sub = list.subList(1, 3); // [1,3)

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

// Put / Get
map.put("key", 1);
map.get("key");                    // returns null if missing — not 0!
map.getOrDefault("key", 0);      // safe get — use this always

// Check
map.containsKey("key");
map.containsValue(1);             // O(n) — rarely useful
map.size();
map.isEmpty();

// Remove
map.remove("key");

// Frequency count pattern — most common use
for (char c : s.toCharArray()) {
    map.put(c, map.getOrDefault(c, 0) + 1);
}
// Shortcut — same thing
map.merge(c, 1, Integer::sum);

// putIfAbsent
map.putIfAbsent("key", 0);        // only puts if key not present

// computeIfAbsent — for nested maps / grouping
map.computeIfAbsent("key", k -> new ArrayList<>()).add("value");

// Iterate — 3 ways
for (Map.Entry<String, Integer> e : map.entrySet()) {
    e.getKey(); e.getValue();
}
for (String key : map.keySet()) { }
for (int val : map.values()) { }

// Sort by value (common interview need)
map.entrySet().stream()
   .sorted(Map.Entry.comparingByValue(Comparator.reverseOrder()))
   .forEach(e -> { });

// LinkedHashMap preserves insertion order
Map<String, Integer> lmap = new LinkedHashMap<>();

// LRU Cache trick — access-order LinkedHashMap
Map<Integer, Integer> lru = new LinkedHashMap<>(16, 0.75f, true) {
    protected boolean removeEldestEntry(Map.Entry e) {
        return size() > capacity;
    }
};

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

set.add(5);                         // returns false if already exists
set.contains(5);                   // O(1) — this is the whole point
set.remove(5);
set.size();

// Init from array — very common
Set<Integer> set = new HashSet<>(Arrays.asList(1, 2, 3));

// Duplicate check pattern
boolean hasDup(int[] nums) {
    Set<Integer> seen = new HashSet<>();
    for (int n : nums)
        if (!seen.add(n)) return true; // add returns false if dup
    return false;
}

// Longest consecutive sequence — O(n)
Set<Integer> set = new HashSet<>();
for (int n : nums) set.add(n);
for (int n : nums) {
    if (!set.contains(n - 1)) { // start of sequence
        int len = 1;
        while (set.contains(n + len)) len++;
    }
}

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

stack.push(5);                      // add to top
stack.pop();                        // remove from top — throws if empty
stack.peek();                       // look at top — throws if empty
stack.isEmpty();
stack.size();

// Safe versions — return null instead of throwing
stack.offerFirst(5);               // push
stack.pollFirst();                  // pop — returns null if empty
stack.peekFirst();                  // peek — returns null if empty

// Valid parentheses pattern
Deque<Character> stk = new ArrayDeque<>();
for (char c : s.toCharArray()) {
    if (c == '(') stk.push(c);
    else if (!stk.isEmpty()) stk.pop();
    else return false;
}
return stk.isEmpty();

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

queue.offer(5);                    // enqueue — add to back
queue.poll();                      // dequeue — remove from front (null if empty)
queue.peek();                      // look at front

// Deque as double-ended (sliding window maximum)
Deque<Integer> dq = new ArrayDeque<>();
dq.offerFirst(5);   dq.offerLast(3);
dq.pollFirst();      dq.pollLast();
dq.peekFirst();      dq.peekLast();

// Min heap (default) — smallest element at head
PriorityQueue<Integer> minH = new PriorityQueue<>();

// Max heap
PriorityQueue<Integer> maxH = new PriorityQueue<>(Comparator.reverseOrder());
// or lambda:
PriorityQueue<Integer> maxH = new PriorityQueue<>((a, b) -> b - a);

minH.offer(5);                    // add — O(log n)
minH.poll();                      // remove min — O(log n)
minH.peek();                      // look at min — O(1)

// Top K frequent elements pattern
PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) -> a[1] - b[1]);
for (var e : freqMap.entrySet()) {
    pq.offer(new int[]{e.getKey(), e.getValue()});
    if (pq.size() > k) pq.poll();   // keep only top K
}

// Custom object in PQ
PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) -> a[0] - b[0]);
pq.offer(new int[]{dist, node});

TreeMap<Integer, String> tm = new TreeMap<>();
tm.put(1, "a"); tm.put(3, "c"); tm.put(5, "e");

tm.firstKey();                     // 1 — smallest
tm.lastKey();                      // 5 — largest
tm.floorKey(4);                   // 3 — largest key <= 4
tm.ceilingKey(4);                 // 5 — smallest key >= 4
tm.lowerKey(3);                   // 1 — strictly less than 3
tm.higherKey(3);                  // 5 — strictly greater than 3

// TreeSet — same but just keys
TreeSet<Integer> ts = new TreeSet<>();
ts.floor(4);  ts.ceiling(4);

// Max sum of subarray of size k
int sum = 0, max = 0;
for (int i = 0; i < nums.length; i++) {
    sum += nums[i];
    if (i >= k) sum -= nums[i - k];  // shrink from left
    if (i >= k - 1) max = Math.max(max, sum);
}

// Longest substring without repeating characters
Map<Character, Integer> map = new HashMap<>();
int left = 0, max = 0;
for (int right = 0; right < s.length(); right++) {
    char c = s.charAt(right);
    if (map.containsKey(c))
        left = Math.max(left, map.get(c) + 1); // shrink
    map.put(c, right);
    max = Math.max(max, right - left + 1);
}

int left = 0, right = nums.length - 1;
while (left < right) {
    int sum = nums[left] + nums[right];
    if      (sum == target) return new int[]{left, right};
    else if (sum < target)  left++;
    else                    right--;
}

int slow = 0;
for (int fast = 1; fast < nums.length; fast++) {
    if (nums[fast] != nums[slow])
        nums[++slow] = nums[fast];
}
return slow + 1; // new length

// Detect cycle
ListNode slow = head, fast = head;
while (fast != null && fast.next != null) {
    slow = slow.next;
    fast = fast.next.next;
    if (slow == fast) return true; // cycle!
}
return false;

// Find middle (slow is at middle when fast reaches end)
ListNode slow = head, fast = head;
while (fast != null && fast.next != null) {
    slow = slow.next;
    fast = fast.next.next;
}
// slow is now at middle

int left = 0, right = nums.length - 1;
while (left <= right) {              // <= not <
    int mid = left + (right - left) / 2; // avoid overflow — never (l+r)/2
    if      (nums[mid] == target) return mid;
    else if (nums[mid] < target)  left = mid + 1;
    else                          right = mid - 1;
}
return -1;

// "What is the minimum X such that condition(X) is true?"
// Example: Koko eating bananas, capacity ship packages
int left = minPossible, right = maxPossible;
while (left < right) {               // < not <=
    int mid = left + (right - left) / 2;
    if (canDo(mid)) right = mid;       // mid works, try smaller
    else           left = mid + 1;    // mid too small
}
return left;

Deque<Integer> queue = new ArrayDeque<>();
Set<Integer> visited = new HashSet<>();
queue.offer(start);
visited.add(start);
int level = 0;

while (!queue.isEmpty()) {
    int size = queue.size();           // process level by level
    for (int i = 0; i < size; i++) {
        int node = queue.poll();
        if (node == target) return level;
        for (int nei : graph.get(node)) {
            if (!visited.contains(nei)) {
                visited.add(nei);
                queue.offer(nei);
            }
        }
    }
    level++;
}

// Recursive DFS
void dfs(int node, Set<Integer> visited) {
    visited.add(node);
    for (int nei : graph.get(node)) {
        if (!visited.contains(nei))
            dfs(nei, visited);
    }
}

// Grid DFS (islands pattern)
int[][] dirs = {{0,1},{0,-1},{1,0},{-1,0}};
void dfs(char[][] grid, int r, int c) {
    if (r < 0 || r >= grid.length || c < 0 ||
        c >= grid[0].length || grid[r][c] != '1') return;
    grid[r][c] = '0';                 // mark visited by mutating
    for (int[] d : dirs)
        dfs(grid, r + d[0], c + d[1]);
}

// Coin change — minimum coins to make amount
int[] dp = new int[amount + 1];
Arrays.fill(dp, amount + 1);        // fill with "infinity"
dp[0] = 0;
for (int a = 1; a <= amount; a++)
    for (int c : coins)
        if (c <= a)
            dp[a] = Math.min(dp[a], dp[a - c] + 1);
return dp[amount] > amount ? -1 : dp[amount];

int[] result = new int[nums.length];
Arrays.fill(result, -1);
Deque<Integer> stack = new ArrayDeque<>(); // stores indices

for (int i = 0; i < nums.length; i++) {
    while (!stack.isEmpty() && nums[stack.peek()] < nums[i]) {
        result[stack.pop()] = nums[i]; // found next greater
    }
    stack.push(i);
}

// Sort int array descending — must use Integer[]
Integer[] arr = {3,1,4,1,5};
Arrays.sort(arr, (a, b) -> b - a);

// Sort 2D array by first element
Arrays.sort(intervals, (a, b) -> a[0] - b[0]);

// Sort by length then alphabetically
Arrays.sort(words, (a, b) ->
    a.length() != b.length() ? a.length() - b.length() : a.compareTo(b));

// WARNING: b - a overflows with large negatives. Safe version:
(a, b) -> Integer.compare(b, a)

String s = "hello";

s.charAt(0);                        // 'h'
s.length();                         // 5 — with parens, unlike array
s.substring(1, 3);                  // "el" — [1,3)
s.indexOf('l');                     // 2 — first occurrence
s.contains("ell");
s.startsWith("he");
s.endsWith("lo");
s.toCharArray();                    // char[] — use in loops
s.split(",");                       // String[]
s.trim();                           // remove leading/trailing spaces
s.toLowerCase(); s.toUpperCase();
s.replace('l', 'r');              // replaces ALL
String.valueOf(42);                 // int to String
Integer.parseInt("42");            // String to int

// Char arithmetic
char c = 'a';
c - 'a';                            // 0 — index in alphabet
(char)(c + 1);                      // 'b'
Character.isLetter(c);
Character.isDigit(c);
Character.toLowerCase(c);

// StringBuilder — use in loops, not + concatenation
StringBuilder sb = new StringBuilder();
sb.append("hi");
sb.reverse();
sb.deleteCharAt(0);
sb.toString();

// Frequency array (only lowercase letters)
int[] freq = new int[26];
for (char c : s.toCharArray()) freq[c - 'a']++;
// Faster than HashMap for lowercase-only problems

Math.max(a, b);  Math.min(a, b);
Math.abs(a);
Math.pow(2, 10);                    // returns double
Math.sqrt(25);                      // returns double
(int) Math.sqrt(25);                // cast to int when needed

// Integer limits — use these, not magic numbers
Integer.MAX_VALUE;                   // 2^31 - 1 = 2147483647
Integer.MIN_VALUE;                   // -2^31 = -2147483648
Long.MAX_VALUE;                      // when int overflows

// Modulo (always positive)
((a % m) + m) % m;                   // safe mod for negative numbers

// Even / Odd
n % 2 == 0;                         // even
(n & 1) == 0;                        // even — bitwise, slightly faster

// Divide rounding up
(int) Math.ceil((double) a / b);
(a + b - 1) / b;                    // integer ceiling division

// Bit tricks
n & (n - 1);                        // removes lowest set bit (check power of 2: == 0)
n & (-n);                            // isolates lowest set bit
Integer.bitCount(n);                // count set bits