Класс Double

• Если аргумент NaN, результат — строка "NaN".
• В противном случае результат — строка, представляющая знак и модуль (абсолютное значение) аргумента. Если знак отрицательный, первый символ результата — '-' ('\u002D'); если знак положительный, символ знака в результате отсутствует. Что касается модуля m:
  • Если m — бесконечность, она представляется символами "Infinity"; таким образом, положительная бесконечность даёт результат "Infinity", а отрицательная — результат "-Infinity".
  • Если m — ноль, она представляется символами "0.0"; таким образом, отрицательный ноль даёт результат "-0.0", а положительный — результат "0.0".
  • В противном случае m — положительное и конечное значение. Оно преобразуется в строку в два этапа:
    • Выбор десятичного представления: Выбирается хорошо определённое десятичное число d_m для представления m. Это десятичное число (почти всегда) является кратчайшим, которое округляется до m в соответствии с политикой округления до ближайшего значения IEEE 754 для чисел с плавающей запятой.
    • Форматирование как строки: Десятичное число d_m форматируется как строка, либо в обычном, либо в компьютерном научном формате, в зависимости от его значения.

Десятичное число — это число вида s×10ⁱ для некоторых (уникальных) целых чисел s > 0 и i, таких что s не является кратным 10. Эти целые числа являются соответственно мантиссой и экспонентой десятичного числа. Длина десятичного числа — это (уникальное) положительное целое число n, удовлетворяющее условию 10^n-1 ≤ s < 10ⁿ.

Десятичное число d_m для конечного положительного m определяется следующим образом:

• Пусть R — множество всех десятичных чисел, которые округляются до m в соответствии с обычной политикой округления до ближайшего значения IEEE 754 для чисел с плавающей запятой.
• Пусть p — минимальная длина среди всех десятичных чисел в R.
• Когда p ≥ 2, пусть T — множество всех десятичных чисел в R с длиной p. В противном случае пусть T — множество всех десятичных чисел в R с длиной 1 или 2.
• Определите d_m как десятичное число в T, которое наиболее близко к m. Или, если таких десятичных чисел в T два, выберите то, у которого чётная мантисса.

Выбранное (уникальное) десятичное число d_m затем форматируется. Пусть s, i и n — соответственно мантисса, экспонента и длина d_m. Кроме того, пусть e = n + i - 1, и пусть s₁…s_n — обычная десятичная запись s. Обратите внимание, что s₁ ≠ 0 и s_n ≠ 0. Ниже, десятичная точка '.' является '\u002E', а индикатор экспоненты 'E' равен '\u0045'.

• Случай -3 ≤ e < 0: d_m форматируется как 0.0…0s₁…s_n, где ровно -(n + i) нулей находятся между десятичной точкой и s₁. Например, 123 × 10^-4 форматируется как 0.0123.
• Случай 0 ≤ e < 7:
  • Подслучай i ≥ 0: d_m форматируется как s₁…s_n0…0.0, где ровно i нулей находятся между s_n и десятичной точкой. Например, 123 × 10² форматируется как 12300.0.
  • Подслучай i < 0: d_m форматируется как s₁…s_n+i.s_n+i+1…s_n, где ровно -i цифр находятся справа от десятичной точки. Например, 123 × 10^-1 форматируется как 12.3.
• Случай e < -3 или e ≥ 7: используется компьютерный научный формат для форматирования d_m. Здесь e форматируется как в Integer.toString(int).
  • Подслучай n = 1: d_m форматируется как s₁.0Ee. Например, 1 × 10²³ форматируется как 1.0E23.
  • Подслучай n > 1: d_m форматируется как s₁.s₂…s_nEe. Например, 123 × 10^-21 форматируется как 1.23E-19.

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

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

Если 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

Обратите внимание, что заключительные спецификаторы формата, определяющие тип числа с плавающей запятой (1.0f — это значение типа float; 1.0d — это значение типа double), не влияют на результаты этого метода. Другими словами, числовое значение входной строки преобразуется непосредственно в целевой тип числа с плавающей запятой. Последовательность преобразований «строка в float, а затем float в double» не эквивалентна прямому преобразованию строки в double. Например, числовая константа float 0.1f равна значению с плавающей запятой double; числовая константа float 0.1f представляет другое числовое значение, чем числовая константа double 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
 }

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

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

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

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

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

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

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

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

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

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

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

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

Если аргумент равен 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;

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

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

    Double.valueOf(d1).compareTo(Double.valueOf(d2))