解决java数值范围以及float与double精度丢失的问题

 更新时间:2017年06月26日 08:47:36   投稿:jingxian  
下面小编就为大家带来一篇解决java数值范围以及float与double精度丢失的问题。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧

1.java中int,float,long,double取值范围

public class TestOutOfBound { 
public static void main(String[] args) { 
 
System.out.println(Integer.MAX_VALUE-(-Integer.MAX_VALUE)); //内存溢出 
System.out.println(Integer.MAX_VALUE); //2的31次方-1,10个数位,正的20亿左右,用在钱上面不一定够 
System.out.println(Integer.MIN_VALUE); //负的2的31次方 
System.out.println(Long.MAX_VALUE); //2的64次方-1,19个数位,很大了,可放心用在钱上面 
System.out.println(Long.MIN_VALUE); //负的2的64次方 
System.out.println(Float.MAX_VALUE); //2的128次方-1,38个数位,比long多了一倍,这个主要用来做简单数学精确运算使用 
System.out.println(Float.MIN_VALUE); //2的-149次方 
System.out.println(Double.MAX_VALUE); //2的1024次方-1,308个数位,是float数位的10倍,主要用来做复杂运算和天文运算 
System.out.println(Double.MIN_VALUE); //2的-1074次方 
 
} 
} 

2.float与double精度丢失问题

例子:

举例:double result = 1.0 - 0.9; 
 
这个结果不用说了吧,都知道了,0.09999999999999998

为什么会出现这个问题呢,就这是java和其它计算机语言都会出现的问题,下面我们分析一下为什么会出现这个问题:

float和double类型主要是为了科学计算和工程计算而设计的。他们执行二进制浮点运算,这是为了在广泛的数字范围上提供较为精确的快速近似计算而精心设计的。然而,它们并没有提供完全精确的结果,所以我们不应该用于精确计算的场合。float和double类型尤其不适合用于货币运算,因为要让一个float或double精确的表示0.1或者10的任何其他负数次方值是不可能的(其实道理很简单,十进制系统中能不能准确表示出1/3呢?同样二进制系统也无法准确表示1/10)。

浮点运算很少是精确的,只要是超过精度能表示的范围就会产生误差。往往产生误差不是因为数的大小,而是因为数的精度。因此,产生的结果接近但不等于想要的结果。尤其在使用 float 和 double 作精确运算的时候要特别小心。

现在我们就详细剖析一下浮点型运算为什么会造成精度丢失?

首先我们要搞清楚下面两个问题: 
 
  (1) 十进制整数如何转化为二进制数 
 
     算法很简单。举个例子,11表示成二进制数: 
 
          11/2=5 余  1 
 
           5/2=2  余  1 
 
           2/2=1  余  0 
 
           1/2=0  余  1 
 
            0结束     11二进制表示为(从下往上):1011 
 
    这里提一点:只要遇到除以后的结果为0了就结束了,大家想一想,所有的整数除以2是不是一定能够最终得到0。换句话说,所有的整数转变为二进制数的算法会不会无限循环下去呢?绝对不会,整数永远可以用二进制精确表示 ,但小数就不一定了。 
 
  (2) 十进制小数如何转化为二进制数 
 
     算法是乘以2直到没有了小数为止。举个例子,0.9表示成二进制数 
 
          0.9*2=1.8  取整数部分 1 
 
          0.8(1.8的小数部分)*2=1.6  取整数部分 1 
 
          0.6*2=1.2  取整数部分 1 
 
          0.2*2=0.4  取整数部分 0 
 
          0.4*2=0.8  取整数部分 0 
 
          0.8*2=1.6 取整数部分 1 
 
          0.6*2=1.2  取整数部分 0 
 
              .........   0.9二进制表示为(从上往下): 1100100100100...... 
 
     注意:上面的计算过程循环了,也就是说*2永远不可能消灭小数部分,这样算法将无限下去。很显然,小数的二进制表示有时是不可能精确的 。其实道理很简单,十进制系统中能不能准确表示出1/3呢?同样二进制系统也无法准确表示1/10。这也就解释了为什么浮点型减法出现了"减不尽"的精度丢失问题。

3.解决方法一:

如果不介意自己记录十进制的小数点,而且数值不大,那么可以使用long ,int等基本类型,具体用int还是long要看涉及的数值范围大小,缺点是要自己处理十进制小数点,最明显的做法就是处理货币使用分来计算,而不用元(只涉及加减)。

如:

int resultInt = 10 - 9;  
double result = (double) resultInt / 100;//最终时候自己控制小数点  

4.解决方法二:

使用BigDecmal,而且需要在构造参数使用String类型。

在《Effective Java》这本书中就给出了一个解决方法。该书中也指出,float和double只能用来做科学计算或者是工程计算,在商业计算等精确计算中,我们要用java.math.BigDecimal。

BigDecimal类一个有4个方法,我们只关心对我们解决浮点型数据进行精确计算有用的方法,即

BigDecimal(double value) // 将double型数据转换成BigDecimal型数据

思路很简单,我们先通过BigDecimal(double value)方法,将double型数据转换成BigDecimal数据,然后就可以正常进行精确计算了。等计算完毕后,我们可以对结果做一些处理,比如 对除不尽的结果可以进行四舍五入。最后,再把结果由BigDecimal型数据转换回double型数据。

这个思路很正确,但是如果你仔细看看API里关于BigDecimal的详细说明,你就会知道,如果需要精确计算,我们不能直接用double,而非要用 String来构造BigDecimal不可!所以,我们又开始关心BigDecimal类的另一个方法,即能够帮助我们正确完成精确计算的 BigDecimal(String value)方法。
// BigDecimal(String value)能够将String型数据转换成BigDecimal型数据

那么问题来了,想像一下吧,如果我们要做一个浮点型数据的加法运算,需要先将两个浮点数转为String型数据,然后用 BigDecimal(String value)构造成BigDecimal,之后要在其中一个上调用add方法,传入另一个作为参数,然后把运算的结果(BigDecimal)再转换为浮 点数。如果每次做浮点型数据的计算都要如此,你能够忍受这么烦琐的过程吗?至少我不能。所以最好的办法,就是写一个类,在类中完成这些繁琐的转换过程。这 样,在我们需要进行浮点型数据计算的时候,只要调用这个类就可以了。网上已经有高手为我们提供了一个工具类Arith来完成这些转换操作。它提供以下静态 方法,可以完成浮点型数据的加减乘除运算和对其结果进行四舍五入的操作:

public static double add(double v1,double v2)

public static double sub(double v1,double v2)

public static double mul(double v1,double v2)

public static double div(double v1,double v2)

public static double div(double v1,double v2,int scale)

public static double round(double v,int scale)

下面会附上Arith的源代码,大家只要把它编译保存好,要进行浮点数计算的时候,在你的源程序中导入Arith类就可以使用以上静态方法来进行浮点数的精确计算了。

附录:Arith源代码

import java.math.BigDecimal; 
 
/** 
* 由于Java的简单类型不能够精确的对浮点数进行运算,这个工具类提供精 
* 确的浮点数运算,包括加减乘除和四舍五入。 
*/ 
 
public class Arith{ 
  //默认除法运算精度 
  private static final int DEF_DIV_SCALE = 10; 
  //这个类不能实例化 
  private Arith(){ 
  } 
 
  /** 
   * 提供精确的加法运算。 
   * @param v1 被加数 
   * @param v2 加数 
   * @return 两个参数的和 
   */ 
  public static double add(double v1,double v2){ 
    BigDecimal b1 = new BigDecimal(Double.toString(v1)); 
    BigDecimal b2 = new BigDecimal(Double.toString(v2)); 
    return b1.add(b2).doubleValue(); 
  } 
  /** 
   * 提供精确的减法运算。 
   * @param v1 被减数 
   * @param v2 减数 
   * @return 两个参数的差 
   */ 
  public static double sub(double v1,double v2){ 
    BigDecimal b1 = new BigDecimal(Double.toString(v1)); 
    BigDecimal b2 = new BigDecimal(Double.toString(v2)); 
    return b1.subtract(b2).doubleValue(); 
  } 
  /** 
   * 提供精确的乘法运算。 
   * @param v1 被乘数 
   * @param v2 乘数 
   * @return 两个参数的积 
   */ 
  public static double mul(double v1,double v2){ 
    BigDecimal b1 = new BigDecimal(Double.toString(v1)); 
    BigDecimal b2 = new BigDecimal(Double.toString(v2)); 
    return b1.multiply(b2).doubleValue(); 
  } 
 
  /** 
   * 提供(相对)精确的除法运算,当发生除不尽的情况时,精确到 
   * 小数点以后10位,以后的数字四舍五入。 
   * @param v1 被除数 
   * @param v2 除数 
   * @return 两个参数的商 
   */ 
  public static double div(double v1,double v2){ 
    return div(v1,v2,DEF_DIV_SCALE); 
  } 
 
  /** 
   * 提供(相对)精确的除法运算。当发生除不尽的情况时,由scale参数指 
   * 定精度,以后的数字四舍五入。 
   * @param v1 被除数 
   * @param v2 除数 
   * @param scale 表示表示需要精确到小数点以后几位。 
   * @return 两个参数的商 
   */ 
  public static double div(double v1,double v2,int scale){ 
    if(scale<0){ 
      throw new IllegalArgumentException( 
        "The scale must be a positive integer or zero"); 
    } 
    BigDecimal b1 = new BigDecimal(Double.toString(v1)); 
    BigDecimal b2 = new BigDecimal(Double.toString(v2)); 
    return b1.divide(b2,scale,BigDecimal.ROUND_HALF_UP).doubleValue(); 
  } 
 
  /** 
   * 提供精确的小数位四舍五入处理。 
   * @param v 需要四舍五入的数字 
   * @param scale 小数点后保留几位 
   * @return 四舍五入后的结果 
   */ 
  public static double round(double v,int scale){ 
 
    if(scale<0){ 
      throw new IllegalArgumentException( 
        "The scale must be a positive integer or zero"); 
    } 
    BigDecimal b = new BigDecimal(Double.toString(v)); 
    BigDecimal one = new BigDecimal("1"); 
    return b.divide(one,scale,BigDecimal.ROUND_HALF_UP).doubleValue(); 
  } 
}; 

以上这篇解决java数值范围以及float与double精度丢失的问题就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持脚本之家。

相关文章

  • Java编程实现非对称加密的方法详解

    Java编程实现非对称加密的方法详解

    这篇文章主要介绍了Java编程实现非对称加密的方法,简单讲述了非对称加密的概念、原理,并结合实例形式分析了java实现DH加密解密、RSA加密解密、ElGamal加密等具体操作技巧,需要的朋友可以参考下
    2017-08-08
  • Spring成员对象注入的三种方式详解

    Spring成员对象注入的三种方式详解

    这篇文章主要为大家详细介绍了Spring成员对象注入的三种方式,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下,希望能够给你带来帮助
    2022-02-02
  • 代码分析Spring MVC的工作原理

    代码分析Spring MVC的工作原理

    在本篇文章里小编给大家整理了关于Spring MVC的工作原理的相关知识点以及实例代码内容,需要的朋友们可以参考下。
    2019-06-06
  • 在lambda的foreach遍历中break退出操作(lambda foreach break)

    在lambda的foreach遍历中break退出操作(lambda foreach break)

    这篇文章主要介绍了在lambda的foreach遍历中break退出操作(lambda foreach break),具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
    2020-09-09
  • SpringBoot自动装配之@Import深入讲解

    SpringBoot自动装配之@Import深入讲解

    由于最近的项目需求,需要在把配置类导入到容器中,通过查询,使用@Import注解就能实现这个功能,@Import注解能够帮我们吧普通配置类(定义为Bean的类)导入到IOC容器中
    2023-01-01
  • Spring MVC URL地址映射的示例代码

    Spring MVC URL地址映射的示例代码

    @RequestMapping是一个用来处理请求地址映射的注解,可用于类或方法上。用于类上,表示类中的所有响应请求的方法都是以该地址作为父路径。,这篇文章主要介绍了Spring MVC URL地址映射,需要的朋友可以参考下
    2022-07-07
  • SpringBoot Jpa 自定义查询实现代码详解

    SpringBoot Jpa 自定义查询实现代码详解

    这篇文章主要介绍了SpringBoot Jpa 自定义查询实现代码详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
    2020-02-02
  • java生成随机数的方法

    java生成随机数的方法

    这篇文章主要介绍了java生成随机数的方法,涉及java随机数及字符串操作的相关技巧,需要的朋友可以参考下
    2015-05-05
  • SpringBoot动态更新yml文件

    SpringBoot动态更新yml文件

    在系统运行过程中,可能由于一些配置项的简单变动需要重新打包启停项目,这对于在运行中的项目会造成数据丢失,客户操作无响应等情况发生,针对这类情况对开发框架进行升级提供yml文件实时修改更新功能,这篇文章主要介绍了SpringBoot动态更新yml文件
    2023-01-01
  • Java8中用foreach循环获取对象的index下标详解

    Java8中用foreach循环获取对象的index下标详解

    这篇文章主要给大家介绍了关于Java8中用foreach循环获取对象的index下标的相关资料,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
    2021-04-04

最新评论