Класс 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))