Cheat sheet Java
Una referenza Java consultabile e stampabile: tipi, stringhe, collezioni, stream, record, pattern matching, concorrenza e I/O su file. Gratis.
Basics & types
10var list = new ArrayList<String>();
Local variable type inference
int x = 42; double d = 3.14;
Primitive declarations
long big = 9_000_000_000L;
Digit separators + long literal
char c = 'A'; boolean ok = true;
Char and boolean primitives
final int MAX = 100;
Constant (cannot be reassigned)
int i = (int) 3.99;
Explicit narrowing cast (→ 3)
double d = x;
Implicit widening conversion
int n = Integer.parseInt("42");
String → int
String s = String.valueOf(42);
Number → string
Integer boxed = 42; int y = boxed;
Auto-boxing and unboxing
Strings & text blocks
12s.length(); s.charAt(0);
Length and character access
s.substring(1, 3)
Slice (end index exclusive)
s.contains("x"); s.startsWith("a");
Search checks
s.replace("a", "b")
Replace all occurrences
s.strip()
Trim whitespace (Unicode-aware)
s.split(",")
Split into a String[]
String.join(", ", parts)
Join with a separator
"ab".repeat(3)
Repeat a string ("ababab")
s.isBlank(); s.isEmpty();
Whitespace-only / zero-length
"%s: %d".formatted(key, count)
Inline printf-style formatting
String html = """\n <p>Hi</p>\n """;
Multi-line text block
new StringBuilder().append(a).append(b)
Efficient string building in loops
Collections
12List<String> l = List.of("a", "b");
Immutable list factory
Map<String, Integer> m = Map.of("a", 1);
Immutable map factory
Set<Integer> s = Set.of(1, 2, 3);
Immutable set factory
new ArrayList<>(List.of("a", "b"))
Mutable copy of a list
List.copyOf(list)
Immutable defensive copy
map.getOrDefault(key, 0)
Read with a fallback value
map.computeIfAbsent(k, x -> new ArrayList<>())
Lazily create grouped values
map.merge(key, 1, Integer::sum)
Increment a counter map
list.removeIf(s -> s.isBlank())
Bulk remove matching items
list.sort(Comparator.naturalOrder())
Sort a list in place
for (var e : map.entrySet())
Iterate map entries
list.forEach(System.out::println)
Iterate with a method reference
Streams & lambdas
12list.stream().map(String::toUpperCase).toList()
Transform every element
.filter(n -> n > 0)
Keep matching elements
.sorted(Comparator.comparing(User::name))
Sort by a key extractor
.distinct().limit(10).skip(5)
Dedupe and paginate a stream
.collect(Collectors.groupingBy(User::city))
Group into Map<K, List<V>>
.collect(Collectors.joining(", "))
Join strings with a separator
.collect(Collectors.toMap(User::id, u -> u))
Build a map from a stream
.flatMap(List::stream)
Flatten nested collections
.mapToInt(Order::total).sum()
Numeric stream aggregation
.reduce(0, Integer::sum)
Fold to a single value
.anyMatch(s -> s.isBlank())
anyMatch / allMatch / noneMatch
IntStream.range(0, 10)
Stream of ints 0..9
Records & sealed classes
9record Point(int x, int y) {}
Immutable data carrier
var p = new Point(1, 2); p.x();
Construct + generated accessors
equals(), hashCode(), toString()
Generated for free on records
record Range(int lo, int hi) { Range { if (lo > hi) throw new IllegalArgumentException(); } }
Compact constructor validation
record Point(...) implements Shape {}
Records can implement interfaces
static Point origin() { return new Point(0, 0); }
Static factory inside a record
sealed interface Shape permits Circle, Square {}
Restrict allowed subtypes
final class Circle implements Shape {}
Permitted type must be final...
non-sealed class Square implements Shape {}
...or sealed / non-sealed
Pattern matching & switch
8if (obj instanceof String s) use(s);
instanceof pattern binds a var
int n = switch (day) { case MON -> 1; default -> 0; };
Switch as an expression
case MON, TUE -> "early week";
Multiple labels per arm
case X -> { ...; yield value; }
Block arm returns via yield
case String s when s.length() > 2 ->
Guarded pattern (when clause)
case Point(int x, int y) -> x + y;
Record pattern deconstruction
case null, default -> "none";
Handle null inside the switch
switch (shape) { case Circle c -> ... }
Exhaustive over sealed types
OOP essentials
11interface Greeter { default String hi() { return "hi"; } }
Interface with default method
class Impl implements A, B {}
Implement multiple interfaces
class Admin extends User {}
Single-class inheritance
@Override public String toString()
Mark overridden methods
super.method(); super(args);
Call parent method / constructor
class Box<T> { T value; }
Generic class
<T extends Comparable<T>> T max(...)
Bounded type parameter
List<? extends Number> nums
Covariant wildcard
enum Status { ACTIVE, DONE }
Enum type (can hold methods)
abstract class Base { abstract void run(); }
Abstract class + method
public static User of(String n) { ... }
Static factory method idiom
Optional
10Optional.of(v); Optional.empty();
Create (of throws on null)
Optional.ofNullable(maybeNull)
Wrap a possibly-null value
opt.isPresent(); opt.isEmpty();
Presence checks
opt.orElse(defaultValue)
Fallback value
opt.orElseGet(() -> compute())
Lazy fallback (only if empty)
opt.orElseThrow()
Get or throw NoSuchElement
opt.map(User::name).filter(n -> !n.isBlank())
Chain transformations safely
opt.ifPresent(v -> use(v))
Run only when present
opt.ifPresentOrElse(use, this::warn)
Branch on both cases
opt.get()
Avoid: prefer orElseThrow()
Exceptions & try-with-resources
9try { ... } catch (IOException e) { ... }
Catch a checked exception
catch (IOException | SQLException e)
Multi-catch in one block
finally { cleanup(); }
Always runs (even on throw)
try (var in = Files.newBufferedReader(p)) { ... }
Auto-close resources
throw new IllegalArgumentException("bad id");
Throw with a message
class AppException extends RuntimeException {}
Custom unchecked exception
RuntimeException vs Exception
Unchecked vs checked (declared)
e.getMessage(); e.getCause();
Inspect an exception
Objects.requireNonNull(x, "x is required")
Fail fast on null arguments
Concurrency
12Thread.startVirtualThread(() -> work());
Cheap virtual thread (21+)
Executors.newVirtualThreadPerTaskExecutor()
One virtual thread per task
var pool = Executors.newFixedThreadPool(4);
Bounded platform thread pool
Future<T> f = pool.submit(task); f.get();
Submit and await a result
CompletableFuture.supplyAsync(() -> fetch())
Async computation
.thenApply(r -> parse(r))
Transform the async result
.thenCombine(other, (a, b) -> a + b)
Join two futures
.exceptionally(e -> fallback)
Recover from async failure
CompletableFuture.allOf(f1, f2).join();
Wait for all to finish
new AtomicInteger().incrementAndGet()
Lock-free counter
new ConcurrentHashMap<K, V>()
Thread-safe map
synchronized (lock) { ... }
Mutual exclusion block
I/O & files (java.nio)
12Path p = Path.of("data", "file.txt");
Build a platform-safe path
String s = Files.readString(p);
Read a whole file as text
Files.writeString(p, text);
Write text (creates/truncates)
List<String> lines = Files.readAllLines(p);
Read all lines
try (var st = Files.lines(p)) { ... }
Stream lines lazily
Files.exists(p); Files.size(p);
Existence and size checks
Files.createDirectories(dir);
mkdir -p equivalent
Files.copy(src, dst); Files.move(src, dst);
Copy / move files
Files.deleteIfExists(p);
Delete without throwing
try (var files = Files.list(dir)) { ... }
List directory entries
Files.walk(dir)
Recursive directory stream
Files.createTempFile("up-", ".tmp")
Temporary file
Build & CLI
12javac Main.java && java Main
Compile then run
java Main.java
Run a source file directly
java -jar app.jar
Run an executable jar
java -Xmx512m -jar app.jar
Cap the max heap size
jshell
Interactive Java REPL
mvn clean package
Maven: build the artifact
mvn test
Maven: run the test suite
mvn dependency:tree
Maven: inspect dependencies
./gradlew build
Gradle: full build via wrapper
./gradlew test --tests "UserTest"
Gradle: run selected tests
jar tf app.jar
List a jar's contents
java --version
Show the JDK version
Nessuna voce corrisponde a “:q”.
Informazioni su Cheat sheet Java
Questo cheat sheet Java comprime il Java moderno in un'unica pagina consultabile: basi e tipi, stringhe e text block, collezioni, stream e lambda, record e classi sealed, pattern matching e switch, elementi essenziali OOP, Optional, eccezioni e try-with-resources, concorrenza, I/O di file con java.nio, e i comandi di build e CLI.
Copre sia i fondamentali che scrivi ogni giorno (una List, una HashMap, un ciclo for-each, un blocco try-with-resources) sia le funzionalità linguistiche più recenti che hanno cambiato il modo di leggere Java, inclusi record, tipi sealed, espressioni switch con pattern matching e text block.
Il foglio è gratuito e lato client: filtra le righe dal vivo con la casella di ricerca, salta tra le sezioni con l'indice fisso, copia qualsiasi frammento con un clic e stampa la pagina come riferimento accanto alla tastiera.
Come usare Cheat sheet Java
- Scorri le sezioni, da Basi e tipi e Collezioni fino a Concorrenza e Build e CLI.
- Cerca una parola chiave come stream, record o Optional per filtrare ogni riga dal vivo.
- Salta a Pattern matching e switch o Stream e lambda quando ti serve la sintassi moderna.
- Fai clic su un frammento o sulla sua icona di copia per copiare il codice Java negli appunti.
- Stampa il foglio per un riferimento Java offline.
Domande frequenti
Dodici sezioni: basi e tipi, stringhe e text block, collezioni, stream e lambda, record e classi sealed, pattern matching e switch, elementi essenziali OOP, Optional, eccezioni e try-with-resources, concorrenza, I/O di file java.nio, e comandi di build e CLI.
Sì. Record, classi sealed, text block, var, espressioni switch avanzate e pattern matching hanno ciascuno le proprie righe accanto alla sintassi classica.
È costruita attorno a ciò che scrivi davvero: creazione e iterazione di List, Set, Map e Deque, poi map, filter, collect, groupingBy, reduce e i collector più comuni.
Sì. Fai clic su qualsiasi frammento o sulla sua icona di copia al passaggio del mouse e finisce negli appunti con una breve conferma.
Sì, completamente gratuito: consultabile, stampabile e visualizzato nel tuo browser senza registrazione.
Ricerche popolari
cheat sheet java
riferimento sintassi java
cheat sheet collezioni java
esempi stream java
record e classi sealed java
pattern matching switch java
basi concorrenza java
Hai bisogno di aiuto?
Hai riscontrato un problema con questo strumento? Faccelo sapere.