Cheat Sheets

Three dense quick references by persona—syntax and collections for beginners, streams and concurrency for mid-level, JVM and architecture for senior engineers. Use Copy sheet for plain text, persona filters to focus one level, or print (Cmd/Ctrl+P).

beginner mid senior

Beginner Cheat Sheet

Syntax, primitives, control flow, String API, core Collections, exceptions. Deep dives: Basics, Collections, Exceptions.

beginner

Data types & variables

Type	Size	Example / notes
`byte`	8-bit	`-128` … `127`
`short`	16-bit	Rare except I/O buffers
`int`	32-bit	Default for integers
`long`	64-bit	Suffix `L`: `1_000_000L`
`float`	32-bit	Suffix `f`
`double`	64-bit	Default for decimals
`char`	16-bit UTF-16	`'A'`, not a string
`boolean`	—	`true` / `false` only
`var` (10+)	inferred	Local only; must have initializer

int count = 0;
final String name = "Ada";   // reference final — can't reassign ref
var list = new ArrayList<String>();  // inferred type

Operators & control flow

Construct	Syntax	Notes
if / else	`if (x > 0) { } else { }`	Condition must be boolean
for	`for (int i = 0; i < n; i++)`	Classic index loop
enhanced for	`for (var x : list)`	Iterable / array
while	`while (cond)`	Pre-test loop
do-while	`do { } while (cond);`	Runs at least once
switch	`switch (x) { case 1 -> … }`	Arrow form: no fall-through
break / continue	inside loops/switch	Labeled break rare
ternary	`cond ? a : b`	Both branches evaluated type-compatible

String methods (high-use)

Method	Returns	Use
`length()`	int	Char count (not UTF-8 bytes)
`isEmpty()` / `isBlank()`	boolean	Blank = whitespace only (11+)
`equals(s)`	boolean	Content compare; never `==` for strings
`equalsIgnoreCase(s)`	boolean	Case-insensitive
`compareTo(s)`	int	Sort order; sign = less/greater
`substring(b, e)`	String	[begin, end) index
`indexOf / lastIndexOf`	int	-1 if missing
`contains / startsWith / endsWith`	boolean	Search helpers
`strip()` (11+)	String	Trim Unicode whitespace
`split(regex)`	String[]	Regex split; limit param for max parts
`join(delimiter, parts)`	String	Static — join collection/array
`formatted` / `format`	String	`"%s %d".formatted(a, n)`
`toLowerCase / toUpperCase`	String	Locale overload for i18n

// Text blocks (15+)
String sql = """
    SELECT id, name FROM users
    WHERE active = true
    """;

Common Collections

Interface	Implementations	Key ops
`List`	`ArrayList`, `LinkedList`	`add`, `get(i)`, `remove`, `size`
`Set`	`HashSet`, `TreeSet`	`add`, `contains` — unique elements
`Map`	`HashMap`, `TreeMap`	`put`, `get`, `getOrDefault`, `keySet`
`Queue`	`ArrayDeque`	`offer`, `poll` — FIFO

List<String> list = new ArrayList<>();
list.add("a");
Map<String, Integer> map = new HashMap<>();
map.put("k", 1);
for (var e : map.entrySet()) {
    String k = e.getKey();
    int v = e.getValue();
}

Exception handling

Form	When
`try { } catch (E e) { }`	Handle checked or unchecked
`finally { }`	Always runs (except System.exit)
`try-with-resources`	`try (var in = …) { }` — auto-close
`throw new E("msg")`	Signal error
`throws E`	Declare checked exceptions on method
Unchecked	`RuntimeException`, `IllegalArgumentException` — no throws required

try (var reader = Files.newBufferedReader(path)) {
    // use reader
} catch (IOException e) {
    throw new UncheckedIOException(e);
}

Mid-Level Cheat Sheet

Streams, Optional, generics wildcards, java.util.concurrent, complexity. Chapters: Functional, Generics, Concurrency.

mid

Stream operations

Op	Type	Example
`stream()`	source	`list.stream()`, `Arrays.stream(a)`
`filter`	intermediate	`.filter(x -> x > 0)`
`map`	intermediate	`.map(User::name)`
`flatMap`	intermediate	`.flatMap(u -> u.roles().stream())`
`distinct`	intermediate	Unique by equals
`sorted`	intermediate	`.sorted(Comparator.naturalOrder())`
`limit / skip`	intermediate	Pagination-style
`takeWhile / dropWhile`	intermediate	Ordered streams (9+)
`collect`	terminal	`.toList()` (16+), `Collectors.toSet()`
`reduce`	terminal	`.reduce(0, Integer::sum)`
`forEach`	terminal	Side effects — avoid in pure pipelines
`count / min / max`	terminal	Reductions
`findFirst / anyMatch`	terminal short-circuit	Stops early when possible
`groupingBy`	collector	`Collectors.groupingBy(User::dept)`
`partitioningBy`	collector	Split by predicate → two buckets
`toMap`	collector	Merge function for duplicate keys

Map<String, List<User>> byDept = users.stream()
    .filter(User::active)
    .collect(Collectors.groupingBy(User::department));

// Parallel — only when data large & ops cheap; watch ordering
long n = list.parallelStream().filter(x -> x > 0).count();

Optional

Method	Purpose
`of(v)` / `ofNullable(v)`	Present box; nullable safe
`empty()`	Singleton empty
`isPresent()` / `isEmpty()`	Check (11+ `isEmpty`)
`ifPresent(Consumer)`	Run if present
`orElse(x)` / `orElseGet(Supplier)`	Default value
`orElseThrow()`	Fail if empty
`map` / `flatMap`	Transform without nested Optional
`filter`	Empty if predicate false
`stream()` (9+)	0 or 1 element stream

// Don't use Optional fields/parameters by default in domain models
String city = Optional.ofNullable(user)
    .flatMap(User::address)
    .map(Address::city)
    .orElse("unknown");

Generics wildcards (PECS)

Wildcard	Means	Producer / Consumer
`<T>`	Type parameter	Definition site
`? extends X`	Upper bound — read as X	Producer — get items out
`? super X`	Lower bound — accept X	Consumer — put X in
`?`	Unbounded	Only safe via `Object`

// PECS: Producer Extends, Consumer Super
void copy(List<? extends Number> src, List<? super Integer> dest) {
    for (Number n : src) dest.add(n.intValue());
}

Concurrency utilities

API	Use
`synchronized`	Intrinsic lock on object
`volatile`	Visibility — not atomic compound ops
`ReentrantLock`	Explicit lock, tryLock, fairness
`AtomicInteger` etc.	Lock-free CAS counters
`ConcurrentHashMap`	Thread-safe map — segment/CAS
`CopyOnWriteArrayList`	Read-heavy, rare writes
`ExecutorService`	`submit`, `invokeAll`, shutdown
`Executors`	`newFixedThreadPool`, `newCachedThreadPool`
`CountDownLatch`	Wait for N events
`CyclicBarrier`	Threads rendezvous
`Semaphore`	Limit concurrent access
`CompletableFuture`	Async pipeline — see senior sheet
`BlockingQueue`	`ArrayBlockingQueue`, `LinkedBlockingQueue`

ExecutorService pool = Executors.newFixedThreadPool(4);
Future<String> f = pool.submit(() -> "ok");
pool.shutdown();
pool.awaitTermination(30, TimeUnit.SECONDS);

Collections — time complexity (average)

Structure	get / contains	add	remove	Notes
`ArrayList`	O(1) index / O(n) search	O(1)* end	O(n)	*amortized; insert middle O(n)
`LinkedList`	O(n)	O(1) ends	O(1) with iterator	Poor cache locality
`HashMap`	O(1)	O(1)	O(1)	Worst O(n) if hash degrade
`TreeMap`	O(log n)	O(log n)	O(log n)	Sorted keys
`HashSet`	O(1)	O(1)	O(1)	Backed by map
`TreeSet`	O(log n)	O(log n)	O(log n)	Sorted set
`PriorityQueue`	peek O(1)	O(log n)	O(log n)	Heap — not sorted iteration
`ConcurrentHashMap`	O(1)	O(1)	O(1)	Scalable concurrent reads/writes

Senior / Architect Cheat Sheet

JVM flags, GC tuning, JMH, async composition, virtual threads, patterns. Chapters: JVM, Performance, Modern Java, Patterns.

senior

JVM flags (common)

Flag	Purpose
`-Xms` / `-Xmx`	Initial / max heap (e.g. `-Xmx4g`)
`-XX:MaxRAMPercentage`	Container-aware heap % (CGroup)
`-XX:+UseG1GC`	G1 collector (default on many JDKs)
`-XX:MaxGCPauseMillis`	G1 pause target (hint)
`-XX:+UseZGC` / `UseGenerationalZGC`	Low-latency ZGC (21+ generational)
`-Xlog:gc*`	Unified GC logging (9+)
`-XX:+HeapDumpOnOutOfMemoryError`	Dump on OOM
`-XX:HeapDumpPath=…`	Dump file location
`-XX:NativeMemoryTracking`	NMT summary / detail
`-XX:+AlwaysPreTouch`	Touch heap pages at start (latency vs startup)
`-XX:+PrintCompilation`	Log JIT compiles (with UnlockDiagnosticVMOptions)
`-XX:+FlightRecorder`	Enable JFR
`-D…`	System properties

GC tuning (practical)

Symptom	Direction
Frequent long pauses	Reduce heap pressure; tune pause goal; consider ZGC
High throughput batch	G1 or parallel; larger young gen
Container OOMKilled	Set `-Xmx` below cgroup limit; MaxRAMPercentage
Metaspace growth	Class loaders / reflection; `-XX:MaxMetaspaceSize`
Native memory leak	NMT, direct buffers, JNI, thread stacks

# JDK 9+ GC log
java -Xlog:gc*:file=gc.log:time,uptime,level -jar app.jar

# JFR short recording
jcmd <pid> JFR.start name=debug settings=profile duration=120s filename=out.jfr

JMH annotations

Annotation	Role
`@Benchmark`	Measured method
`@Warmup`	Iterations/time before score
`@Measurement`	Recorded iterations
`@Fork`	Separate JVM runs
`@State(Scope.Thread)`	Per-thread fixture
`@BenchmarkMode`	Throughput, AverageTime, SampleTime, …
`@OutputTimeUnit`	Report units
`Blackhole.consume`	Prevent dead code elimination

@BenchmarkMode(Mode.Throughput)
@Warmup(iterations = 3, time = 1)
@Measurement(iterations = 5, time = 1)
@Fork(1)
public class MyBench {
    @Benchmark
    public void run(Blackhole bh) { bh.consume(work()); }
}

CompletableFuture

Method	Purpose
`supplyAsync(Supplier)`	Async value
`runAsync(Runnable)`	Async void
`thenApply` / `thenAccept`	Map / consume result
`thenCompose`	Flat-map nested CF
`thenCombine`	Merge two CFs
`allOf` / `anyOf`	Wait for all / first
`exceptionally`	Recover from failure
`handle`	Success or failure branch
`orTimeout` / `completeOnTimeout`	Deadline (9+)
`join()` / `get()`	Block for result

CompletableFuture<User> user = CompletableFuture
    .supplyAsync(() -> fetchUser(id), executor)
    .thenCompose(u -> enrichAsync(u))
    .orTimeout(2, TimeUnit.SECONDS);

CompletableFuture.allOf(f1, f2).join();

Virtual threads (Java 21+)

API	Notes
`Thread.startVirtualThread(r)`	Fire-and-forget virtual thread
`Thread.ofVirtual().start(r)`	Builder: name, factory
`Executors.newVirtualThreadPerTaskExecutor()`	One virtual thread per task
`Thread.isVirtual()`	Check thread kind
Pinned	`synchronized` + blocking native can pin carrier

try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    IntStream.range(0, 10_000).forEach(i ->
        executor.submit(() -> handleRequest(i)));
}

Design patterns — quick reference

Pattern	Problem	Java / Spring hint
Singleton	One instance	Enum; Spring default scope
Factory Method	Defer concrete type	`@Bean` methods
Abstract Factory	Related product family	Profile-specific config
Builder	Many optional fields	`HttpRequest.newBuilder()`
Strategy	Swap algorithm	Inject interface
Observer	Notify dependents	`@EventListener`
Decorator	Add behavior	I/O streams
Adapter	Legacy API bridge	Wrapper implements port
Facade	Simple API over subsystem	Service layer
Proxy	Control access	Spring AOP, JDK/CGLIB
Template Method	Fixed skeleton	`JdbcTemplate`
Chain of Responsibility	Pipeline handlers	Servlet / Security filters
Command	Request as object	Undo, job queue
Repository	Persistence boundary	Spring Data JPA
Null Object	Avoid null checks	NOOP implementation

Profiling one-liners

Tool	Command / action
async-profiler	`./profiler.sh -d 60 -f cpu.html <pid>`
Heap dump	`jcmd <pid> GC.heap_dump heap.hprof`
Thread dump	`jcmd <pid> Thread.print`
JMC	Open `.jfr` — Hot Methods, GC, locks