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

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

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

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

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

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

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

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

Там могут быть некоторые библиотеки , которые на самом деле заставить ваше использование float, но в целом - если вы не можете гарантировать , что ваш результат будет достаточно мал , чтобы поместиться в float«s предписанного диапазона , то это лучше сделать выбор с double.

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

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

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

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

   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 hightemp, lowtemp;

двойной

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

Тем не менее, 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;
    }
}

Это даст ошибку:

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

/MyClass.java:3: ошибка: несовместимые типы: возможное преобразование с потерями от двойного к плавающему с плавающей точкой 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 занимает меньше места, но менее точно.

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

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

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

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

Этот пример иллюстрирует, как извлечь знак (крайний левый бит), показатель степени (8 следующих битов) и мантиссу (23 крайних правых бита) из числа с плавающей запятой в 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://sj.github.io/java-float/

Вы должны использовать double вместо float для точных вычислений и float вместо double при использовании менее точных вычислений. Float содержит только десятичные числа, но double содержит число с плавающей точкой двойной точности IEEE754, что упрощает более точное хранение и вычисление чисел. Надеюсь это поможет.

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

• Если мы хотим использовать число с плавающей запятой в качестве типа данных с плавающей запятой, то вызывающий метод должен явно суффикс F или f, потому что по умолчанию каждое число с плавающей запятой обрабатывается как double. Это увеличивает нагрузку на программиста. Если мы используем число с плавающей точкой в ​​качестве двойного типа данных, нам не нужно добавлять суффикс.
• Float - это тип данных с одинарной точностью, то есть он занимает 4 байта. Следовательно, в больших вычислениях мы не получим полный результат. Если мы выберем двойной тип данных, он займет 8 байтов, и мы получим полные результаты.

Типы данных с плавающей запятой и двойной тип данных были разработаны специально для научных расчетов, где допустимы ошибки аппроксимации. Если точность является наиболее приоритетной задачей, то рекомендуется использовать класс BigDecimal вместо типов данных с плавающей запятой или типа double. Источник: - Float и двойные типы данных в Java