1. Quels types de nombres existent ?
En programmation, nous travaillons constamment avec des nombres — de l’âge d’un utilisateur au nombre d’étoiles dans la galaxie, ou encore les centimes sur un compte bancaire. Mais différentes tâches exigent différents types de nombres : parfois il faut ne stocker que des entiers, parfois des fractions très précises, et parfois on a besoin de nombres « sans signe moins ».
Nombres entiers (int et autres)
Un nombre entier est un nombre sans partie fractionnaire.
En Java, on utilise le plus souvent le type int, mais il en existe plusieurs variantes qui diffèrent par leur taille et leur plage de valeurs.
- int — le type de base pour les entiers. Il couvre des valeurs très grandes (et très petites) tout en ne consommant pas beaucoup de mémoire. Par exemple, pour compter les likes, l’âge, le nombre de jours dans l’année, on utilisera presque toujours int.
- long — utilisé si les valeurs peuvent être très grandes (par exemple, des milliards ou des billions). Exemple : stocker le total de toutes les vues YouTube depuis le début.
- short — un type économe mais rarement utilisé. Convient là où l’on a beaucoup de petites valeurs similaires (par exemple, des données audio, des composantes de couleur).
- byte — pour des valeurs encore plus petites, notamment en graphisme et lors de la manipulation de fichiers, où l’économie de mémoire est importante.
Nombres à virgule flottante (double, float)
Parfois, il faut travailler avec des nombres qui ont une partie fractionnaire. Par exemple, la température de l’air, la moyenne d’un étudiant, le prix d’un produit avec des centimes.
- double — le type par défaut pour stocker des nombres à virgule flottante. Suffisamment précis pour la plupart des calculs (exemple : 3.1415926535…).
- float — plus léger et moins précis, on le rencontre souvent en infographie ou pour traiter de grands volumes de données, quand l’économie de mémoire est importante.
Types numériques spécialisés
- BigInteger — pour travailler avec d’énormes nombres, au-delà des plages standard, par exemple en cryptographie ou en calculs astronomiques.
- BigDecimal — une classe pour des calculs exacts avec des nombres décimaux (finance, calcul d’intérêts), qui aide à éviter les imprécisions propres à double et float.
2. Plages de valeurs
Les types entiers peuvent stocker des nombres positifs comme négatifs. C’est pratique lorsque les valeurs peuvent être « au-dessus et au-dessous de zéro » : par exemple, la température, le solde d’un compte, l’altitude par rapport au niveau de la mer.
Exemple :
- int : -10, 0, 50
- long : 0, 10, -1000_000_000_000_000_000L
Types entiers
| Type | Taille | Plage de valeurs | Exemple d’utilisation |
|---|---|---|---|
|
1 octet | -128 à 127 | -128, 0, 127 |
|
2 octets | -32 768 à 32 767 | -1000, 0, 32000 |
|
4 octets | -2 147 483 648 à 2 147 483 647 | -1000000, 0, 2000000 |
|
8 octets | -9 223 372 036 854 775 808 à 9 223 372 036 854 775 807 |
-10_000_000_000, 1 |
Types à virgule flottante
| Type | Taille | Exemples de valeurs | Description |
|---|---|---|---|
|
4 octets | 3.14f, -0.001f | précision simple (7 chiffres) |
|
8 octets | 3.1415, -1.7E+308 | précision double (15–16 chiffres) |
3. Suffixes pour les nombres
Dans certaines situations, il faut indiquer explicitement le type que vous souhaitez utiliser pour un nombre. Cela se fait à l’aide de suffixes :
- L ou l — pour le type long (par exemple, 10000000000L)
- F ou f — pour le type float (par exemple, 3.14f)
- D ou d — pour le type double (généralement inutile, car un nombre à virgule sans suffixe est un double)
Si vous n’indiquez pas de suffixe, alors par défaut un entier est considéré comme un int, et un nombre à virgule comme un double. Par exemple, 42 est un int, et 3.14 est un double.
Pourquoi est-ce utile ? Par exemple, pour éviter une erreur lors de l’affectation d’un grand nombre à une variable de type long :
long bigNumber = 9000000000L; // si on retire le L, il y aura une erreur de compilation
Séparateur underscore _
Quand les nombres sont longs, on se perd facilement dans les zéros. Par souci de lisibilité, Java permet d’utiliser des tirets bas dans un nombre.
int population = 146_700_000;
long stars = 100_000_000_000L;
C’est parfaitement valide : le compilateur ignore les tirets bas, et vous voyez d’un coup d’œil les groupes de chiffres. L’essentiel — ne pas mettre d’underscore au début, à la fin, après le point décimal ni avant un suffixe.
4. Type caractère char : qu’est-ce que c’est et à quoi sert-il ?
Le type char est utilisé pour stocker un seul caractère : lettre, chiffre, signe de ponctuation, espace, caractère spécial et même un smiley.
Exemples :
char letter = 'A';
char digit = '7';
char symbol = '?';
char cyrillic = '\u0416';
char euro = '€';
char smile = '☺'; // Oui, c'est aussi possible !
Règles importantes :
- La valeur de type char s’écrit entre apostrophes : 'A', '7', '#'.
- C’est bien un seul caractère ! Si vous écrivez 'AB' — le compilateur protestera.
- Derrière chaque caractère se cache son code numérique (Unicode).
Unicode : des caractères du monde entier
Java utilise le standard Unicode, ce qui permet de stocker non seulement des lettres latines, mais aussi du cyrillique, des idéogrammes, des émojis et même des hiéroglyphes de l’Égypte antique (si jamais vous en avez besoin).
Fait intéressant :
Le type char est en fait un nombre 16 bits (de 0 à 65535), où chaque valeur correspond à un caractère.
5. Caractères et nombres : le lien via Unicode
Puisque chaque caractère est un nombre en interne, on peut aisément convertir un char en int et inversement.
Exemple : obtenir le code Unicode d’un caractère
public class CharToInt {
public static void main(String[] args) {
char ch = 'A';
int code = ch; // Conversion implicite char → int
System.out.println("Code du caractère '" + ch + "': " + code);
}
}
Résultat :
Code du caractère 'A': 65
Et maintenant l’inverse — obtenir un caractère à partir d’un code :
public class IntToChar {
public static void main(String[] args) {
int code = 1040; // Code du caractère 'A cyrillique' en Unicode (alphabet cyrillique)
char ch = (char) code; // Conversion explicite int → char
System.out.println("Caractère avec le code " + code + ": " + ch);
}
}
Résultat :
Caractère avec le code 1040: \u0410
6. Types primitifs principaux de Java
| Type | Taille (bits) | Plage de valeurs | Exemple de valeur | Remarque |
|---|---|---|---|---|
|
8 | -128 ... 127 | 42 | Très rarement utilisé |
|
16 | -32,768 ... 32,767 | 12345 | Pour économiser la mémoire |
|
32 | -2,147,483,648 ... 2,147,483,647 | 1000000 | Type principal pour les entiers |
|
64 | ≈ −9.22 × 1018 ... ≈ 9.22 × 1018 | 5000000000L | Pour des entiers très grands |
|
32 | ~±3.4 × 10-38 ... ±3.4 × 1038 | 3.14f | Nombres à virgule flottante, faible précision |
|
64 | ~±1.7 × 10-308 ... ±1.7 × 10308 | 2.718 | Nombres à virgule flottante, haute précision |
|
16 | 0 ... 65 535 (Unicode) | '\u0416', 'A', '?' | Un seul caractère |
|
1 | true, false | true | Valeur booléenne |
GO TO FULL VERSION