Класс Double

public static final double POSITIVE_INFINITY

Константа, содержащая положительную бесконечность типа double. Она равна значению, возвращаемому Double.longBitsToDouble(0x7ff0000000000000L).

public static final double NEGATIVE_INFINITY

Константа, содержащая отрицательную бесконечность типа double. Она равна значению, возвращаемому Double.longBitsToDouble(0xfff0000000000000L).

public static final double NaN

Константа, содержащая значение «Не число» (NaN) типа double. Она эквивалентна значению, возвращаемому Double.longBitsToDouble(0x7ff8000000000000L).

public static final double MAX_VALUE

Константа, содержащая наибольшее положительное конечное значение типа double, (2-2^-52)·2¹⁰²³. Она равна шестнадцатеричной плавающей точке 0x1.fffffffffffffP+1023 и также равна Double.longBitsToDouble(0x7fefffffffffffffL).

public static final double MIN_NORMAL

Константа, содержащая наименьшее положительное нормализованное значение типа double, 2^-1022. Она равна шестнадцатеричной плавающей точке 0x1.0p-1022 и также равна Double.longBitsToDouble(0x0010000000000000L).

public static final double MIN_VALUE

Константа, содержащая наименьшее положительное ненулевое значение типа double, 2^-1074. Она равна шестнадцатеричной плавающей точке 0x0.0000000000001P-1022 и также равна Double.longBitsToDouble(0x1L).

public static final int MAX_EXPONENT

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

public static final int MIN_EXPONENT

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

public static final int SIZE

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

public static final int BYTES

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

public static final Class<Double> TYPE

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

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

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

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

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

public static String toString(double d)

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

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

public static String toHexString(double d)

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

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

Примеры

Значение с плавающей точкой	Шестнадцатеричная строка
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
Double.MAX_VALUE	0x1.fffffffffffffp1023
Minimum Normal Value	0x1.0p-1022
Maximum Subnormal Value	0x0.fffffffffffffp-1022
Double.MIN_VALUE	0x0.0000000000001p-1022

public static Double valueOf(String s) throws NumberFormatException

Возвращает объект Double, содержащий значение, представленное строковым аргументом 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 рассматривается как представление точного десятичного значения в обычной "компьютерной научной записи" или точного шестнадцатеричного значения; это точное числовое значение затем концептуально преобразуется в "бесконечно точное" двоичное значение, которое затем округляется до типа double по общему правилу округления IEEE 754 с плавающей запятой, которое включает сохранение знака нулевого значения. Обратите внимание, что правило округления до ближайшего также подразумевает переполнение и подпотолочение; если точное значение s достаточно велико по модулю (больше или равно (MAX_VALUE + ulp(MAX_VALUE)/2), округление до double приведет к бесконечности, а если точное значение s достаточно мало по модулю (меньше или равно MIN_VALUE/2), округление до float приведёт к нулю. Наконец, после округления возвращается объект Double, представляющий это double значение.

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

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

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

  final String Digits     = "(\\p{Digit}+)";
  final String HexDigits  = "(\\p{XDigit}+)";
  // an exponent is 'e' or 'E' followed by an optionally
  // signed decimal integer.
  final String Exp        = "[eE][+-]?"+Digits;
  final String fpRegex    =
      ("[\\x00-\\x20]*"+  // Optional leading "whitespace"
       "[+-]?(" + // Optional sign character
       "NaN|" +           // "NaN" string
       "Infinity|" +      // "Infinity" string

       // A decimal floating-point string representing a finite positive
       // number without a leading sign has at most five basic pieces:
       // Digits . Digits ExponentPart FloatTypeSuffix
       //
       // Since this method allows integer-only strings as input
       // in addition to strings of floating-point literals, the
       // two sub-patterns below are simplifications of the grammar
       // productions from section 3.10.2 of
       // The Java Language Specification.

       // Digits ._opt Digits_opt ExponentPart_opt FloatTypeSuffix_opt
       "((("+Digits+"(\\.)?("+Digits+"?)("+Exp+")?)|"+

       // . Digits ExponentPart_opt FloatTypeSuffix_opt
       "(\\.("+Digits+")("+Exp+")?)|"+

       // Hexadecimal strings
       "((" +
        // 0[xX] HexDigits ._opt BinaryExponent FloatTypeSuffix_opt
        "(0[xX]" + HexDigits + "(\\.)?)|" +

        // 0[xX] HexDigits_opt . HexDigits BinaryExponent FloatTypeSuffix_opt
        "(0[xX]" + HexDigits + "?(\\.)" + HexDigits + ")" +

        ")[pP][+-]?" + Digits + "))" +
       "[fFdD]?))" +
       "[\\x00-\\x20]*");// Optional trailing "whitespace"

  if (Pattern.matches(fpRegex, myString))
      Double.valueOf(myString); // Will not throw NumberFormatException
  else {
      // Perform suitable alternative action
  }
 

public static Double valueOf(double d)

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

public static double parseDouble(String s) throws NumberFormatException

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

public static boolean isNaN(double v)

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

public static boolean isInfinite(double v)

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

public static boolean isFinite(double d)

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

public boolean isNaN()

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

public boolean isInfinite()

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

public String toString()

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

public byte byteValue()

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

public short shortValue()

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

public int intValue()

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

public long longValue()

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

public float floatValue()

Возвращает значение этого Double в виде float после сужения примитивного преобразования.

public double doubleValue()

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

public int hashCode()

Возвращает код хэширования для этого объекта Double. Результатом является исключающее ИЛИ двух половин представления целого числа в формате двоичного кода long , точно так же, как и производится методом doubleToLongBits(double) для примитивного значения с плавающей запятой double , представленного этим объектом Double. То есть, код хэширования — это значение выражения:

(int)(v^(v>>>32))

где v определяется следующим образом:

long v = Double.doubleToLongBits(this.doubleValue());

public static int hashCode(double value)

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

public boolean equals(Object obj)

Сравнивает этот объект с указанным объектом. Результатом является true тогда и только тогда, когда аргумент не null и является объектом типа Double , представляющим значение с плавающей запятой double , которое имеет то же значение, что и значение с плавающей запятой double , представленное этим объектом. Для этой цели два значения с плавающей запятой считаются одинаковыми тогда и только тогда, когда метод doubleToLongBits(double) возвращает одинаковое значение long при применении к каждому.

public static long doubleToLongBits(double value)

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

Бит 63 (бит, выбранный маской 0x8000000000000000L) представляет знак числа с плавающей запятой. Биты 62-52 (биты, выбранные маской 0x7ff0000000000000L) представляют показатель степени. Биты 51-0 (биты, выбранные маской 0x000fffffffffffffL) представляют мантиссу (иногда называемую значащей частью) числа с плавающей запятой.

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

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

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

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

public static long doubleToRawLongBits(double value)

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

Бит 63 (бит, выбранный маской 0x8000000000000000L) представляет знак числа с плавающей точкой. Биты 62-52 (биты, выбранные маской 0x7ff0000000000000L) представляют показатель степени. Биты 51-0 (биты, выбранные маской 0x000fffffffffffffL) представляют мантиссу (иногда называемую значащей частью) числа с плавающей точкой.

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

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

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

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

public static double longBitsToDouble(long bits)

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

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

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

Если аргумент имеет любое значение в диапазоне от 0x7ff0000000000001L до 0x7fffffffffffffffL или в диапазоне от 0xfff0000000000001L до 0xffffffffffffffffL, результат — NaN. Ни одна операция с плавающей точкой IEEE 754, предоставляемая Java, не может различать два значения NaN одного типа с различными битовыми шаблонами. Разные значения NaN различимы только с помощью метода Double.doubleToRawLongBits.

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

 int s = ((bits >> 63) == 0) ? 1 : -1;
 int e = (int)((bits >> 52) & 0x7ffL);
 long m = (e == 0) ?
                 (bits & 0xfffffffffffffL) << 1 :
                 (bits & 0xfffffffffffffL) | 0x10000000000000L;
 

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

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

public int compareTo(Double anotherDouble)

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

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

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

public static int compare(double d1, double d2)

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

    new Double(d1).compareTo(new Double(d2))
 

public static double sum(double a, double b)

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

public static double max(double a, double b)

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

public static double min(double a, double b)

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

public Optional<Double> describeConstable()

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

public Double resolveConstantDesc(MethodHandles.Lookup lookup)

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