Java Collections Framework Cheat Sheet

List<String> list = new ArrayList<>();list.add("a");list.add("b");list.get(0);            // "a" - indexed access, O(1) for ArrayListlist.remove("a");Set<String> set = new HashSet<>();set.add("x");set.add("x");            // ignored - duplicates not allowedSystem.out.println(set.size()); // 1Map<String, Integer> map = new HashMap<>();map.put("age", 30);map.getOrDefault("height", 0); // 0 - safe default lookupmap.forEach((k, v) -> System.out.println(k + "=" + v));

List<Integer> arrayList = new ArrayList<>();   // fast random access, slow middle insertsList<Integer> linkedList = new LinkedList<>(); // fast insert/remove at ends, slow random accessSet<Integer> hashSet = new HashSet<>();        // O(1) avg, no order guaranteeSet<Integer> linkedHashSet = new LinkedHashSet<>(); // preserves insertion orderSet<Integer> treeSet = new TreeSet<>();        // sorted, O(log n)Map<String, Integer> hashMap = new HashMap<>();       // no order guaranteeMap<String, Integer> linkedHashMap = new LinkedHashMap<>(); // insertion orderMap<String, Integer> treeMap = new TreeMap<>();       // sorted by key

List<String> names = new ArrayList<>(List.of("Charlie", "Alice", "Bob"));Collections.sort(names);                    // natural ordering (alphabetical)names.sort(Comparator.reverseOrder());       // descendingnames.sort(Comparator.comparing(String::length).thenComparing(Comparator.naturalOrder()));for (String name : names) { // enhanced for-loop (uses Iterator internally)    System.out.println(name);}Iterator<String> it = names.iterator();while (it.hasNext()) {    if (it.next().equals("Bob")) it.remove(); // safe removal during iteration}

List<String> immutable = List.of("a", "b", "c"); // Java 9+, throws on mutationMap<String, Integer> immutableMap = Map.of("x", 1, "y", 2);List<String> unmodifiable = Collections.unmodifiableList(list); // read-only viewCollections.max(list);Collections.reverse(list);Collections.emptyList();

List<String> names = List.of("Alice", "Bob", "Charlie", "Ana", "Ben");Map<Character, List<String>> byFirstLetter = names.stream()    .collect(Collectors.groupingBy(n -> n.charAt(0)));long countLongNames = names.stream()    .filter(n -> n.length() > 3)    .count();String joined = names.stream()    .sorted()    .collect(Collectors.joining(", ", "[", "]"));Map<Boolean, List<String>> partitioned = names.stream()    .collect(Collectors.partitioningBy(n -> n.length() <= 3));double avgLength = names.stream()    .collect(Collectors.averagingInt(String::length));

Map<String, Integer> concurrentMap = new ConcurrentHashMap<>();concurrentMap.computeIfAbsent("hits", k -> 0);concurrentMap.merge("hits", 1, Integer::sum); // atomic read-modify-writeList<String> cowList = new CopyOnWriteArrayList<>(); // safe iteration, expensive writescowList.add("event"); // copies the backing array on every mutationBlockingQueue<Runnable> tasks = new LinkedBlockingQueue<>();tasks.put(() -> System.out.println("work")); // blocks if bounded and full// Legacy synchronized wrapper - coarser locking than ConcurrentHashMapMap<String, Integer> syncMap = Collections.synchronizedMap(new HashMap<>());

NavigableMap<Integer, String> scores = new TreeMap<>();scores.put(60, "D"); scores.put(70, "C"); scores.put(85, "B"); scores.put(95, "A");scores.floorKey(80);    // 70 - greatest key <= 80scores.ceilingKey(80);  // 85 - smallest key >= 80scores.higherKey(85);   // 95 - smallest key strictly > 85scores.lowerKey(85);    // 70 - greatest key strictly < 85scores.headMap(85, true); // {60=D, 70=C, 85=B} - inclusive up to 85NavigableSet<Integer> nums = new TreeSet<>(List.of(1, 5, 10, 15));nums.pollFirst(); // removes and returns 1nums.descendingSet(); // view iterating in reverse order

public final class CacheKey {    private final String tenant;    private final long id;    public CacheKey(String tenant, long id) { this.tenant = tenant; this.id = id; }    @Override    public boolean equals(Object o) {        if (!(o instanceof CacheKey other)) return false;        return id == other.id && tenant.equals(other.tenant);    }    @Override    public int hashCode() { return Objects.hash(tenant, id); } // must match equals}Map<CacheKey, Object> cache = new HashMap<>();cache.put(new CacheKey("acme", 1), "value");cache.containsKey(new CacheKey("acme", 1)); // true - different instance, equal key// Mutating a field used in equals/hashCode AFTER insertion corrupts the bucket - avoid mutable keys

PriorityQueue<Task> tasks = new PriorityQueue<>(Comparator.comparingInt(Task::priority));tasks.offer(new Task("low", 3));tasks.offer(new Task("urgent", 1));tasks.poll(); // returns "urgent" first - lowest value = highest priority (min-heap)Deque<Integer> stack = new ArrayDeque<>();stack.push(1); stack.push(2);stack.pop(); // 2 - LIFODeque<Integer> queue = new ArrayDeque<>();queue.offer(1); queue.offer(2);queue.poll(); // 1 - FIFO// ArrayDeque is preferred over Stack/LinkedList for both use cases - no legacy sync overhead