Mot-clé flottant Java

À un moment donné du développement de la technologie informatique, il est devenu évident que les unités centrales de traitement avaient besoin de dispositifs matériels pour traiter les nombres à virgule flottante. Aujourd’hui, toutes les architectures informatiques peuvent fonctionner efficacement avec de tels nombres. Bien entendu, dans les langages de programmation, vous ne pouvez pas non plus vous passer des types de données correspondants. Il existe deux types de données à virgule flottante en Java : float et double. Le mot clé Java Float définit un nombre réel qui occupe 32 bits en mémoire. Nous parlerons de ces chiffres dans cet article.

Nombres à virgule flottante. Comment les nombres réels sont-ils stockés dans un ordinateur ?

Pour stocker des nombres réels dans la mémoire de l'ordinateur, un certain nombre de bits sont alloués. Un nombre réel est stocké sous forme de signe (plus ou moins), de mante et d'exposant. La mantisse et l'exposant sont mieux expliqués avec un exemple. La masse approximative de la lune est de 7* 1022. Ici 7 est la mante, dans 22 l'exposant. Lors de l'affichage de grands nombres ou vice versa, de très petits nombres à l'écran, vous pouvez voir une entrée comme 7E22. Il s'agit du nombre à virgule flottante, et 7 est ici la mante, et 22 est l'exposant ou la puissance de 10. Cette notation est appelée notation exponentielle.

Mot-clé flottant Java et mot-clé double Java

Les valeurs flottantes (nombres à virgule flottante ou nombres réels) en Java sont représentées par les types float et double . Ce sont ces mots-clés qui permettent de stocker des valeurs jusqu'à un certain signe après la virgule décimale. double sont des nombres à double précision, aussi proches que possible des valeurs données ou obtenues à la suite de calculs. Java Double est utilisé pour tous les calculs mathématiques (racine carrée, sinus, cosinus, ..), ainsi que pour tous les calculs où une certaine précision est importante. Le type de données float est utilisé pour un type à virgule flottante moins précis. Il est très rarement utilisé pour économiser de la mémoire. Ci-dessous, nous avons un tableau avec les principales informations sur float et double, ainsi que leurs différences. Le mot-clé Float signifie donc un nombre, une valeur simple précision qui prend 32 bits ou 4 octets en mémoire. Sur certains processeurs, travailler avec de tels nombres est plus rapide et, comme déjà mentionné, ils prennent moins de place par rapport aux nombres à double précision. Cependant, il est impossible de le dire sans équivoque avec rapidité. Disons que certains processeurs modernes traitent plus rapidement les nombres exactement en double précision.

Java Float et double déclaration

Vous pouvez déclarer un nombre de type double de la même manière que des nombres d'autres types :

double myDouble = 2.7;

Cependant, si vous représentez un nombre à virgule flottante de cette manière, le compilateur vous demandera de modifier le type du nombre pour qu'il double. Voici un exemple incorrect de variable float :

public class FloatExample {
   public static void main(String[] args) {
//double and float variables
       double myDouble = 2.7;
       float myFloat = 3.14;
   }
}

Voici ce qui se passe si vous exécutez ce programme :

Error:(4, 25) java: incompatible types: possible lossy conversion from double to float

Le fait est qu'il n'est pas souhaitable d'utiliser des nombres flottants, et cela ne devrait être fait que pour économiser de la mémoire. Tous les nombres fractionnaires réels en Java sont Double par défaut, et la syntaxe du langage le souligne également. Si vous voulez vraiment travailler avec le type float, vous devez le spécifier explicitement avec un f terminant le nombre.

public class FloatExample {
   public static void main(String[] args) {
//double and float variables
       double myDouble = 2.7;
       float myFloat = 3.14f;
   }
}

À propos, les nombres flottants et doubles peuvent être écrits sous forme exponentielle.

float myFloat2 = 2E22f;
double myDouble2 = 3e10;

Si vous utilisez des nombres suffisamment grands dans leur représentation « normale », Java les affichera immédiatement sous forme exponentielle. Prenons un exemple :

public class FloatExample {
   public static void main(String[] args) {
//float variables
               float myFloatNumber1=2182818284590.45f;
               float myFloatNumber2=19822612787260.141592181f;
               System.out.println("myFloatNumber1 = " + myFloatNumber1);
               System.out.println("myFloatNumber2 = " + myFloatNumber2);
       System.out.println("myFloatNumber1 + myFloatNumber2 = " + myFloatNumber1 + myFloatNumber2);
           }
       }

Le résultat de ce travail de programme est ici :

Exemple de nombres flottants et doubles spéciaux

Il existe trois nombres à virgule flottante spéciaux en langage Java, qui sont utilisés pour indiquer les débordements et les erreurs. Les voici:

• L'infini positif est le résultat de la division d'un nombre positif par 0. Représenté par les constantes Double.POSITIVE_INFINITY et Float.POSITIVE_INFINITY .

• L'infini négatif est le résultat de la division d'un nombre négatif par 0. Représenté par les constantes Double.NEGATIVE_INFINITY et Float.NEGATIVE_INFINITY .

• NaN (pas un nombre) représente le calcul de 0/0 ou la racine carrée d'un nombre négatif. Représenté par les constantes Double.NaN et Float.NAN .

Voici un exemple d'utilisation de ces nombres à virgule flottante spéciaux :

public class FloatExample {
   public static void main(String[] args) {
       int myInt = 1;
       float zero = 0.0f;
       double negZero = -0.0;
       double negativeInfinity = Double.NEGATIVE_INFINITY;
       double positiveInfinity = Float.POSITIVE_INFINITY;

       System.out.println(myInt / zero);
       System.out.println(myInt / negZero);
       System.out.println(zero == negZero);
       System.out.println(negativeInfinity * 0);
       System.out.println(positiveInfinity+negativeInfinity);

   }
}

Le résultat est:

La double précision est-elle suffisante ?

En effet, malgré la double précision du type Double , utiliser des nombres à virgule flottante, par exemple, dans des calculs financiers, n'est pas la meilleure idée car les erreurs d'arrondi sont inacceptables. Essayez donc d’afficher la sortie du programme suivant à l’écran.

public class FloatExample {
   public static void main(String[] args) {
       System.out. println( "2.0 - 1.1 = " + (2.0 - 1.1));
   }
}

Vous obtiendrez le résultat suivant : Il serait logique de supposer que le résultat sera de 0,9. Cependant, de telles erreurs sont assez courantes et sont associées à la représentation binaire interne des nombres. Nous ne pouvons pas, par exemple, représenter la valeur exacte de ⅓ sous forme de fraction décimale ; bien entendu, il existe des restrictions similaires dans le système binaire. Si la tâche nécessite d'éliminer les erreurs d'arrondi, Java dispose de la classe BigDecimal pour cela.