Java 判断2个字符串日常相差几天

在日常应用中如用户签到会判断用户是否连续签到，则判断2个字符串日期相差几天就可以满足条件，以下为我在开发中运用：

案例：

/**
* @descript:当前用户：App端司机签到积分业务逻辑（用户类型user_type=1）
* @param results  返回结果
* @* @param obj  前台传递的json参数
 */
public ModelResults  driverSignAndIntegralUpdate(Long userId){
    ModelResults results=new ModelResults();
    //查询司机app用户主表
    YkatUser user=userDao.findDriverUserById(userId);
    if(user==null){//用户不存在直接返回
    	results.setCode(MsgInfo.a_sign_null_code);
    	results.setMessage(MsgInfo.a_sign_null_msg);
    	return results;
    }
    //用户名
    String userName=user.getPhone();
    //查询系统配置表
    List<YkatSysSetting> sysSettingList = sysDao.sysSettingQuery();
    //每日签到可获得分数
    Integer getDayPoints=Constants.GETDAYPOINTS;
    //累积签到可获得积分天数
    Integer accumulateDays=Constants.ACCUMULATEDAYS;
    //累积签到可获得积分数
    Integer accumulatePoints=Constants.ACCUMULATEPOINTS;
    if(sysSettingList!=null&&!sysSettingList.isEmpty()){//判断集合是否为空
	getDayPoints=sysSettingList.get(0).getGetDayPoints();
	accumulateDays=sysSettingList.get(0).getAccumulateDays();
	accumulatePoints=sysSettingList.get(0).getAccumulatePoints();
    }
    //查询积分表：最后一次积分
    YkatIntegral integral=integralDao.integralQuery(userId,Constants.INTEGRAL_DRIVER);
    //最后一次当前可用积分
    int sumPointsAvail=0;
    if(integral!=null){
        sumPointsAvail=integral.getPointsAvail();
    }
    //系统当前时间
    Date sysTime=new Date();
    //封装签到天数
    Map<String, Object> signMap=new HashMap<String, Object>();
    //查询签到表：查询最后一次签到时间，签到天数
    YkatUserSign userSign=userSignDao.findSignByUserId(userId,Constants.SIGN_DRIVER);
    if(userSign==null){//判断查询签到是否为空
        //插入签到表
    	YkatUserSign userSign2=createUserSign(userId,userName,Constants.SIGN_DRIVER,sysTime,sysTime,1);
    	userSignDao.addSign(userSign2);
	//插入积分表：当前可用积分=交易积分+上一次累计总积分
    	int pointsAvail=getDayPoints+sumPointsAvail;
	YkatIntegral integral2=createIntegral(userId,userName,Constants.INTEGRAL_DRIVER,getDayPoints,1,0,pointsAvail,
        sysTime,sysTime);
	integralDao.addIntegral(integral2);
	//更新司机表：司机积分=当前可用积分
	Map<String, Object> driverMap=createMap(pointsAvail,userId);
	driverDao.updateDriverByUserId(driverMap);
	//返回签到天数
	signMap.put("serialDays", userSign2.getSerialDays());
	results.setData(signMap);
    }else{
        //最后一次签到时间
        Date signTime=userSign.getCreateTime();
        //最后一次连续签到天数
        Integer serialDays=userSign.getSerialDays();
        String sysTimeStr=DateUtil.dateToString(sysTime, DateUtil.DEFAULT_DATE_PATTERN);
        String signTimeStr=DateUtil.dateToString(signTime, DateUtil.DEFAULT_DATE_PATTERN);
        //系统当前时间与最后一次签到时间相差天数
        long diffSignDay=DateUtil.dayDiff(sysTimeStr, signTimeStr, DateUtil.DEFAULT_DATE_PATTERN);
        //查询签到不为空时判断最后一次签到时间与当前时间是否连续签到
        if(diffSignDay>1){//非连续签到
            //插入签到表
            YkatUserSign userSign3=createUserSign(userId,userName,Constants.SIGN_DRIVER,sysTime,sysTime,1);
    	    userSignDao.addSign(userSign3);
	    //插入积分表：当前可用积分=交易积分+上一次累计总积分
    	    int pointsAvail=getDayPoints+sumPointsAvail;
	    YkatIntegral integral3=createIntegral(userId,userName,Constants.INTEGRAL_DRIVER,getDayPoints,1,0,pointsAvail,
            sysTime,sysTime);
	    integralDao.addIntegral(integral3);
	    //更新司机表：司机积分=当前可用积分
	    Map<String, Object> driverMap2=createMap(pointsAvail,userId);
	    driverDao.updateDriverByUserId(driverMap2);
	    //返回签到天数
	    signMap.put("serialDays", userSign3.getSerialDays());
	    results.setData(signMap);
        }else if(diffSignDay==1){//连续签到
    	     //连续签到天数与系统配置表累计签到天数比较，判断是否超过累计签到天数
    	     if((serialDays+1)<accumulateDays){//连续签到天数小于系统配置签到天数：正常插入签到，积分表，更新司机表
    	         //插入签到表
    	         YkatUserSign userSign4=createUserSign(userId,userName,Constants.SIGN_DRIVER,
                 sysTime,sysTime,(serialDays+1));
    	         userSignDao.addSign(userSign4);
	         //插入积分表：当前可用积分=交易积分+上一次累计总积分
    	         int pointsAvail=getDayPoints+0+sumPointsAvail;
	         YkatIntegral integral4=createIntegral(userId,userName,Constants.INTEGRAL_DRIVER,getDayPoints,1,0,pointsAvail,
                 sysTime,sysTime);
	         integralDao.addIntegral(integral4);
	         //更新司机表：司机积分=当前可用积分
	         Map<String, Object> driverMap3=createMap(pointsAvail,userId);
	         driverDao.updateDriverByUserId(driverMap3);
	         //返回签到天数
	         signMap.put("serialDays", userSign4.getSerialDays());
	         results.setData(signMap);
            }else if((serialDays+1)==accumulateDays){//连续签到天数等于系统配置签到天数：插入签到，积分加额外奖励积分，更新司机表
    	         //插入签到表
    	         YkatUserSign userSign5=createUserSign(userId,userName,Constants.SIGN_DRIVER,
                 sysTime,sysTime,(serialDays+1));
    	         userSignDao.addSign(userSign5);
    	         //插入积分表1：积分类型为1签到；当前可用积分=交易积分+上一次累计总积分
    	         int pointsAvail1=getDayPoints+sumPointsAvail;//当前可用积分
    	         YkatIntegral integral5=createIntegral(userId,userName,Constants.INTEGRAL_DRIVER,getDayPoints,1,0,pointsAvail1,
                 sysTime,sysTime);
	         integralDao.addIntegral(integral5);
	         //插入积分表2：积分类型为3连续签到奖励积分；当前可用积分=交易积分+上一次累计总积分
    	         int pointsAvail2=accumulatePoints+integral5.getPointsAvail();//当前可用积分
	         YkatIntegral integral6=createIntegral(userId,userName,Constants.INTEGRAL_DRIVER,accumulatePoints,3,0,pointsAvail2,
                 sysTime,sysTime);
	         integralDao.addIntegral(integral6);
	         //更新司机表：司机积分=当前可用积分
	         int pointsAvail3=getDayPoints+accumulatePoints+sumPointsAvail;//当前可用积分
	         Map<String, Object> driverMap4=createMap(pointsAvail3,userId);
	         driverDao.updateDriverByUserId(driverMap4);
	         //返回签到天数
	         signMap.put("serialDays", userSign5.getSerialDays());
	         results.setData(signMap);
    	   }else{//连续签到天数大于系统配置签到天数
    	       if((serialDays+1)%accumulateDays==0){//若连续签到天数与系统配置签到天数整除为0则额外加奖励积分
    		   //插入签到表
        	   YkatUserSign userSign6=createUserSign(userId,userName,Constants.SIGN_DRIVER,
                   sysTime,sysTime,(serialDays+1));
        	   userSignDao.addSign(userSign6);
        	   //插入积分表1：积分类型为1签到；当前可用积分=交易积分+上一次累计总积分
        	   int pointsAvail1=getDayPoints+0+sumPointsAvail;//当前可用积分
        	   YkatIntegral integral6=createIntegral(userId,userName,Constants.INTEGRAL_DRIVER,getDayPoints,1,0,pointsAvail1,
                   sysTime,sysTime);
    		   integralDao.addIntegral(integral6);
    		   //插入积分表2：积分类型为3连续签到奖励积分；当前可用积分=交易积分+上一次累计总积分
        	   int pointsAvail2=accumulatePoints+0+integral6.getPointsAvail();//当前可用积分
    		   YkatIntegral integral7=createIntegral(userId,userName,Constants.INTEGRAL_DRIVER,accumulatePoints,3,0,pointsAvail2,
                   sysTime,sysTime);
    		   integralDao.addIntegral(integral7);
    		   //更新司机表：司机积分=当前可用积分
    		   int pointsAvail3=getDayPoints+accumulatePoints+sumPointsAvail;//当前可用积分
    		   Map<String, Object> driverMap5=createMap(pointsAvail3,userId);
    		   driverDao.updateDriverByUserId(driverMap5);
    		   //返回签到天数
    		   signMap.put("serialDays", userSign6.getSerialDays());
    		   results.setData(signMap);
    	       }else{//正常插入签到，积分表，更新司机表
    		   //插入签到表
        	   YkatUserSign userSign7=createUserSign(userId,userName,Constants.SIGN_DRIVER,
                   sysTime,sysTime,(serialDays+1));
        	   userSignDao.addSign(userSign7);
        	   //插入积分表1：积分类型为1签到；当前可用积分=交易积分+上一次累计总积分
        	   int pointsAvail=getDayPoints+0+sumPointsAvail;//当前可用积分
        	   YkatIntegral integral7=createIntegral(userId,userName,Constants.INTEGRAL_DRIVER,getDayPoints,1,0,pointsAvail,
                   sysTime,sysTime);
    		   integralDao.addIntegral(integral7);
    		   //更新司机表：司机积分=当前可用积分
    		   Map<String, Object> driverMap6=createMap(pointsAvail,userId);
    		   driverDao.updateDriverByUserId(driverMap6);
    		   //返回签到天数
    		  signMap.put("serialDays", userSign7.getSerialDays());
    		  results.setData(signMap);
    	      }
    	  }
      }else if(diffSignDay==0){//已经签到（不允许重复签到）直接返回
    	    //返回签到天数
    	   signMap.put("serialDays",serialDays);
	   results.setData(signMap);
    	   results.setCode(MsgInfo.a_sign_repeat_code);
    	   results.setMessage(MsgInfo.a_sign_repeat_msg);
    	   return results;
     }
   }
   results.setCode(MsgInfo.a_suc_code);
   results.setMessage(MsgInfo.a_suc_msg);
   return results;
}
	
	
/**
* @descript:抽取公共方法：插入签到表
* @param userId 用户id
* @param userName 用户名
* @param userType 用户类型 1司机2门店
* @param createTime 创建时间默认系统当前时间
* @param updateTime 更新时间默认系统当前时间
* @param serialDays 连续签到天数
* @return
* @throws NumberFormatException
*/
protected YkatUserSign createUserSign(Long userId, String userName,Integer userType,Date createTime, Date updateTime,
Integer serialDays) throws NumberFormatException {
	YkatUserSign userSign=new YkatUserSign();
	 userSign.setUserId(userId);
	 userSign.setUserName(userName);
	 userSign.setUserType(userType);
	 userSign.setCreateTime(createTime);
	 userSign.setUpdateTime(updateTime);
	 userSign.setSerialDays(serialDays);
	 return userSign;
	}
	
/**
* @descript:抽取公共方法：插入积分表
* @param userId 用户id
* @param userName 用户名
* @param userType 用户类型 1司机2门店
* @param tradePoints 交易积分
* @param tradeType 交易类型1签到2推荐3评分
* @param pointsReward 奖励积分默认为0
* @param pointsAvail 当前可用积分 pointsAvail=交易积分+奖励积分+上一次累计总分
* @param createTime 创建时间默认为系统当前时间
* @param updateTime 更新时间默认为系统当前时间
* @return
* @throws NumberFormatException
*/
protected YkatIntegral createIntegral(Long userId, String userName, Integer userType,Integer tradePoints,Integer tradeType ,
Integer pointsReward,Integer pointsAvail,Date createTime , Date updateTime)throws NumberFormatException{
	YkatIntegral integral=new YkatIntegral();
	integral.setUserId(userId);
	integral.setUserName(userName);
	integral.setUserType(userType);
	integral.setTradePoints(tradePoints);
	integral.setTradeType(tradeType);
	integral.setPointsReward(pointsReward);
	integral.setPointsAvail(pointsAvail);
	integral.setCreateTime(createTime);
	integral.setUpdateTime(updateTime);
	return integral;
}
	
/**
* @descript:抽取公共方法：根据用户id更新司机或者门店店员积分
* @param integral 用户积分
* @param userId  用户id
* @return
*/
protected Map<String, Object> createMap(Object integral,Object userId){
	Map<String, Object> driverMap=new HashMap<String, Object>();
	driverMap.put("integral", integral);
	driverMap.put("userId", userId);
	return driverMap;
}

测试类：

package util;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateUtil {
    /**
     * 默认日期格式, yyyy-MM-dd
     */
    public static String DEFAULT_DATE_PATTERN = "yyyy-MM-dd";
    /**
     * 默认日期格式, yyyy-MM-dd
     */
    public static String DEFAULT_DATE_PATTERN_HOUR = "yyyy-MM-dd HH:mm";
    /**
     * 默认时间格式, yyyy-MM-dd hh24:mm:ss
     */
    public static String DEFAULT_TIME_PATTERN = "yyyy-MM-dd HH:mm:ss";
  
    /**
    * 把符合日期格式的字符串转换为日期类型
    */
    public static Date stringtoDate(String dateStr, String format) {
		Date d = null;
		SimpleDateFormat formater = new SimpleDateFormat(format);
		try {
			formater.setLenient(false);// 指定日期\时间解析是否不严格
			d = formater.parse(dateStr);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return d;
    }
	
    /**
     * @descript:把日期转换为字符串
     * @param date 日期
     * @param format 日期格式化方式
     * @return
     */
     public static String dateToString(Date date, String format) {
		SimpleDateFormat formater = new SimpleDateFormat(format);
		String result = formater.format(date);
		return result;
     }
	
    /**
     * @descript:计算两个字符串日期相差的天数
     * @param date1 字符串日期1
     * @param date2 字符串日期2
     * @param format 日期格式化方式
     * @return
     */
     public static long dayDiff(String date1, String date2,String format) {
		SimpleDateFormat formater = new SimpleDateFormat(format);
		long diff=0l;
		try {
			long d1 = formater.parse(date1).getTime();
			long d2 = formater.parse(date2).getTime();
			diff=(Math.abs(d1-d2) / (1000 * 60 * 60 * 24));
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return diff;
    }
	
    /**
    * 计算两个日期相差的天数，如果date1 > date2 返回正数，否则返回负数
    * 日期精确到时分秒，若是不满足24小时则不满足一天，相差的天数为0
    */
     public static long dayDiff(Date date1, Date date2) {
		long diff = Math.abs(date1.getTime() - date2.getTime());
		diff /= 3600 * 1000 * 24;
		return diff;
     }
	
     /**
	* @descript:工具类测试
	* @param args
	* @throws ParseException 
      */
     public static void main(String[] args) {
		//测试比较2个日期相差天数
		Date date1=new Date();
		Date date2=DateUtil.stringtoDate("2016-10-25 00:00:00", DEFAULT_TIME_PATTERN);
		long diff1=DateUtil.dayDiff(date1, date2);
		System.out.println("2个日期相差的天数："+diff1);
		
		//测试比较2个字符串日期相差天数
		String date3="2016-10-20";
		String date4="2016-10-15";
		String format=DEFAULT_DATE_PATTERN;
		long diff2=DateUtil.dayDiff(date3, date4, format);
		System.out.println("2个字符串日期相差的天数："+diff2);
		
    }
	
}

控制台输出信息：