java 向上取整方法 Math.ceil() 用法、源码分析

刷题用到了，正好好好看看源码。

Math.ceil() 返回值、参数均为double类型， 如果参数为int类型，idea不会报错，但是方法同时不会向上取整。

参数为int类型时，Math.ceil(3*1.0 / 2)。

ctrl + 左键 点进源码

public static double ceil(double a) {
        return StrictMath.ceil(a); // default impl. delegates to StrictMath
}

Math.java:

public static double ceil(double a) {
        return StrictMath.ceil(a); // default impl. delegates to StrictMath
}

StrictMath.java:

 //向上取整
 public static double ceil(double a) {                                     
     return floorOrCeil(a, -0.0, 1.0, 1.0);                                
 }                                                                         
                                                                           
 //向下取整                                       
 public static double floor(double a) {                                    
     return floorOrCeil(a, -1.0, 0.0, -1.0);                               
 }                                                                         
                                                                           
                                                                  
 private static double floorOrCeil(double a,                               
                                   double negativeBoundary,                
                                   double positiveBoundary,                
                                   double sign) {                          
     int exponent = Math.getExponent(a);//获取a的指数                                   
                                                                           
     if (exponent < 0) { //如果参数的指数的绝对值小于0，那么一定-1= 52) {                                                                                                        
         return a;//指数大于52 超出了double的范围 为无穷大直接返回                                                         
     }
     //此时指数在[0，51]                                                                                                              
     assert exponent >= 0 && exponent <= 51;                               
                                                                           
     long doppel = Double.doubleToRawLongBits(a);                      
     long mask   = DoubleConsts.SIGNIF_BIT_MASK >> exponent;               
                                                                           
     if ( (mask & doppel) == 0L )                                          
         return a;                                      
     else {                                                                
         double result = Double.longBitsToDouble(doppel & (~mask));        
         if (sign*a > 0.0)                                                 
             result = result + sign;                                       
         return result;                                                    
     }                                                                     
 }                                                                         
                                                                                                                                                  

下面着重看一下这些代码：

long doppel = Double.doubleToRawLongBits(a); //doppel时a的二进制格式                      
long mask   = DoubleConsts.SIGNIF_BIT_MASK >> exponent;               
//mask 是获得a的小数位的掩码，mask & doppel获得a的小数位，如果a的小数位为0那么a是整数，则直接返回。                                                                           
if ( (mask & doppel) == 0L )                                          
     return a;                                      
else {
     //result将a的小数部分去掉，获得a的整数。                                                                
     double result = Double.longBitsToDouble(doppel & (~mask)); 
     //sign为1时  为ceil调用  sign为-1时 为floor调用       
     if (sign*a > 0.0)                                                 
         result = result + sign;                                       
     return result;                                                    
}