public class TestOutOfBound { 
public static void main(String[] args) { 
 
System.out.println(Integer.MAX_VALUE-(-Integer.MAX_VALUE)); //內(nèi)存溢出 
System.out.println(Integer.MAX_VALUE); //2的31次方-1,10個數(shù)位，正的20億左右,用在錢上面不一定夠 
System.out.println(Integer.MIN_VALUE); //負的2的31次方 
System.out.println(Long.MAX_VALUE); //2的64次方-1,19個數(shù)位，很大了,可放心用在錢上面 
System.out.println(Long.MIN_VALUE); //負的2的64次方 
System.out.println(Float.MAX_VALUE); //2的128次方-1,38個數(shù)位，比long多了一倍,這個主要用來做簡單數(shù)學精確運算使用 
System.out.println(Float.MIN_VALUE); //2的-149次方 
System.out.println(Double.MAX_VALUE); //2的1024次方-1,308個數(shù)位，是float數(shù)位的10倍，主要用來做復雜運算和天文運算 
System.out.println(Double.MIN_VALUE); //2的-1074次方 
 
} 
} 

舉例：double result = 1.0 - 0.9; 
 
這個結(jié)果不用說了吧，都知道了，0.09999999999999998

首先我們要搞清楚下面兩個問題： 
 
  (1) 十進制整數(shù)如何轉(zhuǎn)化為二進制數(shù) 
 
     算法很簡單。舉個例子，11表示成二進制數(shù)： 
 
          11/2=5 余  1 
 
           5/2=2  余  1 
 
           2/2=1  余  0 
 
           1/2=0  余  1 
 
            0結(jié)束     11二進制表示為(從下往上):1011 
 
    這里提一點：只要遇到除以后的結(jié)果為0了就結(jié)束了，大家想一想，所有的整數(shù)除以2是不是一定能夠最終得到0。換句話說，所有的整數(shù)轉(zhuǎn)變?yōu)槎M制數(shù)的算法會不會無限循環(huán)下去呢？絕對不會，整數(shù)永遠可以用二進制精確表示 ，但小數(shù)就不一定了。 
 
  (2) 十進制小數(shù)如何轉(zhuǎn)化為二進制數(shù) 
 
     算法是乘以2直到?jīng)]有了小數(shù)為止。舉個例子，0.9表示成二進制數(shù) 
 
          0.9*2=1.8  取整數(shù)部分 1 
 
          0.8(1.8的小數(shù)部分)*2=1.6  取整數(shù)部分 1 
 
          0.6*2=1.2  取整數(shù)部分 1 
 
          0.2*2=0.4  取整數(shù)部分 0 
 
          0.4*2=0.8  取整數(shù)部分 0 
 
          0.8*2=1.6 取整數(shù)部分 1 
 
          0.6*2=1.2  取整數(shù)部分 0 
 
              .........   0.9二進制表示為(從上往下): 1100100100100...... 
 
     注意：上面的計算過程循環(huán)了，也就是說*2永遠不可能消滅小數(shù)部分，這樣算法將無限下去。很顯然，小數(shù)的二進制表示有時是不可能精確的 。其實道理很簡單，十進制系統(tǒng)中能不能準確表示出1/3呢？同樣二進制系統(tǒng)也無法準確表示1/10。這也就解釋了為什么浮點型減法出現(xiàn)了"減不盡"的精度丟失問題。

int resultInt = 10 - 9;  
double result = (double) resultInt / 100;//最終時候自己控制小數(shù)點  

import java.math.BigDecimal; 
 
/** 
* 由于Java的簡單類型不能夠精確的對浮點數(shù)進行運算，這個工具類提供精 
* 確的浮點數(shù)運算，包括加減乘除和四舍五入。 
*/ 
 
public class Arith{ 
  //默認除法運算精度 
  private static final int DEF_DIV_SCALE = 10; 
  //這個類不能實例化 
  private Arith(){ 
  } 
 
  /** 
   * 提供精確的加法運算。 
   * @param v1 被加數(shù) 
   * @param v2 加數(shù) 
   * @return 兩個參數(shù)的和 
   */ 
  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 被減數(shù) 
   * @param v2 減數(shù) 
   * @return 兩個參數(shù)的差 
   */ 
  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 被乘數(shù) 
   * @param v2 乘數(shù) 
   * @return 兩個參數(shù)的積 
   */ 
  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(); 
  } 
 
  /** 
   * 提供（相對）精確的除法運算，當發(fā)生除不盡的情況時，精確到 
   * 小數(shù)點以后10位，以后的數(shù)字四舍五入。 
   * @param v1 被除數(shù) 
   * @param v2 除數(shù) 
   * @return 兩個參數(shù)的商 
   */ 
  public static double div(double v1,double v2){ 
    return div(v1,v2,DEF_DIV_SCALE); 
  } 
 
  /** 
   * 提供（相對）精確的除法運算。當發(fā)生除不盡的情況時，由scale參數(shù)指 
   * 定精度，以后的數(shù)字四舍五入。 
   * @param v1 被除數(shù) 
   * @param v2 除數(shù) 
   * @param scale 表示表示需要精確到小數(shù)點以后幾位。 
   * @return 兩個參數(shù)的商 
   */ 
  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(); 
  } 
 
  /** 
   * 提供精確的小數(shù)位四舍五入處理。 
   * @param v 需要四舍五入的數(shù)字 
   * @param scale 小數(shù)點后保留幾位 
   * @return 四舍五入后的結(jié)果 
   */ 
  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(); 
  } 
};