精华内容
下载资源
问答
  • java 小数相加
    2019-09-17 03:32:25
    import java.math.BigDecimal;
    /**
     * 类描述:
     * @version 1.0
     * @author chenairu
     * 
     */
    public class TM {
    	public static void main(String[] args) {
    		String s1 = "0.00001";
    		String s2 = "0.00002";
    		String s = s1+ s2;
    		Double db1 = Double.valueOf(s1);
    		Double db2 = Double.valueOf(s2);
    		
    		BigDecimal bs1 = new BigDecimal(s1);
    		BigDecimal bs2 = new BigDecimal(s2);
    		
    		BigDecimal bs11 = new BigDecimal(db1);
    		System.out.println("s:"+s);
    		System.out.println("db1:"+bs1.add(bs2));
    		System.out.println("bs11:"+bs11.add(new BigDecimal(db2)));
    		System.out.println("db1+db2:"+(db1+db2));
    	}
    }

    转载于:https://my.oschina.net/chenxiaoxiao/blog/718523

    更多相关内容
  • float、double类型的问题我们都知道,计算机是使用二进制存储数据的。而平常生活中,大多数情况下我们...我们先来看看十进制小数转二进制小数的方法对小数点以后的数乘以2,会得到一个结果,取结果的整数部分(不是1...

    float、double类型的问题

    我们都知道,计算机是使用二进制存储数据的。而平常生活中,大多数情况下我们都是使用的十进制,因此计算机显示给我们看的内容大多数也是十进制的,这就使得很多时候数据需要在二进制与十进制之间进行转换。对于整数来说,两种进制可以做到一一对应。而对于小数来讲就不是这样的啦。

    我们先来看看十进制小数转二进制小数的方法

    对小数点以后的数乘以2,会得到一个结果,取结果的整数部分(不是1就是0),然后再用小数部分再乘以2,再取结果的整数部分……以此类推,直到小数部分为0或者位数已经够了。顺序取每次运算得到的整数部分,即为转换后的小数部分。

    演示:

    0.125 ×2=0.25 .......................0

    0.25×2=0.5.............................0

    0.5×2=1.0................................1

    即 0.125的二进制表示为小数部分为0.001

    其实我们可以看出,这种方法实质上就是用1/2,1/4,8/1...来组合加出我们要转换的数据值,但显然不是所有的数都能够组合出来的。如0.1。

    0.1×2=0.2 .....................0

    0.2×2=0.4 ......................0

    0.4×2=0.8 .....................0

    0.8×2=1.6.......................1

    0.6×2=1.2.......................1

    0.2×2=0.4.......................0

    .....

    从上述计算过程我们可以看出,这是个无限小数,所以在这种情况下我们的float、double只能舍去一些位。

    那为什么我们在直接给float赋值在输出时没有看到精度损失而在运算时却会出现呢?

    确实是这样,如下

    float a = 0.2f;

    System.out.println(a);

    //输出0.2

    对于上述情况我只是查了资料,好像是因为编译器会进行优化,当我们存储的数据特别接近的时候,编译器会很贴心的返回我们想看到的数值(即二进制浮点数并不能准确的表示0.1这个十进制小数,它使用了0.100000001490116119384765625来代替0.1。),至于到了运算中,就会出现精度损失较大从而看到了真相。如果这块说的不对欢迎小伙伴们在评论区指正!

    解决方法

    BigDecimal 原理

    我们一般会使用

    BigDecimal 来避免出现精度丢失问题,至于为什么BigDecimal 可以避免,而float或double不行,我们在此不详细讨论,简单来说就是BigDecimal 通过借助整数来表示小数的方式,因为对于整数而言,二进制和十进制是完全一一对应的,用整数来表示小数,再记录下小数的位数,就可以完美的解决该问题。

    BigDecimal 用法

    java.math.BinInteger 类和 java.math.BigDecimal 类都是Java提供的用于高精度计算的类.其中 BigInteger 类是针对大整数的处理类,而 BigDecimal 类则是针对大小数的处理类.

    BigDecimal构造方法

    BigDecimal BigDecimal(double d); //不允许使用

    BigDecimal BigDecimal(String s); //常用,推荐使用

    static BigDecimal valueOf(double d); //常用,推荐使用

    double 参数的构造方法,不允许使用!!!!因为它不能精确的得到相应的值;

    String 构造方法是完全可预知的: 写入 new BigDecimal("0.1") 将创建一个 BigDecimal,它正好等于预期的0.1; 因此,通常建议优先使用 String 构造方法;

    静态方法 valueOf(double val) 内部实现,仍是将 double 类型转为 String 类型; 这通常是将 double(或float)转化为 BigDecimal 的首选方法;

    测试

    System.out.println(new BigDecimal(0.1));

    System.out.println(BigDecimal.valueOf(0.1));

    \\输出*****************************************

    0.1000000000000000055511151231257827021181583404541015625

    0.1

    BigDecimal常用操作

    我们通过一个工具类源码来体会BigDecimal的常规用法

    package com.util;

    import java.math.BigDecimal;

    /**

    * 提供精确的浮点数运算(包括加、减、乘、除、四舍五入)工具类

    */

    public class ArithUtil {

    // 除法运算默认精度

    private static final int DEF_DIV_SCALE = 10;

    private ArithUtil() {

    }

    /**

    * 精确加法

    */

    public static double add(double value1, double value2) {

    BigDecimal b1 = BigDecimal.valueOf(value1);

    BigDecimal b2 = BigDecimal.valueOf(value2);

    return b1.add(b2).doubleValue();

    }

    /**

    * 精确减法

    */

    public static double sub(double value1, double value2) {

    BigDecimal b1 = BigDecimal.valueOf(value1);

    BigDecimal b2 = BigDecimal.valueOf(value2);

    return b1.subtract(b2).doubleValue();

    }

    /**

    * 精确乘法

    */

    public static double mul(double value1, double value2) {

    BigDecimal b1 = BigDecimal.valueOf(value1);

    BigDecimal b2 = BigDecimal.valueOf(value2);

    return b1.multiply(b2).doubleValue();

    }

    /**

    * 精确除法 使用默认精度

    */

    public static double div(double value1, double value2) throws IllegalAccessException {

    return div(value1, value2, DEF_DIV_SCALE);

    }

    /**

    * 精确除法

    * @param scale 精度

    */

    public static double div(double value1, double value2, int scale) throws IllegalAccessException {

    if(scale < 0) {

    throw new IllegalAccessException("精确度不能小于0");

    }

    BigDecimal b1 = BigDecimal.valueOf(value1);

    BigDecimal b2 = BigDecimal.valueOf(value2);

    // return b1.divide(b2, scale).doubleValue();

    return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();

    }

    /**

    * 四舍五入

    * @param scale 小数点后保留几位

    */

    public static double round(double v, int scale) throws IllegalAccessException {

    return div(v, 1, scale);

    }

    /**

    * 比较大小

    */

    public static boolean equalTo(BigDecimal b1, BigDecimal b2) {

    if(b1 == null || b2 == null) {

    return false;

    }

    return 0 == b1.compareTo(b2);

    }

    }

    标签:Java,运算,double,valueOf,b1,b2,小数,BigDecimal

    来源: https://www.cnblogs.com/wunsiang/p/12811661.html

    展开全文
  • java编写的表达式求值(支持小数,指数运算),第一次上传,多多指教
  • JAVA小数运算

    千次阅读 2021-03-09 05:19:00
    同样,大多数开发人员也容易忽略java.math.BigDecimal 所提供的任意精度的小数 ―大多数应用程序不使用它们。然而,在以整数为主的程序中有时确实会出人意料地需要表示非整型数据。例如,JDBC使用 B...

    虽然几乎每种处理器和编程语言都支持浮点运算,但大多数程序员很少注意它。这容易理解

    我们中大多数很少需要使用非整数类型。除了科学计算和偶尔的计时测试或基准测试程序,其它情况下几乎都用不着它。同样,大多数开发人员也容易忽略

    java.math.BigDecimal 所提供的任意精度的小数 ―

    大多数应用程序不使用它们。然而,在以整数为主的程序中有时确实会出人意料地需要表示非整型数据。例如,JDBC

    使用 BigDecimal 作为 SQL DECIMAL 列的首选互换格式。

    IEEE 浮点

    Java 语言支持两种基本的浮点类型: float 和 double

    ,以及与它们对应的包装类 Float 和 Double 。它们都依据 IEEE 754

    标准,该标准为 32 位浮点和 64

    位双精度浮点二进制小数定义了二进制标准。

    IEEE 754 用科学记数法以底数为 2 的小数来表示浮点数。IEEE

    浮点数用 1 位表示数字的符号,用 8 位来表示指数,用 23

    位来表示尾数,即小数部分。作为有符号整数的指数可以有正负之分。小数部分用二进制(底数

    2)小数来表示,这意味着最高位对应着值 ?(2 -1),第二位对应着 ?(2

    -2),依此类推。对于双精度浮点数,用 11 位表示指数,52

    位表示尾数。

    因为用科学记数法可以有多种方式来表示给定数字,所以要规范化浮点数,以便用底数为

    2 并且小数点左边为 1

    的小数来表示,按照需要调节指数就可以得到所需的数字。所以,例如,数

    1.25 可以表示为尾数为 1.01,指数为 0: (-1) 0*1.01 2*2 0

    数 10.0 可以表示为尾数为 1.01,指数为 3: (-1) 0*1.01 2*2

    3

    特殊数字

    除了编码所允许的值的标准范围(对于 float ,从 1.4e-45 到

    3.4028235e+38),还有一些表示无穷大、负无穷大、 -0 和

    NaN(它代表“不是一个数字”)的特殊值。这些值的存在是为了在出现错误条件(譬如算术溢出,给负数开平方根,除以

    0 等)下,可以用浮点值集合中的数字来表示所产生的结果。

    这些特殊的数字有一些不寻常的特征。例如, 0 和 -0

    是不同值,但在比较它们是否相等时,被认为是相等的。用一个非零数去除以无穷大的数,结果等于

    0 。特殊数字 NaN 是无序的;使用 == 、 < 和 > 运算符将 NaN

    与其它浮点值比较时,结果为 false 。如果 f 为 NaN,则即使 (f == f)

    也会得到 false 。如果想将浮点值与 NaN 进行比较,则使用

    Float.isNaN() 方法。表 1 显示了无穷大和 NaN 的一些属性。

    表 1. 特殊浮点值的属性

    表达式 结果

    Math.sqrt(-1.0) -> NaN

    0.0 / 0.0 -> NaN

    1.0 / 0.0 -> 无穷大

    -1.0 / 0.0 -> 负无穷大

    NaN + 1.0 -> NaN

    无穷大 + 1.0 -> 无穷大

    无穷大 + 无穷大 -> 无穷大

    NaN > 1.0 -> false

    NaN == 1.0 -> false

    NaN < 1.0 -> false

    NaN == NaN -> false

    0.0 == -0.01 -> true

    基本浮点类型和包装类浮点有不同的比较行为

    使事情更糟的是,在基本 float 类型和包装类 Float

    之间,用于比较 NaN 和 -0 的规则是不同的。对于 float 值,比较两个

    NaN 值是否相等将会得到 false ,而使用 Float.equals() 来比较两个 NaN

    Float 对象会得到 true

    。造成这种现象的原因是,如果不这样的话,就不可能将 NaN Float

    对象用作 HashMap 中的键。类似的,虽然 0 和 -0

    在表示为浮点值时,被认为是相等的,但使用 Float.compareTo()

    来比较作为 Float 对象的 0 和 -0 时,会显示 -0 小于 0 。

    浮点中的危险

    由于无穷大、NaN 和 0

    的特殊行为,当应用浮点数时,可能看似无害的转换和优化实际上是不正确的。例如,虽然好象

    0.0-f 很明显等于 -f ,但当 f 为 0 时,这是不正确的。还有其它类似的

    gotcha,表 2 显示了其中一些 gotcha。

    表 2. 无效的浮点假定

    这个表达式…… 不一定等于…… 当……

    0.0 - f -f f 为 0

    f < g ! (f >= g) f 或 g 为 NaN

    f == f true f 为 NaN

    f + g - g f g 为无穷大或 NaN

    舍入误差

    浮点运算很少是精确的。虽然一些数字(譬如 0.5

    )可以精确地表示为二进制(底数 2)小数(因为 0.5 等于 2

    -1),但其它一些数字(譬如 0.1

    )就不能精确的表示。因此,浮点运算可能导致舍入误差,产生的结果接近

    ― 但不等于 ― 您可能希望的结果。例如,下面这个简单的计算将得到

    2.600000000000001 ,而不是 2.6 :

    double s=0;

    for (int i=0; i<26; i++)

    s += 0.1;

    System.out.println(s);

    类似的, .1*26 相乘所产生的结果不等于 .1 自身加 26

    次所得到的结果。当将浮点数强制转换成整数时,产生的舍入误差甚至更严重,因为强制转换成整数类型会舍弃非整数部分,甚至对于那些“看上去似乎”应该得到整数值的计算,也存在此类问题。例如,下面这些语句:

    double d = 29.0 * 0.01;

    System.out.println(d);

    System.out.println((int) (d * 100));

    将得到以下输出:

    0.29

    28

    这可能不是您起初所期望的。

    浮点数比较指南

    由于存在 NaN

    的不寻常比较行为和在几乎所有浮点计算中都不可避免地会出现舍入误差,解释浮点值的比较运算符的结果比较麻烦。

    最好完全避免使用浮点数比较。当然,这并不总是可能的,但您应该意识到要限制浮点数比较。如果必须比较浮点数来看它们是否相等,则应该将它们差的绝对值同一些预先选定的小正数进行比较,这样您所做的就是测试它们是否“足够接近”。(如果不知道基本的计算范围,可以使用测试“abs(a/b

    - 1) <

    epsilon”,这种方法比简单地比较两者之差要更准确)。甚至测试看一个值是比零大还是比零小也存在危险

    ―“以为”会生成比零略大值的计算事实上可能由于积累的舍入误差会生成略微比零小的数字。

    NaN

    的无序性质使得在比较浮点数时更容易发生错误。当比较浮点数时,围绕无穷大和

    NaN 问题,一种避免 gotcha

    的经验法则是显式地测试值的有效性,而不是试图排除无效值。在清单 1

    中,有两个可能的用于特性的 setter

    的实现,该特性只能接受非负数值。第一个实现会接受

    NaN,第二个不会。第二种形式比较好,因为它显式地检测了您认为有效的值的范围。

    清单 1. 需要非负浮点值的较好办法和较差办法

    // Trying to

    test by exclusion -- this doesn't catch NaN or

    infinitypublic void setFoo(float foo) {if (foo < 0)throw new IllegalArgumentException(Float.toString(f));this.foo =

    foo;   }// Testing by

    inclusion -- this does catch NaNpublic void setFoo(float foo) {if (foo >= 0

    && foo < Float.INFINITY)this.foo =

    foo;elsethrow new IllegalArgumentException(Float.toString(f));

    }

    不要用浮点值表示精确值

    一些非整数值(如几美元和几美分这样的小数)需要很精确。浮点数不是精确值,所以使用它们会导致舍入误差。因此,使用浮点数来试图表示象货币量这样的精确数量不是一个好的想法。使用浮点数来进行美元和美分计算会得到灾难性的后果。浮点数最好用来表示象测量值这类数值,这类值从一开始就不怎么精确。

    用于较小数的 BigDecimal

    从 JDK 1.3 起,Java

    开发人员就有了另一种数值表示法来表示非整数: BigDecimal 。

    BigDecimal

    是标准的类,在编译器中不需要特殊支持,它可以表示任意精度的小数,并对它们进行计算。在内部,可以用任意精度任何范围的值和一个换算因子来表示

    BigDecimal

    ,换算因子表示左移小数点多少位,从而得到所期望范围内的值。因此,用

    BigDecimal 表示的数的形式为 unscaledValue*10 -scale 。

    用于加、减、乘和除的方法给 BigDecimal 值提供了算术运算。由于

    BigDecimal 对象是不可变的,这些方法中的每一个都会产生新的

    BigDecimal 对象。因此,因为创建对象的开销, BigDecimal

    不适合于大量的数学计算,但设计它的目的是用来精确地表示小数。如果您正在寻找一种能精确表示如货币量这样的数值,则

    BigDecimal 可以很好地胜任该任务。

    所有的 equals 方法都不能真正测试相等

    如浮点类型一样, BigDecimal

    也有一些令人奇怪的行为。尤其在使用 equals()

    方法来检测数值之间是否相等时要小心。 equals()

    方法认为,两个表示同一个数但换算值不同(例如, 100.00 和 100.000 )的

    BigDecimal 值是不相等的。然而, compareTo()

    方法会认为这两个数是相等的,所以在从数值上比较两个 BigDecimal

    值时,应该使用 compareTo() 而不是 equals() 。

    另外还有一些情形,任意精度的小数运算仍不能表示精确结果。例如,

    1 除以 9 会产生无限循环的小数 .111111...

    。出于这个原因,在进行除法运算时, BigDecimal

    可以让您显式地控制舍入。 movePointLeft() 方法支持 10

    的幂次方的精确除法。

    使用 BigDecimal 作为互换类型

    SQL-92 包括 DECIMAL

    数据类型,它是用于表示定点小数的精确数字类型,它可以对小数进行基本的算术运算。一些

    SQL 语言喜欢称此类型为 NUMERIC 类型,其它一些 SQL 语言则引入了

    MONEY 数据类型,MONEY

    数据类型被定义为小数点右侧带有两位的小数。

    如果希望将数字存储到数据库中的 DECIMAL 字段,或从 DECIMAL

    字段检索值,则如何确保精确地转换该数字?您可能不希望使用由 JDBC

    PreparedStatement 和 ResultSet 类所提供的 setFloat() 和 getFloat()

    方法,因为浮点数与小数之间的转换可能会丧失精确性。相反,请使用

    PreparedStatement 和 ResultSet 的 setBigDecimal() 及

    getBigDecimal() 方法。

    对于 BigDecimal

    ,有几个可用的构造函数。其中一个构造函数以双精度浮点数作为输入,另一个以整数和换算因子作为输入,还有一个以小数的

    String 表示作为输入。要小心使用 BigDecimal(double)

    构造函数,因为如果不了解它,会在计算过程中产生舍入误差。请使用基于整数或

    String 的构造函数。

    构造 BigDecimal 数

    对于 BigDecimal

    ,有几个可用的构造函数。其中一个构造函数以双精度浮点数作为输入,另一个以整数和换算因子作为输入,还有一个以小数的

    String 表示作为输入。要小心使用 BigDecimal(double)

    构造函数,因为如果不了解它,会在计算过程中产生舍入误差。请使用基于整数或

    String 的构造函数。

    如果使用 BigDecimal(double) 构造函数不恰当,在传递给 JDBC

    setBigDecimal() 方法时,会造成似乎很奇怪的 JDBC

    驱动程序中的异常。例如,考虑以下 JDBC 代码,该代码希望将数字 0.01

    存储到小数字段:

    PreparedStatement ps

    =connection.prepareStatement("INSERT

    INTO Foo SET name=?, value=?");

    ps.setString(1,

    "penny");

    ps.setBigDecimal(2,

    new BigDecimal(0.01));

    ps.executeUpdate();

    在执行这段似乎无害的代码时会抛出一些令人迷惑不解的异常(这取决于具体的

    JDBC 驱动程序),因为 0.01

    的双精度近似值会导致大的换算值,这可能会使 JDBC

    驱动程序或数据库感到迷惑。JDBC

    驱动程序会产生异常,但可能不会说明代码实际上错在哪里,除非意识到二进制浮点数的局限性。相反,使用

    BigDecimal("0.01") 或 BigDecimal(1, 2) 构造 BigDecimal

    来避免这类问题,因为这两种方法都可以精确地表示小数。

    展开全文
  • Java中的小数运算与精度丢掉float、double类型的问题咱们都知道,核算机是运用二进制存储数据的。而往常日子中,大多数情况下咱们都是运用的十进制,因而核算机显示给咱们看的内容大多数也是十进制的,这就使得许多...

    Java中的小数运算与精度丢掉

    float、double类型的问题

    咱们都知道,核算机是运用二进制存储数据的。而往常日子中,大多数情况下咱们都是运用的十进制,因而核算机显示给咱们看的内容大多数也是十进制的,这就使得许多时分数据需要在二进制与十进制之间进行转化。关于整数来说,两种进制能够做到一一对应。而关于小数来讲就不是这样的啦。

    咱们先来看看十进制小数转二进制小数的办法

    对小数点今后的数乘以2,会得到一个成果,取成果的整数部分(不是1便是0),然后再用小数部分再乘以2,再取成果的整数部分……以此类推,直到小数部分为0或许位数现已够了。次序取每次运算得到的整数部分,即为转化后的小数部分。

    演示:

    0.125 ×2=0.25 .......................0

    0.25×2=0.5.............................0

    0.5×2=1.0................................1

    即 0.125的二进制表明为小数部分为0.001

    其实咱们能够看出,这种办法实质上便是用1/2,1/4,8/1...来组合加出咱们要转化的数据值,但明显不是一切的数都能够组合出来的。如0.1。

    0.1×2=0.2 .....................0

    0.2×2=0.4 ......................0

    0.4×2=0.8 .....................0

    0.8×2=1.6.......................1

    0.6×2=1.2.......................1

    0.2×2=0.4.......................0

    .....

    从上述核算进程咱们能够看出,这是个无限小数,所以在这种情况下咱们的float、double只能舍去一些位。

    那为什么咱们在直接给float赋值在输出时没有看到精度丢掉而在运算时却会呈现呢?

    确实是这样,如下

    float a = 0.2f;

    System.out.println(a);

    //输出0.2

    关于上述情况我仅仅查了材料,如同是由于编译器会进行优化,当咱们存储的数据特别挨近的时分,编译器会很交心的回来咱们想看到的数值(即二进制浮点数并不能准确的表明0.1这个十进制小数,它运用了0.100000001490116119384765625来替代0.1。),至于到了运算中,就会呈现精度丢掉较大然后看到了本相。假如这块说的不对欢迎小伙伴们在谈论区纠正!

    处理办法

    BigDecimal 原理

    咱们一般会运用

    BigDecimal 来防止呈现精度丢掉问题,至于为什么BigDecimal 能够防止,而float或double不可,咱们在此不具体评论,简略来说便是BigDecimal 经过凭借整数来表明小数的办法,由于关于整数而言,二进制和十进制是彻底一一对应的,用整数来表明小数,再记录下小数的位数,就能够完美的处理该问题。

    BigDecimal 用法

    java.math.BinInteger 类和 java.math.BigDecimal 类都是Java供给的用于高精度核算的类.其间 BigInteger 类是针对大整数的处理类,而 BigDecimal 类则是针对巨细数的处理类.

    BigDecimal结构办法

    BigDecimal BigDecimal(double d); //不允许运用

    BigDecimal BigDecimal(String s); //常用,引荐运用

    static BigDecimal valueOf(double d); //常用,引荐运用

    double 参数的结构办法,不允许运用!!!!由于它不能准确的得到相应的值;

    String 结构办法是彻底可预知的: 写入 new BigDecimal("0.1") 将创立一个 BigDecimal,它正好等于预期的0.1; 因而,一般主张优先运用 String 结构办法;

    静态办法 valueOf(double val) 内部完成,仍是将 double 类型转为 String 类型; 这一般是将 double(或float)转化为 BigDecimal 的首选办法;

    测验

    System.out.println(new BigDecimal(0.1));

    System.out.println(BigDecimal.valueOf(0.1));

    输出*

    0.1000000000000000055511151231257827021181583404541015625

    0.1

    BigDecimal常用操作

    咱们经过一个东西类源码来领会BigDecimal的惯例用法

    package com.util;

    import java.math.BigDecimal;

    /**

    供给准确的浮点数运算(包含加、减、乘、除、四舍五入)东西类

    */

    public class ArithUtil {

    // 除法运算默许精度

    private static final int DEF_DIV_SCALE = 10;

    private ArithUtil() {

    }

    /**

    * 准确加法

    */

    public static double add(double value1, double value2) {

    BigDecimal b1 = BigDecimal.valueOf(value1);

    BigDecimal b2 = BigDecimal.valueOf(value2);

    return b1.add(b2).doubleValue();

    }

    /**

    * 准确减法

    */

    public static double sub(double value1, double value2) {

    BigDecimal b1 = BigDecimal.valueOf(value1);

    BigDecimal b2 = BigDecimal.valueOf(value2);

    return b1.subtract(b2).doubleValue();

    }

    /**

    * 准确乘法

    */

    public static double mul(double value1, double value2) {

    BigDecimal b1 = BigDecimal.valueOf(value1);

    BigDecimal b2 = BigDecimal.valueOf(value2);

    return b1.multiply(b2).doubleValue();

    }

    /**

    * 准确除法 运用默许精度

    */

    public static double div(double value1, double value2) throws IllegalAccessException {

    return div(value1, value2, DEF_DIV_SCALE);

    }

    /**

    * 准确除法

    * @param scale 精度

    */

    public static double div(double value1, double value2, int scale) throws IllegalAccessException {

    if(scale < 0) {

    throw new IllegalAccessException("准确度不能小于0");

    }

    BigDecimal b1 = BigDecimal.valueOf(value1);

    BigDecimal b2 = BigDecimal.valueOf(value2);

    // return b1.divide(b2, scale).doubleValue();

    return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();

    }

    /**

    * 四舍五入

    * @param scale 小数点后保存几位

    */

    public static double round(double v, int scale) throws IllegalAccessException {

    return div(v, 1, scale);

    }

    /**

    * 比较巨细

    */

    public static boolean equalTo(BigDecimal b1, BigDecimal b2) {

    if(b1 == null || b2 == null) {

    return false;

    }

    return 0 == b1.compareTo(b2);

    }

    }

    展开全文
  • function add(arg1, arg2) {var r1, r2, mtry {r1 = arg1.toString().split('.')[1].length} catch (e) {r1 = 0}try {r2 = arg2.toString().split('.')[1].length} catch (e) {r2 = 0}let b = Math.pow(10, Math.max...
  • 答:这里十进制的计算会转化为二进制的计算,而二进制有的时候无法精确地表示十进制的小数,因为有些小数无法写成1/(2^n)的和的形式(比如0.1),如此就会出现误差,那么最后计算得出的结果自然也会有误差。...
  • java 中提供BigDecimal对小数的精确处理a) 通常用到下面的方法: 保留两位小数, 四舍五入setScale(int newScale, int roundingMode)- newScale:保留的小数位数- roundingMode:精度取值方式roundingMode的取值有...
  • package Java; import java.math.BigDecimal; public class BigDecimalUtil { //无参构造 private BigDecimalUtil() { } //将String字符串转换成double public static double strToDouble(String str) { ...
  • 一、BigDecimal常用方法 加法:add 减法:subtract ...setScale(1,BigDecimal.ROUND_DOWN)直接删除多余的小数位,如2.35会变成2.3 setScale(1,BigDecimal.ROUND_UP)进位处理,2.35变成2.4 setScale...
  • 目录1. 提供精确的加法运算2. 提供精确的减法运算2.1 参数为double类型2.2 参数为字符串类型2.3 减法运算精确小数点位数3. 提供精确的乘法运算4. 提供指定小数点位数的除法运算4.1 除不尽四舍五入4.2 除不尽指定精度...
  • 原因简单来说:2进制的小数无法十分精准的表达十进制的小数,计算机在计算十进制小数运算的时候需要先转换成2进制进行计算,这个过程中出现了一些误差。 两个解决办法 办法一 使用 BigDecimal 使用 BigDecimal ...
  • Java精确运算小数

    千次阅读 2018-10-10 12:44:33
    在学习完二进制后知道了二进制不能精确的表示有的小数(比如0.1,就好比十进制无法精确表示1/3一样), 所以一般会对小数格式化处理。 但是如果涉及到金钱的项目,一点点误差都不能有,必须使用精确运算的时候,就可以...
  • 举个简单的例子吧publicclassCalulator{doublenum1;...}publicvoidshowAdd(){System.out.println("两个数相加的结果为"+add());}//加法的...举个简单的例子吧public class Calulator {double num1;dou...
  • 代替double和float精确计算小数
  • java基础之小数计算

    2021-03-06 04:33:22
    项目中会经常用到小数位的计算。...出现原因分析:Java在计算浮点数的时候,由于二进制无法精确表示0.1的值(就好比十进制无法精确表示1/3一样)。解决方案:2种1.先用整数加减乘除,再除以小数位。2.使用BigDecimal...
  • 转自一提到Java里面的商业计算,我们都知道不能用float和double,因为他们无法进行精确计算。但是Java的设计者给编程人员提供了一个很有用的类BigDecimal,他可以完善float和double类无法进行精确计算的缺憾。...
  • 先来看一个例子: System.out.println(2.0 - 1.1); 结果为: 0.8999999999999999 很明显,这不是我们开发中需要的精度,我们需要...import java.math.BigDecimal; BigDecimal bd1 = new BigDecimal(2.0); BigD...
  • 次序取每次运算得到的整数部分,即为转化后的小数部分。 演示: 0.125 ×2=0.25 …0 0.25×2=0.5…0 0.5×2=1.0…1 即 0.125的二进制表明为小数部分为0.001 其实咱们能够看出,这种办法实质上便是用1/2,1/4,8/1…来...
  • JAVA-BigDecimal精确小数运算 创建对象的方式 //推荐使用字符串的构造方法进行创建 BigDecimal b1 = new BigDecimal("893"); BigDecimal b2 = new BigDecimal("1"); //加法 b1.add(b2); //减法 b1.subtract...
  • java的浮点类型数据进行运算都是近似值,不符合数学的运算,所以这里用了两个方法来解决这种问题 第一种:四舍五入法 double doublea=4.35*100; System.out.println(doublea);//java浮点类型值是近似值不精准,...
  • 基于Java的简易计算器,能够完成整数和小数的基本运算。运用策略模式完成具体的运算
  • import java.math.BigDecimal;/*** @program: simple_tools* @description: 精准浮点运算* @author: ChenWenLong* @create: 2019-10-18 11:51**/public class BigDecimalUtils {/*** 默认除法运算精...
  • JAVA)超大小数运算

    2021-08-21 17:20:04
    import java.math.BigDecimal; /** * @author zhangyu * @date 2021年08月21日 4:56 * 双精度大数据运算 * divide()除法运算。 * public BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)...
  • 但实际上,即使在一些非常基本的小数运算中,计算的结果也是不精确的。 比如: float f = 0.1f*0.1f; System.out.println(f); 这个结果看上去,不言而喻,应该是0.01,但实际上,屏幕输出却是0.010000001,后面多了...
  • Java精确计算小数

    千次阅读 2019-04-24 11:41:57
    Java在计算浮点数的时候,由于二进制无法精确表示0.1的值(就好比十进制无法精确表示1/3一样),所以一般会对小数格式化处理. 但是如果涉及到金钱的项目,一点点误差都不能有,必须使用精确运算的时候,就可以使用...
  • Java基础之小数的加减乘除

    千次阅读 2018-09-03 11:05:22
    小数的加减乘除  今天修改项目的时候,突然发现版本号的递增出现了问题,本来应该是当前版本号 + 0.1 = 递增后的版本号,结果获得的版本号出现了很多的小数。 例如: public class Test04 { public static ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 60,455
精华内容 24,182
关键字:

java小数相加

java 订阅