Класс Float

java.lang.Object
- java.lang.Number
- - java.lang.Float

Все реализованные интерфейсы:: Serializable, Comparable<Float>

public final class Float
extends Number
implements Comparable<Float>

Класс Float оборачивает значение примитивного типа float в объект. Объект типа Float содержит единственное поле типа float.

Кроме того, этот класс предоставляет несколько методов для преобразования float в String и String в float, а также другие константы и методы, полезные при работе с float.

С тех пор:: JDK1.0
См. также:: Сериализованная форма

Поля

Модификатор и тип	Поле и описание
`static int`	`BYTES` Количество байт, используемых для представления значения `float`.
`static int`	`MAX_EXPONENT` Максимальный порядок конечной переменной типа `float`.
`static float`	`MAX_VALUE` Константа, содержащая наибольшее положительное конечное значение типа `float`, (2-2^-23)·2¹²⁷.
`static int`	`MIN_EXPONENT` Минимальный порядок нормализованной переменной типа `float`.
`static float`	`MIN_NORMAL` Константа, содержащая наименьшее положительное нормализованное значение типа `float`, 2^-126.
`static float`	`MIN_VALUE` Константа, содержащая наименьшее положительное ненулевое значение типа `float`, 2^-149.
`static float`	`NaN` Константа, содержащая значение "Не число" (NaN) типа `float`.
`static float`	`NEGATIVE_INFINITY` Константа, содержащая отрицательную бесконечность типа `float`.
`static float`	`POSITIVE_INFINITY` Константа, содержащая положительную бесконечность типа `float`.
`static int`	`SIZE` Количество битов, используемых для представления значения `float`.
`static Class<Float>`	`TYPE` Экземпляр `Class`, представляющий примитивный тип `float`.

Конструкторы

Конструктор и описание
`Float(double value)` Создает новый объект `Float`, который представляет аргумент, преобразованный к типу `float`.
`Float(float value)` Создает новый объект `Float`, который представляет примитивный аргумент `float`.
`Float(String s)` Создает новый объект `Float`, который представляет значение с плавающей запятой типа `float`, представленное строкой.

Методы

Модификатор и тип	Метод и описание
`byte`	`byteValue()` Возвращает значение этого `Float` как `byte` после сужающего преобразования примитивов.
`static int`	`compare(float f1, float f2)` Сравнивает два указанных значения `float`.
`int`	`compareTo(Float anotherFloat)` Числовое сравнение двух объектов `Float`.
`double`	`doubleValue()` Возвращает значение этого `Float` как `double` после расширяющего преобразования примитивов.
`boolean`	`equals(Object obj)` Сравнивает этот объект с указанным объектом.
`static int`	`floatToIntBits(float value)` Возвращает представление указанного значения с плавающей запятой согласно битовой структуре "формата с плавающей запятой единичной точности" IEEE 754.
`static int`	`floatToRawIntBits(float value)` Возвращает представление указанного значения с плавающей запятой согласно битовой структуре "формата с плавающей запятой единичной точности" IEEE 754, сохраняя значения "Не число" (NaN).
`float`	`floatValue()` Возвращает значение с плавающей запятой этого объекта `Float`.
`int`	`hashCode()` Возвращает хеш-код для этого объекта `Float`.
`static int`	`hashCode(float value)` Возвращает хеш-код для значения с плавающей запятой; совместимо с `Float.hashCode()`.
`static float`	`intBitsToFloat(int bits)` Возвращает значение с плавающей запятой, соответствующее данному битовому представлению.
`int`	`intValue()` Возвращает значение этого объекта `Float` как `int` после сужающего преобразования примитивов.
`static boolean`	`isFinite(float f)` Возвращает `true` , если аргумент является конечным значением с плавающей запятой; возвращает `false` в противном случае (для аргументов NaN и бесконечности).
`boolean`	`isInfinite()` Возвращает `true` , если это значение `Float` бесконечно велико по модулю; `false` в противном случае.
`static boolean`	`isInfinite(float v)` Возвращает `true` , если указанное число бесконечно велико по модулю; `false` в противном случае.
`boolean`	`isNaN()` Возвращает `true` , если это значение `Float` равно "Не числу" (NaN); `false` в противном случае.
`static boolean`	`isNaN(float v)` Возвращает `true` , если указанное число является значением "Не число" (NaN); `false` в противном случае.
`long`	`longValue()` Возвращает значение этого `Float` как `long` после сужающего преобразования примитивов.
`static float`	`max(float a, float b)` Возвращает большее из двух значений `float` как если бы вызывалось `Math.max`.
`static float`	`min(float a, float b)` Возвращает меньшее из двух значений `float` как если бы вызывалось `Math.min`.
`static float`	`parseFloat(String s)` Возвращает новый `float`, инициализированный значением, представленным указанным `String`, как выполняется метод `valueOf` класса `Float`.
`short`	`shortValue()` Возвращает значение этого `Float` как `short` после сужающего преобразования примитивов.
`static float`	`sum(float a, float b)` Складывает два значения с плавающей запятой согласно оператору +.
`static String`	`toHexString(float f)` Возвращает шестнадцатеричное строковое представление аргумента `float`.
`String`	`toString()` Возвращает строковое представление этого объекта `Float`.
`static String`	`toString(float f)` Возвращает строковое представление аргумента `float`.
`static Float`	`valueOf(float f)` Возвращает экземпляр `Float`, представляющий заданное значение с плавающей запятой `float`.
`static Float`	`valueOf(String s)` Возвращает объект `Float`, содержащий значение с плавающей запятой, представленное строкой-аргументом `s`.

Методы, унаследованные от класса java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Поля

POSITIVE_INFINITY

public static final float POSITIVE_INFINITY

Постоянная, хранящая положительную бесконечность типа float. Она равна значению, возвращаемому Float.intBitsToFloat(0x7f800000).

См. также:: Значения константных полей

NEGATIVE_INFINITY

public static final float NEGATIVE_INFINITY

Постоянная, хранящая отрицательную бесконечность типа float. Она равна значению, возвращаемому Float.intBitsToFloat(0xff800000).

См. также:: Значения константных полей

NaN

public static final float NaN

Постоянная, хранящая значение Не число (NaN) типа float. Оно эквивалентно значению, возвращаемому Float.intBitsToFloat(0x7fc00000).

См. также:: Значения константных полей

MAX_VALUE

public static final float MAX_VALUE

Постоянная, хранящая наибольшее положительное конечное значение типа float, (2-2^-23)·2¹²⁷. Она равна шестнадцатеричной плавающей точке 0x1.fffffeP+127f и также равна Float.intBitsToFloat(0x7f7fffff).

См. также:: Значения константных полей

MIN_NORMAL

public static final float MIN_NORMAL

Постоянная, хранящая наименьшее положительное нормализованное значение типа float, 2^-126. Она равна шестнадцатеричной плавающей точке 0x1.0p-126f и также равна Float.intBitsToFloat(0x00800000).

С:: 1.6
См. также:: Значения константных полей

MIN_VALUE

public static final float MIN_VALUE

Постоянная, хранящая наименьшее положительное ненулевое значение типа float, 2^-149. Она равна шестнадцатеричной плавающей точке 0x0.000002P-126f и также равна Float.intBitsToFloat(0x1).

См. также:: Значения константных полей

MAX_EXPONENT

public static final int MAX_EXPONENT

Максимальный порядок, который может иметь конечная переменная float. Он равен значению, возвращаемому Math.getExponent(Float.MAX_VALUE).

С:: 1.6
См. также:: Значения константных полей

MIN_EXPONENT

public static final int MIN_EXPONENT

Минимальный порядок, который может иметь нормализованная переменная float. Он равен значению, возвращаемому Math.getExponent(Float.MIN_NORMAL).

С:: 1.6
См. также:: Значения константных полей

SIZE

public static final int SIZE

Количество битов, используемых для представления значения float.

С:: 1.5
См. также:: Значения константных полей

BYTES

public static final int BYTES

Количество байтов, используемых для представления значения float.

С:: 1.8
См. также:: Значения константных полей

TYPE

public static final Class<Float> TYPE

Экземпляр Class представляющий примитивный тип float.

С:: JDK1.1

Конструкторы

Float

public Float(float value)

Создаёт новый объект Float, представляющий примитивное значение float.

Параметры:: value - значение, которое будет представлено объектом Float.

Float

public Float(double value)

Создаёт новый объект Float, представляющий аргумент, преобразованный к типу float.

Параметры:: value - значение, которое будет представлено объектом Float.

Float

public Float(String s)
      throws NumberFormatException

Создаёт новый объект Float, представляющий значение с плавающей точкой типа float, представленное строкой. Строка преобразуется в значение с плавающей точкой как если бы это делалось методом valueOf.

Параметры:: s - строка, которая должна быть преобразована в значение с плавающей точкой.
Исключения:: NumberFormatException - если строка не содержит анализируемого числа.
См. также:: valueOf(java.lang.String)

Методы

toString

public static String toString(float f)

Возвращает строковое представление аргумента float. Все символы, упомянутые ниже, являются символами ASCII.

Если аргумент NaN, результат — строка "NaN".
В противном случае, результат — строка, которая представляет знак и модуль (абсолютное значение) аргумента. Если знак отрицательный, первый символ результата — '-' ('\u002D'); если знак положительный, знак в результате не отображается. Что касается величины m:
- Если m — бесконечность, она представляется символами "Infinity"; таким образом, положительная бесконечность даёт результат "Infinity", а отрицательная бесконечность — результат "-Infinity".
- Если m — ноль, она представляется символами "0.0"; таким образом, отрицательный ноль даёт результат "-0.0", а положительный ноль — результат "0.0".
- Если m больше или равно 10^-3, но меньше 10⁷, она представляется целой частью m в десятичной форме без ведущих нулей, за которой следует '.' ('\u002E'), за которым следует одна или несколько десятичных цифр, представляющие дробную часть m.
- Если m меньше 10^-3 или больше или равно 10⁷, то она представляется в так называемой "компьютерной научной нотации". Пусть n — единственное целое число такое, что 10ⁿ ≤ m < 10ⁿ⁺¹; пусть a — математически точный результат деления m на 10ⁿ, так что 1 ≤ a < 10. Тогда величина представляется целой частью a, как одиночная десятичная цифра, за которой следует '.' ('\u002E'), за которым следуют десятичные цифры, представляющие дробную часть a, за которыми следует буква 'E' ('\u0045'), за которой следует представление n как десятичного целого числа, которое производится методом Integer.toString(int).

Сколько цифр должно быть напечатано для дробной части m или a? Должна быть по крайней мере одна цифра для дробной части, а за ней — столько дополнительных цифр, сколько необходимо для уникального различения значения аргумента от соседних значений типа float. То есть, предположим, что x — точное математическое значение, представленное десятичным представлением, созданным этим методом для конечного ненулевого аргумента f. Тогда f должно быть значением float, ближайшим к x; или, если два значения float равноудалены от x, то f должно быть одним из них, а наименее значимый бит значащей части f должен быть 0.

Для создания локализованных строковых представлений значения с плавающей точкой используйте подклассы NumberFormat.

Параметры:: f - плавающее значение, которое нужно преобразовать.
Возвращает:: строковое представление аргумента.

toHexString

public static String toHexString(float f)

Возвращает шестнадцатеричную строковую запись аргумента float. Все символы, упомянутые ниже, являются ASCII-символами.

Если аргумент — NaN, результат — строка "NaN".
В противном случае результат — строка, представляющая знак и модуль (абсолютное значение) аргумента. Если знак отрицательный, первый символ результата — '-' ('\u002D'); если знак положительный, символ знака в результате отсутствует. Что касается модуля m:
- Если m — бесконечность, она представлена строкой "Infinity"; таким образом, положительная бесконечность даёт результат "Infinity", а отрицательная бесконечность — результат "-Infinity".
- Если m — ноль, она представлена строкой "0x0.0p0"; таким образом, отрицательный ноль даёт результат "-0x0.0p0", а положительный ноль — результат "0x0.0p0".
- Если m — значение с нормализованным представлением, подстроки используются для представления полей мантиссы и порядка. Мантисса представлена символами "0x1." и далее шестнадцатеричным представлением остальной части мантиссы в виде дроби. Конечные нули в шестнадцатеричном представлении удаляются, за исключением случая, когда все цифры нули, в этом случае используется один ноль. Далее порядок представлен "p" и десятичной строкой необъявленного порядка, как будто полученной вызовом Integer.toString для значения порядка.
- Если m — значение с субнормализованным представлением, мантисса представлена символами "0x0." и далее шестнадцатеричным представлением остальной части мантиссы в виде дроби. Конечные нули в шестнадцатеричном представлении удаляются. Далее порядок представлен "p-126". Обратите внимание, что в субнормализованной мантиссе должно быть по крайней мере одна ненулевая цифра.

Значение с плавающей точкой	Шестнадцатеричная строка
`1.0`	`0x1.0p0`
`-1.0`	`-0x1.0p0`
`2.0`	`0x1.0p1`
`3.0`	`0x1.8p1`
`0.5`	`0x1.0p-1`
`0.25`	`0x1.0p-2`
`Float.MAX_VALUE`	`0x1.fffffep127`
`Minimum Normal Value`	`0x1.0p-126`
`Maximum Subnormal Value`	`0x0.fffffep-126`
`Float.MIN_VALUE`	`0x0.000002p-126`

Параметры:: f - преобразуемое float.
Возвращает:: шестнадцатеричную строковую запись аргумента.
С:: 1.5

valueOf

public static Float valueOf(String s)
                     throws NumberFormatException

Возвращает объект Float, содержащий значение float, представленное строкой-аргументом s.

Если s равно null, выбрасывается исключение NullPointerException.

Пробельные символы в начале и конце строки s игнорируются. Пробелы удаляются так же, как и методом String.trim(); то есть, удаляются как пробелы ASCII, так и управляющие символы. Остальная часть строки s должна представлять собой FloatValue, как определено правилами лексического синтаксиса:

FloatValue:

Sign_opt NaN
Sign_opt Infinity
Sign_opt FloatingPointLiteral
Sign_opt HexFloatingPointLiteral
SignedInteger

HexFloatingPointLiteral:

HexSignificand BinaryExponent FloatTypeSuffix_opt

HexSignificand:

HexNumeral
HexNumeral .
0x HexDigits_opt . HexDigits
0X HexDigits_opt . HexDigits

BinaryExponent:

BinaryExponentIndicator SignedInteger

BinaryExponentIndicator:

p
P

где Sign, FloatingPointLiteral, HexNumeral, HexDigits, SignedInteger и FloatTypeSuffix определены в разделах лексической структуры спецификации языка Java™, за исключением того, что подчёркивание не допускается между цифрами. Если s не имеет формы FloatValue, выбрасывается исключение NumberFormatException. В противном случае, s рассматривается как представление точного десятичного значения в обычном "компьютерном научном формате" или как точное шестнадцатеричное значение; это точное числовое значение затем концептуально преобразуется в "бесконечно точное" двоичное значение, которое затем округляется до типа float по обычному правилу округления до ближайшего значения IEEE 754 арифметики с плавающей точкой, включающему сохранение знака нулевого значения. Обратите внимание, что правило округления до ближайшего значения также подразумевает переполнение и подпотолочное поведение; если точное значение s достаточно велико по модулю (больше или равно (MAX_VALUE + ulp(MAX_VALUE)/2), округление до float даст бесконечность, а если точное значение s достаточно мало по модулю (меньше или равно MIN_VALUE/2), округление до float даст ноль. Наконец, после округления возвращается объект Float, представляющий это float значение.

Для интерпретации локальных строковых представлений значения с плавающей точкой используйте подклассы NumberFormat.

Обратите внимание, что заключительные спецификаторы формата, определяющие тип литерала с плавающей точкой (1.0f - это значение float; 1.0d - это значение double значение), не влияют на результаты этого метода. Другими словами, числовое значение входной строки преобразуется непосредственно в целевой тип с плавающей точкой. В общем случае, двухэтапный процесс преобразований, строка в double и далее double в float, не эквивалентен непосредственному преобразованию строки в float. Например, если сначала преобразовать в промежуточное double и затем в float, строка
"1.00000017881393421514957253748434595763683319091796875001d"
даст значение с плавающей точкой float; если строка преобразуется непосредственно в float, то 1.0000001f.

Чтобы избежать вызова этого метода для неверной строки и последующего выбрасывания исключения NumberFormatException, документация для Double.valueOf содержит регулярное выражение, которое может быть использовано для проверки входных данных.

Параметры:: s - строка для разбора.
Возвращает:: объект Float, содержащий значение, представленное аргументом String.
Исключения:: NumberFormatException - если строка не содержит разборного числа.

valueOf

public static Float valueOf(float f)

Возвращает экземпляр Float, представляющий указанное значение с плавающей точкой float. Если новый экземпляр Float не требуется, этот метод следует предпочесть конструктору Float(float), так как этот метод, вероятно, обеспечит значительно лучшую производительность за счёт кэширования часто запрашиваемых значений.

Параметры:: f - значение с плавающей точкой.
Возвращает:: экземпляр Float, представляющий f.
С:: 1.5

parseFloat

public static float parseFloat(String s)
                        throws NumberFormatException

Возвращает новый float, инициализированный значением, представленным указанной строкой String, как выполняется методом valueOf класса Float.

Параметры:: s - строка для разбора.
Возвращает:: значение с плавающей точкой, представленное строковым аргументом.
Исключения:: NullPointerException - если строка равна null; NumberFormatException - если строка не содержит разборного числа с плавающей точкой.
С:: 1.2
См. также:: valueOf(String)

isNaN

public static boolean isNaN(float v)

Возвращает true, если указанное число является значением «не число» (NaN), false в противном случае.

Параметры:: v - значение для проверки.
Возвращает:: true если аргумент — NaN; false в противном случае.

isInfinite

public static boolean isInfinite(float v)

Возвращает true, если указанное число бесконечно велико по модулю, false в противном случае.

Параметры:: v - значение для проверки.
Возвращает:: true если аргумент — положительная или отрицательная бесконечность; false в противном случае.

isFinite

public static boolean isFinite(float f)

Возвращает true если аргумент — конечное значение с плавающей точкой; возвращает false в противном случае (для аргументов NaN и бесконечности).

Параметры:: f - значение с плавающей точкой для проверки
Возвращает:: true если аргумент — конечное значение с плавающей точкой, false в противном случае.
С:: 1.8

isNaN

public boolean isNaN()

Возвращает true если данное значение с плавающей точкой — «не число» (NaN), false в противном случае.

Возвращает:: true если значение, представленное этим объектом, — NaN; false в противном случае.

isInfinite

public boolean isInfinite()

Возвращает true если данное значение с плавающей точкой бесконечно велико по модулю, false в противном случае.

Возвращает:: true если значение, представленное этим объектом, равно положительной или отрицательной бесконечности; false в противном случае.

toString

public String toString()

Возвращает строковое представление этого объекта Float. Примитивное значение float, представленное этим объектом, преобразуется в String точно так же, как и методом toString с одним аргументом.

Переопределяет:: toString в классе Object
Возвращает:: представление этого объекта в виде String.
См. также:: toString(float)

byteValue

public byte byteValue()

Возвращает значение этого объекта Float в виде byte после сужающего преобразования примитивного типа.

Переопределяет:: byteValue в классе Number
Возвращает:: значение float представленное этим объектом, преобразованное к типу byte

shortValue

public short shortValue()

Возвращает значение этого объекта Float в виде short после сужающего преобразования примитивного типа.

Переопределяет:: shortValue в классе Number
Возвращает:: значение float представленное этим объектом, преобразованное к типу short
С момента:: JDK1.1

intValue

public int intValue()

Возвращает значение этого объекта Float в виде int после сужающего преобразования примитивного типа.

Определяет:: intValue в классе Number
Возвращает:: значение float представленное этим объектом, преобразованное к типу int

longValue

public long longValue()

Возвращает значение этого объекта Float в виде long после сужающего преобразования примитивного типа.

Определяет:: longValue в классе Number
Возвращает:: значение float представленное этим объектом, преобразованное к типу long

floatValue

public float floatValue()

Возвращает значение с плавающей запятой этого объекта Float.

Определяет:: floatValue в классе Number
Возвращает:: значение с плавающей запятой, представленное этим объектом

doubleValue

public double doubleValue()

Возвращает значение этого объекта Float в виде double после расширяющего преобразования примитивного типа.

Определяет:: doubleValue в классе Number
Возвращает:: значение float представленное этим объектом, преобразованное к типу double

hashCode

public int hashCode()

Возвращает код хэширования для этого объекта Float. Результат — целое число, представляющее битовое представление, точно так же, как это возвращает метод floatToIntBits(float), примитивного значения с плавающей запятой float, представленного этим объектом Float.

Переопределяет:: hashCode в классе Object
Возвращает:: значение кода хэширования для этого объекта.
См. также:: Object.equals(java.lang.Object), System.identityHashCode(java.lang.Object)

hashCode

public static int hashCode(float value)

Возвращает код хэширования для значения с плавающей запятой; совместимо с Float.hashCode().

Параметры:: value - значение для хэширования
Возвращает:: значение кода хэширования для значения с плавающей запятой.
С момента:: 1.8

equals

public boolean equals(Object obj)

Сравнивает этот объект с указанным объектом. Результат — true тогда и только тогда, когда аргумент не null и является объектом типа Float, представляющим значение с плавающей запятой float с тем же значением, что и значение float , представленное этим объектом. Для этой цели два значения с плавающей запятой считаются одинаковыми, если и только если метод floatToIntBits(float) возвращает одинаковое значение int при применении к каждому из них.

Обратите внимание, что в большинстве случаев для двух экземпляров класса Float, f1 и f2, значение f1.equals(f2) равно true тогда и только тогда

f1.floatValue() == f2.floatValue()

также имеет значение true. Однако существуют два исключения:

Если f1 и f2 оба представляют Float.NaN, то метод equals возвращает true, даже если Float.NaN==Float.NaN имеет значение false.
Если f1 представляет +0.0f , а f2 представляет -0.0f, или наоборот, тест equal имеет значение false, даже если 0.0f==-0.0f имеет значение true.

Это определение позволяет правильно работать хеш-таблицам.

Переопределяет:: equals в классе Object
Параметры:: obj - объект для сравнения
Возвращает:: true если объекты одинаковы; false в противном случае.
См. также:: floatToIntBits(float)

floatToIntBits

public static int floatToIntBits(float value)

Возвращает представление указанного значения с плавающей запятой в соответствии с битовой маской формата с плавающей запятой IEEE 754 "single format".

Бит 31 (выбирается маской 0x80000000) представляет знак числа с плавающей запятой. Биты 30-23 (выбираются маской 0x7f800000) представляют показатель степени. Биты 22-0 (выбираются маской 0x007fffff) представляют мантиссу (иногда называемую дробной частью) числа с плавающей запятой.

Если аргумент равен положительной бесконечности, результат равен 0x7f800000.

Если аргумент равен отрицательной бесконечности, результат равен 0xff800000.

Если аргумент равен NaN, результат равен 0x7fc00000.

Во всех случаях результат представляет собой целое число, которое при передаче в метод intBitsToFloat(int) даст значение с плавающей запятой, такое же, как аргумент для floatToIntBits (за исключением того, что все значения NaN сводятся к одному "каноническому" значению NaN).

Параметры:: value - число с плавающей запятой.
Возвращает:: биты, представляющие число с плавающей запятой.

floatToRawIntBits

public static int floatToRawIntBits(float value)

Возвращает представление указанного значения с плавающей запятой в соответствии с битовой маской формата с плавающей запятой IEEE 754 "single format", сохраняя значения "Не число" (NaN).

Если аргумент равен положительной бесконечности, результат равен 0x7f800000.

Если аргумент равен отрицательной бесконечности, результат равен 0xff800000.

Если аргумент равен NaN, результат — целое число, представляющее фактическое значение NaN. В отличие от метода floatToIntBits, метод floatToRawIntBits не сводит все битовые шаблоны, кодирующие NaN, к одному "каноническому" значению NaN.

Во всех случаях результат — целое число, которое, при передаче в метод intBitsToFloat(int), даст значение с плавающей запятой, такое же, как аргумент для floatToRawIntBits.

Параметры:: value - число с плавающей запятой.
Возвращает:: биты, представляющие число с плавающей запятой.
С момента:: 1.3

intBitsToFloat

public static float intBitsToFloat(int bits)

Возвращает значение с плавающей запятой, соответствующее заданному битовому представлению. Аргумент рассматривается как представление значения с плавающей запятой в соответствии с битовой маской формата с плавающей запятой IEEE 754 "single format".

Если аргумент равен 0x7f800000, результат равен положительной бесконечности.

Если аргумент равен 0xff800000, результат равен отрицательной бесконечности.

Если аргумент имеет любое значение в диапазоне 0x7f800001 до 0x7fffffff или в диапазоне 0xff800001 до 0xffffffff, результат — NaN. Ни одна операция с плавающей запятой IEEE 754, предоставляемая Java, не может различать два значения NaN одного типа с различными битовыми шаблонами. Различные значения NaN различимы только с помощью метода Float.floatToRawIntBits.

Во всех остальных случаях, пусть s, e и m — три значения, которые можно вычислить из аргумента:

int s = ((bits >> 31) == 0) ? 1 : -1;
int e = ((bits >> 23) & 0xff);
int m = (e == 0) ?
                (bits & 0x7fffff) << 1 :
                (bits & 0x7fffff) | 0x800000;

Тогда результат с плавающей запятой равен значению математического выражения s·m·2^e-150.

Обратите внимание, что этот метод может не быть в состоянии вернуть NaN с плавающей запятой с точным битовым шаблоном, как у аргумента int. IEEE 754 различает два типа NaN, тихие NaN и сигнализирующие NaN. Различия между этими двумя типами NaN обычно не видны в Java. Арифметические операции над сигнализирующими NaN преобразуют их в тихие NaN с другим, но часто похожим, битовым шаблоном. Однако на некоторых процессорах простое копирование сигнализирующего NaN также выполняет это преобразование. В частности, копирование сигнализирующего NaN для его возврата вызывающему методу может выполнить это преобразование. Поэтому intBitsToFloat может не быть в состоянии вернуть NaN с сигнализирующим NaN битовым шаблоном. Следовательно, для некоторых значений int значение floatToRawIntBits(intBitsToFloat(start)) может не равняться start. Более того, какие именно битовые шаблоны представляют сигнализирующие NaN, зависят от платформы; хотя все битовые шаблоны NaN, тихие или сигнализирующие, должны быть в диапазоне NaN, указанном выше.

Параметры:: bits - целое число.
Возвращает:: значение с плавающей запятой float с той же битовой структурой.

compareTo

public int compareTo(Float anotherFloat)

Сравнивает два объекта Float численно. Сравнения, выполняемые этим методом, отличаются от сравнений, выполняемых операторами числового сравнения языка Java (<, <=, ==, >=, >) при применении к примитивным значениям float в двух аспектах:

Float.NaN в этом методе считается равным самому себе и больше всех других значений float (включая Float.POSITIVE_INFINITY) .
0.0f в этом методе считается больше, чем -0.0f.

Это гарантирует, что естественный порядок объектов Float , заданный этим методом, согласован с методом equals.

Задано в:: compareTo в интерфейсе Comparable<Float>
Параметры:: anotherFloat - сравниваемое значение Float.
Возвращает:: значение 0 , если anotherFloat численно равно этому значению Float; значение меньше 0 , если это значение Float численно меньше anotherFloat; и значение больше 0 , если это значение Float численно больше anotherFloat.
С:: 1.2
См. также:: Comparable.compareTo(Object)

compare

public static int compare(float f1,
                          float f2)

Сравнивает два указанных значения float. Знак возвращаемого целочисленного значения совпадает со знаком целого числа, которое было бы возвращено вызовом:

new Float(f1).compareTo(new Float(f2))

Параметры:: f1 - первое значение float для сравнения.; f2 - второе значение float для сравнения.
Возвращает:: значение 0 , если f1 численно равно f2; значение меньше 0 , если f1 численно меньше f2; и значение больше 0 , если f1 численно больше f2.
С:: 1.4

sum

public static float sum(float a,
                        float b)

Складывает два значения float вместе, как и оператор +.

Параметры:: a - первый операнд; b - второй операнд
Возвращает:: сумму a и b
С:: 1.8
См. также:: BinaryOperator

max

public static float max(float a,
                        float b)

Возвращает большее из двух значений float, как если бы вы вызывали Math.max.

Параметры:: a - первый операнд; b - второй операнд
Возвращает:: большее из a и b
С:: 1.8
См. также:: BinaryOperator

min

public static float min(float a,
                        float b)

Возвращает меньшее из двух значений float, как если бы вы вызывали Math.min.

Параметры:: a - первый операнд; b - второй операнд
Возвращает:: меньшее из a и b
С:: 1.8
См. также:: BinaryOperator

© 1993, 2020, Oracle and/or its affiliates. All rights reserved.
Documentation extracted from Debian's OpenJDK Development Kit package.
Licensed under the GNU General Public License, version 2, with the Classpath Exception.
Various third party code in OpenJDK is licensed under different licenses (see Debian package).
Java and OpenJDK are trademarks or registered trademarks of Oracle and/or its affiliates.