Représentant les valeurs flottantes en Java

Regard sur les trois lignes de code ci-dessous.

  float f = 1;

  float g = 1.1;

  float h = 1.1f;

Deuxième ligne a des erreurs de compilation, tandis que les autres lignes n'ont pas les erreurs de compilation. La première ligne fonctionne très bien sans suffixe f et de la troisième ligne est de travailler avec le suffixe f. Pourquoi est-ce?

OriginalL'auteur Abhishek Jain | 2010-06-13

  1. 21

    Virgule flottante littéraux en Java est un double valeur par défaut.

    JLS 3.10.2 à virgule Flottante Littéraux

    A floating-point littéral est de type float si il est suffixé par un ASCII de la lettre F ou f; autrement, son type est double et en option, il peut être suffixé par un ASCII de la lettre D ou d.

    Vous ne pouvez pas affecter un double de la valeur à un float sans explicitement un rétrécissement de conversion. Vous avez donc deux options:

    • Pour les littéraux, utiliser le suffixe f ou F pour désigner un float valeur
    • Pour les non-littéraux, utiliser un cast explicite (float)

    Un exemple de ce dernier est:

    double d = 1.1;
float f = (float) d; //compiles fine!

    Sur l'élargissement des conversions

    La raison pour laquelle cette compile:

    float f = 1;

    est parce que l'élargissement de conversion de int à float peut être fait implicitement dans le cadre d'une cession.

    JLS 5.2 Affectation de Conversion

    Cession de conversion se produit lorsque la valeur d'une expression est affectée à une variable: le type de l'expression doit être converti dans le type de la variable. Affectation des contextes de permettre l'utilisation de l'une des opérations suivantes:

    • un élargissement des primitives de conversion (§5.1.2)
    • [...]

    JLS 5.1.2 l'Élargissement des Primitives de Conversion

    Les 19 conversions spécifiques sur les types primitifs sont appelés les élargissement primitive conversions:

    • int à long, float, ou double
    • [...]

    Autre type de données suffixe pour les littéraux

    Comme mentionné ci-dessus, il y a aussi le D ou d suffixe pour double. Considérons cet extrait par exemple:

    static void f(int i) {
    System.out.println("(int)");
}
static void f(double d) {
    System.out.println("(double)");
}

//...
f(1);   //prints "(int)"
f(1D);  //prints "(double)"

    Il y a aussi un suffixe pour long littéraux, qui est L ou l (lettre minuscule). Il est fortement recommandé que vous utilisez les majuscules variante.

    JLS 3.10.1 les Littéraux Entiers

    Un entier littéral est de type long si il est suffixé par un ASCII de la lettre L ou l (ell); sinon, il est de type int. Le suffixe L est préféré, car la lettre l (ell) est souvent difficile à distinguer du chiffre 1 (one).

    OriginalL'auteur polygenelubricants

  2. 7

    Vous êtes l'affectation d'un double de la valeur à un float variable. 1.1 par lui-même (sans le f cloué sur la fin) qui est utilisé par le compilateur pour être de type double. Le compilateur n'aime pas faire implicite downcasts car il y a du potentiel là pour perdre de la précision.

    (Pour être plus explicite - les constantes en virgule flottante en Java sont double par défaut, sauf si elles incluent la f sur la fin ce qui les rend float.)

    OriginalL'auteur Bill the Lizard

  3. 0

    Première ligne autocasts int en float (ok).

    Deuxième ligne ne peuvent pas chasser double flotter à cause de la perte de précision. Vous avez à jeter:

    float g = (float) 1.1;

    Troisième ligne, n'a pas besoin de convertir.

    OriginalL'auteur Arne Deutsch

  4. 0

    En Java, chaque nombre à virgule flottante (n'importe quel nombre avec une virgule) la valeur par défaut d'un double, qui est plus précis qu'un float. Et par défaut, Java ne vous permet pas de convertir un double à un float en raison de la perte de précision.

    Vous pouvez toujours affecter une double à un float par casting:

    float g = (float) 1.1;

    OriginalL'auteur Justin Ardini