精华内容
下载资源
问答
  • 测试Double的parseDouble方法,即,首先将字符串"12345.00"转换为double类型并输出结果,然后,将字符串"¥12345.00"转换为double类型,并查看运行效果。 方案 首先,使用Double的parseDouble方法,将字符串"12345...

    码字不易,请大家关注公众号,点赞,谢谢!

    问题

        测试Double的parseDouble方法,即,首先将字符串"12345.00"转换为double类型并输出结果,然后,将字符串"¥12345.00"转换为double类型,并查看运行效果。

    方案

        首先,使用Double的parseDouble方法,将字符串"12345.00"转换为double类型,正常运行并可以输出double类型的值12345.00;然后,再次使用Double的parseDouble方法,将字符串"¥12345.00"转换为double类型,运行后,会出现异常。

    步骤

        实现此案例需要按照如下步骤进行。

    步骤一:构建测试方法

        在TestInteger类中添加单元测试方法testParseDouble,代码如下所示:

        package day02;
        
        import org.junit.Test;
        
        public class TestInteger{
        
        /**
         *测试Double的parseDouble方法
         */
         @Test
         public void testParseDouble(){
         
         }
        
        }

    步骤二:将字符串"12345.00"转为double类型

        使用Double的parseDouble方法,将字符串"12345.00"转换为double类型,正常运行并可以输出double类型的值12345.0,代码如下所示:

        package day02;
        
        import org.junit.Test;
        
        public class TestInteger{
        
        /**
         *测试Double的parseDouble方法
         */
         @Test
         public void testParseDouble(){
             
             String str="12345.00";
             double value=Double.parseDouble(str);//12345.0
             System.out.println(value);
         }
        
        }

        运行上述代码,控制台输出结果为:

        12345.0

        说明已经成功的将字符串"12345.00"转换为double类型的12345.0。

    步骤三:字符串"¥12345.00"转换为double类型

        再次使用Double的parseDouble方法,将字符串"¥12345.00"转换为double类型,代码如下所示:

        package day02;
        
        import org.junit.Test;
        
        public class TestInteger{
        
        /**
         *测试Double的parseDouble方法
         */
         @Test
         public void testParseDouble(){
             
             String str="12345.00";
             double value=Double.parseDouble(str);//12345.0
             System.out.println(value);
             
             str="¥12345.00";
             //会抛出NumberFormatException
             //value=Double.parseDouble(str);
         }
        
        }

        运行上述代码后,会出现异常:

    java.lang.NumberFormatException:For input string:"¥12345.00"

        从异常情况可以看出,Java程序无法将字符串"¥12345.00"转换为double类型,因此,抛出了java.lang.NumberFormatException异常。所以在使用Double的parseDouble方法时,要注意传入的方法的参数为数字。

    关注公众号,获取学习视频

    展开全文
  • 深入学习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.lang.Double.parseDouble()方法

    万次阅读 2017-04-01 21:52:10
    The java.lang.Double.parseDouble() 方法返回一个新的双初始化为指定字符串表示的值,这样做因为Double类有valueOf这个方法。 声明 java.lang.Double.parseDouble()方法 public static double parseDouble...

    描述

    The java.lang.Double.parseDouble() 方法返回一个新的双初始化为指定字符串表示的值,这样做因为Double类有valueOf这个方法。

    声明

    java.lang.Double.parseDouble()方法

    public static double parseDouble(String s) throws NumberFormatException

    参数

    • s -- This is the string to be parsed.






    返回值



    此方法返回的字符串参数表示的double值.

    异常

    • NumberFormatException -- 如果字符串不包含可解析的double.

    实例







    下面的例子显示java.lang.Double.parseDouble()的使用方法.

    package com.yiibai;
    
    import java.lang.*;
    
    public class DoubleDemo {
    
       public static void main(String[] args) {
    
         Double d = new Double("6.35");
       
         // returns the double value represented by the string argument
         String str = "50";
         double retval = d.parseDouble(str);
         System.out.println("Value = " + retval);
       }
    } 

    让我们来编译和运行上面的程序,这将产生以下结果:

    Value = 50.0



    展开全文
  • //将字符串n强制转化成int型赋给x int y=Double.parseDouble(n);//将字符串n强制转化成double型赋给y 3、截取字符串中的一段: String ss=s.substring(cnt,i);//截取字符串s中从编号为cnt的位置到编号为i的位置(前...
  • 其中service action是一个通过java的ExecutorService实现并发的多任务处理,在单个任务当中做的主要包括3大块:分别是大量for循环计算、fastjson反序列化、大量的Double.parsedouble计算。 解决思路  其实在整个...
  • BigDecimal b1 = new BigDecimal(user.getDeposit_rate()); BigDecimal b2 = new BigDecimal(100); deposit_rate= b1.multiply(b2).doubleValue();...import java.math.BigDecimal; public class Arith{ /
  • Double类parseDouble()方法 (Double class ...parseDouble() method is available in java.lang package. parseDouble()方法在java.lang包中可用。 parseDouble() method is used to return the double v...
  • java.lang.NullPointerException : ...1:java.lang.Double.parseDouble   java.lang.NullPointerException sun.misc.FloatingDecimal.readJavaFormatString(FloatingDecimal.java:991) java.lang.Double.pars...
  • Double类将一个String字符串转换为浮点型的方式有两个,一个是parseDouble(java.lang.String) 方法,一个是valueOf(java.lang.String)方法。之前有时会遇到需要将一个String字符串转换为浮点数,打开ide的自动补全会...
  • PTA46题(Java基础练习)

    万次阅读 多人点赞 2019-10-03 20:40:59
    Java作业练习(1) 这学期Java课的第一次作业嗷 (做完再删掉这句话) 我觉得可以 7-1 写一个程序,输出你的姓名、年龄、所在学院、所在专业、所在班级 写一个程序,输出你的姓名、年龄、所在学院、所在专业、所在班级...
  • Java中Double保留后小数位的几种方法

    千次阅读 2019-12-18 11:42:56
    最近做个小实验,其中一部分要求将表单提交的数据转换为double,这个功能其实很简单直接一句Double.parseDouble(request.getParameter(“chinese”).trim())就可以实现,但因为是统计成绩,所以需要保留小数点后两位...
  • 测试题。 要求0.00000000004 这个字符串格式化为 4.00e-11 这样的格式。 同excel表格中的展示一样。 demo BigDecimal c = new BigDecimal("0.000000004", new MathContext(0, RoundingMode.HALF_UP));...
  • Java的简单输入输出问题

    千次阅读 2017-10-18 10:57:16
    最近正在学Java,了解了一些Java的输入输出的基本语法。。。1.在Java中如何输入以空格隔开的数字呢? 由于一开始输入的数据都是被当成字符串来处理的,所以我们就相当于处理一个字符串,来获得所需要的数据。 ...
  • 保留两位小数(Python和Java

    千次阅读 2018-06-25 15:39:53
    Java保留两位小数: import java.math.BigDecimal; import java.text.DecimalFormat; import java.text.NumberFormat; /** * Created by zfr on 2018/06/25. * Java保留小数的几种方式 */ public class ...
  • 基于Java的员工管理系统

    万次阅读 多人点赞 2019-07-18 14:52:40
    基于Java的员工管理系统 简介 使用ArrayList对完成一个员工管理系统,员工信息包含:员工工号,姓名,职位,年龄,月薪,所在部门;要求功能入下: a)实现从控制台输入员工信息并存储 b)通过员工工号查询指定员工信息...
  • Java中从键盘输入多个整数

    万次阅读 2017-09-18 20:42:11
    Java中从键盘输入多个整数,Scanner
  • JAVA编写计算器

    千次阅读 多人点赞 2019-05-23 22:32:02
    JAVA编写一个实现加减乘除运算的计算器 1.实现加减乘除以及乘方运算; 2.C是清除键,清除之前输入所有数据,计算结果归零。 3.CE也是清除键,清除上一个输入的数据。 思路就是创建一个窗口,然后给窗口添加容器或...
  • java计算器

    千次阅读 多人点赞 2016-07-23 15:59:02
    java计算器
  • get_double = Double.ParseDouble(String.format("%.2f",result_value)); //方案四: BigDecimal bd = new BigDecimalresult_value(); BigDecimal bd2 = bd.setScale(2,BigDecimal .ROUND_HALF_UP); get_double =...
  • JAVA计算器

    千次阅读 2017-06-01 13:04:34
    JAVA计算器实现
  • Double.parseDouble的返回值类型为double。 但是由于后期JAVA的自动的封装和自动的解装,使得这两个函数区分并不明显。 package a; import java.util.HashSet; import java.util.Random; import java.util.Set; ...
  • 可以利用Double.parseDouble(string s)进行判断,当s为null或不能转换为Double时均会抛出异常。 代码如下: double a; try { a = Double.parseDouble(s); } catch (Exception e) { return -1; } return 0;...
  • Double.parseDouble()

    2020-05-11 10:05:12
    Double.parseDouble()是把括号里面内容变成double类型;如果要变成int,则用Integer.parseInt()。
  • 通过java实现输入系数求一元二次方程根,学习Scanner()、split()和Substring()函数 学习目的: 1、针对scan未关闭问题处理 2、参数输入,可以用scan直接获取,也可以用split()分割 3、Substring()获取子字符串...
  • java.lang.NumberFormatException: empty String

    万次阅读 2015-07-27 19:12:40
    1、错误描述java.lang.NumberFormatException: empty String at sun.misc.FloatingDecimal.readJavaFormatString(FloatingDecimal.java:... at java.lang.Double.parseDouble(Double.java:540) service.impl.BillSer
  • parseDouble

    2014-05-26 22:03:46
    关于parseDouble用法( (2007-04-29 00:01:00) 转载▼   1.JAVA中的compareTo方法和strcmp完全类似,你可以使用 if(greeting.compareTo("help")==0).....或者用s.quals(t)来判断两个...
  • 说明你的java类文件中你运用了强制转换。什么是强制转换也就是,你用一种类型接受了另一种类型,发生了类型转化,但是类型转换一般 都是向上转型的。如 int 转 double,还有 int 转 String。这些都是自动转换不要...
  • //double的金额类型显示为科学计数法 //这里以String转换double举例 public static void main(String[] args) { //double类型在小数点前位数... double amount = Double.parseDouble(amountStr); System.out.pr

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 29,418
精华内容 11,767
关键字:

javaparsedouble

java 订阅