Класс Double

• Если аргумент равен NaN, результатом является строка "NaN".
• В противном случае результатом является строка, представляющая знак и модуль (абсолютное значение) аргумента. Если знак отрицательный, первый символ результата — '-' ('\u002D'); если знак положительный, в результате не отображается символ знака. Что касается модуля m:
  • Если m — бесконечность, она представляется символами "Infinity"; таким образом, положительная бесконечность дает результат "Infinity", а отрицательная бесконечность — "-Infinity".
  • Если m равен нулю, он представляется символами "0.0"; таким образом, отрицательный ноль дает результат "-0.0", а положительный ноль — "0.0".
  • В противном случае m — положительное конечное число. Оно преобразуется в строку в два этапа:
    • Выбор десятичного числа: Для представления m выбирается однозначно определенное десятичное число d_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, где между десятичным разделителем и s₁ находится ровно -(n + i) нулей. Например, 123 × 10^-4 форматируется как 0.0123.
• Случай 0 ≤ e < 7:
  • Подслучай i ≥ 0: d_m форматируется как s₁…s_n0…0.0, где между s_n и десятичным разделителем находится ровно i нулей. Например, 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 — значение double с нормализованным представлением, для представления полей значащей части и показателя степени используются подстроки. Значащая часть представляется символами "0x1.", за которыми следует строчное шестнадцатеричное представление оставшейся части значащей части в виде дроби. Конечные нули в шестнадцатеричном представлении удаляются, если только все цифры не равны нулю; в этом случае используется один ноль. Затем показатель степени представляется символом "p", за которым следует десятичная строка смещенного показателя степени, как если бы она была получена вызовом Integer.toString для значения показателя степени.
  • Если m — значение double с субнормальным представлением, значащая часть представляется символами "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 0.10000000149011612; литерал 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;

Обратите внимание: этот метод может оказаться не в состоянии вернуть значение NaN double с тем же битовым шаблоном, что и у аргумента 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))