精华内容
下载资源
问答
  • double双精度保留两位小数最简单实用的操作,介绍一个,当然还有几个专业的操作方法,这里就不介绍了。 如果想要专业写法,建议百度,或者查阅java帮助文档中的java.lang.math class Test01 { public static void...

    我是学习java的新手,对于遇到的一些问题自己做个总结,java中最常见的就是保留精度。


    double双精度只保留两位小数最简单实用的操作,介绍一个,当然还有几个专业的操作方法,这里就不介绍了。

    如果想要专业写法,建议百度,或者查阅java帮助文档中的java.lang.math

    class Test01
    {
       public static void main(String[] args)
      {
        double a=2.2343545465;
        //保留两位小数
        a=(int)(a*100)/100.0; 
        System.out.println("a="+a);
      }
    }
    输出结果就是2.23;

    欢迎测试。
    如果有更多交流的,请加入QQ群214875382群链接:http://url.cn/RjCNG6

    展开全文
  • JavaDecimalFormat dcmFmt = new DecimalFormat("0.00");double db = 12333.353;...JS//保留两位小数//功能:将浮点数四舍五入,取小数点后2位function toDecimal(x) {var f = parseFloat(x);if (isNaN(f...

    Java

    DecimalFormat dcmFmt = new DecimalFormat("0.00");

    double db = 12333.353;

    System.out.println(dcmFmt.format(db));

    JS

    //保留两位小数

    //功能:将浮点数四舍五入,取小数点后2位

    function toDecimal(x) {

    var f = parseFloat(x);

    if (isNaN(f)) {

    return;

    }

    f = Math.round(x*100)/100;

    return f;

    }

    //制保留2位小数,如:2,会在2后面补上00.即2.00

    function toDecimal2(x) {

    var f = parseFloat(x);

    if (isNaN(f)) {

    return false;

    }

    var f = Math.round(x*100)/100;

    var s = f.toString();

    var rs = s.indexOf(‘.‘);

    if (rs < 0) {

    rs = s.length;

    s += ‘.‘;

    }

    while (s.length <= rs + 2) {

    s += ‘0‘;

    }

    return s;

    }

    function fomatFloat(src,pos){

    return Math.round(src*Math.pow(10, pos))/Math.pow(10, pos);

    }

    //四舍五入

    alert("保留2位小数:" + toDecimal(3.14159267));

    alert("强制保留2位小数:" + toDecimal2(3.14159267));

    alert("保留2位小数:" + toDecimal(3.14559267));

    alert("强制保留2位小数:" + toDecimal2(3.15159267));

    alert("保留2位小数:" + fomatFloat(3.14559267, 2));

    alert("保留1位小数:" + fomatFloat(3.15159267, 1));

    //五舍六入

    alert("保留2位小数:" + 1000.003.toFixed(2));

    alert("保留1位小数:" + 1000.08.toFixed(1));

    alert("保留1位小数:" + 1000.04.toFixed(1));

    alert("保留1位小数:" + 1000.05.toFixed(1));

    //科学计数

    alert(3.1415.toExponential(2));

    alert(3.1455.toExponential(2));

    alert(3.1445.toExponential(2));

    alert(3.1465.toExponential(2));

    alert(3.1665.toExponential(1));

    //精确到n位,不含n位

    alert("精确到小数点第2位" + 3.1415.toPrecision(2));

    alert("精确到小数点第3位" + 3.1465.toPrecision(3));

    alert("精确到小数点第2位" + 3.1415.toPrecision(2));

    alert("精确到小数点第2位" + 3.1455.toPrecision(2));

    alert("精确到小数点第5位" + 3.141592679287.toPrecision(5));

    原文:http://www.cnblogs.com/htys/p/5159414.html

    展开全文
  • Java DecimalFormat dcmFmt = new DecimalFormat("0.00"); double db = 12333.353; System.out.println(dcmFmt.format(db)); JS <script type="text/javascript"> //保留两位小数 //功能:将...

    Java

    DecimalFormat dcmFmt = new DecimalFormat("0.00");

    double db = 12333.353;

    System.out.println(dcmFmt.format(db));

     

    JS

    <script type="text/javascript">  
    //保留两位小数
    //功能:将浮点数四舍五入,取小数点后2位
    function toDecimal(x) {
    var f = parseFloat(x);
    if (isNaN(f)) {
    return;
    }
    f = Math.round(x*100)/100;
    return f;
    }


    //制保留2位小数,如:2,会在2后面补上00.即2.00
    function toDecimal2(x) {
    var f = parseFloat(x);
    if (isNaN(f)) {
    return false;
    }
    var f = Math.round(x*100)/100;
    var s = f.toString();
    var rs = s.indexOf('.');
    if (rs < 0) {
    rs = s.length;
    s += '.';
    }
    while (s.length <= rs + 2) {
    s += '0';
    }
    return s;
    }

    function fomatFloat(src,pos){
    return Math.round(src*Math.pow(10, pos))/Math.pow(10, pos);
    }
    //四舍五入
    alert("保留2位小数:" + toDecimal(3.14159267));
    alert("强制保留2位小数:" + toDecimal2(3.14159267));
    alert("保留2位小数:" + toDecimal(3.14559267));
    alert("强制保留2位小数:" + toDecimal2(3.15159267));
    alert("保留2位小数:" + fomatFloat(3.14559267, 2));
    alert("保留1位小数:" + fomatFloat(3.15159267, 1));

    //五舍六入
    alert("保留2位小数:" + 1000.003.toFixed(2));
    alert("保留1位小数:" + 1000.08.toFixed(1));
    alert("保留1位小数:" + 1000.04.toFixed(1));
    alert("保留1位小数:" + 1000.05.toFixed(1));

    //科学计数
    alert(3.1415.toExponential(2));
    alert(3.1455.toExponential(2));
    alert(3.1445.toExponential(2));
    alert(3.1465.toExponential(2));
    alert(3.1665.toExponential(1));
    //精确到n位,不含n位
    alert("精确到小数点第2位" + 3.1415.toPrecision(2));
    alert("精确到小数点第3位" + 3.1465.toPrecision(3));
    alert("精确到小数点第2位" + 3.1415.toPrecision(2));
    alert("精确到小数点第2位" + 3.1455.toPrecision(2));
    alert("精确到小数点第5位" + 3.141592679287.toPrecision(5));
    </script>

    转载于:https://www.cnblogs.com/htys/p/5159414.html

    展开全文
  • 基础浮点数是用机器上浮点数的本机双精度(64 bit)表示的。提供大约17的精度和范围从-308到308的指数。和C语言里面的double类型相同。Python不支持32bit的单精度浮点数。如果程序需要精确控制区间和数字精度,可以...

    基础

    浮点数是用机器上浮点数的本机双精度(64 bit)表示的。提供大约17位的精度和范围从-308到308的指数。和C语言里面的double类型相同。Python不支持32bit的单精度浮点数。如果程序需要精确控制区间和数字精度,可以考虑使用numpy扩展库。

    Python 3.X对于浮点数默认的是提供17位数字的精度。

    关于单精度和双精度的通俗解释:

    单精度型和双精度型,其类型说明符为float 单精度说明符,double 双精度说明符。在Turbo C中单精度型占4个字节(32位)内存空间,其数值范围为3.4E-38~3.4E+38,只能提供七位有效数字。双精度型占8 个字节(64位)内存空间,其数值范围为1.7E-308~1.7E+308,可提供16位有效数字。

    要求较小的精度

    将精度高的浮点数转换成精度低的浮点数。

    1.round()内置方法

    这个是使用最多的,刚看了round()的使用解释,也不是很容易懂。round()不是简单的四舍五入的处理方式。

    For the built-in types supporting round(), values are rounded to the closest multiple of 10 to the power minus ndigits; if two multiples are equally close, rounding is done toward the even choice (so, for example, both round(0.5) and round(-0.5) are 0, and round(1.5) is 2).

    1 >>> round(2.5)

    2 2

    3 >>> round(1.5)

    4 2

    5 >>> round(2.675)

    6 3

    7 >>> round(2.675, 2)

    8 2.67

    round()如果只有一个数作为参数,不指定位数的时候,返回的是一个整数,而且是最靠近的整数(这点上类似四舍五入)。但是当出现.5的时候,两边的距离都一样,round()取靠近的偶数,这就是为什么round(2.5) = 2。当指定取舍的小数点位数的时候,一般情况也是使用四舍五入的规则,但是碰到.5的这样情况,如果要取舍的位数前的小数是奇数,则向下取舍,如果偶数则向上取舍。看下面的示例:

    1 >>> round(2.635, 2)

    2 2.63

    3 >>> round(2.645, 2)

    4 2.65

    5 >>> round(2.655, 2)

    6 2.65

    7 >>> round(2.665, 2)

    8 2.67

    9 >>> round(2.675, 2)

    10 2.67

    2. 使用格式化

    效果和round()是一样的。

    1 >>> a = ("%.2f" % 2.635)

    2 >>> a

    3 '2.63'

    4 >>> a = ("%.2f" % 2.645)

    5 >>> a

    6 '2.65'

    7 >>> a = int(2.5)

    8 >>> a

    9 2

    要求超过17位的精度分析

    python默认的是17位小数的精度,但是这里有一个问题,就是当我们的计算需要使用更高的精度(超过17位小数)的时候该怎么做呢?

    1. 使用格式化(不推荐)

    1 >>> a = "%.30f" % (1/3)

    2 >>> a

    3 '0.333333333333333314829616256247'

    可以显示,但是不准确,后面的数字往往没有意义。

    2. 高精度使用decimal模块,配合getcontext

    1 >>> from decimal import *

    2 >>> print(getcontext())

    3 Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[InvalidOperation, DivisionByZero, Overflow])

    4 >>> getcontext().prec = 50

    5 >>> b = Decimal(1)/Decimal(3)

    6 >>> b

    7 Decimal('0.33333333333333333333333333333333333333333333333333')

    8 >>> c = Decimal(1)/Decimal(17)

    9 >>> c

    10 Decimal('0.058823529411764705882352941176470588235294117647059')

    11 >>> float(c)

    12 0.058823529411764705

    默认的context的精度是28位,可以设置为50位甚至更高,都可以。这样在分析复杂的浮点数的时候,可以有更高的自己可以控制的精度。其实可以留意下context里面的这rounding=ROUND_HALF_EVEN 参数。ROUND_HALF_EVEN, 当half的时候,靠近even.

    关于小数和取整

    既然说到小数,就必然要说到整数。一般取整会用到这些函数:

    1. round()

    这个不说了,前面已经讲过了。一定要注意它不是简单的四舍五入,而是ROUND_HALF_EVEN的策略。

    2. math模块的ceil(x)

    取大于或者等于x的最小整数。

    3. math模块的floor(x)

    去小于或者等于x的最大整数。

    1 >>> from math import ceil, floor

    2 >>> round(2.5)

    3 2

    4 >>> ceil(2.5)

    5 3

    6 >>> floor(2.5)

    7 2

    8 >>> round(2.3)

    9 2

    10 >>> ceil(2.3)

    11 3

    12 >>> floor(2.3)

    13 2

    14 >>>

    展开全文
  • 基础浮点数是用机器上浮点数的本机双精度(64 bit)表示的。提供大约17的精度和范围从-308到308的指数。和C语言里面的double类型相同。Python不支持32bit的单精度浮点数。如果程序需要精确控制区间和数字精度,可以...
  • Java中数字保留两位小数

    万次阅读 2019-05-20 15:22:44
    Java中数字保留小数Double...下列代码表示保留两位小数并且四舍五入的双精度类型数据处理。 Double num = 69.26345; BigDecimal bd = new BigDecimal(num); num = bd.setScale(2, BigDecimal.ROUND_HALF_UP).doubleV...
  • 一、前言通过定义MoneyUtil金额工具类,对金额数字字符串进行转换为"BigDecimal"、保留两位小数、四舍五入、排除科学计数法的影响等常用处理,详情代码示例说明部分。二、代码示例importjava.lang.reflect.Field;@b@...
  • 总时间限制:1000ms内存限制:65536kB描述读入一个双精度浮点数,分别按输出格式“%f”,“%f”保留5位小数,“%e”和“%g”的形式输出这个整数,每次在单独一行上输出。输入一个双精度浮点数。输出输出有四行:第一行...
  • 双精度浮点型变量double可以处理16有效数,但在实际应用中,可能需要对更大或者更小的数进行运算和处理。一般情况下,对于那些不需要准确计算精度的数字,我们可以直接使用Float和Double处理,但是
  • 1. Double x2=0.5698; System.out.println(String.format("%.2f", x1));... * 以指定的舍入模式格式化双精度浮点型小数 * @param d 需格式化小数 * @param precision 保留小数位数 * @param roundingMode 舍
  • 已知 双精度标量 f, 如果想以字符串形式输出,小数点后保留2,可直接通过C语言的输出格式,System.out.printf("%.2f", f), 达到目的。 如果想要先转变成小数点后保留2双精度变量,然后再输出,可以尝试用 f...
  • double 是双精度类型,也就是说你的d是double,而你的d*100中的100是整形(int)。这是自动类型转换 符合以下条件时java将会做自动类型转换: (1)转换前的数据类型与转换后的类型兼容。 (2)转换后的数据类型的...
  • c语言double类型默认保留位小数?发布时间:2020-04-23 09:31:42来源:亿速云阅读:945作者:小新c语言double类型默认保留位小数?相信有很多人都不太了解,今天小编为了让大家更加了解c语言double类型,所以给...
  • BigDecimal的用法详解(保留两位小数,四舍五入,数字格式化,科学计数法转数字,数字里的逗号处理)2016年05月29日 14:52:47阅读数:64378 一、简介 Java在java.math包中提供的API类BigDecimal,用来对超过16位有效位...
  • 作者:极客小俊 一个专注于web技术的80后我不用拼过聪明人,我...float 浮点类型用于表示单精度浮点数值, double浮点类型用于表示双精度浮点数值 这里肯定有些小伙伴要问了 什么是单精度 什么是双精度 ? 下面我们就...
  • BigDecimal的用法详解(保留两位小数,四舍五入,数字格式化,科学计数法转数字,数字里的逗号处理)http://www.bieryun.com/972.html 一、简介 Java在java.math包中提供的API类BigDecimal,用来对超过16位有效位的数...
  • 双精度浮点型变量double可以处理16有效数。在实际应用中,需要对更大或者更小的数进行运算和处理。float和double只能用来做科学计算或者是工程计算,在商业计算中要用java.math.BigDecimal。BigDecimal所创建的是...
  • 双精度浮点型变量double可以处理16有效数。在实际应用中,需要对更大或者更小的数进行运算和处理。float和double只能用来做科学计算或者是工程计算,在商业计算中要用java.math.BigDecimal。BigDecimal所创建的是...

空空如也

空空如也

1 2 3 4 5 ... 9
收藏数 173
精华内容 69
关键字:

双精度保留两位小数