Introduzione a Java Primitives

1. Panoramica

Il linguaggio di programmazione Java presenta otto tipi di dati primitivi.

In questo articolo, ricorderemo cosa sono le primitive e le esamineremo.

2. Tipi di dati primitivi

Le otto primitive definite in Java sono int , byte , short , long , float , double , boolean e char - quelle non sono considerate oggetti e rappresentano valori grezzi.

Sono archiviati direttamente nello stack (consulta questo articolo per ulteriori informazioni sulla gestione della memoria in Java).

Diamo un'occhiata alle dimensioni di archiviazione, ai valori predefiniti e agli esempi di come utilizzare ciascun tipo.

Cominciamo con un rapido riferimento:

genere Dimensioni (bit) Minimo Massimo Esempio
byte 8 -27 27– 1 byte b = 100;
corto 16 -215 215– 1 breve s = 30_000;
int 32 -231 231– 1 int i = 100_000_000;
lungo 64 -263 263– 1 lungo l = 100_000_000_000_000;
galleggiante 32 -2-149 (2-2-23) · 2127 float f = 1.456f;
Doppio 64 -2-1074 (2-2-52) · 21023 doppia f = 1,456789012345678;
char 16 0 216– 1 char c = 'c';
booleano 1 - - booleano b = vero;

2.1. int

Il primo tipo di dati primitivo che tratteremo è int . Conosciuto anche come numero intero, il tipo int contiene un'ampia gamma di valori numerici non frazionari.

In particolare, Java lo memorizza utilizzando 32 bit di memoria . In altre parole, può rappresentare valori da -2.147.483.648 (-231) a 2.147.483.647 (231-1).

In Java 8, è possibile memorizzare un valore intero senza segno fino a 4.294.967.295 (232-1) utilizzando nuove funzioni di supporto speciali.

Possiamo semplicemente dichiarare un int semplicemente:

int x = 424_242; int y;

Il valore predefinito di un int dichiarato senza un'assegnazione è 0.

Se la variabile è definita in un metodo, dobbiamo assegnare un valore prima di poterla utilizzare.

Possiamo eseguire tutte le operazioni aritmetiche standard su int s. Basta essere consapevoli che i valori decimali verranno tagliati quando li si esegue su numeri interi.

2.2. byte

byte è un tipo di dati primitivo simile a int , tranne per il fatto che occupa solo 8 bit di memoria . Quindi, perché lo chiamiamo byte. Poiché la dimensione della memoria è così piccola, byte può contenere solo i valori da -128 (-27) a 127 (27-1).

Possiamo creare byte :

byte b = 100; byte empty;

Anche il valore predefinito di byte è 0.

2.3. corto

La prossima tappa nel nostro elenco di tipi di dati primitivi in ​​Java è breve .

Se vogliamo risparmiare memoria e il byte è troppo piccolo, possiamo usare il tipo a metà tra i due: short .

A 16 bit di memoria, è la metà della dimensione di int e due volte la dimensione del byte . Il suo intervallo di valori possibili è compreso tra -32.768 (-215) e 32.767 (215 - 1).

short è dichiarato così:

short s = 202_020; short s;

Anche simile agli altri tipi, il valore predefinito è 0. Possiamo usare anche tutta l'aritmetica standard su di esso.

2.4. lungo

Il nostro ultimo tipo di dati primitivo relativo agli interi è lungo .

long è il fratello maggiore di int . È archiviato in 64 bit di memoria in modo che possa contenere un insieme significativamente più ampio di valori possibili.

I possibili valori di un long sono compresi tra -9.223.372.036.854.775.808 (-263) e 9.223.372.036.854.775.807 (263 - 1).

Possiamo semplicemente dichiararne uno:

long l = 1_234_567_890; long l;

As with other integer types, the default is also 0. We can use all arithmetic on long that works on int.

2.5. float

We represent basic fractional numbers in Java using the float type. This is a single-precision decimal number. Which means if we get past six decimal points, this number becomes less precise and more of an estimate.

In most cases, we don't care about the precision loss. But, if our calculation requires absolute precision (i.e., financial operations, landing on the moon, etc.) we need to use specific types designed for this work. For more information, check out the Java class Big Decimal.

This type is stored in 32 bits of memory just like int. However, because of the floating decimal point its range is much different. It can represent both positive and negative numbers. The smallest decimal is 1.40239846 x 10-45, and the largest value is 3.40282347 x 1038.

We declare floats the same as any other type:

float f = 3.145f; float f;

And the default value is 0.0 instead of 0. Also, notice we add the f designation to the end of the literal number to define a float. Otherwise, Java will throw an error because the default type of a decimal value is double.

We can also perform all standard arithmetic operations on floats. However, it's important to note that we perform floating point arithmetic very differently than integer arithmetic.

2.6. double

Next, we look at double – its name comes from the fact that it's a double-precision decimal number.

It's stored in 64 bits of memory. Which means it represents a much larger range of possible numbers than float.

Although, it does suffer from the same precision limitation as float does. The range is 4.9406564584124654 x 10-324 to 1.7976931348623157 x 10308. That range can also be positive or negative.

Declaring double is the same as other numeric types:

double d = 3.13457599923384753929348D; double d;

The default value is also 0.0 as it is with float.Similar to float, we attach the letter D to designate the literal as a double.

2.7. boolean

The simplest primitive data type is boolean. It can contain only two values: true or false. It stores its value in a single bit.

However, for convenience, Java pads the value and stores it in a single byte.

Declare boolean like this:

boolean b = true; boolean b;

Declaring it without a value defaults to false. boolean is the cornerstone of controlling our programs flow. We can use boolean operators on them (i.e., and, or, etc.).

2.8. char

The final primitive data type to look at is char.

Also called a character, char is a 16-bit integer representing a Unicode-encoded character. Its range is from 0 to 65,535. Which in Unicode represents ‘\u0000' to ‘\uffff'.

For a list of all possible Unicode values check out sites like Unicode Table.

Let's now declare a char:

char c = 'a'; char c = 65; char c;

When defining our variables, we can use any character literal, and they will get automatically transformed into their Unicode encoding for us. A characters default value is ‘/u0000'.

2.9. Overflow

The primitive data types have size limits. But what happens if we try to store a value that's larger than the maximum value?

We run into a situation called overflow.

When an integer overflows, it rolls over to the minimum value and begins counting up from there.

Floating point number overflow by returning Infinity. When they underflow, they return 0.0.

Here's an example:

int i = Integer.MAX_VALUE; int j = i + 1; // j will roll over to -2_147_483_648 double d = Double.MAX_VALUE; double o = d + 1; // o will be Infinity

Underflow is the same issue except if we store a value smaller than the minimum value.

2.10. Autoboxing

Each primitive data type also has a full Java class implementation that can wrap it. For instance, the Integer class can wrap an int. There is sometimes a need to convert from the primitive type to its object wrapper (e.g., using them with generics).

Fortunatamente, Java può eseguire questa conversione automaticamente. Chiamiamo questo processo Autoboxing . Ecco un esempio:

Character c = 'c'; Integer i = 1;

3. Conclusione

In questo tutorial, abbiamo coperto gli otto tipi di dati primitivi supportati in Java.

Questi sono gli elementi costitutivi utilizzati dalla maggior parte, non da tutti i programmi Java in circolazione, quindi vale la pena capire come funzionano.