it-swarm.com.ru

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

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

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

189
Leo

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

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

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

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

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

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

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

225
Makoto

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

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

66
Henry

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

13
Ye Win

Тем не менее, у 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;
    }
}
2
Raymond Wachaga

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

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

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

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

1
Rubal

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

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

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

0
Himanshu Singh

Этот пример иллюстрирует, как извлечь знак (крайний левый бит), показатель степени (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://s-j.github.io/Java-float/

0
acohen