Java Collections

String s = "hello";

s.length();
s.charAt(i);
s.isEmpty();
s.trim();
s.substring(start, end);      // end is exclusive
s.indexOf("lo");              // index or -1
s.contains("ell");
s.equals(other);              // never use == on strings
s.equalsIgnoreCase(other);
s.compareTo(other);           // <0, 0, >0
s.toLowerCase();
s.split(",");                 // takes a regex, not a plain string
s.repeat(3);
String.join(",", list);

StringBuilder sb = new StringBuilder();
StringBuilder sb = new StringBuilder("Hello world");

sb.append('c');               // char, String, int, double all work
sb.insert(0, "x");
sb.deleteCharAt(i);
sb.setCharAt(i, 'a');
sb.charAt(i);
sb.indexOf("lo");
sb.length();
sb.reverse();
sb.toString();

// Two builders are only equal as strings
sb.toString().equals(other.toString());

// String and char[]
char[] chars = s.toCharArray();
String back = String.valueOf(chars);
String back = new String(chars);

// String and int
int n = Integer.parseInt("200");
String s = String.valueOf(200);
String s = Integer.toString(200);

// char and String
String s = Character.toString('a');
String s = String.valueOf('a');

// char and int digit
int d = c - '0';              // '7' becomes 7
int idx = c - 'a';            // 'c' becomes 2, for int[26] buckets

// List and array
List<Integer> list = new ArrayList<>(Arrays.asList(arr));   // arr is Integer[]
Integer[] arr = list.toArray(new Integer[0]);
int[][] grid = list.toArray(new int[0][]);                  // List<int[]>

Character.isLetter(c);
Character.isDigit(c);
Character.isLetterOrDigit(c);
Character.isUpperCase(c);
Character.isWhitespace(c);
Character.toUpperCase(c);
Character.toLowerCase(c);

Integer.MIN_VALUE;
Integer.MAX_VALUE;
Integer.parseInt(s);
Integer.parseInt(s, 2);       // binary string to int
Integer.toBinaryString(n);
Integer.bitCount(n);          // number of set bits
Integer.compare(a, b);        // overflow safe, unlike a - b
Integer.valueOf(s);           // boxed Integer, parseInt gives a primitive int

Integer.MIN_VALUE;            // -2147483648
Integer.MAX_VALUE;            //  2147483647
Long.MIN_VALUE;               // -9223372036854775808
Long.MAX_VALUE;               //  9223372036854775807
Byte.MIN_VALUE;               Byte.MAX_VALUE;
Short.MIN_VALUE;              Short.MAX_VALUE;
Character.MIN_VALUE;          Character.MAX_VALUE;

Integer.SIZE;                 // 32 bits
Integer.BYTES;                // 4 bytes

Double.MAX_VALUE;             // largest positive double
Double.MIN_VALUE;             // smallest positive double, 4.9e-324, not the most negative
Double.POSITIVE_INFINITY;
Double.NEGATIVE_INFINITY;
Double.NaN;

long x = 10;                       // widening from int is automatic
long big = 10000000000L;           // literal past int range needs the L
int back = (int) big;              // narrowing needs a cast and can silently truncate
int safe = Math.toIntExact(big);   // throws ArithmeticException instead

Long.MIN_VALUE;               Long.MAX_VALUE;
Long.SIZE;                    // 64 bits
Long.BYTES;                   // 8 bytes
Long.parseLong(s);
Long.compare(a, b);
Long.toBinaryString(n);
Long.bitCount(n);

long ms = 24 * 60 * 60 * 1000;         // fine, fits in int
long us = 24 * 60 * 60 * 1000 * 1000;  // overflows, all int math
long us = 24L * 60 * 60 * 1000 * 1000; // one L on the left fixes the whole expression

long sum = 0;
for (int n : nums) sum += n;           // sum is long, each n widens, safe

Math.abs(Long.MIN_VALUE);              // still Long.MIN_VALUE, negative
-Long.MIN_VALUE;                       // same, wraps to itself
Long.MIN_VALUE / -1;                   // Long.MIN_VALUE, no exception thrown
Math.negateExact(Long.MIN_VALUE);      // throws ArithmeticException

Integer.MAX_VALUE + 1;                 // -2147483648
Math.abs(Integer.MIN_VALUE);           // still -2147483648, abs has no positive answer here

int big = 100000 * 100000;             // overflows before the assignment
long ok = 100000L * 100000;            // one L makes the whole product long

int mid = (low + high) / 2;            // overflows on large indexes
int mid = low + (high - low) / 2;      // safe binary search midpoint

int[] dist = new int[n];
Arrays.fill(dist, Integer.MAX_VALUE);
if (dist[u] != Integer.MAX_VALUE && dist[u] + w < dist[v]) { }   // guard first

// or give yourself headroom
final int INF = Integer.MAX_VALUE / 2;
// or hold distances in long

Math.abs(n);
Math.max(a, b);               Math.min(a, b);
Math.pow(2, 10);              // returns double, cast for int
Math.sqrt(n);                 // double
Math.cbrt(n);
Math.floor(x);                Math.ceil(x);        // double in, double out
Math.round(x);                // long for double, int for float
Math.hypot(a, b);

Math.floorDiv(-7, 2);         // -4, rounds down
Math.floorMod(-7, 3);         // 2, never negative
-7 % 3;                       // -1, the sign follows the left operand

Math.addExact(a, b);          // throws on overflow
Math.multiplyExact(a, b);
Math.toIntExact(longValue);

int[] freq = new int[26];
for (char c : s.toCharArray()) {
    freq[c - 'a']++;
}

Map<Character, Integer> freq = new HashMap<>();
for (char c : s.toCharArray()) {
    freq.merge(c, 1, Integer::sum);
}

int[] a = new int[20];                 // filled with 0
int[] a = {1, 2, 3, 4, 5};
int[][] grid = new int[10][10];

a.length;                              // field, no parentheses

Arrays.fill(a, 10);
Arrays.fill(grid[0], -1);
Arrays.sort(a);                        // dual pivot quicksort, O(n log n)
Arrays.sort(a, from, to);
Arrays.binarySearch(a, key);           // array must be sorted first
Arrays.copyOf(a, newLength);
Arrays.copyOfRange(a, from, to);
Arrays.equals(a, b);
Arrays.toString(a);
Arrays.deepToString(grid);             // for 2D
Arrays.stream(a).sum();
Arrays.stream(a).max().getAsInt();

Integer[] a = {3, 1, 2};
Arrays.sort(a, Collections.reverseOrder());

// For int[], sort ascending then reverse by hand
int[] b = {3, 1, 2};
Arrays.sort(b);
for (int i = 0, j = b.length - 1; i < j; i++, j--) {
    int tmp = b[i]; b[i] = b[j]; b[j] = tmp;
}

// Sort 2D by a column
int[][] intervals = {{1, 3}, {0, 2}};
Arrays.sort(intervals, (x, y) -> x[0] - y[0]);
Arrays.sort(intervals, Comparator.comparingInt(x -> x[0]));

List<Integer> list = new ArrayList<>();
List<Integer> list = new ArrayList<>(Arrays.asList(60, 25, 12));
List<Integer> list = new ArrayList<>(other);           // copy

list.size();
list.isEmpty();
list.get(i);
list.set(i, value);
list.add(10);                                          // append
list.add(i, 10);                                       // insert at i, shifts right
list.addAll(other);
list.remove(2);                                        // by index for List<Integer>
list.remove(Integer.valueOf(2));                       // by value
list.contains(120);
list.indexOf(o);                                       // first match or -1
list.clear();
list.subList(from, to);                                // view, not a copy
list.toArray(new Integer[0]);

List<List<String>> grid = new ArrayList<>();
for (int i = 0; i < 100; i++) {
    grid.add(new ArrayList<>());
}

list.removeIf(n -> n % 2 == 0);               // in place, no iterator needed

// Filter and map
List<Integer> evens = list.stream().filter(n -> n % 2 == 0).toList();
List<String> names = people.stream().map(Person::getName).toList();
List<Integer> flat = nested.stream().flatMap(List::stream).toList();

// Group, partition, join
Map<String, List<Person>> byCity =
    people.stream().collect(Collectors.groupingBy(Person::getCity));
Map<Boolean, List<Integer>> split =
    list.stream().collect(Collectors.partitioningBy(n -> n > 10));
String csv = String.join(", ", names);

// Reduce to one value
int sum = list.stream().mapToInt(Integer::intValue).sum();
double avg = list.stream().mapToInt(Integer::intValue).average().orElse(0);
int max = list.stream().mapToInt(Integer::intValue).max().orElseThrow();

// Ask a question
boolean any = list.stream().anyMatch(n -> n > 100);
boolean all = list.stream().allMatch(n -> n > 0);
long count = list.stream().filter(n -> n > 10).count();

// Dedupe and slice
List<Integer> unique = list.stream().distinct().toList();
List<Integer> firstFive = list.stream().limit(5).toList();

// Back to an array
Integer[] arr = list.stream().toArray(Integer[]::new);
int[] prim = list.stream().mapToInt(Integer::intValue).toArray();

List<Integer> slice = list.subList(2, 5);              // indexes 2, 3, 4
slice.clear();                                          // deletes them from list
List<Integer> copy = new ArrayList<>(list.subList(2, 5));   // real copy

LinkedList<String> ll = new LinkedList<>();

ll.add(e);            ll.add(i, e);
ll.addFirst(e);       ll.addLast(e);
ll.getFirst();        ll.getLast();
ll.peekFirst();       ll.peekLast();        // null if empty
ll.removeFirst();     ll.removeLast();      // throw if empty
ll.pollFirst();       ll.pollLast();        // null if empty
ll.size();

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

stack.push(10);       // addFirst
stack.pop();          // removeFirst, throws if empty
stack.peek();         // null if empty
stack.isEmpty();
stack.size();

Stack<Integer> stack = new Stack<>();
stack.push(10);
stack.pop();
stack.peek();
stack.isEmpty();

Queue<Integer> queue = new ArrayDeque<>();      // LinkedList also works, slower

queue.offer(10);      // add at tail, returns false when full
queue.add(10);        // add at tail, throws when full
queue.poll();         // remove head, null if empty
queue.remove();       // remove head, throws if empty
queue.peek();         // head without removing, null if empty
queue.isEmpty();
queue.size();

Queue<int[]> q = new ArrayDeque<>();
q.offer(new int[]{0, 0});
boolean[][] seen = new boolean[rows][cols];
seen[0][0] = true;

while (!q.isEmpty()) {
    int size = q.size();               // one level at a time
    for (int i = 0; i < size; i++) {
        int[] cur = q.poll();
        // visit neighbours, mark seen, offer
    }
}

PriorityQueue<Integer> minHeap = new PriorityQueue<>();
PriorityQueue<Integer> maxHeap = new PriorityQueue<>(Collections.reverseOrder());
PriorityQueue<Integer> maxHeap = new PriorityQueue<>((a, b) -> b - a);

// By a field
PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) -> a[1] - b[1]);
PriorityQueue<int[]> pq = new PriorityQueue<>(Comparator.comparingInt(a -> a[1]));

pq.offer(10);
pq.poll();            // smallest, null if empty
pq.peek();
pq.size();
pq.isEmpty();

PriorityQueue<Integer> pq = new PriorityQueue<>();
for (int n : nums) {
    pq.offer(n);
    if (pq.size() > k) pq.poll();
}
// pq.peek() is the kth largest

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

map.size();
map.isEmpty();
map.containsKey(key);
map.containsValue(value);                       // O(n)
map.get(key);                                   // null if absent
map.getOrDefault(key, 0);
map.put(key, value);                            // returns the old value or null
map.putIfAbsent(key, value);
map.remove(key);
map.clear();
map.keySet();
map.values();
map.entrySet();

// Counting and grouping without null checks
map.merge(key, 1, Integer::sum);
map.computeIfAbsent(key, k -> new ArrayList<>()).add(item);

TreeMap<String, Integer> tm = new TreeMap<>();                          // ascending
TreeMap<String, Integer> tm = new TreeMap<>(Collections.reverseOrder());

tm.put(key, value);
tm.get(key);
tm.getOrDefault(key, 0);
tm.remove(key);

tm.firstKey();        tm.lastKey();
tm.firstEntry();      tm.lastEntry();
tm.pollFirstEntry();  tm.pollLastEntry();

tm.floorKey(k);       // greatest key <= k
tm.ceilingKey(k);     // smallest key >= k
tm.lowerKey(k);       // greatest key <  k
tm.higherKey(k);      // smallest key >  k
tm.headMap(k);        tm.tailMap(k);        tm.subMap(from, to);

for (Map.Entry<String, Integer> e : map.entrySet()) {
    String key = e.getKey();
    int value = e.getValue();
}

for (String key : map.keySet()) { }
for (int value : map.values()) { }

map.forEach((k, v) -> System.out.println(k + " " + v));

List<String> keys = new ArrayList<>(map.keySet());
List<Integer> values = new ArrayList<>(map.values());

Iterator<Map.Entry<String, Integer>> it = map.entrySet().iterator();
while (it.hasNext()) {
    if (it.next().getValue() == 0) it.remove();
}

Set<Integer> set = new HashSet<>();
Set<Integer> set = new HashSet<>(list);         // dedupes the list

set.add(10);          // false if already present
set.contains(10);
set.remove(10);
set.size();
set.isEmpty();
set.clear();

set.addAll(other);    // union
set.retainAll(other); // intersection
set.removeAll(other); // difference

TreeSet<Integer> ts = new TreeSet<>();                          // ascending
TreeSet<Integer> ts = new TreeSet<>((a, b) -> b - a);           // descending

ts.add(10);
ts.contains(10);
ts.remove(10);

ts.first();           ts.last();
ts.pollFirst();       ts.pollLast();
ts.floor(k);          ts.ceiling(k);
ts.lower(k);          ts.higher(k);
ts.headSet(k);        ts.tailSet(k);        ts.subSet(from, to);

List<String> list = List.of("a", "b", "c");
Set<Integer> set = Set.of(1, 2, 3);
Map<String, Integer> map = Map.of("a", 1, "b", 2);

// Map.of tops out at 10 pairs, so past that use entries
Map<String, Integer> bigger = Map.ofEntries(
    Map.entry("a", 1),
    Map.entry("b", 2)
);

// unmodifiable snapshot of a collection you were handed
List<String> snapshot = List.copyOf(other);

List<String> editable = new ArrayList<>(List.of("a", "b"));

Collections.sort(list);                              // natural order
Collections.sort(list, Collections.reverseOrder());
list.sort(Comparator.naturalOrder());
list.sort(Comparator.reverseOrder());

// By a field
people.sort(Comparator.comparing(Person::getName));
people.sort(Comparator.comparingInt(Person::getAge));

// Descending, then a tie breaker
people.sort(Comparator.comparingInt(Person::getAge).reversed()
                      .thenComparing(Person::getName));

Collections.reverse(list);
Collections.shuffle(list);
Collections.max(list);
Collections.min(list);
Collections.frequency(list, item);
Collections.swap(list, i, j);