Класс Double

Все реализованные интерфейсы:
Serializable, Comparable<Double> 
public final class Double
extends Number
implements Comparable<Double>

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

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

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

Поля

Модификатор и тип Поле Описание
static int BYTES

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

Максимальный порядок конечной переменной типа double.
static double MAX_VALUE

Константа, хранящая наибольшее положительное конечное значение типа double, (2-2-52)·21023.
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​(String s)

Устарело.

Использовать этот конструктор редко уместно.

Методы

Модификатор и тип Метод Описание
byte byteValue()

Возвращает значение этого Double как byte после сужающего преобразования примитива.
static int compare​(double d1, double d2)

Сравнивает два указанных значения double.
int compareTo​(Double anotherDouble)

Сравнивает два объекта Double численно.
static long doubleToLongBits​(double value)

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

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

Возвращает значение double этого объекта Double.
boolean equals​(Object obj)

Сравнивает этот объект с указанным объектом.
float floatValue()

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

Возвращает хэш-код для этого объекта Double.
static int hashCode​(double value)

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

Возвращает значение этого Double как int после сужающего преобразования примитива.
static boolean isFinite​(double d)

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

Возвращает true если это значение Double бесконечно велико по модулю; в противном случае false.
static boolean isInfinite​(double v)

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

Возвращает true если это значение Double является значением Не Число (NaN); в противном случае false.
static boolean isNaN​(double v)

Возвращает true если указанное число является значением Не Число (NaN); в противном случае false.
static double longBitsToDouble​(long bits)

Возвращает значение double соответствующее заданному битовому представлению.
long longValue()

Возвращает значение этого Double как long после сужающего преобразования примитива.
static double max​(double a, double b)

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

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

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

Возвращает значение этого Double как short после сужающего преобразования примитива.
static double sum​(double a, double b)

Складывает два значения double вместе в соответствии с оператором +.
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)·21023. Она равна шестнадцатеричной плавающей точке 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.

С:
1.1

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

Double

@Deprecated(since="9")
public Double(double value)
Устаревший.
Использование этого конструктора редко уместно. Статический фабричный метод valueOf(double) обычно является лучшим выбором, так как, вероятно, обеспечит значительно лучшую производительность в отношении памяти и времени.

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

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

Double

@Deprecated(since="9")
public Double(String s)
       throws NumberFormatException
Устаревший.
Использование этого конструктора редко уместно. Используйте parseDouble(String) для преобразования строки в примитивное значение double или valueOf(String) для преобразования строки в объект Double.

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

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

Методы

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, но меньше 107, то он представляется целой частью m в десятичном формате без ведущих нулей, за которым следует '.' ('\u002E'), за которым следуют одна или несколько десятичных цифр, представляющих дробную часть m.
    • Если m меньше 10-3 или больше или равен 107, то он представляется в так называемой "компьютерной научной записи". Пусть n — единственное целое число такое, что 10n ≤ m < 10n+1; затем пусть a — математически точное частное от деления m на 10n, так что 1 ≤ a < 10. Модуль затем представляется целой частью a как одиночная десятичная цифра, за которой следует '.' ('\u002E'), за которой следуют десятичные цифры, представляющие дробную часть a, за которой следует буква 'E' ('\u0045'), за которой следует представление n как целого десятичного числа, полученного методом Integer.toString(int).
Сколько цифр должно быть напечатано для дробной части m или a? Должна быть хотя бы одна цифра для представления дробной части, а после этого столько же, сколько необходимо для уникального различения значения аргумента от соседних значений типа double. То есть, предположим, что x — точное математическое значение, представленное десятичным представлением, полученным этим методом для конечного ненулевого аргумента d. Тогда d должно быть значением, ближайшим к x; или если два значения double равноудалены от x, тогда d должно быть одним из них, и самый младший бит значащих цифр d должен быть 0.

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

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

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:
Signopt NaN
Signopt Infinity
Signopt FloatingPointLiteral
Signopt HexFloatingPointLiteral
SignedInteger
HexFloatingPointLiteral:
HexSignificand BinaryExponent FloatTypeSuffixopt
HexSignificand:
HexNumeral
HexNumeral .
0x HexDigitsopt . HexDigits
0X HexDigitsopt . 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 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
  }
Параметры:
s - строка, подлежащая разбору.
Возвращает:
объект Double, содержащий значение, представленное аргументом String.
Выбрасывает:
NumberFormatException - если строка не содержит разборного числа.

valueOf

public static Double valueOf(double d)

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

Параметры:
d - значение типа 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 - значение double для проверки
Возвращает:
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 с одним аргументом.

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

byteValue

public byte byteValue()

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

Переопределяет:
byteValue в классе Number
Возвращает:
значение double представляемое этим объектом, преобразованное в тип byte
С:
1.1

shortValue

public short shortValue()

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

Переопределяет:
shortValue в классе Number
Возвращает:
значение double представляемое этим объектом, преобразованное в тип short
С:
1.1

intValue

public int intValue()

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

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

longValue

public long longValue()

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

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

floatValue

public float floatValue()

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

Указано в:
floatValue в классе Number
Возвращает:
значение double представляемое этим объектом, преобразованное в тип float
С:
1.0

doubleValue

public double doubleValue()

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

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

hashCode

public int hashCode()

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

(int)(v^(v>>>32))
, где v определяется следующим образом: 
long v = Double.doubleToLongBits(this.doubleValue());

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

hashCode

public static int hashCode(double value)

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

Параметры:
value - значение, подлежащее хэшированию
Возвращает:
значение кода хэша для значения double.
С:
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.
Это определение позволяет правильно работать таблицам хеширования.
Переопределяет:
equals в классе Object
Параметры:
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).

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

doubleToRawLongBits

public static long doubleToRawLongBits(double value)

Возвращает представление указанного значения с плавающей запятой в соответствии с битовым представлением формата чисел с плавающей запятой IEEE 754 «double», сохраняя значения Не Число (NaN).

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

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

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

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

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

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

longBitsToDouble

public static double longBitsToDouble(long bits)

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

Если аргумент — 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·2e-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.

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

compareTo

public int compareTo(Double anotherDouble)

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

  • Double.NaN считается этим методом равным самому себе и больше всех остальных значений с плавающей запятой (включая 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)

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

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

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

sum

public static double sum(double a,
                         double b)

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

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

max

public static double max(double a,
                         double b)

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

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

min

public static double min(double a,
                         double b)

Возвращает меньшее из двух значений с плавающей запятой, как если бы вызывали 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.
https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Double.html

Spec-Zone .ru
спецификации, руководства, описания, API