Float и Double тип данных в Java

поплавок дает вам приблизительно. 6-7 десятичных цифр точность в то время как двойной дает вам прибл. 15-16. Также диапазон чисел больше для double.

двойнику требуется 8 байт пространства для хранения, а float - всего 4 байта.

числа с плавающей запятой, также известные как действительные числа, используются при оценке выражений, требующих дробной точности. Например, вычисления, такие как квадратный корень, или трансцендентальные значения, такие как синус и косинус, приводят к значению, точность которого требует типа с плавающей запятой. Java реализует стандартный (IEEE–754) набор типов и операторов floatingpoint. Существует два типа типов с плавающей запятой: float и double, которые представляют собой числа с одной и двойной точностью, соответственно. Их ширина и диапазоны показаны здесь:

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

float

тип float задает значение с одной точностью, использующее 32 бита хранилища. Одиночная точность быстрее на некоторых процессорах и занимает вдвое меньше места, чем двойная точность, но станет неточной, когда значения будут либо очень большими, либо очень маленькими. Переменные типа float полезны, когда вам нужен дробный компонент, но не требуется большая степень точности. Например, float может быть полезен при представлении долларов и центов.

вот несколько примеров объявлений переменных float:

float hightemp, lowtemp;

двойной

двойная точность, обозначаемая ключевым словом double, использует 64 бита для хранения значения. Двойная точность фактически более быстра чем одиночная точность на некоторых самомоднейших обработчиках которые были оптимизированы для высокоскоростного математические выкладки. Все трансцендентальные математические функции, такие как sin (), cos () и sqrt( ), возвращают двойные значения. Когда вам нужно поддерживать точность во многих итеративных вычислениях или манипулировать большими числами, double-лучший выбор.

Java, похоже, имеет уклон к использованию double для вычислений, тем не менее:

Case in point программа, которую я написал ранее сегодня, методы не работали, когда я использовал float, но теперь отлично работают, когда я заменил float double (в IDE 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;
    }
}

согласно стандартам IEEE, float-это 32-битное представление реального числа, а double-64-битное представление.

в Java-программах мы обычно видим использование двойного типа данных. Это просто, чтобы избежать переполнения, поскольку диапазон чисел, которые могут быть размещены с использованием типа данных double больше, чем диапазон при использовании float.

также когда высокая точность необходима, польза двойника ободрена. Несколько методов библиотеки, которые были реализованы давным-давно все еще требуется использовать тип данных float как обязательный (то есть только потому, что он был реализован с помощью float, ничего больше!).

но если вы уверены, что ваша программа требует небольших чисел и переполнение не произойдет с использованием float, то использование float в значительной степени улучшит вашу сложность пространства, поскольку поплавки требуют половину памяти, как требуется double.

в этом примере показано, как извлечь знак (самый левый бит), экспоненту (8 следующих битов) и мантиссу (23 самых правых бита) из float в 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));

тот же подход можно использовать для double (11-битная экспонента и 52-битная мантисса).

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

кредит:http://s-j.github.io/java-float/

это даст ошибка:

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

/MyClass.java: 3: ошибка: несовместимые типы: возможное преобразование с потерями из double в float float a = 0.5;

это будет отлично работать

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

Это также будет работать отлично

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

причина : Java по умолчанию хранит реальные числа как двойные, чтобы обеспечить более высокую точность.

Double занимает больше места но более точный во время вычисления и поплавка занимает меньше места, но менее точный.