日期之间的差值计算

两个日期做减法，返回类型是Object，参数中可以定义返回类型的具体类型，可以定义差多少天，差多少小时等等，基本上用到可能性不是太大，但是相对还是比较好用的

import java.math.BigDecimal;
import java.util.Date;

import org.apache.commons.lang.StringUtils;

/**
 * 
 * desc: 日期差值计算工具类
 * 
 * @author <a href="mailto:yourmail">Hegege</a>
 * @version CVS $Revision: 1.1 $ $Date: 2005/12/05 08:42:21 $
 */
public class DateOperationUtil {

 public static final String OUTPUT_TYPE_STRING = "String";
 public static final String OUTPUT_TYPE_DOUBLE = "Double";
 public static final String OUTPUT_TYPE_FLOAT = "Float";
 public static final String OUTPUT_TYPE_INTEGER = "Integer";

 public static final String CALCULATE_TYPE_DAY = "day";
 public static final String CALCULATE_TYPE_HOUR = "hour";
 public static final String CALCULATE_TYPE_MINUTE = "minute";
 public static final String CALCULATE_TYPE_SECOND = "second";

 /**
  * @param args
  */
 public static void main(String[] args) {
  Date d1 = new Date();
  d1.setYear(2011-1900);
  d1.setMonth(11-1);
  d1.setDate(27);
  d1.setHours(23);
  d1.setMinutes(55);
  d1.setSeconds(35);
  Date d2 = new Date();
  d2.setYear(2011-1900);
  d2.setMonth(12-1);
  d2.setDate(3);
  d2.setHours(12);
  d2.setMinutes(11);
  d2.setSeconds(1);
//  System.out.println(doDateMinusValue(d1, d2, OUTPUT_TYPE_STRING, 3, CALCULATE_TYPE_MINUTE));
  System.out.println(doDateMinusValue(d1, d2, OUTPUT_TYPE_INTEGER, 3, CALCULATE_TYPE_HOUR));

 }

 /**
  * 两个日期的差值，d2-d1
  * returnType：返回类型,默认为string
  * f：小数位数,-1为默认全部(建议f不大于8)默认为2
  * calculateType：换算单位(天，小时，分钟，秒)默认为天
  */
 public static Object doDateMinusValue(Date d1,Date d2,String returnType,int f,String calculateType){

  long l1 = d1.getTime();
  long l2 = d2.getTime();
  long ll = l2-l1;
  if(ll>=0){
   if(StringUtils.isNotEmpty(returnType)){
    if(OUTPUT_TYPE_STRING.equals(returnType)){
     return returnString(f, calculateType, ll);
    }else if(OUTPUT_TYPE_DOUBLE.equals(returnType)){
     return returnDouble(calculateType, ll);
    }else if(OUTPUT_TYPE_FLOAT.equals(returnType)){
     return returnFloat(calculateType, ll);
    }else if(OUTPUT_TYPE_INTEGER.equals(returnType)){
     return returnInteger(calculateType, ll);
    }else{

    }
   }else{

   }
  }else{
   return null;
  }

  return returnType;

 }

 private static Object returnInteger(String calculateType, long l) {
  //如果是按照整数来计算，那么应该是有尾数就进一位，而不是四舍五入或者只去整数位
  if(StringUtils.isNotEmpty(calculateType)){
   if(CALCULATE_TYPE_DAY.equals(calculateType)){
    return returnInteger(l, 1000*60*60*24l);
   }else if(CALCULATE_TYPE_HOUR.equals(calculateType)){
    return returnInteger(l, 1000*60*60l);
   }else if(CALCULATE_TYPE_MINUTE.equals(calculateType)){
    return returnInteger(l, 1000*60l);
   }else if(CALCULATE_TYPE_SECOND.equals(calculateType)){
    return returnInteger(l, 1000l);
   }else{
    return returnInteger(l, 1000*60*60*24l);
   }
  }else{
   return returnInteger(l, 1000*60*60*24l);
  }
 }

 private static Object returnFloat(String calculateType, long ll) {
  if(StringUtils.isNotEmpty(calculateType)){
   if(CALCULATE_TYPE_DAY.equals(calculateType)){
    float ff = ll/(float)(1000*60*60*24);
    return Float.valueOf(ff);
   }else if(CALCULATE_TYPE_HOUR.equals(calculateType)){
    float ff = ll/(float)(1000*60*60);
    return Float.valueOf(ff);
   }else if(CALCULATE_TYPE_MINUTE.equals(calculateType)){
    float ff = ll/(float)(1000*60);
    return Float.valueOf(ff);
   }else if(CALCULATE_TYPE_SECOND.equals(calculateType)){
    float ff = ll/(float)(1000);
    return Float.valueOf(ff);
   }else{
    float ff = ll/(float)(1000*60*60*24);
    return Float.valueOf(ff);
   }
  }else{
   float ff = ll/(float)(1000*60*60*24);
   return Float.valueOf(ff);
  }
 }

 private static Object returnDouble(String calculateType, long l) {
  if(StringUtils.isNotEmpty(calculateType)){
   if(CALCULATE_TYPE_DAY.equals(calculateType)){
    return returnDouble(l, 1000*60*60*24l);
   }else if(CALCULATE_TYPE_HOUR.equals(calculateType)){
    return returnDouble(l, 1000*60*60l);
   }else if(CALCULATE_TYPE_MINUTE.equals(calculateType)){
    return returnDouble(l, 1000*60l);
   }else if(CALCULATE_TYPE_SECOND.equals(calculateType)){
    return returnDouble(l, 1000l);
   }else{
    return returnDouble(l, 1000*60*60*24l);
   }
  }else{
   return returnDouble(l, 1000*60*60*24l);
  }
 }

 private static Object returnString(int f, String calculateType, long l) {
  if(StringUtils.isNotEmpty(calculateType)){
   if(CALCULATE_TYPE_DAY.equals(calculateType)){
    return returnString(f, l, 1000*60*60*24l);
   }else if(CALCULATE_TYPE_HOUR.equals(calculateType)){
    return returnString(f, l, 1000*60*60l);
   }else if(CALCULATE_TYPE_MINUTE.equals(calculateType)){
    return returnString(f, l, 1000*60l);
   }else if(CALCULATE_TYPE_SECOND.equals(calculateType)){
    return returnString(f, l, 1000l);
   }else{
    return returnString(f, l, 1000*60*60*24l);
   }
  }else{//默认为天计算
   return returnString(f, l, 1000*60*60*24l);
  }
 }

 private static Double returnDouble(long l,long p){
  float ff = l/(float)(1000*60*60*24);
  BigDecimal bd = new BigDecimal(ff);
  double ddd = bd.doubleValue();
  return Double.valueOf(ddd);
 }
 private static String returnString(int f,long l,long p){
  float ff = l/(float)(p);
  BigDecimal bd = new BigDecimal(ff);
  String sss = bd.toEngineeringString();
  return formatString(f,sss);
 }
 private static Integer returnInteger(long l,long p){
  Float ff = l/(float)(1000*60*60*24);
  if(ff.floatValue()>Float.valueOf(ff.intValue()).floatValue()){
   return Integer.valueOf(ff.intValue()+1);
  }else{
   return Integer.valueOf(ff.intValue());
  }
 }

 private static String formatString(int f, String sss) {
  if(f==-1){
   return sss;
  }else if(f==0){
   if(sss.indexOf(".")>0){
    return sss.substring(0, sss.indexOf(".")+1);
   }else{
    return sss;
   }
  }else{
   if(sss.indexOf(".")+f+1>=sss.length()){
    return sss;
   }else{
    return sss.substring(0,sss.indexOf(".")+f+1);
   }

  }
 }

}