Класс Double

java.lang.Object
- java.lang.Number
- - java.lang.Double

Все реализованные интерфейсы:: Serializable, Comparable<Double>

public final class Double
extends Number
implements Comparable<Double>

Класс Double оборачивает значение примитивного типа double в объект. Объект типа Double содержит единственное поле типа double.

Кроме того, этот класс предоставляет несколько методов для преобразования double в String и String в double, а также другие константы и методы, полезные при работе с double.

С момента:: JDK1.0
См. также:: Сериализованная форма

Поля

Модификатор и тип	Поле и описание
`static int`	`BYTES` Количество байтов, используемых для представления значения `double`.
`static int`	`MAX_EXPONENT` Максимальный порядок (экспонента) конечной переменной типа `double`.
`static double`	`MAX_VALUE` Константа, содержащая наибольшее положительное конечное значение типа `double`, (2-2^-52)·2¹⁰²³.
`static int`	`MIN_EXPONENT` Минимальный порядок (экспонента) нормированной переменной типа `double`.
`static double`	`MIN_NORMAL` Константа, содержащая наименьшее положительное нормализованное значение типа `double`, 2^-1022.
`static double`	`MIN_VALUE` Константа, содержащая наименьшее положительное ненулевое значение типа `double`, 2^-1074.
`static double`	`NaN` Константа, содержащая значение «не число» (NaN) типа `double`.
`static double`	`NEGATIVE_INFINITY` Константа, содержащая отрицательную бесконечность типа `double`.
`static double`	`POSITIVE_INFINITY` Константа, содержащая положительную бесконечность типа `double`.
`static int`	`SIZE` Количество бит, используемых для представления значения `double`.
`static Class<Double>`	`TYPE` Экземпляр `Class` представляющий примитивный тип `double`.

Конструкторы

Конструктор и описание
`Double(double value)` Создает новый объект `Double`, представляющий примитивный аргумент `double`.
`Double(String s)` Создает новый объект `Double`, представляющий значение с плавающей запятой типа `double`, представленное строкой.

Методы

Модификатор и тип	Метод и описание
`byte`	`byteValue()` Возвращает значение этого объекта `Double` как `byte` после сужения примитивного преобразования.
`static int`	`compare(double d1, double d2)` Сравнивает два указанных значения `double`.
`int`	`compareTo(Double anotherDouble)` Сравнивает два объекта `Double` численно.
`static long`	`doubleToLongBits(double value)` Возвращает представление указанного значения с плавающей запятой в соответствии с битовым представлением IEEE 754 «формат double».
`static long`	`doubleToRawLongBits(double value)` Возвращает представление указанного значения с плавающей запятой в соответствии с битовым представлением IEEE 754 «формат double», сохраняя значения «не число» (NaN).
`double`	`doubleValue()` Возвращает значение с плавающей запятой этого объекта `Double`.
`boolean`	`equals(Object obj)` Сравнивает этот объект с указанным объектом.
`float`	`floatValue()` Возвращает значение этого объекта `Double` как `float` после сужения примитивного преобразования.
`int`	`hashCode()` Возвращает код хэширования для этого объекта `Double`.
`static int`	`hashCode(double value)` Возвращает код хэширования для значения с плавающей запятой; совместимо с `Double.hashCode()`.
`int`	`intValue()` Возвращает значение этого объекта `Double` как `int` после сужения примитивного преобразования.
`static boolean`	`isFinite(double d)` Возвращает `true` если аргумент является конечным значением с плавающей запятой; возвращает `false` в противном случае (для аргументов NaN и бесконечности).
`boolean`	`isInfinite()` Возвращает `true` если это значение с плавающей запятой имеет бесконечно большую величину; `false` в противном случае.
`static boolean`	`isInfinite(double v)` Возвращает `true` если заданное число имеет бесконечно большую величину; `false` в противном случае.
`boolean`	`isNaN()` Возвращает `true` если это значение с плавающей запятой является значением «не число» (NaN); `false` в противном случае.
`static boolean`	`isNaN(double v)` Возвращает `true` если указанное число является значением «не число» (NaN); `false` в противном случае.
`static double`	`longBitsToDouble(long bits)` Возвращает значение с плавающей запятой, соответствующее заданному битовому представлению.
`long`	`longValue()` Возвращает значение этого объекта `Double` как `long` после сужения примитивного преобразования.
`static double`	`max(double a, double b)` Возвращает большее из двух значений с плавающей запятой, как если бы вызывали `Math.max`.
`static double`	`min(double a, double b)` Возвращает меньшее из двух значений с плавающей запятой, как если бы вызывали `Math.min`.
`static double`	`parseDouble(String s)` Возвращает новый объект `double`, инициализированный значением, представленным указанным `String`, как выполняется методом `valueOf` класса `Double`.
`short`	`shortValue()` Возвращает значение этого объекта `Double` как `short` после сужения примитивного преобразования.
`static double`	`sum(double a, double b)` Складывает два значения с плавающей запятой вместе в соответствии с оператором +.
`static String`	`toHexString(double d)` Возвращает шестнадцатеричное строковое представление аргумента `double`.
`String`	`toString()` Возвращает строковое представление этого объекта `Double`.
`static String`	`toString(double d)` Возвращает строковое представление аргумента `double`.
`static Double`	`valueOf(double d)` Возвращает экземпляр `Double`, представляющий указанное значение с плавающей запятой `double`.
`static Double`	`valueOf(String s)` Возвращает объект `Double`, содержащий значение `double`, представленное строкой-аргументом `s`.

Методы, унаследованные от класса java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Поля

POSITIVE_INFINITY

public static final double POSITIVE_INFINITY

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

См. также:: Значения константных полей

NEGATIVE_INFINITY

public static final double NEGATIVE_INFINITY

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

См. также:: Значения константных полей

NaN

public static final double NaN

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

См. также:: Значения константных полей

MAX_VALUE

public static final double MAX_VALUE

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

См. также:: Значения константных полей

MIN_NORMAL

public static final double MIN_NORMAL

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

С тех пор как:: 1.6
См. также:: Значения константных полей

MIN_VALUE

public static final double MIN_VALUE

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

См. также:: Значения константных полей

MAX_EXPONENT

public static final int MAX_EXPONENT

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

С тех пор как:: 1.6
См. также:: Значения константных полей

MIN_EXPONENT

public static final int MIN_EXPONENT

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

С тех пор как:: 1.6
См. также:: Значения константных полей

SIZE

public static final int SIZE

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

С тех пор как:: 1.5
См. также:: Значения константных полей

BYTES

public static final int BYTES

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

С тех пор как:: 1.8
См. также:: Значения константных полей

TYPE

public static final Class<Double> TYPE

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

С тех пор как:: JDK1.1

Конструкторы

Double

public Double(double value)

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

Параметры:: value - значение, которое будет представлено объектом Double.

Double

public Double(String s)
       throws NumberFormatException

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

Параметры:: s - строка, которая должна быть преобразована в число с плавающей точкой.
Исключения:: NumberFormatException - если строка не содержит парсируемого числа.
См. также:: valueOf(java.lang.String)

Методы

toString

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

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

Параметры:: d - число с плавающей точкой для преобразования.
Возвращает:: строковое представление аргумента.

toHexString

public static String toHexString(double d)

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

Параметры:: d - преобразуемое double.
Возвращает:: шестнадцатеричное строковое представление аргумента.
С:: 1.5

valueOf

public static Double valueOf(String s)
                      throws NumberFormatException

Возвращает объект Double, содержащий значение 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. Например, литерал float равен значению double с плавающей точкой; литерал float представляет другое числовое значение, чем литерал double с плавающей точкой. (Число 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
  }

Параметры:: s - строка для разбора.
Возвращает:: объект Double, содержащий значение, представленное строкой-аргументом.
Исключения:: NumberFormatException - если строка не содержит разборчивого числа.

valueOf

public static Double valueOf(double d)

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

Параметры:: d - значение типа double.
Возвращает:: экземпляр Double типа Double, представляющий d.
С:: 1.5

parseDouble

public static double parseDouble(String s)
                          throws NumberFormatException

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

Параметры:: s - строка для разбора.
Возвращает:: значение типа double, представленное строкой-аргументом.
Исключения:: NullPointerException - если строка равна null; NumberFormatException - если строка не содержит разборчивого double.
С:: 1.2
См. также:: valueOf(String)

isNaN

public static boolean isNaN(double v)

Возвращает true, если заданное число — значение «не число» (NaN), false в противном случае.

Параметры:: v - проверяемое значение.
Возвращает:: true если значение аргумента равно NaN; false в противном случае.

isInfinite

public static boolean isInfinite(double v)

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

Параметры:: v - проверяемое значение.
Возвращает:: true если значение аргумента — положительная или отрицательная бесконечность; false в противном случае.

isFinite

public static boolean isFinite(double d)

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

Параметры:: d - проверяемое значение с плавающей точкой
Возвращает:: true если аргумент — конечное значение с плавающей точкой, false в противном случае.
С:: 1.8

isNaN

public boolean isNaN()

Возвращает true, если это значение Double — «не число» (NaN), false в противном случае.

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

isInfinite

public boolean isInfinite()

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

Возвращает:: true если значение, представленное этим объектом, равно положительной или отрицательной бесконечности; false в противном случае.

toString

public String toString()

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

Overrides:: toString в классе Object
Возвращает:: строковое представление этого объекта.
См. также:: toString(double)

byteValue

public byte byteValue()

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

Overrides:: byteValue в классе Number
Возвращает:: значение double , представленное этим объектом, преобразованное к типу byte
Since:: JDK1.1

shortValue

public short shortValue()

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

Overrides:: shortValue в классе Number
Возвращает:: значение double , представленное этим объектом, преобразованное к типу short
Since:: JDK1.1

intValue

public int intValue()

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

Specified by:: intValue в классе Number
Возвращает:: значение double , представленное этим объектом, преобразованное к типу int

longValue

public long longValue()

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

Specified by:: longValue в классе Number
Возвращает:: значение double , представленное этим объектом, преобразованное к типу long

floatValue

public float floatValue()

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

Specified by:: floatValue в классе Number
Возвращает:: значение double , представленное этим объектом, преобразованное к типу float
Since:: JDK1.0

doubleValue

public double doubleValue()

Возвращает значение double этого Double объекта.

Specified by:: doubleValue в классе Number
Возвращает:: значение double , представленное этим объектом

hashCode

public int hashCode()

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

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

где v определяется как:

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

Overrides:: hashCode в классе Object
Возвращает:: значение хэш-кода для этого объекта.
См. также:: Object.equals(java.lang.Object), System.identityHashCode(java.lang.Object)

hashCode

public static int hashCode(double value)

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

Parameters:: value - значение для хэширования
Возвращает:: значение хэш-кода для значения double.
Since:: 1.8

equals

public boolean equals(Object obj)

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

Обратите внимание, что в большинстве случаев для двух экземпляров класса Double, d1 и d2, значение d1.equals(d2) равно true тогда и только тогда

d1.doubleValue() == d2.doubleValue()

также имеет значение true. Однако есть два исключения:

Если d1 и d2 оба представляют Double.NaN, то метод equals возвращает true, даже если Double.NaN==Double.NaN имеет значение false.
Если d1 представляет +0.0 , в то время как d2 представляет -0.0, или наоборот, тест equal имеет значение false, даже если +0.0==-0.0 имеет значение true.

Это определение позволяет правильно работать хеш-таблицам.

Overrides:: equals в классе Object
Parameters:: obj - объект для сравнения.
Возвращает:: true если объекты одинаковы; false в противном случае.
См. также:: doubleToLongBits(double)

doubleToLongBits

public static long doubleToLongBits(double value)

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

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

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

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

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

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

Parameters:: value - число с плавающей запятой двойной точности.
Возвращает:: биты, представляющие число с плавающей запятой.

doubleToRawLongBits

public static long doubleToRawLongBits(double value)

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

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

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

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

Parameters:: value - число с плавающей запятой двойной точности.
Возвращает:: биты, представляющие число с плавающей запятой.
Since:: 1.3

longBitsToDouble

public static double longBitsToDouble(long bits)

Возвращает значение double соответствующее заданному битовому представлению. Аргумент рассматривается как представление значения с плавающей точкой в соответствии с битовой структурой формата "double" стандарта 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.

Обратите внимание, что этот метод может не быть способен вернуть 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, указанном выше.

Параметры:: bits - любое long целое число.
Возвращает:: значение double с плавающей точкой с тем же битовым представлением.

compareTo

public int compareTo(Double anotherDouble)

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

Double.NaN рассматривается этим методом как равное самому себе и большее, чем все остальные значения double (включая Double.POSITIVE_INFINITY).
0.0d рассматривается этим методом как большее, чем -0.0d.

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

Указано в:: compareTo в интерфейсе Comparable<Double>
Параметры:: anotherDouble - Double для сравнения.
Возвращает:: значение 0 , если anotherDouble численно равно этому Double; значение меньше 0 , если этот Double численно меньше anotherDouble; и значение больше 0 , если этот Double численно больше anotherDouble.
С:: 1.2

compare

public static int compare(double d1,
                          double d2)

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

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

Параметры:: d1 - первое значение double для сравнения; d2 - второе значение double для сравнения
Возвращает:: значение 0 , если d1 численно равно d2; значение меньше 0 , если d1 численно меньше d2; и значение больше 0 , если d1 численно больше d2.
С:: 1.4

sum

public static double sum(double a,
                         double b)

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

Параметры:: a - первый операнд; b - второй операнд
Возвращает:: сумма a и b
С:: 1.8
См. также:: BinaryOperator

max

public static double max(double a,
                         double b)

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

Параметры:: a - первый операнд; b - второй операнд
Возвращает:: большее из a и b
С:: 1.8
См. также:: BinaryOperator

min

public static double min(double a,
                         double b)

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

Параметры:: a - первый операнд; b - второй операнд
Возвращает:: меньшее из a и b.
С:: 1.8
См. также:: BinaryOperator

© 1993, 2020, Oracle and/or its affiliates. All rights reserved.
Documentation extracted from Debian's OpenJDK Development Kit package.
Licensed under the GNU General Public License, version 2, with the Classpath Exception.
Various third party code in OpenJDK is licensed under different licenses (see Debian package).
Java and OpenJDK are trademarks or registered trademarks of Oracle and/or its affiliates.