1. Nombres à virgule flottante
Supposons que vous décidiez d’écrire une calculatrice très simple. Ou n’importe quel autre programme nécessitant des calculs (du simple comptage d’argent à une physique complexe). Tout n’est pas un nombre entier dans la vie réelle – et il faut faire avec !
Armons-nous donc d’un nouveau type de données !
En programmation, les nombres fractionnaires sont aussi appelés nombres réels, ou nombres à virgule flottante (floating-point). En Java, comme dans la plupart des langages, ils servent à stocker non seulement des entiers, mais aussi des valeurs « fractionnaires » telles que 3.14, -28.57, 2.718281828...
Les nombres à virgule flottante existent en deux types principaux :
| Type | Contient | Plage de valeurs (approx.) | Précision | Taille typique |
|---|---|---|---|---|
|
Nombres | ±1.5 × 10-45 ... ±3.4 × 1038 | ≈7 décimales | 4 octets |
|
Nombres | ±5.0 × 10-324 ... ±1.7 × 10308 | ≈15–16 décimales | 8 octets |
Type float
Le type float tient son nom de floating-point number — nombre à virgule flottante. Les nombres réels appartiennent aux mathématiques et ont des propriétés bien définies, alors que l’ordinateur a beaucoup de contraintes. Il n’est donc pas tout à fait correct d’appeler les nombres fractionnaires en Java des nombres réels. On parle plutôt de « nombres à virgule flottante ».
Le type float stocke généralement 7 chiffres significatifs (par exemple, 0.1234567), un exposant en base dix et occupe 4 octets en mémoire. C’est trop peu pour des calculs précis, c’est pourquoi tout le monde est rapidement passé à la double précision.
Type double
Le type double tire son nom de la double précision. Il occupe 8 octets en mémoire (2 fois plus que float) et peut stocker jusqu’à 15 chiffres significatifs : 0.123456789012345. C’est largement suffisant pour la plupart des calculs avec des nombres fractionnaires ; double est donc le type principal pour stocker des nombres à virgule flottante en Java.
Dans la présente leçon, l’accent sera mis sur le type double : il est recommandé par défaut pour tous les nombres « ordinaires » à virgule flottante. Nous évoquerons toutefois aussi le type float.
2. Déclaration et initialisation de variables de type double
C’est comme avec int — sauf qu’on utilise désormais double.
// Déclarons une variable et lui affectons la valeur de pi
double pi = 3.1415926;
// On peut aussi déclarer sans initialisation
double averageSalary;
averageSalary = 91234.56;
// On peut calculer !
double pizzaPieces = 8;
double friends = 3;
double piecesPerFriend = pizzaPieces / friends; // 2.666... (et non 2)
Particularités de la syntaxe :
- Le séparateur décimal est le point (3.14). Si vous utilisez la virgule, vous obtiendrez une erreur de compilation !
- À strictement parler, en écrivant double d = 3;, vous n’aurez pas d’erreur — les types sont convertis automatiquement (l’entier devient un « flottant » sans perte).
3. Entrée et sortie de nombres à virgule flottante avec Scanner
Commençons par afficher un nombre à virgule flottante :
double amount = 42.75;
System.out.println(amount); // Affiche: 42.75
Très bien ! Et si on ajoute du texte :
System.out.println("Sur votre compte: " + amount + " euros."); // Sur votre compte: 42.75 euros.
Saisie au clavier
Pour lire un double, utilisez la méthode dédiée de la classe Scanner : console.nextDouble().
Scanner console = new Scanner(System.in);
System.out.println("Entrez la température extérieure:");
double temperature = console.nextDouble(); // On lit directement un double
System.out.println("Il fait actuellement: " + temperature + " degrés.");
4. Le type double en action : arithmétique
Toutes les opérations habituelles (+, -, *, /) fonctionnent comme pour int :
double distance = 100.5;
double time = 2.0;
double speed = distance / time; // 50.25
System.out.println("Vitesse moyenne: " + speed); // Vitesse moyenne: 50.25
Voilà pour l’arithmétique. Seule différence : le résultat d’une division est toujours un nombre à virgule flottante si au moins un des opérandes est un double.
Comparaison avec int
int a = 5, b = 2;
System.out.println(a / b); // 2 (le reste est ignoré)
double aa = 5, bb = 2;
System.out.println(aa / bb); // 2.5
5. Erreurs et bizarreries typiques avec double
Erreur de conversion de saisie
Cas classique : l’utilisateur saisit 3,14 alors que le programme attend 3.14. En Java, la méthode Scanner.nextDouble() dépend de la locale courante : dans une locale russe/allemande, la virgule est admise ; dans une locale anglaise, il faut un point. Au besoin, configurez la locale du Scanner ou lisez une chaîne et analysez-la manuellement.
// Cela posera un problème en Locale.US si l'utilisateur saisit "3,14"
double value = console.nextDouble();
Erreur d’« imprécision » des nombres en informatique
C’est ici que les débutants ressentent généralement un léger étonnement :
double x = 0.1 + 0.2;
System.out.println(x); // Hmm... 0.30000000000000004
Félicitations, vous venez de rencontrer la « magie » de la représentation des nombres fractionnaires en machine. En effet, beaucoup de nombres ne peuvent pas être représentés exactement en binaire. Ce n’est en général pas critique pour la plupart des applications, mais il y a des nuances en finance et dans les sciences exactes.
6. Important : double et int — conversions implicites et explicites
Il arrive que vous additionniez un entier et un flottant, ou que vous affectiez un int à une variable double — il n’y aura pas d’erreur :
int i = 2;
double d = i; // Tout va bien !
System.out.println(d); // 2
double dd = 3.7;
int ii = (int) dd; // Il faut convertir explicitement le type double en type int !
System.out.println(ii); // 3, la partie fractionnaire a été tronquée
Cela surprend souvent — pourquoi la partie fractionnaire disparaît-elle après conversion ? Tout simplement parce que le type int ne sait pas stocker des fractions (tout ce qui est après le point disparaît définitivement).
Plus de détails sur la conversion de double vers int et l’opérateur (int) dans la prochaine leçon.
7. Sortie formatée : afficher joliment double
Souvent, par défaut, un double s’affiche avec plein de zéros superflus. On peut formater la sortie :
double temp = 23.56789;
System.out.println(temp); // 23.56789
// 2 décimales
System.out.println(String.format("%.2f", temp)); // 23.57
// 1 décimale
System.out.println(String.format("%.1f%n", temp)); // 23.6
| Format | Résultat | Description |
|---|---|---|
|
23.57 | nombre avec 2 décimales |
|
23.6 | nombre avec 1 décimale |
8. Erreurs typiques avec float et double
Erreur n°1 : conversion implicite de double en float
float f = 1.23; // Erreur !
Le compilateur ne sera pas content : « Tu essaies de mettre un double dans un float — cela peut entraîner une perte de précision ! » Ajoute toujours le suffixe f.
Erreur n°2 : oublier que la division de deux int produit un résultat int
int a = 7, b = 2;
double result = a / b; // 3.0, et non 3.5
Pour obtenir une partie fractionnaire, convertissez explicitement au moins un des opérandes :
double result = (double) a / b; // 3.5
Erreur n°3 : comparaison de nombres à virgule flottante
Ne comparez pas des nombres à virgule flottante avec ==. Utilisez une comparaison avec une petite tolérance (epsilon).
Erreur n°4 : perte de précision avec float
N’enregistrez pas de grands nombres ou des valeurs très précises dans un float — ils peuvent « se casser » ou perdre des chiffres importants.
GO TO FULL VERSION