# I tipi primitivi in Java: tutto quello che devi sapere In Java esistono otto tipi di dati primitivi, ognuno caratterizzato da una dimensione fissa e un intervallo di valori predefinito. Questi tipi sono utilizzati per creare variabili e assegnare loro numeri, caratteri o valori logici individuali. I primitivi di Java sono boolean, byte, char, double, float, int, long e short. ## Cosa sono i tipi primitivi di Java? Come in altri [linguaggi di programmazione](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/linguaggi-programmazione-web/) anche in Java esistono [diversi tipi di dati](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/tipi-di-dati-in-java/), suddivisi in due categorie. Da un lato ci sono i “riferimenti”, che puntano a un oggetto liberamente definibile, come ad esempio stringhe, array, classi o interfacce. Dall’altro abbiamo i “primitivi”, caratterizzati da una **dimensione fissa**, identica su tutte le piattaforme. Ognuno di essi dispone di una **classe wrapper dedicata**, è **integrato in modo invariabile** e presenta un **intervallo di valori predefinito**. I tipi primitivi di Java si usano per creare variabili contenenti singoli numeri, caratteri o valori logici. Questi otto tipi di dati primitivi sono un elemento fondamentale della programmazione Java, tanto che la loro rappresentazione è parte integrante del linguaggio. Sebbene differiscano tra loro principalmente per i **tipi di valori che possono memorizzare**, presentano tutti la stessa caratteristica di base, ovvero contengono un solo valore. I tipi primitivi di Java si suddividono in quattro gruppi, a seconda del loro ambito di applicazione: - Dati booleani (boolean) - Numeri interi (byte, short, int e long) - Valori in virgola mobile (float e double) - Caratteri (char) Dato che i primitivi sono memorizzati direttamente nello stack, ovvero la porzione dinamica di memoria, è importante sapere quanto spazio occupano (su questo punto torneremo in seguito). Siccome Java è un **linguaggio fortemente tipizzato**, prima di avviare la compilazione è necessario dichiarare il tipo di una variabile. Solo in questo modo il codice verrà eseguito correttamente. Di seguito elenchiamo i primitivi di Java:
Tipo di dati Dimensione Intervallo di valori Valore predefiniti Classe wrapper
boolean 1 bit true o false false java.lang.Boolean
byte 8 bit da -128 a 127 0 java.lang.Byte
short 16 bit da -32768 a 32767 0 java.lang.Short
int 32 bit da -2147483648 a 2147483647 0 java.lang.Integer
long 64 bit da -9223372036854775808 a 9223372036854775807 0 java.lang.Long
float 32 bit fino a dieci cifre decimali 0,0 java.lang.Float
double 64 bit fino a 16 cifre decimali 0,0 java.lang.Double
char 16 bit \*\*’\\u0000’ (quindi 0) fino a ‘\\uffff’ (è uguale a 65535) ‘\\u0000’ java.lang.Character
## boolean Il [boolean in Java](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/boolean-in-java/) viene anche chiamato valore di verità. È il tipo primitivo più semplice del linguaggio Java, poiché ammette solo due valori: **“vero” o “falso”**. Viene utilizzato qualora sia necessario esprimere una condizione logica e, pertanto, appartiene al gruppo dei tipi di dati logici. Nelle espressioni, i valori di un boolean soddisfano sempre una condizione, che può essere vera (true) o falsa (false). Qualora non si assegni alcun valore al boolean, questo risulta automaticamente falso. Il boolean può essere usato con [operatori Java](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/operatori-java/) quali [AND e OR](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/operatori-java-and-e-or/). L’assegnazione funziona secondo questo principio: ```java public class Main { public static void main(String[] args) { boolean x = true; System.out.println(x); } } ``` L’output generato dal [comando Java](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/comandi-java/) `System.out.prinln` sarà: ```java true ``` ## byte Il byte è il tipo di dato intero più piccolo della sua categoria. Il suo range di valori è estremamente limitato e va da **-128 a 127**. Il vantaggio, tuttavia, è che occupa solo 8 bit di memoria. Il suo nome deriva proprio da questo: per fare un byte ci vogliono 8 bit. Partendo da range di valore molto limitati, è possibile dichiarare il byte nel seguente modo: ```java public class Main { public static void main(String[] args) { byte x = 101; System.out.println(x); } } ``` L’output è il seguente: ```java 101 ``` ## short short occupa **il doppio di spazio di byte** e appartiene ai tipi primitivi meno usati. Se però byte è troppo piccolo e int troppo grande, questo tipo di dato intero può rappresentare la scelta adatta. Viene specificato come segue: ```java public class Main { public static void main(String[] args) { short x = -27412; System.out.println(x); } } ``` Il relativo output sarà: ```java -27412 ``` ## int int è il tipo di dato intero **maggiormente usato**. Presenta un vasto range di valori e occupa relativamente poca memoria. In molti casi, la sua rappresentazione in complemento a due si usa anche per applicazioni aggiuntive. Il codice è il seguente: ```java public class Main { public static void main(String[] args) { int x = 14; int y = 3; int z = x + y; System.out.println(x + " + " + y + " = " + z); } } ``` Il relativo output sarà: ```java 14 + 3 = 17 ``` ## long long è un’estensione di int ed è in grado di contenere **range di valori ancora più ampi**. Spesso basta usare int; tuttavia, se si desidera dichiarare una variabile di tipo long, sarà necessario procedere nel seguente modo: ```java public class Main { public static void main(String[] args) { long x = 47; System.out.println(x); } } ``` L’output sarà: ```java 47 ``` ## float Se desideri rappresentare frazioni di numeri reali, puoi usare due tipi di primitivi, detti anche **primitivi in virgola mobile**. float è il più piccolo dei due e occupa 32 bit. Può riportare fino a 7 cifre decimali. Tuttavia, non è particolarmente preciso e pertanto si usa solo di rado. Qualora tu abbia bisogno di usarlo comunque, viene specificato in questo modo: ```java public class Main { public static void main(String[] args) { float x = 7.22f; System.out.println(x); } } ``` Dopo il numero compare una “f” minuscola o maiuscola, per indicare al compilatore che si tratta di float e non di double. Nell’output la lettera non viene visualizzata: ```java 7.22 ``` ## double Il secondo tipo di dato in virgola mobile è double. Sebbene sia significativamente più preciso di float non garantisce risultati del tutto esatti. In alternativa, si può considerare l’utilizzo della **classe BigDecimal**. Tuttavia, se desideri comunque usare double, puoi scrivere il codice come segue: ```java public class Main { public static void main(String[] args) { double x = 7.2252; System.out.println(x); } } ``` In questo modo puoi rinunciare alla cifra in più. L’output sarà: ```java 7,2252 ``` ## char char viene usato per rappresentare un carattere di Unicode. Il valore va da ‘\\u0000’ a ‘\\uffff’, ovvero da 0 a 65535. Il tipo di dati character può quindi rappresentare **quasi tutti i caratteri europei e asiatici**. Ciascuno richiede 16 bit di memoria. In Java i valori di questo primitivo sono racchiusi tra virgolette. Il codice viene scritto in questo modo: ```java public class Main { public static void main(String[] args) { char x = '&'; System.out.println(x); } } ``` L’output ottenuto è il seguente: ```java & ``` This is a markdown version of: [https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/tipi-primitivi-di-java/](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/tipi-primitivi-di-java/) for AI/LLM consumption.