Java Cheat Sheet
Ultimo aggiornamento
Hello World e struttura del programma
Ogni programma Java parte da un metodo main dentro una classe.
| Elemento | Codice |
|---|---|
| Dichiarazione della classe | public class Main { ... } |
| Punto di ingresso | public static void main(String[] args) { ... } |
| Stampare una riga | System.out.println("Hello, World!"); |
| Stampare senza andare a capo | System.out.print("text"); |
| Leggere l'input | Scanner sc = new Scanner(System.in); |
| Importare una classe | import java.util.ArrayList; |
| Commenti | // line e /* block */ |
Tipi di dati
I tipi primitivi sono minuscoli; le loro classi wrapper hanno l'iniziale maiuscola.
| Tipo | Descrizione |
|---|---|
int | Intero con segno a 32 bit |
long | Intero con segno a 64 bit |
double / float | Numeri in virgola mobile |
boolean | true o false |
char | Singolo carattere Unicode a 16 bit |
byte / short | Interi a 8 bit / 16 bit |
String | Testo immutabile (una classe, non un primitivo) |
Integer, Double, Boolean | Classi wrapper per i primitivi |
var | Tipo locale dedotto (Java 10+) |
Variabili
| Operazione | Sintassi |
|---|---|
| Dichiarare e inizializzare | int x = 5; |
| Inferenza del tipo (locale) | var name = "Ada"; |
| Costante | final double PI = 3.14159; |
| Concatenazione di stringhe | String s = "Hi " + name; |
| Convertire una stringa in int | int n = Integer.parseInt("42"); |
| Convertire un int in stringa | String s = String.valueOf(42); |
| Stringa formattata | String.format("%d items", n) |
Operatori
Operatori aritmetici, di confronto, logici e di assegnazione.
| Operatore | Significato |
|---|---|
+ - * / % | Addizione, sottrazione, moltiplicazione, divisione, modulo |
++ -- | Incremento / decremento |
== != | Uguale / diverso (confronta i riferimenti per gli oggetti) |
> < >= <= | Confronti maggiore / minore |
&& || ! | AND, OR, NOT logici (cortocircuito) |
& | ^ ~ | AND, OR, XOR, NOT bit a bit |
<< >> >>> | Shift a sinistra, a destra con segno, a destra senza segno |
+= -= *= /= | Assegnazione composta |
? : | Ternario: x > 0 ? "pos" : "neg" |
instanceof | Controllo di tipo: if (o instanceof String s) |
Controllo del flusso
| Istruzione | Sintassi |
|---|---|
| If / else | if (x > 0) { ... } else { ... } |
| Istruzione switch | switch (n) { case 1: ...; break; default: ...; } |
| Espressione switch | var s = switch (n) { case 1 -> "one"; default -> "other"; }; |
| Ciclo while | while (i < n) { ... } |
| Ciclo do-while | do { ... } while (i < n); |
| Ciclo for | for (int i = 0; i < n; i++) { ... } |
| For avanzato (for-each) | for (String item : list) { ... } |
| Break / continue | break; esce da un ciclo, continue; passa all'iterazione successiva |
Metodi delle stringhe
String è immutabile: ogni metodo restituisce una nuova stringa. Usa StringBuilder quando concateni dentro un ciclo.
| Metodo | Cosa fa |
|---|---|
s.length() | Numero di caratteri |
s.charAt(i) | Carattere all'indice i |
s.substring(a, b) | Porzione da a (incluso) a b (escluso) |
s.indexOf("x") | Primo indice di una sottostringa, oppure -1 |
s.contains("x") | true se la sottostringa è presente |
s.replace("a", "b") | Sostituire tutte le occorrenze |
s.split(",") | Dividere in un String[] |
s.trim() / s.strip() | Rimuovere gli spazi iniziali e finali |
s.toUpperCase() / toLowerCase() | Cambiare maiuscole e minuscole |
s.equals(t) / equalsIgnoreCase(t) | Confronto per valore (non ==) |
s.startsWith("x") / endsWith("x") | Verifica di prefisso / suffisso |
String.join(",", list) | Unire elementi con un separatore |
Math e utility comuni
Helper statici di java.lang.Math e delle classi wrapper numeriche.
| Chiamata | Risultato |
|---|---|
Math.max(a, b) / Math.min(a, b) | Il maggiore / minore di due valori |
Math.abs(x) | Valore assoluto |
Math.pow(x, y) | x elevato a y (restituisce double) |
Math.sqrt(x) | Radice quadrata |
Math.round(x) / floor / ceil | Arrotondare al più vicino / per difetto / per eccesso |
Math.random() | double casuale in [0.0, 1.0) |
Integer.parseInt("42") | Convertire una stringa in int |
Integer.MAX_VALUE / MIN_VALUE | int più grande / più piccolo |
Arrays.sort(arr) | Ordinare un array sul posto |
Arrays.toString(arr) | Contenuto dell'array in forma leggibile |
Metodi
| Operazione | Sintassi |
|---|---|
| Definire un metodo | int add(int a, int b) { return a + b; } |
| Nessun valore di ritorno | void greet() { ... } |
| Metodo statico | static int square(int x) { return x * x; } |
| Metodo pubblico | public String getName() { return name; } |
| Varargs | int sum(int... nums) { ... } |
| Chiamare un metodo | int r = add(2, 3); |
| Chiamare un metodo statico | Math.max(a, b); |
| Overloading dei metodi | int max(int a, int b) e double max(double a, double b) |
Classi e OOP
| Operazione | Sintassi |
|---|---|
| Definire una classe | public class Dog { ... } |
| Campo | private String name; |
| Costruttore | public Dog(String name) { this.name = name; } |
| Creare un oggetto | Dog d = new Dog("Rex"); |
| Getter / setter | public String getName() { return name; } |
| Ereditarietà | class Puppy extends Dog { ... } |
| Interfaccia | interface Runnable { void run(); } |
| Implementare un'interfaccia | class Task implements Runnable { ... } |
| Sovrascrivere un metodo | @Override public void speak() { ... } |
Record, enum e Java moderno
Sintassi moderna e concisa (Java 14+) per contenitori di dati e insiemi fissi di valori.
| Funzionalità | Sintassi |
|---|---|
| Record (dati immutabili) | record Point(int x, int y) {} |
| Usare un record | var p = new Point(1, 2); p.x(); |
| Enum | enum Day { MON, TUE, WED } |
| Enum con valori | enum Coin { PENNY(1), DIME(10); ... } |
| Blocco di testo | String s = """\n multi\n line\n """; |
Pattern matching con instanceof | if (o instanceof String s) { s.length(); } |
| Pattern nello switch (Java 21) | case Integer i -> ...; case String s -> ...; |
| Classe sealed | sealed interface Shape permits Circle, Square {} |
Collezioni
Collezioni generiche di java.util.
| Tipo | Uso ed esempio |
|---|---|
ArrayList<T> | Array dinamico: list.add(1); list.get(0); list.size(); |
HashMap<K, V> | Chiave-valore: map.put("a", 1); map.get("a"); |
HashSet<T> | Valori unici: set.add(5); set.contains(5); |
LinkedList<T> | Lista doppiamente collegata, utile come coda/deque |
ArrayDeque<T> | Pila/coda: dq.push(x); dq.pop(); |
| Array | int[] nums = {1, 2, 3}; |
| Iterare una lista | for (T x : list) { ... } |
| Iterare una map | for (var e : map.entrySet()) { e.getKey(); e.getValue(); } |
Stream e lambda
Pipeline in stile funzionale sulle collezioni (Java 8+).
| Operazione | Sintassi |
|---|---|
| Espressione lambda | x -> x * 2 |
| Creare uno stream | list.stream() |
| Filtrare | .filter(n -> n > 0) |
| Mappare / trasformare | .map(n -> n * 2) |
| Ordinare | .sorted() oppure .sorted(Comparator.reverseOrder()) |
| Ridurre / sommare | .reduce(0, Integer::sum) |
| Contare / verificare | .count(), .anyMatch(n -> n > 5) |
| Raccogliere in una lista | .collect(Collectors.toList()) |
| Per ogni elemento | .forEach(System.out::println) |
Schemi comuni (try/catch, generics)
| Schema | Sintassi |
|---|---|
| Try / catch | try { ... } catch (Exception e) { ... } |
| Catturare un'eccezione specifica | catch (IOException e) { ... } |
| Finally | finally { ... } viene sempre eseguito |
| Try-with-resources | try (Scanner sc = new Scanner(...)) { ... } |
| Lanciare un'eccezione | throw new IllegalArgumentException("bad"); |
| Classe generica | class Box<T> { T value; } |
| Metodo generico | <T> T first(List<T> list) { ... } |
| Tipo vincolato | <T extends Number> |
La sintassi, le collezioni e le operazioni sugli stream di Java che usi di più, in una sola pagina. Questa cheat sheet di Java è un riferimento rapido per scrivere in Java: tipi di dati, controllo del flusso, classi, le collezioni ArrayList/HashMap, la Streams API e gli schemi con eccezioni e generics che usi ogni giorno.
Tutto quello che trovi qui è Java standard (Java 8 e successivi) e si compila con javac. Copia quello che ti serve oppure prova qualsiasi frammento dal vivo nel playground Java, senza installare nessun JDK. Sei alle prime armi con il linguaggio? Il corso interattivo gratuito di Java di Coddy costruisce gli stessi concetti passo dopo passo.
Domande frequenti sulla cheat sheet di Java
Questa cheat sheet di Java è gratuita?
Sì. Questa cheat sheet di Java è completamente gratuita e non richiede registrazione. Salvala nei preferiti e torna quando devi controllare la sintassi, una collezione o un'operazione sugli stream.
Qual è la differenza tra == e .equals() in Java?
Per gli oggetti,
== confronta i riferimenti, cioè se due variabili puntano esattamente allo stesso oggetto, mentre .equals() confronta il contenuto. Due oggetti String diversi con lo stesso testo sono .equals() ma potrebbero non essere ==. Usa sempre .equals() per confrontare stringhe e altri oggetti per valore; usa == solo per i primitivi (int, boolean, ecc.) o per controllare null.A cosa servono gli stream in Java?
La Streams API (Java 8+) ti permette di elaborare le collezioni con una pipeline di operazioni leggibile, come
filter, map, sorted, reduce e collect, invece di cicli scritti a mano. Parti da list.stream(), concateni le operazioni intermedie e chiudi con un'operazione terminale come collect(Collectors.toList()) o forEach. Così il codice che trasforma i dati resta conciso ed espressivo.Posso esercitarmi con Java online?
Sì. Apri il playground Java per compilare ed eseguire nel browser qualsiasi frammento di questa cheat sheet, senza installare nessun JDK. Quando vuoi un percorso strutturato, il corso interattivo gratuito di Java di Coddy ti porta passo dopo passo da variabili e cicli fino a classi, collezioni e stream.
Questa cheat sheet va bene per chi inizia?
Sì. È organizzata dai mattoni più comuni (tipi, controllo del flusso, metodi) fino a quelli avanzati (stream, generics, eccezioni), così puoi usare le prime sezioni fin dal primo giorno e arrivare al resto con il tempo.
Come si converte una String in int in Java?
Usa
Integer.parseInt("42") per ottenere un int primitivo, oppure Integer.valueOf("42") per ottenere un oggetto Integer. Entrambi lanciano una NumberFormatException se la stringa non è un numero valido, quindi racchiudili in un try / catch quando l'input non è affidabile. Per la conversione opposta usa String.valueOf(n) o Integer.toString(n).Qual è la differenza tra ArrayList e array in Java?
Un array (
int[] a = new int[5]) ha una lunghezza fissa decisa alla creazione e può contenere direttamente i primitivi. Un ArrayList<T> cresce e si riduce dinamicamente con add() e remove(), ma memorizza solo oggetti, quindi i primitivi vengono convertiti automaticamente con l'autoboxing (ArrayList<Integer>). Usa un array quando la dimensione è nota e fissa; usa un ArrayList quando la collezione cambia dimensione.Risorse correlate
Altre cheat sheet
