Introduction aux primitives Java

1. Vue d'ensemble

Le langage de programmation Java comprend huit types de données primitifs.

Dans cet article, nous allons rappeler ce que sont les primitives et les passer en revue.

2. Types de données primitifs

Les huit primitives définies en Java sont int , byte , short , long , float , double , boolean et char - elles ne sont pas considérées comme des objets et représentent des valeurs brutes.

Ils sont stockés directement sur la pile (consultez cet article pour plus d'informations sur la gestion de la mémoire en Java).

Jetons un coup d'œil à la taille de stockage, aux valeurs par défaut et à des exemples d'utilisation de chaque type.

Commençons par une référence rapide:

Type Taille (bits) Le minimum Maximum Exemple
octet 8 -27 27-1 octet b = 100;
court 16 -215 215– 1 court s = 30_000;
int 32 -231 231– 1 int i = 100_000_000;
longue 64 -263 263– 1 long l = 100_000_000_000_000;
flotte 32 -2-149 (2-2-23) · 2127 flotteur f = 1,456f;
double 64 -2-1074 (2-2-52) · 21023 double f = 1,456789012345678;
carboniser 16 0 216– 1 char c = 'c';
booléen 1 - - booléen b = vrai;

2.1. int

Le premier type de données primitif que nous allons couvrir est int . Également connu sous le nom d'entier, le type int contient une large gamme de valeurs numériques non fractionnaires.

Plus précisément, Java le stocke en utilisant 32 bits de mémoire . En d'autres termes, il peut représenter des valeurs comprises entre -2 147 483 648 (-231) et 2 147 483 647 (231-1).

Dans Java 8, il est possible de stocker une valeur entière non signée jusqu'à 4 294 967 295 (232-1) en utilisant de nouvelles fonctions d'assistance spéciales.

Nous pouvons simplement déclarer un int simplement:

int x = 424_242; int y;

La valeur par défaut d'un int déclaré sans affectation est 0.

Si la variable est définie dans une méthode, nous devons attribuer une valeur avant de pouvoir l'utiliser.

Nous pouvons effectuer toutes les opérations arithmétiques standard sur int s. Sachez simplement que les valeurs décimales seront coupées lors de leur exécution sur des entiers.

2.2. octet

byte est un type de données primitif similaire à int , sauf qu'il ne prend que 8 bits de mémoire . Ainsi, pourquoi nous l'appelons un octet. La taille de la mémoire étant si petite, l' octet ne peut contenir que les valeurs comprises entre -128 (-27) et 127 (27 - 1).

Nous pouvons créer un octet :

byte b = 100; byte empty;

La valeur par défaut de byte est également 0.

2.3. court

Le prochain arrêt sur notre liste de types de données primitifs en Java est court .

Si nous voulons économiser de la mémoire et que l' octet est trop petit, nous pouvons utiliser le type à mi-chemin entre les deux: short .

À 16 bits de mémoire, c'est la moitié de la taille de int et deux fois la taille de l' octet . Sa plage de valeurs possibles va de -32 768 (-215) à 32 767 (215 - 1).

short est déclaré comme ceci:

short s = 202_020; short s;

Également similaire aux autres types, la valeur par défaut est 0. Nous pouvons également utiliser toute l'arithmétique standard dessus.

2.4. longue

Notre dernier type de données primitif lié aux entiers est long .

long est le grand frère de int . Il est stocké dans 64 bits de mémoire afin de pouvoir contenir un ensemble beaucoup plus grand de valeurs possibles.

Les valeurs possibles d'un long sont comprises entre -9 223 372 036 854 775 808 (-263) et 9 223 372 036 854 775 807 (263 - 1).

Nous pouvons simplement en déclarer un:

long l = 1_234_567_890; long l;

Comme pour les autres types d'entiers, la valeur par défaut est également 0. Nous pouvons utiliser toute l'arithmétique sur long qui fonctionne sur int .

2.5. flotte

Nous représentons les nombres fractionnaires de base en Java en utilisant le type float . Il s'agit d'un nombre décimal simple précision. Ce qui signifie que si nous dépassons six décimales, ce nombre devient moins précis et davantage une estimation.

Dans la plupart des cas, nous ne nous soucions pas de la perte de précision. Mais, si notre calcul nécessite une précision absolue (ie, opérations financières, atterrissage sur la lune, etc.), nous devons utiliser des types spécifiques conçus pour ce travail. Pour plus d'informations, consultez la classe Java 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).

Heureusement, Java peut effectuer cette conversion pour nous automatiquement. Nous appelons ce processus Autoboxing . Voici un exemple:

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

3. Conclusion

Dans ce didacticiel, nous avons couvert les huit types de données primitifs pris en charge en Java.

Ce sont les blocs de construction utilisés par la plupart des programmes Java, mais pas tous - il vaut donc la peine de comprendre comment ils fonctionnent.