Float и double datatype в Java

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

Двойнику требуется 8 байт дискового пространства, а поплавку-всего 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 hightemp, lowtemp;

double

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

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

Пример В программе, которую я написал ранее сегодня, методы не работали, когда я использовал 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.

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

Но если вы уверены, что ваша программа требует небольших чисел и переполнение не произойдет при использовании float, то использование float значительно улучшит вашу пространственную сложность, поскольку floats требует половину памяти, как требуется 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));

Тот же подход может быть использован для двойников (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 занимает больше места, но более точно при вычислении, а float занимает меньше места, но менее точный.