Pourquoi Java implicitement (sans cast) convertir un `long` pour un `float`?

À chaque fois que je crois que je comprends sur le casting et les conversions, j'ai trouver un autre comportement étrange.

long l = 123456789L;
float f = l;
System.out.println(f);  //outputs 1.23456792E8

Étant donné qu'un long a une plus grande profondeur de bits qu'un float, je m'attends à ce qu'un cast explicite serait nécessaire pour que cette compilation. Et il n'est pas surprenant, nous voyons que nous avons perdu de la précision dans le résultat.

Pourquoi est une fonte pas nécessaire ici?

InformationsquelleAutor Eric Wilson | 2009-08-18
  1. 43

    La même question pourrait être posée de long à double - les deux conversions risquez de perdre des données.

    L'article 5.1.2 de la Spécification du Langage Java dit:

    Élargissement primitive conversions ne sont pas
    perdre des informations sur l'ensemble de la
    ordre de grandeur d'une valeur numérique. En effet,
    les conversions de l'élargissement de la intégrante
    type vers un autre type intégral n'
    perdre aucune information; la
    valeur numérique est conservée à l'identique.
    Les Conversions de l'élargissement de flotter à
    double dans strictfp expressions aussi
    préserver la valeur numérique exactement;
    cependant, de telles conversions qui ne sont pas
    strictfp peut perdre des informations sur
    l'ampleur globale de la conversion
    valeur.

    Conversion d'un int ou un long valeur
    flotter, ou d'une valeur de type long à
    double, qui peut entraîner la perte de
    précision-c'est, le résultat peut perdre
    certains des bits de poids faible de
    la valeur. Dans ce cas, l'
    valeur à virgule flottante sera un
    arrondie version de la
    valeur d'entier, en utilisant la norme IEEE 754
    d'arrondi au plus proche de mode (§4.2.4).

    En d'autres termes, même si vous risquez de perdre des données, vous savez que la valeur sera toujours dans l'ensemble de la gamme du type de cible.

    Le choix pourrait certainement avoir été faite à exiger que toutes les conversions implicites de ne pas perdre de l'information à tous - int et long à float aurait été explicite et long à double aurait été explicite. (int à double est correct; un double a suffisamment de précision pour représenter avec précision tous les int valeurs).

    Dans certains cas, cela aurait été utile - dans certains cas, même pas. Le langage de conception est une question de compromis; vous ne pouvez pas gagner 'em all. Je ne suis pas sûr de ce que la décision que j'aurais fait...

    • Oui, double dispose de 52 bits de mantisse, qui est plus que suffisant pour représenter avec exactitude 32 bits entiers.
    • Juste pour ajouter à cela, le flotteur a une valeur maximale d'environ 3E38 tandis que l'int est 2147483647 pour le même nombre de bits. Si vous passez cette valeur maximale d'un entier (int), l'imprimer, puis le passer à un flotteur et l'imprimer; la fois de la valeur peut être différente de ce qui est "vous risquez de perdre de l'information". long est d'environ 9E18
    InformationsquelleAutor Jon Skeet
  2. 40

    La Java Langage de Spécification, Chapitre 5: la Conversion et à la Promotion de la traite de cette question:

    5.1.2 L'Élargissement Des Primitives De Conversion

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

    • byte short, int, long, float, double ou
    • short int, long, float, double ou
    • char, int, long, float, double ou
    • int, long, float ou double
    • long float ou double
    • float double

    Élargissement primitive conversions de ne pas perdre d'informations sur l'ampleur globale d'une valeur numérique.

    ...

    Conversion d'un int ou un long valeur à flotteur, ou d'une valeur de type long double, peut entraîner une perte de précision-qui est, le résultat risque de perdre une partie des bits de poids faible de la valeur. Dans ce cas, la valeur à virgule flottante sera arrondie version de la valeur de l'entier

    Pour le dire autrement, la JLS fait la distinction entre une perte de ampleur et une perte de précision.

    int à byte par exemple est un (potentiel) de la perte de l'ampleur parce que vous ne pouvez pas stocker 500 dans un byte.

    long à float est un risque de perte de précision, mais pas de l'ampleur en raison de la fourchette de valeur pour les flotteurs est plus grande que celle de la nostalgie.

    La règle est donc:

    • Perte de grandeur: cast explicite est requis;
    • Perte de précision: pas de cast requis.

    Subtile? Assurez-vous. Mais j'espère que les efface, jusqu'.

    • Je pense qu'il serait raisonnable de penser que les conversions qui peuvent perdre de l'information nécessite un cast. Ces est avec perte de conversions, ce qui pourrait bien surprendre les développeurs. Je peux voir que c'est pratique dans certaines situations, mais peu pratique dans les autres. Je ne pense pas que c'est déraisonnable de demander à propos de ce qui pourrait semer la confusion choix si.
    • La conversion entre un lit double ou float et tous de type entier (à ou de) peut entraîner une perte de précision. Qui aurait besoin d'une conversion explicite, en tout cas. À mon humble avis ce n'est pas nécessaire.
    • Par cette logique, pourquoi un cast jamais est-elle nécessaire?
    • Serait int en double risque de perdre de l'information? J'ai pensé tout entier serait exactement représenté par un double. Évidemment, le contraire serait toujours potentiellement destructive. Compte tenu de votre raisonnement, pourquoi devrait double à long être explicite, comme c'est le cas actuellement? L'intuitif (OMI) le raisonnement est "être explicite si vous risquez de perdre de l'information" - mais cela ne veut pas tout tenir ici.
    • Je suis avec jalf.com, il semble que vous l'encontre de casting entièrement.
    • Le JLS fait la distinction entre l'ampleur et la précision. La perte de magnitude = cast explicite requis. La perte de précision = pas nécessaire. Comme pour les long double de ce qu'environ 10 litres à double?
    • Je ne suis pas contre le casting entièrement. Je suis juste contre les parasites de la coulée.
    • Je pense que le point est que cette distinction est assez subtil, alors que "ne pas perdre d'information" est beaucoup plus simple à comprendre.
    • Si l'on accepte l'idée que la virgule flottante conversions peuvent parfois causer de tort comparer comme indiscernables, mais ne devrait pas inverser le grade de choses qui ne le font pas, alors (float)1E39 sera correctement être considéré comme impossible à distinguer de quelque chose de plus grand (la préservation de l'ampleur), mais un moulage double donnera une valeur qui à tort de comparer plus de 1E308. C'est un des centaines d'ordres de grandeur d'erreur.
    • La perte de précision: pas de cast requis. Si c'est le cas, pourquoi je ne peux pas nous faire flotter un = 3.6? Où 3.6 est interprété comme un double.

    InformationsquelleAutor cletus
  3. 15

    Si vous êtes correct de dire qu'une longue utilise plus de bits en interne qu'un flotteur, le langage java fonctionne sur un élargissement de la voie:

    octet -> court> int -> long -> float -> double

    Pour convertir de gauche à droite (un élargissement de conversion), il n'y a aucune conversion n'est nécessaire (ce qui est pourquoi long à flotteur est autorisé). Pour convertir la droite vers la gauche (un rétrécissement de conversion) un cast explicite est nécessaire.

    InformationsquelleAutor Peter
  4. 2

    Quelque part, j'ai entendu cela. Le flotteur peut stocker dans la forme exponentielle comme nous l'écrire. '23500000000' est stockée en tant que '2.35e10' .Donc, le flotteur a de l'espace à occuper la gamme des valeurs de long. Le stockage dans la forme exponentielle est aussi la raison pour la perte de précision due.

    • Étant donné que cette question est de plus de cinq ans, et a plusieurs réponses à upvotes, sur plus de discussion, il semble que vous devez expliquer comment vous fournir de nouvelles informations et/ou de la façon dont les autres réponses sont insuffisantes.
    • Aucune des autres réponses semblent parler de pourquoi un float, 4 octets, peut contenir l'ampleur de 8 octets long, tandis que pour autant sacrifier la précision. Cette réponse n'est pas de répondre complètement à cette question, mais il ne s'ajouter à la discussion. Il pourrait être mieux adapté qu'un commentaire. On a besoin de la référence et de comprendre le IEEE standard for floating points je pense que pour vraiment comprendre comment cela est possible.
    • Incroyable de voir comment une question de pas de réelle importance qu'à partir de six ans (demain) attire l'intérêt aujourd'hui.
    • Comme l'a déclaré Jon Skeet, "Ces sont à perte de conversions, ce qui pourrait bien surprendre les développeurs". Cette question est encore de dessin d'intérêt aujourd'hui, car il surprises les développeurs.
    • Mon point de vue est que la vraie réponse est "C'est la façon de Java t-il." C'est pourquoi je suis surpris quand je vois l'activité ici.
    InformationsquelleAutor george