Float и Double тип данных в 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:

float hightemp, lowtemp;

двойной

двойная точность, обозначенная ключевым словом double, использует 64 бита для хранения значения. Двойная точность на самом деле быстрее, чем одиночная точность на некоторых современных процессорах, которые были оптимизированы для высокой скорости математические выкладки. Все трансцендентальные математические функции, такие как sin (), 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, поплавок представляет собой 32 битовое представление действительного числа а Double-это 64-разрядное представление.

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

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

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

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 по умолчанию хранит вещественные числа как двойные, чтобы обеспечить более высокую точность.

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