Чем отличается float от double java
Перейти к содержимому

Чем отличается float от double java

  • автор:

Числа с плавающей точкой

Числа с плавающей точкой (или действительные числа) представлены типами float и double. Используются для хранения значений с точностью до определенного знака после десятичной точки.

double — это числа с двойной точностью, максимально приближённые к заданным или полученным в результате вычислений значениям. Используется в Java для любых математических вычислений (квадратный корень, синус, косинус. ).

float — менее точный тип с плавающей точкой. Используется очень редко с целью экономии памяти.

Пример объявления типов с плавающей точкой:

double d1 = 3.45; float f1 = 34.456f;
Тип Размер в байтах Размер в битах Возможные значения (от..до) Значение по умолчанию
float 4 32 -3.4E+38..3.4E+38 (стандарт IEEE 754) 0.0
double 8 64 -1.7E+308..1.7E+308 (стандарт IEEE 754) 0.0

В языке Java есть три специальных числа плавающей точкой, которые используются для обозначения переполнения и ошибок:

  • Положительная бесконечность — результат деления положительного числа на 0. Представлены константами Double.POSITIVE_INFINITY и Float.POSITIVE_INFINITY .
  • Отрицательная бесконечность — результат деления отрицательного числа на 0. Представлены константами Double.NEGATIVE_INFINITY и Float.NEGATIVE_INFINITY.
  • NaN (не число) — вычисление 0/0 или извлечение квадратного корня из отрицательного числа. Представлены константами Double.NaN и Float.NAN .

Пример использования специальных чисел с плавающей точкой в арифметических выражениях:

public class Main < public static void main(String[] args) < int a = 7; double b = 0.0; double c = -0.0; double g = Double.NEGATIVE_INFINITY; System.out.println(a / b); System.out.println(a / c); System.out.println(b == c); System.out.println(g * 0); >>

Числа с плавающей точкой нельзя использовать в финансовых расчетах, где ошибки округления недопустимы. Например, в результате выполнения оператора System.out. println(2.0 — 1.1) будет выведено значение 0.8999999999999999, а не 0.9, как было бы логично предположить. Подобные ошибки связаны с внутренним двоичным представлением чисел. Как в десятичной системе счисления нельзя точно представить результат деления 1/3, так и в двоичной системе невозможно точно представить результат деления 1/10. Если же требуется исключить ошибки округления, то следует воспользоваться классом BigDecimal .

Презентацию с видео можно скачать на Patreon .

  • Пробелы
  • Идентификаторы
  • Правила именования переменных
  • Комментарии
  • Разделители
  • Ключевые слова
  • Примитивные типы данных
  • Тип данных char
  • Типы byte, short, int, long
  • Тип данных boolean
  • Литералы
  • Методы
  • Переменные
  • Прямой код и дополнительный код
  • Преобразование и приведение примитивных типов
  • Ввод с клавиатуры
  • Задания

В чем разница между float и double в Java?

Какая еще есть разница между типами данных float и double или я что-то в упор не вижу?

Отслеживать
14.2k 1 1 золотой знак 21 21 серебряный знак 31 31 бронзовый знак
задан 18 июл 2017 в 21:19
Yuri Migushin Yuri Migushin
61 1 1 серебряный знак 7 7 бронзовых знаков

Вставляйте код прямо в сообщение (в виде кода), а не ссылайтесь на внешние ресурсы. Сообщения должны быть самодостаточными, ссылки могут служить только дополнением.

18 июл 2017 в 22:46

1 ответ 1

Сортировка: Сброс на вариант по умолчанию

Принципиальный нюанс здесь в том, что вы оперируете десятичными числами, а float и double — бинарные. Те числа, которые вы делите и получаете в результате, непредставимы в бинарной системе счисления без периодичных дробей. Подробнее:

То, что вы наблюдаете — это не округления и обрубания, а попытки компьютера впихать невпихуемое и сделать вид, что на самом деле всё в порядке. Так как количество битов у мантиссы и экспоненты типов float и double разная, то «округления» и «обрубания» будут происходить с вашей точки зрения «непредсказуемо». Эта ситуация усугубляется ещё и тем, что точность вычислений на совести процессора, который, вообще говоря, не обязан выдавать точность до последнего знака. На другом компьютере вы можете увидеть другие результаты — если не включите специальный «предсказуемый» режим, который медленнее. Но даже в этом случае вы получите только одинаковые, но «непредсказуемые» результаты на разных компьютерах.

Когда работаете с float и double, примите как данность, что они всегда с погрешностью.

Чем отличается float от double java

На 32-разрядной платформе ARM, в среде разработки IAR EWB for ARM применены следующие типы float, double и long double.

float — 32-битное число с плавающей точкой. Диапазон чисел от ±1.18E-38 до ±3.39E+38, 7 десятичных разрядов, 8 бит показателя степени (экспонента) и 23 бита основания степени (мантисса).

double — 64-битное число с плавающей точкой. Диапазон чисел от ±2.23E-308 to ±1.79E+308, 15 десятичных разрядов, 11 бит показателя степени (экспонента) и 52 бита основания степени (мантисса).

long double — абсолютно то же самое, что и double.

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

Информация получена из документа справки «IAR C/C++ Development Guide» EWARM_DevelopmentGuide.ENU.pdf, раздел «FLOATING-POINT TYPES».

[См. также]

1. Описание стандартных функций < cmath >(math.h) site:cplusplus.com .
2. Как избавиться от чисел с плавающей точкой.

Pro Java

F0000101

Вещественные числа в Java представлены типами данных float и double. Как показано в таблицах выше, float является 32 битным значением с плавающей точкой, с обычной точностью, а double представляет 64 битное значение с плавающей точкой, с двойной точностью. Количество бит отведенные под представление этих чисел смотрите в таблице выше. Оба типа соответствуют стандарту IEEE 754-1985, который определяет формат чисел и арифметические операции, применимые к этим числам. Но есть и небольшие отличия от этого стандарта. К обычным вещественным числам добавляются еще четыре значения:

  • положительная бесконечность, выражаемая константой POSITIVE_INFINITY и возникающая при переполнении положительного значения, например в результате операции умножения 3.0*6e307 или при делении на нуль;
  • отрицательная бесконечность NEGATIVE_INFINITY, возникающая при переполнении отрицательного значения, например в результате операции умножения -3.0*6e307 или при делении на нуль отрицательного числа;
  • «не число», записываемое константой NaN (Not a Number) и возникающее, например, при умножении нуля на бесконечность.
  • кроме того, стандарт различает положительный и отрицательный нуль, возникающий при делении на бесконечность соответствующего знака, хотя сравнение 0.0 == -0.0 дает в результате истину, true.

Операции с бесконечностями выполняются по обычным математическим правилам. Во всем остальном вещественные типы — это обычные вещественные значения, к которым применимы все арифметические операции и операции сравнения.

Вещественные литералы

F00002

Значения с плавающей точкой можно непосредственно включать в Java программу. В такой величине за необязательной последовательностью цифр следует десятичная точка и другая последовательность цифр. Ниже представлены несколько примеров:

Литералы с плавающей точкой можно также представить в экспоненциальной, или научной, нотации, в которой за числом следует буква e или E (показатель степени) и другое число. Второе число представляет степень десятки, на которую умножается первое число . Если же число записано в шестнадцатеричном формате, то экспонента это степень двойки . Например:

1.2345E02 // 1.2345 × 10 2 , или 123.45
1e-6 // 1 × 10 -6 , или 0.000001
6.02e23 // Число Авогадро: 6.02 × 10 23

Так же с Java 6, возможно записывать в шестнадцатеричном формате:

0xFp2 // 15×2 2 =60

Литералы с плавающей точкой по умолчанию являются значениями типа double . При включении значения типа float в программу за числом следует поставить символ f или F :

double d = 6.02E23;
float f = 6.02e23f;

В принципе литералы типа double можно тоже обозначать суффиксом d или D, но это особо не имеет смысла, так как вещественные литералы всегда по умолчанию double .

Большинство вещественных чисел, по самой их природе, нельзя точно представить каким-либо конечным количеством битов. Таким образом, необходимо помнить, что значения float и double являются только приближенными значениями представляемых ими чисел. float – это 32 битное приближение, которое дает как минимум 6 значимых десятичных разрядов, а double – это 64 битное приближение, которое представляет по крайней мере 15 значимых десятичных разрядов. На практике эти числа подходят для большинства вычислений с вещественными числами.

Поскольку типы с плавающей точкой в Java могут сводить переполнение к бесконечности, антипереполнение – к нулю, а также имеют особое NaN значение, то арифметические операции с плавающей точкой никогда не генерируют исключений , даже при выполнении недопустимых операций, например при делении нуля на нуль либо при вычислении корня отрицательного числа.

Бесконечные значения с плавающей точкой ведут себя вполне логично. Например, прибавление к бесконечности или вычитание из нее любого конечного значения дает бесконечность. Поведение отрицательного нуля почти не отличается от положитель ного нуля; фактически оператор равенства == сообщает о равенстве отрицательного и положительного нуля. Единственный способ отличить отрицательный нуль от по ложительного или обычного нуля – разделить на него какоелибо число. 1.0/0.0 дает положительную бесконечность, а деление 1.0 на отрицательный нуль дает отрицательную бесконечность. И наконец, поскольку NaN не является числом, оператор == сообщает, что это значение не равно ни одному другому числу, включая само значение ! Чтобы проверить, являются ли значения float и double нечисловыми (NaN), следует вызвать методы Float.isNaN() и Double.isNaN() .

Арифметические операции

F00003

Поскольку к вещественным типам применимы все арифметические операции и сравнения, целые и вещественные значения можно смешивать в операциях. При этом правило приведения типов дополняется такими условиями:

если в операции один операнд имеет тип double, то и другой приводится к типу double;

иначе, если один операнд имеет тип float, то и другой приводится к типу float;

в противном случае действует правило приведения целых значений.

Побитовые операции с вещественными типами не поддерживаются .

Операция деление по модулю (или остаток) определяется так же как и для целочисленных типов:
a % b = a — (a / b) * b

Так же для операции деления по модулю справедливо следующее выражение:

a = ((long)(a/b))*b+(a%b)

F00004

F00005

Вычисления чисел с плавающей точкой на одном и том же, а тем более на разных процессорах могут давать несколько разные результаты, поскольку виртуальная машина java выполняет эти операции на сопроцессоре (FPU), если он присутствует на устройстве. А в сопроцессоре обычно регистры для работы с плавающей точкой 80 бит, что шире даже чем double. Поэтому, если в эти регистры положить числа double, а потом опять вернуть их в double, то результаты могут быть разные для одинаковых чисел, по умолчанию java эту проблему не решает, то есть нет гарантии, что написанный код работающий с целочисленными типами будет давать одинаковый результат на разных процессорах. Это сделано потому, что желательно использовать сопроцессор для скорости вычислений. Результаты в этом случае могут немного различаться.

Чтобы результаты были на всех процессорах одинаковые, то следует использовать ключевое слово strictfp в декларации метода, например:

public static strictfp void main(String[] args)

В данном случае все что будет происходить в методе main, будет происходить без участия сопроцессора, будет строго округляться в пределах 64 бит и результат будет одинаковым на разных процессорах.

Все математические функции из библиотеки java.lang.Math работают с числами типа double.

Ну и теперь немного практики:

F00006

И вывод этой программы:

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *