double 订阅
double是一个英语单词,意为一对,一双;双重地;酷似的人;把...对折;变成两倍;增加一倍,可作形容词、副词、动词用。 展开全文
double是一个英语单词,意为一对,一双;双重地;酷似的人;把...对折;变成两倍;增加一倍,可作形容词、副词、动词用。
信息
外文名
double
意    为
一对,一双
中文名
双精度数据类型
double单词
形容词a. [Z]1.两倍的;加倍的2.双的;成双的;双层的3.两人用的,双人的副词ad.1.双倍地;加倍地2.双重地名词n.1.两倍(数或量),加倍[C][U]2.酷似的人[C]3.替角演员;替身[C]及物动词vt.1.使加倍;是...的两倍2.把...对折[(+back/over)];握紧(拳头)不及物动词vi.1.变成两倍;增加一倍
收起全文
精华内容
下载资源
问答
  • double类型的输入与输出

    千次阅读 多人点赞 2019-12-07 21:19:19
    scanf()用%lf 来接受double类型 printf()用 %f 输出double 类型 原因: printf的% f 说明符的确可以输出float类型也可以 输出double 类型 。根据“ 默认参数提升” 规则,float 型会被提升为double 类型。 对于scanf...

    scanf()用%lf 来接受double类型
    printf()用 %f 输出double 类型

    原因:
    printf的% f 说明符的确可以输出float类型也可以 输出double 类型 。根据“ 默认参数提升” 规则,float 型会被提升为double 类型。
    对于scanf ,它接受指针,没有类似 的类型提升。(通过指针)向float 存储和double存储大不一样,
    所以,scanf 区别%f 和% l f。

    展开全文
  • c语言中double与float的区别

    万次阅读 多人点赞 2020-02-03 23:19:07
    c语言中double与float的区别 C语言中小数的数据类型为 float 或 double:float 称为单精度浮点数,double 称为双精度浮点数。不像整数,小数的长度始终是固定的,float 占用4个字节,double 占用8个字节。 %f 默认...

    c语言中double与float的区别
    C语言中小数的数据类型为 float 或 double:float 称为单精度浮点数,double 称为双精度浮点数。不像整数,小数的长度始终是固定的,float 占用4个字节,double 占用8个字节。
    %f 默认保留六位小数,不足六位以 0 补齐,超过六位按四舍五入截断。
    例题 圆的面积
    问题描述
    给定圆的半径r,求圆的面积。
    输入格式
    输入包含一个整数r,表示圆的半径。
    输出格式
    输出一行,包含一个实数,四舍五入保留小数点后7位,表示圆的面积。
    说明:在本题中,输入是一个整数,但是输出是一个实数。

    实数输出的问题如果没有特别说明,舍入都是按四舍五入进行。

    样例输入
    4
    样例输出
    50.2654825
    数据规模与约定
    1 <= r <= 10000。

    #include<stdio.h>
    #define PI 3.14159265358979323
    int main()
    {
    int r;
    double s=0;
    scanf("%d",&r);
    s=r* r*PI;
    printf("%.7lf\n",s);
    return 0;
    }
    注意我加粗的地方哦😎

    展开全文
  • 深入学习java源码之Double.parseDouble()与Double.valueOf()  Double类是原始类型double的包装类,它包含若干有效处理double值的方法,如将其转换为字符串表示形式,反之亦然。Double类的对象可以包含一个double值...

    深入学习java源码之Double.parseDouble()与Double.valueOf() 

    Double类是原始类型double的包装类,它包含若干有效处理double值的方法,如将其转换为字符串表示形式,反之亦然。Double类的对象可以包含一个double值。

    public class Double_test
    {
     
        public static void main(String[] args)
        {
            
            double b = 55.05;
            String bb = "45";
     
            // Construct two Double objects
            Double x = new Double(b);
            Double y = new Double(bb);
     
            // toString()
            System.out.println("toString(b) = " + Double.toString(b));
     
            // valueOf()
            // return Double object
            Double z = Double.valueOf(b);
            System.out.println("valueOf(b) = " + z);
            z = Double.valueOf(bb);
            System.out.println("ValueOf(bb) = " + z);
     
            // parseDouble()
            // return primitive double value
            double zz = Double.parseDouble(bb);
            System.out.println("parseDouble(bb) = " + zz);
     
            System.out.println("bytevalue(x) = " + x.byteValue());
            System.out.println("shortvalue(x) = " + x.shortValue());
            System.out.println("intvalue(x) = " + x.intValue());
            System.out.println("longvalue(x) = " + x.longValue());
            System.out.println("doublevalue(x) = " + x.doubleValue());
            System.out.println("floatvalue(x) = " + x.floatValue());
     
            int hash = x.hashCode();
            System.out.println("hashcode(x) = " + hash);
     
            boolean eq = x.equals(y);
            System.out.println("x.equals(y) = " + eq);
     
            int e = Double.compare(x, y);
            System.out.println("compare(x,y) = " + e);
     
            int f = x.compareTo(y);
            System.out.println("x.compareTo(y) = " + f);
     
            Double d = Double.valueOf("1010.54789654123654");
            System.out.println("isNaN(d) = " + d.isNaN());
     
            System.out.println("Double.isNaN(45.12452) = " + Double.isNaN(45.12452));
     
            // Double.POSITIVE_INFINITY stores
            // the positive infinite value
            d = Double.valueOf(Double.POSITIVE_INFINITY + 1);
            System.out.println("Double.isInfinite(d) = " + 
                                        Double.isInfinite(d.doubleValue()));
     
            double dd = 10245.21452;
            System.out.println("Double.toString(dd) = " + Double.toHexString(dd));
     
            long double_to_long = Double.doubleToLongBits(dd);
            System.out.println("Double.doubleToLongBits(dd) = " + double_to_long);
     
            double long_to_double = Double.longBitsToDouble(double_to_long);
            System.out.println("Double.LongBitsToDouble(double_to_long) = " + 
                                        long_to_double);
        }
     
    }

    输出:

    toString(b) = 55.05
    valueOf(b) = 55.05
    ValueOf(bb) = 45.0
    parseDouble(bb) = 45.0
    bytevalue(x) = 55
    shortvalue(x) = 55
    intvalue(x) = 55
    longvalue(x) = 55
    doublevalue(x) = 55.05
    floatvalue(x) = 55.05
    hashcode(x) = 640540672
    x.equals(y) = false
    compare(x,y) = 1
    x.compareTo(y) = 1
    isNaN(d) = false
    Double.isNaN(45.12452) = false
    Double.isInfinite(d) = true
    Double.toString(dd) = 0x1.4029b7564302bp13
    Double.doubleToLongBits(dd) = 4666857980575363115
    Double.LongBitsToDouble(double_to_long) = 10245.21452

     

    Double类型的计算

    如果我们编译运行下面这个程序会看到什么?

    public class Test{
        public static void main(String args[]){
            System.out.println(0.05+0.01);
            System.out.println(1.0-0.42);
            System.out.println(4.015*100);
            System.out.println(123.3/100);
        }
    };

    你没有看错!结果确实是

    0.060000000000000005
    0.5800000000000001
    401.49999999999994
    1.2329999999999999

    Java中的简单浮点数类型float和double不能够进行运算。不光是Java,在其它很多编程语言中也有这样的问题。在大多数情况下,计算的结果是准确的,但是多试几次(可以做一个循环)就可以试出类似上面的错误。现在终于理解为什么要有BCD码了。
    这个问题相当严重,如果你有9.999999999999元,你的计算机是不会认为你可以购买10元的商品的。
    在有的编程语言中提供了专门的货币类型来处理这种情况,但是Java没有。现在让我们看看如何解决这个问题。
     
    四舍五入
    我们的第一个反应是做四舍五入。Math类中的round方法不能设置保留几位小数,我们只能象这样(保留两位):

    public double round(double value){
        return Math.round(value*100)/100.0;
    }

    非常不幸,上面的代码并不能正常工作,给这个方法传入4.015它将返回4.01而不是4.02,如我们在上面看到的
    4.015*100=401.49999999999994
    因此如果我们要做到精确的四舍五入,不能利用简单类型做任何运算
    java.text.DecimalFormat也不能解决这个问题:

    System.out.println(new java.text.DecimalFormat("0.00").format(4.025));

    输出是4.02

    精确计算

    float和double只能用来做科学计算或者是工程计算,在商业计算中我们要用 java.math.BigDecimal

    我们如果需要精确计算,非要用String来够造BigDecimal不可!

    divide方法中推荐使用枚举RoundingMode.HALF_UP

     import java.io.Serializable;
     import java.math.BigDecimal;
     import java.math.RoundingMode;
     /**
      * double的计算不精确,会有类似0.0000000000000002的误差,正确的方法是使用BigDecimal或者用整型
      * 整型地方法适合于货币精度已知的情况,比如12.11+1.10转成1211+110计算,最后再/100即可
      * 以下是摘抄的BigDecimal方法:
      */
     public class DoubleUtil implements Serializable {
         private static final long serialVersionUID = -3345205828566485102L;
         // 默认除法运算精度
         private static final Integer DEF_DIV_SCALE = 2;
     
         /**
          * 提供精确的加法运算。
          *
          * @param value1 被加数
          * @param value2 加数
          * @return 两个参数的和
          */
         public static Double add(Double value1, Double value2) {
             BigDecimal b1 = new BigDecimal(Double.toString(value1));
             BigDecimal b2 = new BigDecimal(Double.toString(value2));
             return b1.add(b2).doubleValue();
         }
     
         /**
          * 提供精确的减法运算。
          *
          * @param value1 被减数
          * @param value2 减数
          * @return 两个参数的差
          */
         public static double sub(Double value1, Double value2) {
             BigDecimal b1 = new BigDecimal(Double.toString(value1));
             BigDecimal b2 = new BigDecimal(Double.toString(value2));
             return b1.subtract(b2).doubleValue();
         }
     
         /**
          * 提供精确的乘法运算。
          *
          * @param value1 被乘数
          * @param value2 乘数
          * @return 两个参数的积
          */
         public static Double mul(Double value1, Double value2) {
             BigDecimal b1 = new BigDecimal(Double.toString(value1));
             BigDecimal b2 = new BigDecimal(Double.toString(value2));
             return b1.multiply(b2).doubleValue();
         }
     
         /**
          * 提供(相对)精确的除法运算,当发生除不尽的情况时, 精确到小数点以后10位,以后的数字四舍五入。
          *
          * @param dividend 被除数
          * @param divisor  除数
          * @return 两个参数的商
          */
         public static Double divide(Double dividend, Double divisor) {
             return divide(dividend, divisor, DEF_DIV_SCALE);
         }
     
         /**
          * 提供(相对)精确的除法运算。 当发生除不尽的情况时,由scale参数指定精度,以后的数字四舍五入。
          *
          * @param dividend 被除数
          * @param divisor  除数
          * @param scale    表示表示需要精确到小数点以后几位。
          * @return 两个参数的商
          */
         public static Double divide(Double dividend, Double divisor, Integer scale) {
             if (scale < 0) {
                 throw new IllegalArgumentException("The scale must be a positive integer or zero");
             }
             BigDecimal b1 = new BigDecimal(Double.toString(dividend));
             BigDecimal b2 = new BigDecimal(Double.toString(divisor));
             return b1.divide(b2, scale,RoundingMode.HALF_UP).doubleValue();
         }
     
         /**
          * 提供指定数值的(精确)小数位四舍五入处理。
          *
          * @param value 需要四舍五入的数字
          * @param scale 小数点后保留几位
          * @return 四舍五入后的结果
          */
         public static double round(double value,int scale){
             if(scale<0){
                 throw new IllegalArgumentException("The scale must be a positive integer or zero");
             }
             BigDecimal b = new BigDecimal(Double.toString(value));
             BigDecimal one = new BigDecimal("1");
             return b.divide(one,scale, RoundingMode.HALF_UP).doubleValue();
         }
     }

     

     

    Modifier and TypeMethod and Description
    bytebyteValue()

    返回此值 Doublebyte的基本收缩转换后。

    static intcompare(double d1, double d2)

    比较两个指定的 double值。

    intcompareTo(Double anotherDouble)

    数字比较两个 Double对象。

    static longdoubleToLongBits(double value)

    根据IEEE 754浮点“双格式”位布局返回指定浮点值的表示。

    static longdoubleToRawLongBits(double value)

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

    doubledoubleValue()

    返回此 Double对象的 double值。

    booleanequals(Object obj)

    将此对象与指定对象进行比较。

    floatfloatValue()

    返回此值 Doublefloat的基本收缩转换后。

    inthashCode()

    返回此 Double对象的哈希码。

    static inthashCode(double value)

    返回一个double值的哈希码; 兼容Double.hashCode()

    intintValue()

    int后,返回 Double作为int的值。

    static booleanisFinite(double d)

    如果参数是有限浮点值,则返回true ; 返回false (对于NaN和无穷大参数)。

    booleanisInfinite()

    返回 true如果这 Double值是无限大, false其他。

    static booleanisInfinite(double v)

    返回 true如果指定的数量是无限大, false其他。

    booleanisNaN()

    如果 DoubleDouble数字(NaN),则返回 truefalse false。

    static booleanisNaN(double v)

    如果指定的数字是非数字(NaN)值,则返回 truefalse false。

    static doublelongBitsToDouble(long bits)

    返回与给 double表示相对应的 double值。

    longlongValue()

    返回此值 Doublelong的基本收缩转换后。

    static doublemax(double a, double b)

    返回两个 double值中的较大值,就像调用 Math.max一样

    static doublemin(double a, double b)

    返回两个 double的较小值,就像调用 Math.min一样

    static doubleparseDouble(String s)

    返回一个新 double初始化为指定的代表的值 String ,如通过执行 valueOf类的方法 Double

    shortshortValue()

    返回此值 Doubleshort的基本收缩转换后。

    static doublesum(double a, double b)

    按照+运算符将两个 double值一起添加。

    static StringtoHexString(double d)

    返回 double参数的十六进制字符串 double形式。

    StringtoString()

    返回此 Double对象的字符串表示形式。

    static StringtoString(double d)

    返回 double参数的字符串 double形式。

    static DoublevalueOf(double d)

    返回一个 Double double值的 Double实例。

    static DoublevalueOf(String s)

    返回一个 Double对象,保存由参数字符串 sdouble值。

    java源码

    package java.lang;
    
    import sun.misc.FloatingDecimal;
    import sun.misc.FpUtils;
    import sun.misc.DoubleConsts;
    
    public final class Double extends Number implements Comparable<Double> {
    
        public static final double POSITIVE_INFINITY = 1.0 / 0.0;
    
        public static final double NEGATIVE_INFINITY = -1.0 / 0.0;
    
        public static final double NaN = 0.0d / 0.0;
    
        public static final double MAX_VALUE = 0x1.fffffffffffffP+1023; // 1.7976931348623157e+308
    
        public static final double MIN_NORMAL = 0x1.0p-1022; // 2.2250738585072014E-308
    
        public static final double MIN_VALUE = 0x0.0000000000001P-1022; // 4.9e-324
    
        public static final int MAX_EXPONENT = 1023;
    
        public static final int MIN_EXPONENT = -1022;
    
        public static final int SIZE = 64;
    
        public static final int BYTES = SIZE / Byte.SIZE;
    
        @SuppressWarnings("unchecked")
        public static final Class<Double>   TYPE = (Class<Double>) Class.getPrimitiveClass("double");
    
        public static String toString(double d) {
            return FloatingDecimal.toJavaFormatString(d);
        }
    
        public static String toHexString(double d) {
            /*
             * Modeled after the "a" conversion specifier in C99, section
             * 7.19.6.1; however, the output of this method is more
             * tightly specified.
             */
            if (!isFinite(d) )
                // For infinity and NaN, use the decimal output.
                return Double.toString(d);
            else {
                // Initialized to maximum size of output.
                StringBuilder answer = new StringBuilder(24);
    
                if (Math.copySign(1.0, d) == -1.0)    // value is negative,
                    answer.append("-");                  // so append sign info
    
                answer.append("0x");
    
                d = Math.abs(d);
    
                if(d == 0.0) {
                    answer.append("0.0p0");
                } else {
                    boolean subnormal = (d < DoubleConsts.MIN_NORMAL);
    
                    // Isolate significand bits and OR in a high-order bit
                    // so that the string representation has a known
                    // length.
                    long signifBits = (Double.doubleToLongBits(d)
                                       & DoubleConsts.SIGNIF_BIT_MASK) |
                        0x1000000000000000L;
    
                    // Subnormal values have a 0 implicit bit; normal
                    // values have a 1 implicit bit.
                    answer.append(subnormal ? "0." : "1.");
    
                    // Isolate the low-order 13 digits of the hex
                    // representation.  If all the digits are zero,
                    // replace with a single 0; otherwise, remove all
                    // trailing zeros.
                    String signif = Long.toHexString(signifBits).substring(3,16);
                    answer.append(signif.equals("0000000000000") ? // 13 zeros
                                  "0":
                                  signif.replaceFirst("0{1,12}$", ""));
    
                    answer.append('p');
                    // If the value is subnormal, use the E_min exponent
                    // value for double; otherwise, extract and report d's
                    // exponent (the representation of a subnormal uses
                    // E_min -1).
                    answer.append(subnormal ?
                                  DoubleConsts.MIN_EXPONENT:
                                  Math.getExponent(d));
                }
                return answer.toString();
            }
        }
    
        public static Double valueOf(String s) throws NumberFormatException {
            return new Double(parseDouble(s));
        }
    
        public static Double valueOf(double d) {
            return new Double(d);
        }
    	
        public static double parseDouble(String s) throws NumberFormatException {
            return FloatingDecimal.parseDouble(s);
        }	
    	
        public static boolean isNaN(double v) {
            return (v != v);
        }
    	
        public static boolean isInfinite(double v) {
            return (v == POSITIVE_INFINITY) || (v == NEGATIVE_INFINITY);
        }	
    	
        public static boolean isFinite(double d) {
            return Math.abs(d) <= DoubleConsts.MAX_VALUE;
        }	
    	
        private final double value;	
    	
        public Double(double value) {
            this.value = value;
        }	
    	
        public Double(String s) throws NumberFormatException {
            value = parseDouble(s);
        }	
    	
        public boolean isNaN() {
            return isNaN(value);
        }	
    	
        public boolean isInfinite() {
            return isInfinite(value);
        }	
    	
        public String toString() {
            return toString(value);
        }
    	
        public byte byteValue() {
            return (byte)value;
        }	
    	
        public short shortValue() {
            return (short)value;
        }	
    	
        public int intValue() {
            return (int)value;
        }	
    	
        public long longValue() {
            return (long)value;
        }	
    	
        public float floatValue() {
            return (float)value;
        }	
    	
        public double doubleValue() {
            return value;
        }	
    	
        @Override
        public int hashCode() {
            return Double.hashCode(value);
        }	
    	
        public static int hashCode(double value) {
            long bits = doubleToLongBits(value);
            return (int)(bits ^ (bits >>> 32));
        }	
    	
        public boolean equals(Object obj) {
            return (obj instanceof Double)
                   && (doubleToLongBits(((Double)obj).value) ==
                          doubleToLongBits(value));
        }	
    	
        public static long doubleToLongBits(double value) {
            long result = doubleToRawLongBits(value);
            // Check for NaN based on values of bit fields, maximum
            // exponent and nonzero significand.
            if ( ((result & DoubleConsts.EXP_BIT_MASK) ==
                  DoubleConsts.EXP_BIT_MASK) &&
                 (result & DoubleConsts.SIGNIF_BIT_MASK) != 0L)
                result = 0x7ff8000000000000L;
            return result;
        }	
    	
        public static native long doubleToRawLongBits(double value);	
    	
        public static native double longBitsToDouble(long bits);	
    	
        public int compareTo(Double anotherDouble) {
            return Double.compare(value, anotherDouble.value);
        }
    	
        public static int compare(double d1, double d2) {
            if (d1 < d2)
                return -1;           // Neither val is NaN, thisVal is smaller
            if (d1 > d2)
                return 1;            // Neither val is NaN, thisVal is larger
    
            // Cannot use doubleToRawLongBits because of possibility of NaNs.
            long thisBits    = Double.doubleToLongBits(d1);
            long anotherBits = Double.doubleToLongBits(d2);
    
            return (thisBits == anotherBits ?  0 : // Values are equal
                    (thisBits < anotherBits ? -1 : // (-0.0, 0.0) or (!NaN, NaN)
                     1));                          // (0.0, -0.0) or (NaN, !NaN)
        }	
    	
        public static double sum(double a, double b) {
            return a + b;
        }	
    	
        public static double max(double a, double b) {
            return Math.max(a, b);
        }	
    
        public static double min(double a, double b) {
            return Math.min(a, b);
        }
    	
        private static final long serialVersionUID = -9172774392245257468L;
    }	
    package java.lang;
    import java.util.*;
    
    public interface Comparable<T> {
        public int compareTo(T o);
    }
    package java.lang;
    
    public abstract class Number implements java.io.Serializable {
    
        public abstract int intValue();
    
        public abstract long longValue();
    
        public abstract float floatValue();
    
        public abstract double doubleValue();
    
        public byte byteValue() {
            return (byte)intValue();
        }
    
        public short shortValue() {
            return (short)intValue();
        }
    	
        private static final long serialVersionUID = -8742448824652078965L;
    }

     

    展开全文
  • Double.parseDouble()是什么意思

    千次阅读 2019-10-29 09:51:45
    Double.parseDouble()的使用 用Double.parseDouble()是把括号里面内容变成double类型的。 其中括号中的参数必须是String类型,否转转换会报错。 例如:Double overdueMoney = Double.parseDouble(map.get(...

    Double.parseDouble()的使用

    用Double.parseDouble()是把括号里面内容变成double类型的。
    其中括号中的参数必须是String类型,否则转换会报错。
    例如:Double overdueMoney = Double.parseDouble(map.get(“overdue_money”).toString());

    如果要变成int,则用Integer.parseInt()

    展开全文
  • 在Java中将Double转换为Integer

    千次阅读 2020-06-18 11:41:16
    Any way to cast java.lang.Double to java.lang.Integer ? 有什么方法可以将java.lang.Double为java.lang.Integer吗
  • doubleDouble的区别

    万次阅读 多人点赞 2017-08-21 17:43:46
    double是基本数据类型,Double是原始数据类型 double没有方法,Double有自己的属性和方法 double只创建引用,Double创建对象 集合类不能存放double,只能存放Double double存放在栈中,Double存放在堆中 栈的...
  • Double类型详解

    千次阅读 2020-11-01 17:51:06
    System.out.println("位数是: " + Double.SIZE); System.out.println("最大值是: " + Double.MAX_VALUE); System.out.println("最小值是: " + Double.MIN_VALUE); System.out.println(“所占字节是: " + Double....
  • 如何在Java中将double转换为int?

    万次阅读 2021-03-09 10:54:46
    在本文中,我们将看到如何将double转换为int。 在Java编程中,您将有一个double原语值(例如82.14),但是要执行进一步的操作,您需要一个int值(例如82),所以让我们看看如何在Java中将double转换为int。 您可以...
  • double类型是否相等的判断方法 在Java中int类型数据的大小比较可以使用双等号,double类型则不能使用双等号来比较大小,如果使用的话得到的结果将永远是不相等,即使两者的精度是相同的也不可以。下面介绍两种比较...
  • c++ string转int, double,int,double转string

    千次阅读 2019-07-02 11:56:25
    c++ string与常用数值变量互转 ...以下函数自动判断int或者double。 测试环境: 系统:win7或者win10 IDE:vs2015 本文包含的内容: c++ string与常用数值变量互转 1. 头文件 2. int转...
  • 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中 Doubledouble区别

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

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

    千次阅读 2020-05-05 20:15:53
    骑士李四记录: 在《Effective Java》这本书中也提到这个原则,float和double只能用来做科学计算或者是工程计算,在商业计算中我们要用 java.math.BigDecimal 我们如果需要精确计算,非要用String来够造BigDecimal不...
  • 对于不需要任何准确计算精度的数字可以直接使用float或double,但是如果需要精确计算的结果,则必须使用BigDecimal类,而且使用BigDecimal类也可以进行大数的操作。BigDecimal类的常用方法如表11-15所示。 表11-15 ...
  • float和double的精度

    千次阅读 2019-09-10 11:23:03
    float和double的范围是由指数的位数来决定的。 float的指数位有8位,而double的指数位有11位,分布如下: float: 1bit(符号位) 8bits(指数位) 23bits(尾数位) double: 1bit(符号位) 11bits(指数...
  • C语言之double

    千次阅读 2020-02-13 13:43:43
    前面的几篇文章中写到了int,float,char,long几种数据类型,而这篇文章主要的内容就是了解double。众所周知C语言可以提供另外的一种哦浮点数类型double(简称为双精度),而double数据类型和float类型的最小的取值...
  • JAVA中Double转为String

    千次阅读 2019-10-11 16:15:10
    至少有三种方法可以将表示double值的String 转换为Double对象。可能还有多种方法可以做同样的事情,如果你了解此处还有未列出的其他转换方法,请在下方留言与我们一起分享。 1)将String转换为Double的第一种方法...
  • 首先我们应该知道double是可以与int类型直接进行比较的 例如 int a=2; double c=3.0; if(c>a) ...... 下面我们分析double与int的误差分析 我写了如下代码作为探究的作证以便大家分析: #include<stdio.h> ...
  • double相乘

    千次阅读 2019-06-06 18:11:59
    1.报错程序 ... public static Double multiply(Double a, Double b) { return a * b } } 2.分析造成问题的原因 直接执行报错 3.解决方案 public class Multiply { public static Double m...
  • float和double的精度区别

    千次阅读 2021-01-15 16:56:15
    float和double的范围是由指数的位数来决定的。 float的指数位有8位,而double的指数位有11位,分布如下: float: 1bit(符号位) 8bits(指数位) 23bits(尾数位) double: 1bit(符号位) 11bits(指数位) 52...
  • JAVA中的float和double的区别

    万次阅读 多人点赞 2018-04-02 16:28:39
    1.两个在定义时的区别  1)float型 内存分配4个字节,占32位,范围从10^-38到10^38 和 -10^38到-10^-38  例float x=123.456f,y=2e20f;... (2)double型 内存分配8个字节,范围从10^-308到10^308 和 ...
  • Double类型数据保留指定位数方法总结 import java.math.BigDecimal; import java.text.DecimalFormat; import java.text.NumberFormat; /** * @program: youpin * @description: * @author: Mr.Jkx * @create: ...
  • Using new Double(double) is guaranteed to always result in a new object whereas Double.valueOf(double) allows caching of values to be done by the compiler, class library, or JVM. Using of cac...
  • double保留两位小数,返回double

    千次阅读 2019-01-21 10:05:37
    3 4 5 6 7 8 9 10 ...private Double get(){ ... double a=1.0;... return new Double(df.format(a).toString()); } private double get(){ DecimalFormat df=new DecimalFormat("0.
  • C# string转doubledouble转string

    千次阅读 2020-03-14 19:52:15
    string转double string str_test_wall; double numDouble= double.Parse(str_test_wall); double转string double numDouble = 123.321; string str_test_wall= Convert.ToString(numDouble); ...
  • matlab图像数据类型uint8,double关系

    千次阅读 多人点赞 2019-04-05 20:07:50
    数字图像处理深入思考(一)double型的图像矩阵转化为uint8(I)类型(二)图像的【0,1】和【0,255】显示 深入思考 (一)double型的图像矩阵转化为uint8(I)类型 为了节省存储空间,matlab为图像提供了特殊的数据...
  • Java中double转BigDecimal的注意事项

    万次阅读 多人点赞 2018-08-10 16:01:20
    先上结论:不要直接用double变量作为构造BigDecimal的参数。   线上有这么一段Java代码逻辑: 1,接口传来一个JSON串,里面有个数字:57.3。 2,解析JSON并把这个数字保存在一个float变量。 3,把这个float...
  • Java Double类详解

    千次阅读 2020-03-06 14:36:39
    Double 类的构造方法 Double 类中的构造方法有如下两个。 Double(double value):构造一个新分配的 Double 对象,它表示转换为 double 类型的参数。 Double(String s):构造一个新分配的 Double 对象,它表示 ...
  • 图像类和类型间的转换 im2uint8 &amp;nbsp;将输入中所有小于0的设置为0,而将输入中所有大于1的设置为255 其他的所有乘以255 ... 把一个double类的任意数组转换成值范围在[0,1]的归一化dou...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,981,924
精华内容 792,769
关键字:

double