java中数值范围的精度丢失如何解决

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次方 
 
} 
} 

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

首先我们要搞清楚下面两个问题： 
 
  (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。这也就解释了为什么浮点型减法出现了"减不尽"的精度丢失问题。

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

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(); 
  } 
};