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);

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

// Sort by value ascending — get entries in order
List<Map.Entry<String, Integer>> asc = freq.entrySet().stream()
    .sorted(Map.Entry.comparingByValue())
    .collect(Collectors.toList());

// Sort by value descending
List<Map.Entry<String, Integer>> desc = freq.entrySet().stream()
    .sorted(Map.Entry.comparingByValue(Comparator.reverseOrder()))
    .collect(Collectors.toList());

// Get just the keys sorted by value — most common in interviews
List<String> keysByFreq = freq.entrySet().stream()
    .sorted(Map.Entry.<String, Integer>comparingByValue().reversed())
    .map(Map.Entry::getKey)
    .collect(Collectors.toList());

// Top K keys by frequency
List<String> topK = freq.entrySet().stream()
    .sorted(Map.Entry.<String, Integer>comparingByValue().reversed())
    .limit(k)
    .map(Map.Entry::getKey)
    .collect(Collectors.toList());

// Sort by key ascending (same as using TreeMap)
List<Map.Entry<Integer, String>> byKey = map.entrySet().stream()
    .sorted(Map.Entry.comparingByKey())
    .collect(Collectors.toList());

// Collect back into sorted LinkedHashMap (preserves order)
Map<String, Integer> sorted = freq.entrySet().stream()
    .sorted(Map.Entry.comparingByValue(Comparator.reverseOrder()))
    .collect(Collectors.toLinkedHashMap(
        Map.Entry::getKey,
        Map.Entry::getValue,
        (e1, e2) -> e1,
        LinkedHashMap::new
    ));

// int[] → List<Integer>
List<Integer> list = Arrays.stream(arr)
    .boxed()
    .collect(Collectors.toList());

// List<Integer> → int[]
int[] arr = list.stream()
    .mapToInt(Integer::intValue)
    .toArray();

// String[] → List<String>
List<String> strList = Arrays.stream(strArr).collect(Collectors.toList());

// List<String> → String[] 
String[] strArr = list.toArray(String[]::new);

// int[] → Set<Integer> — fast lookup after building from array
Set<Integer> set = Arrays.stream(arr).boxed().collect(Collectors.toSet());

// char[] → String (StringBuilder is faster but this works)
String s = new String(charArray);
// String → char[] then sort → String (anagram canonical form)
char[] c = s.toCharArray(); Arrays.sort(c); String key = new String(c);

// Keep only even numbers
List<Integer> evens = list.stream()
    .filter(n -> n % 2 == 0)
    .collect(Collectors.toList());

// Filter and count
long count = list.stream().filter(n -> n > 5).count();

// Filter map entries — keep entries with value > threshold
Map<String, Integer> filtered = freq.entrySet().stream()
    .filter(e -> e.getValue() > 1)
    .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

// distinct — deduplicate
List<Integer> unique = list.stream().distinct().collect(Collectors.toList());

// Group anagrams — canonical form as key
Map<String, List<String>> groups = Arrays.stream(strs)
    .collect(Collectors.groupingBy(s -> {
        char[] c = s.toCharArray();
        Arrays.sort(c);
        return new String(c);
    }));
// groups.values() = List<List<String>> — answer directly

// Group by length
Map<Integer, List<String>> byLen = Arrays.stream(words)
    .collect(Collectors.groupingBy(String::length));

// Group and count (frequency map via streams)
Map<Integer, Long> freqMap = Arrays.stream(nums).boxed()
    .collect(Collectors.groupingBy(n -> n, Collectors.counting()));

int[] nums = {3, 1, 4, 1, 5};

Arrays.stream(nums).sum();             // 14
Arrays.stream(nums).max().getAsInt(); // 5 — returns OptionalInt
Arrays.stream(nums).min().getAsInt(); // 1
Arrays.stream(nums).average().getAsDouble(); // 2.8
Arrays.stream(nums).count();           // 5

// Max by comparator on a list of objects
Optional<String> longest = list.stream()
    .max(Comparator.comparingInt(String::length));
longest.orElse("");                   // safe unwrap

// Sum of values in a map
int total = freq.values().stream().mapToInt(Integer::intValue).sum();

// anyMatch / allMatch / noneMatch — short-circuit
list.stream().anyMatch(n -> n > 10);  // true if any match
list.stream().allMatch(n -> n > 0);  // true if all match
list.stream().noneMatch(n -> n < 0); // true if none match

// Flatten List<List<Integer>> → List<Integer>
List<Integer> flat = nested.stream()
    .flatMap(Collection::stream)
    .collect(Collectors.toList());

// All characters from a list of strings
List<Character> chars = words.stream()
    .flatMap(s -> s.chars().mapToObj(c -> (char) c))
    .collect(Collectors.toList());

// All unique characters across all strings
Set<Character> uniqueChars = words.stream()
    .flatMapToInt(String::chars)
    .mapToObj(c -> (char) c)
    .collect(Collectors.toSet());

// Extract field from object list
List<String> names = employees.stream()
    .map(Employee::getName)
    .collect(Collectors.toList());

// Transform values — square each element
int[] squared = Arrays.stream(nums)
    .map(n -> n * n)
    .toArray();

// String transformation
List<String> upper = list.stream()
    .map(String::toUpperCase)
    .collect(Collectors.toList());

// mapToInt — when you need IntStream (for sum/max/etc)
int totalLen = words.stream().mapToInt(String::length).sum();

// IntStream.range(start, end) — exclusive end, like for(i=0; i<n; i++)
IntStream.range(0, 5).forEach(i -> System.out.println(i));

// Build a list of indices where condition is true
List<Integer> indices = IntStream.range(0, nums.length)
    .filter(i -> nums[i] % 2 == 0)
    .boxed()
    .collect(Collectors.toList());

// Generate a frequency array as a map with stream
Map<Integer, Long> freq = IntStream.of(nums).boxed()
    .collect(Collectors.groupingBy(n -> n, Collectors.counting()));

// rangeClosed — inclusive end, like for(i=1; i<=n; i++)
IntStream.rangeClosed(1, 10).sum(); // 55

  // 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