精华内容
下载资源
问答
  • 今天在开发过程中,加载界面,然后在初始化数据的时候报错“ ... Attempt to invoke virtual method 'double java.lang.Double.doubleValue()' on a null object reference”。定位报错代码到对应的行数: private

    今天在开发过程中,加载界面,然后在初始化数据的时候报错“  Caused by: java.lang.NullPointerException: Attempt to invoke virtual method 'double java.lang.Double.doubleValue()' on a null object reference”。定位报错代码到对应的行数:

     private Double totalExpenses; //提前声明好了变量
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_decoration_bills);
    
           .......
           totalExpenses = totalExpenses + pay;
           .......
    
        }
    


    这是因为 声明的全局变量totalExpenses,没有初始化。改成:初始化就好了 就不会报空指针了

    private Double totalExpenses = 0.0;


    这些小的细节很重要。


    展开全文
  • int cannot be converted to double java

    千次阅读 2018-08-15 17:39:11
    amp;qa_1=eatsleepdrink-int-cannot-be-converted-to-double https://stackoverflow.com/questions/5566336/classcastexception-casting-integer-to-doub...
    展开全文
  • java Double

    千次阅读 2015-09-24 10:00:46
    java.lang 类 Double java.lang.Object ... java.lang.Double 所有已实现的接口:Serializable, Comparable public final class Doubleextends Numberimplements Comparable Double 类在对象

    java.lang
    类 Double

    java.lang.Object
      java.lang.Number
          java.lang.Double
    
    所有已实现的接口:
    Serializable, Comparable<Double>

    public final class Double
    extends Numberimplements Comparable<Double>

    Double 类在对象中包装一个基本类型 double 的值。每个 Double 类型的对象都包含一个 double 类型的字段。

    此外,该类还提供多个方法,可以将 double 转换为 String,将 String 转换为 double,也提供了其他一些处理 double 时有用的常量和方法。

    从以下版本开始:
    JDK1.0
    另请参见:
    序列化表格

    字段摘要
    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 
              保存 double 类型的 NaN 值的常量。
    static double NEGATIVE_INFINITY 
              保存 double 类型的负无穷大值的常量。
    static double POSITIVE_INFINITY 
              保存 double 类型的正无穷大值的常量。
    static int SIZE 
              用于表示 double 值的位数。
    static Class<Double> TYPE 
              表示基本类型 double 的 Class 实例。
     
    构造方法摘要
    Double(double value) 
              构造一个新分配的 Double 对象,它表示基本的 double 参数。
    Double(String s) 
              构造一个新分配的 Double 对象,表示用字符串表示的 double 类型的浮点值。
     
    方法摘要
     byte byteValue() 
              以 byte 形式返回此 Double 的值(通过强制转换为 byte)。
    static int compare(double d1, double d2) 
              比较两个指定的 double 值。
     int compareTo(Double anotherDouble) 
              对两个 Double 对象所表示的数值进行比较。
    static long doubleToLongBits(double value) 
              根据 IEEE 754 浮点双精度格式 ("double format") 位布局,返回指定浮点值的表示形式。
    static long doubleToRawLongBits(double value) 
              根据 IEEE 754 浮点“双精度格式”位布局,返回指定浮点值的表示形式,并保留 NaN 值。
     double doubleValue() 
              返回此 Double 对象的 double 值。
     boolean equals(Object obj) 
              将此对象与指定对象比较。
     float floatValue() 
              返回此 Double 对象的 float 值。
     int hashCode() 
              返回此 Double 对象的哈希码。
     int intValue() 
              以 int 形式返回此 Double 的值(通过强制转换为 int 类型)。
     boolean isInfinite() 
              如果此 Double 值在数值上为无穷大,则返回 true;否则返回 false
    static boolean isInfinite(double v) 
              如果指定数在数值上为无穷大,则返回 true;否则返回 false
     boolean isNaN() 
              如果此 Double 值是非数字(NaN)值,则返回 true;否则返回 false
    static boolean isNaN(double v) 
              如果指定的数是一个 NaN 值,则返回 true;否则返回 false
    static double longBitsToDouble(long bits) 
              返回对应于给定位表示形式的 double 值。
     long longValue() 
              以 long 形式返回此 Double 的值(通过强制转换为 long 类型)。
    static double parseDouble(String s) 
              返回一个新的 double 值,该值被初始化为用指定 String 表示的值,这与 Double 类的 valueOf 方法一样。
     short shortValue() 
              以 short 形式返回此 Double 的值(通过强制转换为 short)。
    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) 
              返回保存用参数字符串 s 表示的 double 值的 Double 对象。
     
    从类 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
    保存 double 类型的 NaN 值的常量。它等于 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
    另请参见:
    常量字段值

    TYPE

    public static final Class<Double> TYPE
    表示基本类型 double 的 Class 实例。

    从以下版本开始:
    JDK1.1
    构造方法详细信息

    Double

    public Double(double value)
    构造一个新分配的 Double 对象,它表示基本的 double 参数。

    参数:
    value - 用 Double 表示的值。

    Double

    public Double(String s)
           throws NumberFormatException
    构造一个新分配的 Double 对象,表示用字符串表示的 double 类型的浮点值。该方法与 valueOf 方法一样,可将字符串转换为 double 值。

    参数:
    s - 要转换为 Double 的字符串。
    抛出:
    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",正 0 生成结果 "0.0"
      • 如果 m 大于或者等于 10-3,但小于 107,则采用不带前导 0 的十进制形式,用 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 是用十进制表示法表示的精确算术值,是通过对有限非 0 参数 d 调用此方法生成的。那么 d 一定是最接近 x 的 double 值;如果两个 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 为 0,则用字符串 "0x0.0p0" 表示;因此,负 0 生成结果 "-0x0.0p0",正 0 生成结果 "0x0.0p0"
      • 如果 m 是具有标准化表示形式的 double 值,则使用子字符串表示有效数字和指数字段。有效数字用字符 "0x1." 表示,后跟该有效数字剩余小数部分的小写十六进制表示形式。除非所有位数都为 0,否则移除十六进制表示中的尾部 0,在所有位数都为零的情况下,可以用一个 0 表示。接下来用 "p" 表示指数,后跟无偏指数的十进制字符串,该值与通过对指数值调用 Integer.toString 生成的值相同。
      • 如果 m 是非标准表示形式的 double 值,则用字符 "0x0." 表示有效数字,后跟该有效数字剩余小数部分的十六进制表示形式。移除十六进制表示中的尾部 0。然后用 "p-1022"表示指数。注意,在非标准有效数字中,必须至少有一个非 0 数字。

    示例

    浮点值 十六进制字符串 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
    返回保存用参数字符串 s 表示的 double 值的 Double 对象。

    如果 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
    其中 SignFloatingPointLiteralHexNumeralHexDigitsSignedInteger 和 FloatTypeSuffix 与 Java Language Specification 的词法结构部分中定义的相同。如果 s 不具有FloatValue 的形式,则抛出 NumberFormatException。否则,可以认为 s 是一个以常用的“计算机科学记数法”表示的精确十进制值,或者是一个精确的十六进制值;在概念上,这个精确的数值将被转换为一个“无限精确的”二进制值,然后根据常用的 IEEE 754 浮点算法的“舍入为最接近的数”规则,将该值舍入为 double 类型,其中包括保留 0 值的符号。最后,返回表示此 double 值的 Double 对象。

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

    注意,尾部格式说明符、确定浮点字面值类型的说明符(1.0f 是一个 float 值;1.0d 是一个 double 值)不会 影响此方法的结果。换句话说,输入字符串的数值被直接转换为目标浮点类型。分两步的转换(先将字符串转换为 float,然后将 float 转换为 double)不 同于直接将字符串转换为 double。例如,float 字面值 0.1f 等于 double 值0.10000000149011612float 字面值 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 
            // .
            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 the Java Language Specification, 2nd 
                 // edition, section 3.10.2.
    
                 // 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 - 要解析的字符串。
    返回:
    保存用 String 参数表示的值的 Double 对象。
    抛出:
    NumberFormatException - 如果字符串不包含可解析的数。

    valueOf

    public static Double valueOf(double d)
    返回表示指定的 double 值的 Double 实例。如果不需要新的 Double 实例,则通常应优先使用此方法,而不是构造方法 Double(double),因为此方法可能通过缓存经常请求的值来显著提高空间和时间性能。

    参数:
    d - 一个 double 值。
    返回:
    表示 d 的 Double 实例。
    从以下版本开始:
    1.5

    parseDouble

    public static double parseDouble(String s)
                              throws NumberFormatException
    返回一个新的 double 值,该值被初始化为用指定 String 表示的值,这与 Double 类的 valueOf 方法一样。

    参数:
    s - 要解析的字符串。
    返回:
    由字符串参数表示的 double 值。
    抛出:
    NumberFormatException - 如果字符串不包含可解析的 double 值。
    从以下版本开始:
    1.2
    另请参见:
    valueOf(String)

    isNaN

    public static boolean isNaN(double v)
    如果指定的数是一个 NaN 值,则返回 true;否则返回 false

    参数:
    v - 要测试的值。
    返回:
    如果参数值为 NaN,则返回 true;否则返回 false

    isInfinite

    public static boolean isInfinite(double v)
    如果指定数在数值上为无穷大,则返回 true;否则返回 false

    参数:
    v - 要测试的值。
    返回:
    如果参数值是正无穷大或负无穷大,则返回 true;否则返回 false

    isNaN

    public boolean isNaN()
    如果此 Double 值是非数字(NaN)值,则返回 true;否则返回 false

    返回:
    如果此对象表示的值为 NaN,则返回 true;否则返回 false

    isInfinite

    public boolean isInfinite()
    如果此 Double 值在数值上为无穷大,则返回 true;否则返回 false

    返回:
    如果此对象所表示的值是正无穷大或负无穷大,则返回 true;否则返回 false

    toString

    public String toString()
    返回此 Double 对象的字符串表示形式。使用此对象表示的基本 double 值被转换为一个字符串,这与带一个参数的 toString 方法完全一样。

    覆盖:
    类 Object 中的 toString
    返回:
    此对象的 String 表示形式。
    另请参见:
    toString(double)

    byteValue

    public byte byteValue()
    以 byte 形式返回此 Double 的值(通过强制转换为 byte)。

    覆盖:
    类 Number 中的 byteValue
    返回:
    转换为 byte 类型的由此对象所表示的 double 值
    从以下版本开始:
    JDK1.1

    shortValue

    public short shortValue()
    以 short 形式返回此 Double 的值(通过强制转换为 short)。

    覆盖:
    类 Number 中的 shortValue
    返回:
    转换为 short 类型的由此对象所表示的 double 值
    从以下版本开始:
    JDK1.1

    intValue

    public int intValue()
    以 int 形式返回此 Double 的值(通过强制转换为 int 类型)。

    指定者:
    类 Number 中的 intValue
    返回:
    转换为 int 类型的由此对象所表示的 double 值

    longValue

    public long longValue()
    以 long 形式返回此 Double 的值(通过强制转换为 long 类型)。

    指定者:
    类 Number 中的 longValue
    返回:
    转换为 long 类型的由此对象所表示的 double 值

    floatValue

    public float floatValue()
    返回此 Double 对象的 float 值。

    指定者:
    类 Number 中的 floatValue
    返回:
    转换为 float 类型的由此对象所表示的 double 值
    从以下版本开始:
    JDK1.0

    doubleValue

    public double doubleValue()
    返回此 Double 对象的 double 值。

    指定者:
    类 Number 中的 doubleValue
    返回:
    此对象所表示的 double 值

    hashCode

    public int hashCode()
    返回此 Double 对象的哈希码。结果是此 Double 对象所表示的基本 double 值的 long 整数位表示形式(与 doubleToLongBits(double) 方法生成的结果完全一样)两部分整数之间的异或 (XOR)。也就是说,哈希码就是以下表达式的值:
     (int)(v^(v>>>32))
     
    其中 v 的定义为:
     long v = Double.doubleToLongBits(this.doubleValue());
     

    覆盖:
    类 Object 中的 hashCode
    返回:
    此对象的 hashCode 值。
    另请参见:
    Object.equals(java.lang.Object), Hashtable

    equals

    public boolean equals(Object obj)
    将此对象与指定对象比较。当且仅当参数不是 null 而是 Double 对象,且表示的 Double 值与此对象表示的 double 值相同时,结果为 true。为此,当且仅当将方法 doubleToLongBits(double) 应用于两个值所返回的 long 值相同时,才认为这两个 double 值相同。

    注意,在大多数情况下,对于 Double 类的两个实例 d1 和 d2,当且仅当

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

    为 true 时,d1.equals(d2) 的值才为 true。但是,有以下两种例外情况:

    • 如果 d1 和 d2 都表示 Double.NaN,那么即使 Double.NaN==Double.NaN 值为 falseequals 方法也将返回 true
    • 如果 d1 表示 +0.0 而 d2 表示 -0.0,或者相反,那么即使 +0.0==-0.0 值为 trueequals 测试也将返回 false
    此定义使得哈希表得以正确操作。

    覆盖:
    类 Object 中的 equals
    参数:
    obj - 要与之进行比较的对象。
    返回:
    如果对象相同,则返回 true;否则返回 false
    另请参见:
    doubleToLongBits(double)

    doubleToLongBits

    public static long doubleToLongBits(double value)
    根据 IEEE 754 浮点双精度格式 ("double format") 位布局,返回指定浮点值的表示形式。

    第 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 浮点“双精度格式”位布局,返回指定浮点值的表示形式,并保留 NaN 值。

    第 63 位(掩码 0x8000000000000000L 选定的位)表示浮点数的符号。第 62-52 位(掩码 0x7ff0000000000000L 选定的位)表示指数。第 51-0 位(掩码0x000fffffffffffffL 选定的位)表示浮点数的有效数字(有时也称为尾数)。

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

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

    如果参数是 NaN,则结果是表示实际 NaN 值的 long 整数。与 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 方法区分。

    在所有其他情况下,设 se 和 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 的值。

    注意,此方法不能返回与 long 参数具有完全相同位模式的 double NaN。IEEE 754 区分了两种 NaN:quiet NaN 和 signaling NaN。这两种 NaN 之间的差别在 Java 中通常是不可见的。对 signaling NaN 进行的算术运算将它们转换为具有不同(但通常类似)位模式的 quiet NaN。但是在某些处理器上,只复制 signaling NaN 也执行这种转换。特别是在复制 signaling NaN 以将其返回给调用方法时,可能会执行这种转换。因此,longBitsToDouble 可能无法返回具有 signaling NaN 位模式的 double 值。所以,对于某些 long 值,doubleToRawLongBits(longBitsToDouble(start)) 可能 等于 start。此外,尽管所有 NaN 位模式(不管是 quiet NaN 还是 signaling NaN)都必须在上面提到的 NaN 范围内,但表示 signaling 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 一致

    指定者:
    接口 Comparable<Double> 中的 compareTo
    参数:
    anotherDouble - 要比较的 Double 值。
    返回:
    如果 anotherDouble 在数字上等于此 Double,则返回 0;如果此 Double 在数字上小于 anotherDouble,则返回小于 0 的值;如果此 Double 在数字上大于此 anotherDouble,则返回大于 0 的值。
    从以下版本开始:
    1.2

    compare

    public static int compare(double d1,
                              double d2)
    比较两个指定的 double 值。返回整数值的符号与以下调用返回的整数的符号相同:
        new Double(d1).compareTo(new Double(d2))
     

    参数:
    d1 - 要比较的第一个 double
    d2 - 要比较的第二个 double
    返回:
    如果 d1 在数字上等于 d2,则返回 0;如果 d1 在数字上小于 d2,则返回小于 0 的值;如果 d1 在数字上大于d2,则返回大于 0 的值。
    从以下版本开始:
    展开全文
  • 有方法 java.math.BigDecimal.doubleValue() BigDecimal a = new BigDecimal(1000); return a.doubleValue(); public static void printDoubleToBigDecimal(double v1, double v2){ BigDecimal d1TobigDe...
    有方法   java.math.BigDecimal.doubleValue()
    
    BigDecimal a = new BigDecimal(1000);
    return a.doubleValue();





    1.  public static void printDoubleToBigDecimal(double v1, double v2){  
    2.         BigDecimal d1TobigDe = new BigDecimal(v1);  
    3.         BigDecimal d2TobigDe = new BigDecimal(v2);  
    4.         System.out.println("d1TobigDe="+d1TobigDe);  
    5.         System.out.println("d2TobigDe="+d2TobigDe);  
    6.     } 

    展开全文
  • java double转string

    万次阅读 2016-04-25 20:00:06
    java中,double转string可以用Double.toString(d)的方式。但是,这种方式有隐藏的坑,请大家看仔细了:package hello;public class DoubleToString { public static void test1(double dou) { String dou_str = ...
  • javaDoubledouble区别

    千次阅读 2020-04-02 17:34:25
    1、Doublejava定义的类,而double是预定义数据类型(8种中的一种) 2、Double就好比是对double类型的封装,内置很多方法可以实现String到double的转换,以及获取各种double类型的属性值(MAX_VALUE、SIZE等等) ...
  • java Double 详解

    千次阅读 2019-08-27 11:52:29
    public class DoubleDome { static void m1() { Double double1=new Double(2.0); System.out.println(double1); Double double2=new Double("12"); System.out.println(double2); ...
  • java double方法 双类compare()方法 (Double class compare() method) compare() method is available in java.lang package. compare()方法在java.lang包中可用。 compare() method is used to check equality or ...
  • Java面试官:兄弟,你确定double精度比float低吗?

    万次阅读 多人点赞 2019-03-31 07:25:46
    我有一个朋友,叫老刘,戴着度数比我还高的近视镜,显得格外的“程序员”;...散席的时候,老刘特意叮嘱我把他和面试者的对话整理一下发出来,因为他觉得这段对话非常的精彩,值得推荐给更多初学Java的年轻人...
  • 简化 java.lang.Double 类的源码

    万次阅读 2020-09-25 23:20:36
    public final class Double extends Number ... @java.io.Serial private static final long serialVersionUID = -9172774392245257468L; //序列化版本号 private final double value; // 实际存储double数据
  • Java BigDecimal和double

    千次阅读 2019-05-22 17:16:51
    Java BigDecimal和double
  • Java Double类详解

    千次阅读 2020-03-06 14:36:39
    Double 类的构造方法 Double 类中的构造方法有如下两个。 Double(double value):构造一个新分配的 Double 对象,它表示转换为 double 类型的参数。 Double(String s):构造一个新分配的 Double 对象,它表示 ...
  • java double类型格式

    千次阅读 2019-05-13 09:03:40
    不显示科学记数法 ...Double d = new Double("1234567890.12"); System.out.println("d:="+d); //d:=1.23456789012E9 java.text.NumberFormat nf = java.text.NumberFormat.getInstance(); nf.setGroupingU...
  • Line 12: error: incompatible types: Double[] cannot be converted to double[] Doubledouble 不能互相转换?? 刚开始我是一脸懵的,后来baidu一下: Double类型是double的包装类,在JDK1.5以后,二者可du以...
  • Java中String转换Double类型 double num1 = 0.0; String qq = "19.987"; num1 = Double.valueOf(qq.toString()); 太祖元年 Java小数点后留两位 double num1 =11; double num1 =21; Stri...
  • Java面试题】Doubledouble 区别

    万次阅读 2019-02-11 23:04:03
    1、Doublejava定义的类,而double是预定义数据类型(8种中的一种) 2、Double就好比是对double类型的封装,内置很多方法可以实现String到double的转换,以及获取各种double类型的属性值(MAX_VALUE、SIZE等等) ...
  • Java类型转换: int转double

    万次阅读 2019-02-23 16:52:10
    标题Java类型转换: int转double 由于double的范围比int数据类型大,所以当int值被赋给double时,java会自动将int值转换为double。 隐式转换:由于double数据类型的范围和内存大小都比int大,因此从int到double的...
  • java Date转Double

    2020-06-05 11:17:34
    * 时间转double * * @param date * @return 返回值类似:43322.3770190278 */ public static double date2Double(Date date) { Calendar calendar = Calendar.getInstance(); calendar.setTime(date); long...
  • Java double数据类型

    千次阅读 2017-03-22 09:08:19
    double数据类型使用64位来存储浮点数。double值也称为双精度浮点数。 它可以表示一个最小为4.9 x 10^-324,最大为1.7 x 10^308的数字。它可以是正的或负的。 所有实数被称为double字面量。 double字面量可以...
  • java String 转 double

    万次阅读 2018-11-05 15:13:12
    Double.parseDouble(String)  
  • Java double转long方法

    千次阅读 2019-06-03 16:31:00
    Java double转long方法 double random = Math.round(Math.random()*10000);long l = new Double(random).longValue() 转载于:https://www.cnblogs.com/mark5/p/10968349.html
  • Java中将Double转换为Integer

    千次阅读 2020-06-18 11:41:16
    Any way to cast java.lang.Double to java.lang.Integer ? 有什么方法可以将java.lang.Doublejava.lang.Integer吗
  • java double比较大小

    千次阅读 2017-02-12 15:40:31
    double和float不能表达每个数值,他们是使用近似来表示值的。 考虑一下下面例子的输出内容 public classOne{ publicstaticvoidmain(String[] args) { double a = 1.000001; doubleb = 0.000001; doubled = a - ...
  • Java double转String

    千次阅读 2017-04-10 03:36:07
    把一个double类型的值转成string,网上有很多的方法,包括用String.valueOf(Double d),或者 String str = "" + d, 或者用DecimalFormat df = new DecimalFormat("#.00"), 以及用NumberFormat类等。但是,当double...
  • java object 转 double

    万次阅读 2017-05-10 16:00:16
    Map, Object> map = list....double lon = Double.parseDouble(map.get("LON").toString()); double lat = Double.parseDouble(map.get("LAT").toString()); Object 是所有的基类, 将Object先转成String 之后 再将Str
  • java double float 区别

    2011-04-01 03:21:00
    float 单精度 4字节 32位 double双精度 8字节64位 表示的范围和精度都比float大,java默认的小数声明是doubledouble d=4.0 而float则必须如下声明, float f=4.0f 不过double性能方面可能会差一些, 小程序...
  • java中基本类型double和对象类型Double

    千次阅读 2019-04-19 13:44:00
    Double.valueOf(str)把String转化成Double类型的对象比如Stirng str="1.0";那么Double.valueOf(str)等价于new Double("1.0");而doubleValue();就是求double类型的原始值,等价于double dnum=Double.valueOf(str)....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 50,902
精华内容 20,360
关键字:

doublejava

java 订阅