模块  java.base
软件包  java.lang

Class Double

  • 实现的所有接口
    SerializableComparable<Double>

    public final class Doubleextends Numberimplements Comparable<Double>
    Double类在对象中包装基本类型double的值。 类型为Double的对象包含单个字段,其类型为double

    此外,此类提供了几种将double转换为StringString转换为double ,以及处理double时有用的其他常量和方法。

    从以下版本开始:
    1.0
    另请参见:
    Serialized Form
    • 字段汇总

      字段  
      变量和类型 字段 描述
      static int BYTES
      用于表示 double值的字节数。
      static int MAX_EXPONENT
      最大指数有限 double变量可能有。
      static double MAX_VALUE
      持有 double类型的最大正有限值的 double ,(2-2 -52 )·2 1023
      static int MIN_EXPONENT
      标准化 double变量的最小指数可能有。
      static double MIN_NORMAL
      保持 double -1022类型的最小正正常值的常量。
      static double MIN_VALUE
      保持 double类型的最小正非零值的 常量
      static double NaN
      保持类型为 double非数字(NaN)值的 double
      static double NEGATIVE_INFINITY
      持有 double类型的负无穷大的 double
      static double POSITIVE_INFINITY
      保持 double类型的正无穷大的 double
      static int SIZE
      用于表示 double值的位数。
      static <Double> TYPE
      实例表示基本类型 double
    • 构造方法摘要

      构造方法  
      构造器 描述
      Double​(double value)
      已过时。
      使用此构造函数很少是合适的。
      Double​(String s)
      已过时。
      使用此构造函数很少是合适的。
    • 方法摘要

      所有方法  静态方法  实例方法 具体的方法 
      变量和类型 方法 描述
      byte byteValue()
      返回此值 Doublebyte的基本收缩转换后。
      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()
      返回此值 Doublefloat的基本收缩转换后。
      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()
      返回此值 Doublelong的基本收缩转换后。
      static double max​(double a, double b)
      返回两个 double值中较大的一个, double调用 Math.max一样
      static double min​(double a, double b)
      返回两个 double值中较小的一个, double调用 Math.min一样
      static double parseDouble​(String s)
      返回一个新 double初始化为指定的代表的值 String ,如通过执行 valueOf类的方法 Double
      short shortValue()
      返回此值 Doubleshort的基本收缩转换后。
      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表示的 double值。
    • 字段详细信息

      • POSITIVE_INFINITY

        public static final double POSITIVE_INFINITY
        持有double型正无穷大的double 它等于Double.longBitsToDouble(0x7ff0000000000000L)返回的值。
        另请参见:
        常数字段值
      • NEGATIVE_INFINITY

        public static final double NEGATIVE_INFINITY
        持有double类型的负无穷大的double 它等于Double.longBitsToDouble(0xfff0000000000000L)返回的值。
        另请参见:
        常数字段值
      • NaN

        public static final double NaN
        保持类型为double非数字(NaN)值的double 它相当于Double.longBitsToDouble(0x7ff8000000000000L)返回的值。
        另请参见:
        常数字段值
      • MAX_VALUE

        public static final double MAX_VALUE
        持有double类型的最大正有限值的double ,(2-2 -52 )·2 1023 它等于十六进制浮点文字0x1.fffffffffffffP+1023 ,也等于Double.longBitsToDouble(0x7fefffffffffffffL)
        另请参见:
        常数字段值
      • MIN_NORMAL

        public static final double MIN_NORMAL
        保持double -1022类型的最小正正常值的常量。 它等于十六进制浮点文字0x1.0p-1022 ,也等于Double.longBitsToDouble(0x0010000000000000L)
        从以下版本开始:
        1.6
        另请参见:
        常数字段值
      • MIN_VALUE

        public static final double MIN_VALUE
        保持double类型的最小正非零值的常量 它等于十六进制浮点文字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 <Double> TYPE
        实例表示基本类型 double
        从以下版本开始:
        1.1
    • 构造方法详细信息

      • Double

        @Deprecated(since="9")public Double​(double value)
        Deprecated.
        It is rarely appropriate to use this constructor. The static factory valueOf(double) is generally a better choice, as it is likely to yield significantly better space and time performance.
        构造一个新分配的 Double对象,该对象表示原始 double参数。
        参数
        value - 由 Double表示的值。
      • Double

        @Deprecated(since="9")public Double​(String s)       throws NumberFormatException
        Deprecated.
        It is rarely appropriate to use this constructor. Use parseDouble(String) to convert a string to a double primitive, or use valueOf(String) to convert a string to a Double object.
        构造一个新分配的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但小于10 7 ,那么它表示为m的整数部分,以十进制形式表示,没有前导零,后跟' . '( '\u002E' ),后跟一个或多个表示m的小数部分的十进制数字。
          • 如果m小于10 -3或大于或等于10 7 ,则表示为所谓的“计算机化科学记数法”。 n是唯一的整数,使得10N的‰¤ <10 N + 1; 然后让一个m的精确算术商和10 牛顿 ,使1个≤ 一个 <10.然后将大小被表示为a的整数部分,作为一个单一的十进制数字,后跟“ . ”( '\u002E' ),再后面是表示一个小数部分十进制数字,后面跟有字母“ E ”( '\u0045' ),接着为十进制整数n的表示,作为由该方法制备Integer.toString(int)
        ma的小数部分必须打印多少位? 必须至少有一个数字来表示小数部分,并且除此之外必须有多个,但只有多少个,更多的数字才能唯一地将参数值与类型double相邻值区double 也就是说,假设x是由此方法为有限非零参数d生成的十进制表示所表示的精确数学值。 那么d必须是最接近xdouble值; 或者如果两个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是具有规范化表示的double值,则子串用于表示有效数和指数字段。 有效数字由字符"0x1."表示,后跟有效数字的其余部分的小写十六进制表示形式作为分数。 除非所有数字都为零,否则将删除十六进制表示中的尾随零,在这种情况下使用单个零。 接下来,指数由"p"表示,后跟无偏指数的十进制字符串,就好像通过对指数值调用Integer.toString产生的一样。
          • 如果m是具有次正规表示的double值,则有效数字由字符"0x0."表示,后跟有效数字的其余部分的十六进制表示形式作为分数。 删除十六进制表示中的尾随零。 接下来,指数由"p-1022"表示。 请注意,在次正规有效数中必须至少有一个非零数字。
        Examples Floating-point Value Hexadecimal String 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表示的double值。

        如果snull ,则抛出NullPointerException

        s中的前导和尾随空格字符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
        其中SignFloatingPointLiteralHexNumeralHexDigitsSignedIntegerFloatTypeSuffixThe Java™ Language Specification的词法结构部分中定义 ,除了数字之间不接受下划线。 如果s不具有的floatValue的形式,那么NumberFormatException异常。 否则, s被视为代表通常的“计算机化科学记数法”中的精确十进制值或精确的十六进制值; 然后,这个精确的数值在概念上被转换为“无限精确”的二进制值,然后通过IEEE 754浮点运算的通常的舍入到最接近的规则四舍五入到double类型,其中包括保留零值的符号。 请注意,舍入到最近的规则也意味着溢出和下溢行为; 如果s的确切值足够大(大于或等于( MAX_VALUE + ulp(MAX_VALUE)/2 ),则舍入到double将导致无穷大,如果s的确切值足够小(小于或等于)到MIN_VALUE/2 ),舍入到浮点将导致零。最后,在舍入后,返回表示此double值的Double对象。

        要解释浮点值的本地化字符串表示形式,请使用NumberFormat子类。

        请注意,尾随格式说明符,确定浮点文字类型的说明符( 1.0ffloat值; 1.0ddouble值), 不会影响此方法的结果。 换句话说,输入字符串的数值直接转换为目标浮点类型。 两步转换序列,字符串为float后跟floatdouble等于将字符串直接转换为double 例如, float文字0.1f等于double0.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 - 双 d值。
        结果
        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
        结果
        String此对象的表示形式。
        另请参见:
        toString(double)
      • byteValue

        public byte byteValue()
        返回此值 Doublebyte的基本收缩转换后。
        重写:
        byteValue在类 Number
        结果
        此对象表示的 double值已转换为类型 byte
        从以下版本开始:
        1.1
        See The Java™ Language Specification:
        5.1.3缩小原始转换
      • shortValue

        public short shortValue()
        返回此值 Doubleshort的基本收缩转换后。
        重写:
        shortValue在类 Number
        结果
        此对象表示的 double值转换为类型 short
        从以下版本开始:
        1.1
        See The Java™ Language Specification:
        5.1.3缩小原始转换
      • intValue

        public int intValue()
        返回此的值 Double作为 int的基本收缩转换之后。
        Specified by:
        intValueNumber
        结果
        此对象表示的 double值转换为类型 int
        See The Java™ Language Specification:
        5.1.3缩小原始转换
      • longValue

        public long longValue()
        返回此值 Doublelong的基本收缩转换后。
        Specified by:
        longValue在类 Number
        结果
        此对象表示的 double值转换为类型 long
        See The Java™ Language Specification:
        5.1.3缩小原始转换
      • floatValue

        public float floatValue()
        返回此值 Doublefloat的基本收缩转换后。
        Specified by:
        floatValue在类 Number
        结果
        此对象表示的 double值转换为类型 float
        从以下版本开始:
        1.0
        See The Java™ Language Specification:
        5.1.3缩小原始转换
      • doubleValue

        public double doubleValue()
        返回此 Double对象的 double值。
        Specified by:
        doubleValue在类 Number
        结果
        此对象表示的 double
      • 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 为此目的,当且仅当方法doubleToLongBits(double)在应用于每个时返回相同的long值时,才认为两个double值相同。

        请注意,在大多数情况下,类的两个实例Doubled1d2 ,价值d1.equals(d2)true当且仅当

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

        也有价值true 但是,有两个例外:

        • 如果d1d2均表示Double.NaN ,则equals方法返回true ,即使Double.NaN==Double.NaN的值为false
        • 如果d1代表+0.0d2代表-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浮点“双格式”位布局返回指定浮点值的表示形式。

        位63(由掩码0x8000000000000000L选择的位)表示浮点数的符号。 比特62-52(由掩码0x7ff0000000000000L选择的比特)表示指数。 比特51-0(由掩码0x000fffffffffffffL选择的比特)表示0x000fffffffffffffL的有效数(有时称为尾数)。

        如果参数为正无穷大,则结果为0x7ff0000000000000L

        如果参数为负无穷大,则结果为0xfff0000000000000L

        如果参数为NaN,则结果为0x7ff8000000000000L

        在所有情况下,结果都是一个long整数,当给定longBitsToDouble(long)方法时,将生成与doubleToLongBits的参数相同的浮点值(除了所有NaN值都折叠为单个“规范”NaN值)。

        参数
        value - 精度为 double浮点数。
        结果
        表示浮点数的位。
      • doubleToRawLongBits

        public static long doubleToRawLongBits​(double value)
        根据IEEE 754浮点“双格式”位布局返回指定浮点值的表示,保留非数字(NaN)值。

        位63(由掩码0x8000000000000000L选择的位)表示浮点数的符号。 比特62-52(由掩码0x7ff0000000000000L选择的比特)表示指数。 位51-0(由掩码0x000fffffffffffffL选择的位)表示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)
        返回与给定位表示相对应的double值。 该参数被认为是根据IEEE 754浮点“双格式”位布局的浮点值的表示。

        如果参数为0x7ff0000000000000L ,则结果为正无穷大。

        如果参数为0xfff0000000000000L ,则结果为负无穷大。

        如果参数在上述范围内的任何值0x7ff0000000000001L通过0x7fffffffffffffffL或在范围0xfff0000000000001L通过0xffffffffffffffffL ,结果是NaN。 Java提供的IEEE 754浮点运算不能区分具有不同位模式的相同类型的两个NaN值。 不同的NaN值只能通过使用Double.doubleToRawLongBits方法来区分。

        在所有其他情况下,让sem为可以从参数计算的三个值:

         int s = ((bits >> 63) == 0) ? 1 : -1; int e = (int)((bits >> 52) & 0x7ffL); long m = (e == 0) ?                 (bits & 0xfffffffffffffL) << 1 :                 (bits & 0xfffffffffffffL) | 0x10000000000000L; 
        然后浮点结果等于数学表达式值· m ·2 e -1075

        请注意,此方法可能无法返回具有与long参数完全相同的位模式的double NaN。 IEEE 754区分了两种NaN,即安静的NaN和信号NaN 两种NaN之间的差异通常在Java中不可见。 对信令NaN的算术运算将它们转换为具有不同但通常类似的位模式的安静NaN。 然而,在一些处理器上,仅复制信令NaN也执行该转换。 特别地,复制信令NaN以将其返回到调用方法可以执行该转换。 因此, longBitsToDouble可能无法返回具有信令NaN位模式的double 因此,对于某些long值, doubleToRawLongBits(longBitsToDouble(start))可能等于start 此外,哪些特定位模式表示信令NaN是平台相关的; 虽然所有NaN位模式,安静或信令,必须在上面确定的NaN范围内。

        参数
        bits - 任何 long整数形式。
        结果
        double具有相同位模式的浮点值。
      • compareTo

        public int compareTo​(Double anotherDouble)
        以数字方式比较两个Double对象。 当应用于原始double值时,此方法执行的比较有两种方式与Java语言数值比较运算符( <, <=, ==, >=, > )执行的比较不同:
        • 此方法认为Double.NaN等于其自身且大于所有其他double值(包括Double.POSITIVE_INFINITY )。
        • 0.0d通过该方法被认为是大于-0.0d
        这确保了此方法强加的Double对象的自然顺序 与equals一致
        Specified by:
        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 - 第二个操作数
        结果
        总和 ab
        从以下版本开始:
        1.8
        另请参见:
        BinaryOperator
        See The Java™ Language Specification:
        4.2.4浮点运算
      • max

        public static double max​(double a,                         double b)
        返回两个 double值中较大的一个, double调用 Math.max一样
        参数
        a - 第一个操作数
        b - 第二个操作数
        结果
        ab的较大者
        从以下版本开始:
        1.8
        另请参见:
        BinaryOperator
      • min

        public static double min​(double a,                         double b)
        返回两个 double值中较小的一个, double调用 Math.min一样
        参数
        a - 第一个操作数
        b - 第二个操作数
        结果
        较小的 ab
        从以下版本开始:
        1.8
        另请参见:
        BinaryOperator