解决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精度丢失的问题就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持我们。