Float et double type de données en Java

Un flotteur vous donne env. 6-7 chiffres décimaux précision tandis qu'un double vous donne env. 15-16. En outre, la plage de nombres est plus grande pour le double.

Un double a besoin de 8 octets d'espace de stockage alors qu'un float n'a besoin que de 4 octets.

Les nombres à virgule flottante, également appelés nombres réels, sont utilisés lors de l'évaluation d'expressions nécessitant une précision fractionnaire. Par exemple, des calculs tels que la racine carrée, ou des transcendantaux tels que le sinus et le cosinus, aboutissent à une valeur dont la précision nécessite un type à virgule flottante. Java implémente l'ensemble standard (IEEE–754) de types et d'opérateurs floatingpoint. Il existe deux types de types à virgule flottante, float et double, qui représentent des nombres à simple et à double précision, respectivement. Leur largeur et leurs plages sont indiquées ici:

   Name     Width in Bits   Range 
    double  64              1 .7e–308 to 1.7e+308
    float   32              3 .4e–038 to 3.4e+038

float

Le type float spécifie une valeur de précision unique qui utilise 32 bits de stockage. La simple précision est plus rapide sur certains processeurs et prend moitié moins d'espace que la double précision, mais deviendra imprécise lorsque les valeurs sont très grandes ou très petites. Les variables de type float sont utiles lorsque vous avez besoin d'un composant fractionnaire, mais ne nécessitent pas un grand degré de précision. Par exemple, float peut être utile pour représenter des dollars et des cents.

Voici quelques exemples de déclarations de variables flottantes:

Float hightemp, lowtemp;

double

Double précision, comme indiqué par le mot-clé double, utilise 64 bits pour stocker une valeur. La double précision est en fait plus rapide que la simple précision sur certains processeurs modernes optimisés pour les calculs mathématiques à grande vitesse. Toutes les fonctions mathématiques transcendantales, telles que le péché( ), cos () et sqrt () renvoient des valeurs doubles. Lorsque vous devez maintenir la précision sur de nombreux calculs itératifs, ou que vous manipulez des nombres à grande valeur, double est le meilleur choix.

Java semble néanmoins avoir un biais vers l'utilisation du double pour les calculs:

Exemple le programme que j'ai écrit plus tôt aujourd'hui, les méthodes ne fonctionnaient pas quand j'utilisais float, mais fonctionnent maintenant très bien quand j'ai remplacé float par double (dans l'EDI NetBeans):

package palettedos;
import java.util.*;

class Palettedos{
    private static Scanner Z = new Scanner(System.in);
    public static final double pi = 3.142;

    public static void main(String[]args){
        Palettedos A = new Palettedos();
        System.out.println("Enter the base and height of the triangle respectively");
        int base = Z.nextInt();
        int height = Z.nextInt();
        System.out.println("Enter the radius of the circle");
        int radius = Z.nextInt();
        System.out.println("Enter the length of the square");
        long length = Z.nextInt();
        double tArea = A.calculateArea(base, height);
        double cArea = A.calculateArea(radius);
        long sqArea = A.calculateArea(length);
        System.out.println("The area of the triangle is\t" + tArea);
        System.out.println("The area of the circle is\t" + cArea);
        System.out.println("The area of the square is\t" + sqArea);
    }

    double calculateArea(int base, int height){
        double triArea = 0.5*base*height;
        return triArea;
    }

    double calculateArea(int radius){
        double circArea = pi*radius*radius;
        return circArea;
    }

    long calculateArea(long length){
        long squaArea = length*length;
        return squaArea;
    }
}

Selon les normes IEEE, float est une représentation 32 bits d'un nombre réel tandis que double est une représentation 64 bits.

Dans les programmes Java, nous voyons généralement l'utilisation du double type de données. C'est juste pour éviter les débordements car la plage de nombres pouvant être hébergée à l'aide du type de données double est plus grande que la plage lorsque float est utilisé.

En outre, lorsque la haute précision est requise, l'utilisation du double est encouragée. Peu de méthodes de bibliothèque qui ont été implémentées il y a longtemps nécessite toujours l'utilisation du type de données float comme un must (c'est seulement parce qu'il a été implémenté en utilisant float, rien d'autre!).

Mais si vous êtes certain que votre programme nécessite de petits nombres et qu'un débordement ne se produira pas avec votre utilisation de float, alors l'utilisation de float améliorera largement votre complexité spatiale car les floats nécessitent la moitié de la mémoire requise par double.

Cet exemple illustre comment extraire le signe (le bit le plus à gauche), l'exposant (les 8 bits suivants) et la mantisse (les 23 bits les plus à droite) d'un flotteur en Java.

int bits = Float.floatToIntBits(-0.005f);
int sign = bits >>> 31;
int exp = (bits >>> 23 & ((1 << 8) - 1)) - ((1 << 7) - 1);
int mantissa = bits & ((1 << 23) - 1);
System.out.println(sign + " " + exp + " " + mantissa + " " +
  Float.intBitsToFloat((sign << 31) | (exp + ((1 << 7) - 1)) << 23 | mantissa));

La même approche peut être utilisée pour les doubles (exposant 11 bits et mantisse 52 bits).

long bits = Double.doubleToLongBits(-0.005);
long sign = bits >>> 63;
long exp = (bits >>> 52 & ((1 << 11) - 1)) - ((1 << 10) - 1);
long mantissa = bits & ((1L << 52) - 1);
System.out.println(sign + " " + exp + " " + mantissa + " " +
  Double.longBitsToDouble((sign << 63) | (exp + ((1 << 10) - 1)) << 52 | mantissa));

Crédit: http://s-j.github.io/java-float/

Cela donnera une erreur:

public class MyClass {
    public static void main(String args[]) {
        float a = 0.5;
    }
}

/Maclasse.java: 3: erreur: types incompatibles: conversion avec perte possible de double en float float a = 0,5;

Cela fonctionne parfaitement bien

public class MyClass {
    public static void main(String args[]) {
        double a = 0.5;
    }
}

Cela fonctionnera également parfaitement beaux -

public class MyClass {
    public static void main(String args[]) {
        float a = (float)0.5;
    }
}

Reason : Java stocke par défaut les nombres réels en double pour assurer une plus grande précision.

Double prend plus d'espace mais plus précis pendant le calcul et float prend moins d'espace mais moins précise.