Класс Float

public static final float POSITIVE_INFINITY

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

public static final float NEGATIVE_INFINITY

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

public static final float NaN

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

public static final float MAX_VALUE

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

public static final float MIN_NORMAL

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

public static final float MIN_VALUE

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

public static final int MAX_EXPONENT

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

public static final int MIN_EXPONENT

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

public static final int SIZE

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

public static final int BYTES

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

public static final Class<Float> TYPE

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

@Deprecated(since="9", forRemoval=true) public Float(float value)

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

@Deprecated(since="9", forRemoval=true) public Float(double value)

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

@Deprecated(since="9", forRemoval=true) public Float(String s) throws NumberFormatException

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

public static String toString(float f)

Возвращает строковое представление аргумента. Все упомянутые ниже символы являются 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 должно быть значением, ближайшим к x; или, если два значения f одинаково близки к x, тогда f должно быть одним из них, а младший бит значащей части f должен быть 0.

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

public static String toHexString(float f)

Возвращает шестнадцатеричное строковое представление аргумента. Все упоминаемые ниже символы являются символами 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

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 1.0000002f; если строка преобразована непосредственно в float, результат 1.0000001f.

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

public static Float valueOf(float f)

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

public static float parseFloat(String s) throws NumberFormatException

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

public static boolean isNaN(float v)

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

public static boolean isInfinite(float v)

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

public static boolean isFinite(float f)

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

public boolean isNaN()

Возвращает true, если это значение Float является Not-a-Number (NaN), false в противном случае.

public boolean isInfinite()

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

public String toString()

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

public byte byteValue()

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

public short shortValue()

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

public int intValue()

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

public long longValue()

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

public float floatValue()

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

public double doubleValue()

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

public int hashCode()

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

public static int hashCode(float value)

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

public boolean equals(Object obj)

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

public static int floatToIntBits(float value)

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

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

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

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

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

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

public static int floatToRawIntBits(float value)

Возвращает представление указанного значения с плавающей точкой согласно битовому представлению формата «single» IEEE 754, сохраняя значения «Not-a-Number» (NaN).

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

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

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

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

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

public static float intBitsToFloat(int bits)

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

Если аргумент равен 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 может не вернуть float с битовым шаблоном сигнализирующего NaN. Следовательно, для некоторых значений int floatToRawIntBits(intBitsToFloat(start)) может не быть равно start. Кроме того, конкретные битовые шаблоны, представляющие сигнализирующие NaN, зависят от платформы; хотя все битовые шаблоны NaN, тихие или сигнализирующие, должны находиться в диапазоне NaN, указанном выше.

public int compareTo(Float anotherFloat)

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

• NaN не упорядочен по отношению к другим значениям и не равен самому себе в соответствии с операторами сравнения. Этот метод выбирает определение NaN как равного самому себе и большего, чем все другие значения double (включая Float.POSITIVE_INFINITY).
• Положительный и отрицательный нули сравниваются численно как равные, но являются различными и различимыми значениями. Этот метод выбирает определение положительного нуля (+0.0f) как большего, чем отрицательный ноль (-0.0f).

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

public static int compare(float f1, float f2)

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

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

public static float sum(float a, float b)

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

public static float max(float a, float b)

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

public static float min(float a, float b)

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

public Optional<Float> describeConstable()

Возвращает Optional содержащий номинальное описание для этого экземпляра, которое является самим экземпляром.

public Float resolveConstantDesc(MethodHandles.Lookup lookup)

Разрешает этот экземпляр как ConstantDesc, результат которого — сам экземпляр.