it-swarm.com.de

Float- und Double-Datentyp in Java

Der Float-Datentyp ist ein 32-Bit-Gleitkommazahl mit einfacher Genauigkeit von 32 Bit (IEEE 754) und der doppelte Datentyp ist ein 64-Bit-Gleitkommazahl nach IEEE 754 mit doppelter Genauigkeit.

Was heißt das? Und wann sollte ich Float anstelle von double oder umgekehrt verwenden?

189
Leo

Die Wikipedia-Seite ist ein guter Anfang.

Um zusammenzufassen:

  • float wird in 32 Bits mit 1 Vorzeichenbit, 8 Bits des Exponenten und 23 Bits des Signifikanden dargestellt (oder was aus einer wissenschaftlichen Notationsnummer folgt: 2.33728 * 1012; 33728 ist der Signifikand).

  • double wird in 64 Bits mit 1 Vorzeichenbit, 11 Exponentenbit und 52 Bit Signifikanz dargestellt.

Standardmäßig verwendet Java double zur Darstellung der Gleitkommazahlen (daher wird ein Literal 3.14 als double eingegeben). Es ist auch der Datentyp, der Ihnen einen viel größeren Zahlenbereich gibt, daher würde ich die Verwendung von float dringend empfehlen.

Es gibt möglicherweise bestimmte Bibliotheken, die tatsächlich die Verwendung von float erzwingen, aber im Allgemeinen - sofern Sie nicht garantieren können, dass Ihr Ergebnis klein genug ist, um in floats vorgeschriebenen Bereich zu passen, sollten Sie sich für double entscheiden.

Wenn Sie Genauigkeit verlangen - Sie können beispielsweise keinen Dezimalwert angeben, der ungenau ist (wie 1/10 + 2/10), oder Sie tun irgendetwas mit der Währung (z. B. 10,33 $ im System) und dann eine BigDecimal, das eine beliebige Präzision unterstützt und Situationen wie diese elegant beherrscht.

225
Makoto

Ein Schwimmer gibt Ihnen ca. 6 bis 7 Dezimalstellen, während ein Doppel von ca. 15-16. Auch der Zahlenbereich ist für das Doppelte größer.

Ein Double benötigt 8 Byte Speicherplatz, während ein Float nur 4 Byte benötigt.

66
Henry

Gleitkommazahlen, auch als reelle Zahlen bezeichnet, werden verwendet, um Ausdrücke auszuwerten, die eine gebrochene Genauigkeit erfordern. Beispielsweise führen Berechnungen wie Quadratwurzel oder Transzendentale wie Sinus und Cosinus zu einem Wert, dessen Genauigkeit einen Gleitkommatyp erfordert. Java implementiert den Standardsatz (IEEE-754) von Gleitkommatypen und Operatoren. Es gibt zwei Arten von Gleitkommatypen, Float und Double, die Zahlen mit einfacher bzw. doppelter Genauigkeit darstellen. Ihre Breite und Reichweite werden hier angezeigt: 


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


Schwimmer

Der Typ Float gibt einen Wert mit einfacher Genauigkeit an, der 32 Bit Speicher benötigt. Die Einzelpräzision ist bei manchen Prozessoren schneller und benötigt nur halb so viel Platz wie die Doppelgenauigkeit, wird jedoch ungenau, wenn die Werte entweder sehr groß oder sehr klein sind. Variablen vom Typ Float sind nützlich, wenn Sie eine gebrochene Komponente benötigen, jedoch keine große Genauigkeit benötigen. 

Hier einige Beispiele für Float-Variablendeklarationen:

float Hightemp, Lowtemp; 


doppelt

Doppelte Genauigkeit, wie durch das Schlüsselwort double angegeben, verwendet 64 Bit zum Speichern eines Werts. Die doppelte Genauigkeit ist bei einigen modernen Prozessoren, die für mathematische Hochgeschwindigkeitsberechnungen optimiert wurden, tatsächlich schneller als die einfache Genauigkeit. Alle transzendentalen mathematischen Funktionen wie sin (), cos () und sqrt () geben doppelte Werte zurück. Wenn Sie die Genauigkeit vieler iterativer Berechnungen beibehalten oder große Zahlen bearbeiten müssen, ist double die beste Wahl.

13
Ye Win

Java scheint eine Vorliebe für die Verwendung von Double für Berechnungen zu haben:

Beispiel für das Programm, das ich heute geschrieben habe, funktionierten die Methoden nicht, wenn ich Float verwendete, aber jetzt funktioniert es hervorragend, wenn ich Float mit double (in der NetBeans-IDE) ersetzte:

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;
    }
}
2
Raymond Wachaga

Gemäß den IEEE-Standards ist Float eine 32-Bit-Darstellung einer reellen Zahl, während double eine 64-Bit-Darstellung ist.

In Java-Programmen sehen wir normalerweise meist die Verwendung eines doppelten Datentyps. Nur um Überläufe zu vermeiden, da der Zahlenbereich, der mit dem doppelten Datentyp erstellt werden kann, mehr ist als der Bereich, wenn Float verwendet wird.

Auch wenn hohe Präzision erforderlich ist, wird die Verwendung von double empfohlen. Nur wenige Bibliotheksmethoden, die vor langer Zeit implementiert wurden, erfordern immer noch die Verwendung des Float-Datentyps (dies ist nur der Fall, weil er mit Float implementiert wurde, sonst nichts!).

Wenn Sie jedoch sicher sind, dass Ihr Programm kleine Zahlen erfordert und bei der Verwendung von Float kein Überlauf auftritt, wird die Verwendung von Float die Komplexität des Speicherplatzes erheblich verbessern, da Floats die Hälfte des Speichers benötigen, der doppelt so groß ist.

1
Rubal

Dies wird einen Fehler geben:

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

/MyClass.Java:3: Fehler: Inkompatible Typen: mögliche verlustbehaftete Konvertierung von Double in Float Float a = 0,5;

Das wird perfekt funktionieren

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

Das wird auch perfekt funktionieren

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

Grund : Java speichert reelle Zahlen standardmäßig, um eine höhere Genauigkeit zu gewährleisten. 

Double benötigt mehr Platz, aber präziser bei der Berechnung und Float benötigt weniger Platz, aber weniger Präzision.

0
Himanshu Singh

Dieses Beispiel zeigt, wie das Vorzeichen (das ganz linke Bit), der Exponent (die 8 folgenden Bits) und die Mantisse (die 23 ganz rechten Bits) aus einem Float in Java extrahiert werden.

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));

Der gleiche Ansatz kann für doppelte Werte verwendet werden (11-Bit-Exponent und 52-Bit-Mantisse).

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));

Bildnachweis: http://s-j.github.io/Java-float/

0
acohen