Float en dubbel datatype in Java

Het float-gegevenstype is een 32-bits IEEE 754-zwevende komma met enkele precisie en het dubbele gegevenstype is een 64-bits IEEE 754-zwevende komma met dubbele precisie.

Wat betekent het? En wanneer moet ik float gebruiken in plaats van double of vice versa?


Antwoord 1, autoriteit 100%

De Wikipedia-paginaerop is een goede plek om te beginnen.

Samenvattend:

  • floatwordt weergegeven in 32 bits, met 1 tekenbit, 8 bits exponent en 23 bits van de significand (of wat volgt uit een wetenschappelijke notatie: 2.33728*10 12; 33728 is de betekenis).

  • doublewordt weergegeven in 64 bits, met 1 tekenbit, 11 bits exponent en 52 bits significant.

Java gebruikt standaard doubleom zijn drijvende-kommagetallen weer te geven (dus een letterlijke 3.14wordt doublegetypt). Het is ook het gegevenstype dat u een veel groter bereik van getallen geeft, dus ik zou het gebruik ervan via floatten zeerste aanmoedigen.

Er kunnen bepaalde bibliotheken zijn die uw gebruik van floatafdwingen, maar in het algemeen – tenzij u kunt garanderen dat uw resultaat klein genoeg zal zijn om in floatte passen’ s voorgeschreven bereik, dan kunt u het beste kiezen met double.

Als je nauwkeurigheid nodig hebt, kun je bijvoorbeeld geen decimale waarde hebben die onnauwkeurig is (zoals 1/10 + 2/10), of je doet allesmet valuta (bijvoorbeeld $ 10,33 in het systeem), gebruik dan een BigDecimal, die een willekeurige hoeveelheid precisie kan ondersteunen en dergelijke situaties elegant kan afhandelen.


Antwoord 2, autoriteit 28%

Een float geeft je ongeveer. 6-7 decimale cijfers precisie, terwijl een dubbele geeft u ongeveer. 15-16. Ook is het bereik van getallen groter voor dubbel.

Een double heeft 8 bytes opslagruimte nodig, terwijl een float slechts 4 bytes nodig heeft.


Antwoord 3, autoriteit 5%

Zwevende-kommagetallen, ook wel reële getallen genoemd, worden gebruikt bij het evalueren van uitdrukkingen die fractionele precisie vereisen. Berekeningen zoals vierkantswortel of transcendentale waarden zoals sinus en cosinus resulteren bijvoorbeeld in een waarde waarvan de precisie een zwevend-kommatype vereist. Java implementeert de standaard (IEEE 754) reeks drijvende-kommatypen en operators. Er zijn twee soorten drijvende-kommatypen, float en double, die respectievelijk enkele en dubbele precisiegetallen vertegenwoordigen. Hun breedte en bereiken worden hier getoond:

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

zweven

Het type float specificeert een enkele-precisiewaarde die 32 bits opslag gebruikt. Enkele precisie is sneller op sommige processors en neemt half zoveel ruimte in beslag als dubbele precisie, maar wordt onnauwkeurig wanneer de waarden erg groot of erg klein zijn. Variabelen van het type float zijn handig wanneer u een fractionele component nodig hebt, maar geen grote mate van precisie vereist.

Hier zijn enkele voorbeelden van declaraties van float-variabelen:

drijven op hoge temperatuur, lage temperatuur;

dubbel

Dubbele precisie, zoals aangegeven door het dubbele sleutelwoord, gebruikt 64 bits om een ​​waarde op te slaan. Dubbele precisie is eigenlijk sneller dan enkele precisie op sommige moderne processors die zijn geoptimaliseerd voor snelle wiskundige berekeningen. Alle transcendentale wiskundige functies, zoals sin(), cos() en sqrt(), retourneren dubbele waarden. Wanneer u de nauwkeurigheid van veel iteratieve berekeningen moet behouden of grote getallen moet manipuleren, is dubbel de beste keuze.


Antwoord 4

Dit geeft een foutmelding:

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

/MyClass.java:3: fout: incompatibele typen: mogelijke conversie met verlies van double naar float
zweven a = 0,5;

Dit werkt prima

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

Dit werkt ook prima

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

Reden: Java slaat standaard reële getallen op als dubbel om een ​​hogere nauwkeurigheid te garanderen.

Double neemt meer ruimte in maar is nauwkeuriger tijdens de berekening en float neemt minder ruimte in maar minder nauwkeurig.


Antwoord 5

Java lijkt toch een voorkeur te hebben voor het gebruik van dubbel voor berekeningen:

Bijvoorbeeld het programma dat ik eerder vandaag schreef, de methoden werkten niet toen ik float gebruikte, maar werken nu prima wanneer ik float verving door double (in de NetBeans IDE):

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

Antwoord 6

Volgens de IEEE-normen is float een 32-bits weergave van een reëel getal, terwijl double een 64-bits weergave is.

In Java-programma’s zien we normaal gesproken het gebruik van dubbele gegevenstypen. Het is alleen bedoeld om overflows te voorkomen, aangezien het bereik van getallen dat kan worden ondergebracht met het dubbele gegevenstype groter is dan het bereik wanneer float wordt gebruikt.

Ook wanneer hoge precisie vereist is, wordt het gebruik van dubbel aangemoedigd. Weinig bibliotheekmethoden die lang geleden zijn geïmplementeerd, vereisen nog steeds het gebruik van het gegevenstype float als een must (dat is alleen omdat het is geïmplementeerd met float, niets anders!).

Maar als je er zeker van bent dat je programma kleine aantallen nodig heeft en er geen overflow zal optreden bij het gebruik van float, dan zal het gebruik van float je ruimtecomplexiteit grotendeels verbeteren, aangezien floats de helft van het geheugen nodig hebben, zoals vereist door double.


Antwoord 7

Dit voorbeeld illustreert hoe je het teken (het meest linkse bit), exponent (de 8 volgende bits) en mantisse (de 23 meest rechtse bits) uit een float in Java kunt extraheren.

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

Dezelfde benadering kan worden gebruikt voor double’s (11 bit exponent en 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));

Credit: http://sj.github.io/java-float/


Antwoord 8

Je moet dubbel gebruiken in plaats van float voor nauwkeurige berekeningen, en float in plaats van dubbel als je minder nauwkeurige berekeningen gebruikt. Float bevat alleen decimale getallen, maar double bevat een IEEE754 dubbel-precisie drijvende-kommagetal, waardoor het gemakkelijker wordt om getallen nauwkeuriger te bevatten en te berekenen. Ik hoop dat dit helpt.


Antwoord 9

In reguliere programmeerberekeningen gebruiken we geen float. Als we ervoor zorgen dat het resultaatbereik binnen het bereik van het float-gegevenstype valt, kunnen we een float-gegevenstype kiezen om geheugen te besparen. Over het algemeen gebruiken we dubbel om twee redenen:-

  • Als we het drijvende-kommagetal als float-gegevenstype willen gebruiken, moet de methodeaanroeper expliciet F of f toevoegen, omdat standaard elk getal met drijvende komma als dubbel wordt behandeld. Het verhoogt de last voor de programmeur. Als we een getal met drijvende komma gebruiken als dubbel gegevenstype, hoeven we geen achtervoegsel toe te voegen.
  • Float is een gegevenstype met enkele precisie, wat betekent dat het 4 bytes in beslag neemt. Daarom zullen we bij grote berekeningen geen volledig resultaat krijgen. Als we dubbel gegevenstype kiezen, neemt het 8 bytes in beslag en krijgen we volledige resultaten.

Zowel float- als double-gegevenstypen zijn speciaal ontworpen voor wetenschappelijke berekeningen, waarbij benaderingsfouten acceptabel zijn. Als nauwkeurigheid de belangrijkste zorg is, wordt aanbevolen om de BigDecimal-klasse te gebruiken in plaats van float of dubbele gegevenstypen. Bron:- Float en dubbele datatypes in Java

LEAVE A REPLY

Please enter your comment!
Please enter your name here

Other episodes