Float и двойной тип данных в Java

Тип данных с плавающей точкой - это 32-битная точка с плавающей точкой IEEE 754 с одной точностью, а двойной тип данных - это 64-битная точка с плавающей точкой IEEE 754 с двойной точностью.

Что это значит? И когда следует использовать float вместо double или наоборот?

ОТВЕТЫ

Ответ 1

страница Википедии на нем - хорошее место для начала.

Подводя итог:

  • float представлен в 32 битах с 1 знаковым битом, 8 битами экспоненты и 23 битами значения (или что следует из номера научной нотации: 2.33728 * 10 12; 33728 - значение).

  • double представлен в 64 битах, с 1 знаковым битом, 11 бит экспоненты и 52 бит значимости.

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

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

Если вам нужна точность - например, вы не можете иметь десятичное значение, которое неточно (например, 1/10 + 2/10), или вы делаете что-либо с валютой (например, представляя $10.33 в системе), затем используйте BigDecimal, который может поддерживать произвольное количество точности и обрабатывать ситуации, подобные этому элегантно.

Ответ 2

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

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

Ответ 3

Числа с плавающей запятой, также известные как действительные числа, используются при оценке выражений, требующих дробной точности. Например, вычисления, такие как квадратный корень или трансцендентные элементы, такие как синус и косинус, приводят к значению, для точности которого требуется тип с плавающей запятой. Java реализует стандартный (IEEE-754) набор типов и операторов с плавающей точкой. Существует два типа типов с плавающей запятой, 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 указывает значение с единственной точностью, которое использует 32 бита памяти. Одиночная точность на некоторых процессорах выше и занимает вдвое меньше места, чем двойная точность, но становится неточной, когда значения очень велики или очень малы. Переменные типа float полезны, когда вам нужен дробный компонент, но не требующий большой степени точности. Например, float может быть полезен при представлении долларов и центов.

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

float hightemp, lowtemp;


  двойной

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

Ответ 4

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

Ответ 5

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

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

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

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

Ответ 6

В этом примере показано, как извлечь знак (самый левый бит), показатель степени экспоненты (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/