Date Utils

[leqviet]

public class DateUtil {

private static Logger log = LoggerFactory.getLogger(DateUtil.class);
// unit is years
public static final int ID_NUM_EXPIRE_YEARS = 15;

/**
 * Pattern dd/MM/yyyy
 */
public static final String DATE_FORMAT = "dd/MM/yyyy";

/**
 * Pattern dd-MM-yyyy
 */
public static final String DATE_FORMAT_DD_MM_YYYY = "dd-MM-yyyy";

/**
 * Pattern yyyyMMdd
 */
public static final String DATE_FORMAT_YYYY_MM_DD = "yyyyMMdd";

/**
 * Pattern yyyy-MM-dd'T'HH:mm:ss
 */
public static final String DATE_FORMAT_DATE = "yyyy-MM-dd'T'HH:mm:ss";

/**
 * Pattern yyyy-MM-dd'T'HH:mm:ss.SSS'Z'
 */
public static final String DATE_TIMEZONE_FORMAT = "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'";

/**
 * Pattern dd/MM/yyyy HH:mm:ss
 */
public static final String DATE_TIME_FORMAT = "dd/MM/yyyy HH:mm:ss";

/**
 * Pattern HH:mm
 */
public static final String HOUR_MINUTE_FORMAT = "HH:mm";	

/**
 * Pattern ddMMyyyy
 */
public static final String DATE_FORMAT_DD_YYYY_MM = "ddMMyyyy";

/**
 * 
 */
public static final String DATE_FORMAT_DATABASE = "yyyy-MM-dd";

/**
 * 
 */
public static final String DATE_TIME_FORMAT_LETTER = "yyyy-MM-dd'T'HH:mm:ss.SSSZ";

public static final Date plusMonth(final Date date, final int month) {
	Calendar cal = Calendar.getInstance();
	cal.setTime(date);
	cal.add(Calendar.MONTH, month);
	return cal.getTime();
}

public static final Date plusDay(final Date date, final int day) {
	Calendar cal = Calendar.getInstance();
	cal.setTime(date);
	cal.add(Calendar.DAY_OF_MONTH, day);
	return cal.getTime();
}

public static final Date plus(final Date date, final int target, final int duration) {
	Calendar cal = Calendar.getInstance();
	cal.setTime(date);
	cal.add(target, duration);
	return cal.getTime();
}

public static final Date plusDayIgnoreWeekend(final Date date, final int day) {
	Calendar cal = Calendar.getInstance();
	int dayActual = day;

	for (int i = 1; i <= dayActual; i++) {
		if(isWeekedDay(i, date)){
			dayActual ++;
		}
	}
	
	cal = Calendar.getInstance();
	cal.setTime(date);
	cal.add(Calendar.DAY_OF_MONTH, dayActual);
	
	return cal.getTime();
	
}

public static final Date subtractDayIgnoreWeekend(final Date date, final int day) {
	Calendar cal = Calendar.getInstance();
	int dayActual = day;

	for (int i = 1; i <= dayActual; i++) {
		if(isWeekedDay(-i, date)){
			dayActual ++;
		}
	}
	
	cal = Calendar.getInstance();
	cal.setTime(date);
	cal.add(Calendar.DAY_OF_MONTH, -dayActual);
	
	return cal.getTime();
}

private static boolean isWeekedDay(int i,final Date date) {
	Calendar cal;
	cal = Calendar.getInstance();
	cal.setTime(date);
	cal.add(Calendar.DAY_OF_MONTH, i);
	
	if (cal.get(Calendar.DAY_OF_WEEK) == Calendar.SATURDAY || cal.get(Calendar.DAY_OF_WEEK) == Calendar.SUNDAY) {
		return true;
	}
	
	return false;
}

public static boolean isWeekedDay(final Date date) {
	return isWeekedDay(0,date);
}

public static boolean isMonday(final Date date) {
	Calendar cal;
	cal = Calendar.getInstance();
	cal.setTime(date);
	
	if (cal.get(Calendar.DAY_OF_WEEK) == Calendar.MONDAY) {
		return true;
	}
	
	return false;
}

public static boolean isSaOrSuDay(final Date date) {
	Calendar cal;
	cal = Calendar.getInstance();
	cal.setTime(date);
	
	if (cal.get(Calendar.DAY_OF_WEEK) == Calendar.SUNDAY || cal.get(Calendar.DAY_OF_WEEK) == Calendar.SATURDAY) {
		return true;
	}
	
	return false;
}

public static final Integer getDaysBetween(final Date d1, final Date d2) {
	if (d1 == null || d2 == null)
		return null;
	
	long diff = d2.getTime() - d1.getTime();
	long diffDays = diff / (24 * 60 * 60 * 1000);
	
	return (int) (diffDays);
}

public static final Integer getHoursBetween(final Date d1, final Date d2) {
	if (d1 == null || d2 == null)
		return null;
	
	long diff = d2.getTime() - d1.getTime();
	long diffHours = diff / (60 * 60 * 1000) % 24;
	
	return (int) (diffHours);
}

public static final Integer getMinutesBetween(final Date d1, final Date d2) {
	if (d1 == null || d2 == null)
		return null;
	
	long diff = d2.getTime() - d1.getTime();
	long diffMinutes = diff / (60 * 1000) % 60;
	
	return (int) (diffMinutes);
}

public static final Integer getSecondsBetween(final Date d1, final Date d2) {
	if (d1 == null || d2 == null)
		return null;
	
	long diff = d2.getTime() - d1.getTime();
	long diffSeconds = diff / 1000 % 60;
	
	return (int) (diffSeconds);
}

public static final Date convertStringToDate(final String d, final String format) {
	Date convertedDate = null;
	if (d == null || "".equals(d)) {
		return convertedDate;
	}
	try {
		SimpleDateFormat dateFormat = new SimpleDateFormat(format);
		convertedDate = dateFormat.parse(d);
	} catch (ParseException e) {
		e.printStackTrace();
		return convertedDate;
	}
	return convertedDate;
}

/**
 * compare 2 days without time
 * 
 * @param Date
 *            d1
 * @param Date
 *            d2
 * @return 0: d2 equal d1, -1: d1 before d2, 1: d1 after d2
 */
public static final int compareTwoDaysWithoutTime(final Date d1, final Date d2) {
	Calendar cal1 = Calendar.getInstance();
	cal1.setTime(d1);
	cal1.set(Calendar.HOUR, 0);
	cal1.set(Calendar.MINUTE, 0);
	cal1.set(Calendar.SECOND, 0);

	Calendar cal2 = Calendar.getInstance();
	cal2.setTime(d2);
	cal2.set(Calendar.HOUR, 0);
	cal2.set(Calendar.MINUTE, 0);
	cal2.set(Calendar.SECOND, 0);
	return cal1.getTime().compareTo(cal2.getTime());
}

/**
 * compare param d with now
 * 
 * @param d
 * @return 0: param d equal now, -1: now before d, 1: d before now
 */
public static final int compareWithNow(final Date d) {
	Calendar cal = Calendar.getInstance();
	return compareTwoDates(d, cal.getTime());
}

public static final int compareTwoDates(final Date d1, final Date d2) {
	return d1.compareTo(d2);
}

public static final String convertDateToString(final Date date, final String format) {
	String result = null;
	try {
		SimpleDateFormat formatter = new SimpleDateFormat(format);
		result = formatter.format(date);
	} catch (Exception e) {
		log.error(e.getMessage(), e);
	}
	
	return result;
}

public static final String convertDateToDDMMYYY(final Date date) {
	SimpleDateFormat formatter = new SimpleDateFormat(DATE_FORMAT);
	return formatter.format(date);
}

public static final Date convertFromStringWithTimeZone(final String strDate, final String format) throws ParseException {
	TimeZone tz = TimeZone.getDefault();
	SimpleDateFormat formatter = new SimpleDateFormat(format);
	formatter.setTimeZone(tz);
	return formatter.parse(strDate);
}

public static final Date formatDate(Date d, String format) {
	if(d == null) {
		return null;
	}
	String dateF = convertDateToString(d, format);
	return convertStringToDate(dateF, format);
}

public static final Integer calculateYear(Calendar trDateCal, Calendar birthCalendar){
	double age = (trDateCal.get(Calendar.YEAR) - birthCalendar.get(Calendar.YEAR))
			+ (trDateCal.get(Calendar.MONTH) - birthCalendar.get(Calendar.MONTH)) * 0.031
			+ (trDateCal.get(Calendar.DATE) - birthCalendar.get(Calendar.DATE)) * 0.001;
	return new Double(Math.floor(age)).intValue();
}

public static final Date getCurrentDate() {
	Calendar cal = Calendar.getInstance();
	return cal.getTime();
}

public static Date normalizeDate(Date date) {
	if(date==null) {	
		return null;
	}
	
	Calendar calendar=Calendar.getInstance();
	
	calendar.setTime(date);
	calendar.set(Calendar.HOUR_OF_DAY, 0);
	calendar.set(Calendar.MINUTE, 0);
	calendar.set(Calendar.SECOND, 0);
	calendar.set(Calendar.MILLISECOND, 0);
	return calendar.getTime();
}

public static final Date convertFromStringWithTimeZoneGMT(final String strDate, final String format) throws ParseException {
	SimpleDateFormat formatter = new SimpleDateFormat(format);
	formatter.setTimeZone(TimeZone.getTimeZone("GMT"));
	return formatter.parse(strDate);
}

public static final Date convertFromMilisecond(final long mili) {
	Calendar cal = Calendar.getInstance();
	cal.setTimeInMillis(mili);
	return cal.getTime();
}

public static double monthsBetween(Date startDate, Date endDate){  

    Calendar cal = Calendar.getInstance(); 

    cal.setTime(startDate);  
    int startDayOfMonth = cal.get(Calendar.DAY_OF_MONTH);
    int startMonth =  cal.get(Calendar.MONTH);
    int startYear = cal.get(Calendar.YEAR);  

    cal.setTime(endDate);
    int endDayOfMonth = cal.get(Calendar.DAY_OF_MONTH);  
    int endMonth =  cal.get(Calendar.MONTH);
    int endYear = cal.get(Calendar.YEAR);  


    int diffMonths = endMonth - startMonth;
    int diffYears = endYear - startYear;
    int diffDays = endDayOfMonth - startDayOfMonth;

    return (diffYears * 12) + diffMonths + diffDays/31.0;
}

/**
 *
 * @param c1
 *            from
 * @param c2
 *            to
 * @return amount of days between from and to
 */
public static int diff(Calendar c1, Calendar c2) {
	int years = c2.get(Calendar.YEAR) - c1.get(Calendar.YEAR);
	if (years == 0) {
		return c2.get(Calendar.DAY_OF_YEAR) - c1.get(Calendar.DAY_OF_YEAR);
	} else {
		Calendar endOfYear = Calendar.getInstance();
		endOfYear.set(Calendar.YEAR, c1.get(Calendar.YEAR));
		endOfYear.set(Calendar.MONTH, 11);
		endOfYear.set(Calendar.DAY_OF_MONTH, 31);
		int days = endOfYear.get(Calendar.DAY_OF_YEAR) - c1.get(Calendar.DAY_OF_YEAR);
		for (int i = 1; i < years; i++) {
			endOfYear.add(Calendar.YEAR, 1);
			days += endOfYear.get(Calendar.DAY_OF_YEAR);
		}
		days += c2.get(Calendar.DAY_OF_YEAR);
		return days;
	}
}

public static final String convertLASDateToDDMMYYYY(final Integer date) {
	String dateStr = null;
	if (null == date || Constant.DEFAULT_DATE.equals(String.valueOf(date))) {
		return dateStr;
	}
	String tmp = String.valueOf(date);
	dateStr =  tmp.substring(6) + "/" + tmp.substring(4, 6) + "/" + tmp.substring(0, 4);
	return dateStr;
}

public static final int convertDDMMYYYYLASDate(final String dateStr) {
	int dateNum = Integer.valueOf(Constant.DEFAULT_DATE);
	if (StringUtils.isBlank(dateStr) || Constant.DEFAULT_DATE.equals(String.valueOf(dateStr))) {
		return dateNum;
	}
	Date date = convertStringToDate(dateStr, DATE_FORMAT);
	if (null != date) {
		String tmp = convertDateToString(date, DATE_FORMAT_YYYY_MM_DD);
		dateNum = Integer.valueOf(tmp);
	}
	return dateNum;
}
public static boolean checkExpireDate(Date startDate, Date endDate, int expireYear) {
	return checkExpireDate(dateToCalendar(startDate), dateToCalendar(endDate), expireYear);
}

public static boolean checkExpireDate(Calendar startDate, Calendar endDate, int expireYear) {
	Calendar date = (Calendar) startDate.clone();
	date.add(Calendar.YEAR, expireYear);
	return endDate.getTimeInMillis() - date.getTimeInMillis() > 0;
}

private static Calendar dateToCalendar(Date date) {
	Calendar calendar = Calendar.getInstance();
	calendar.setTime(date);
	return calendar;
}

public static boolean checkExpireIDNum(Date startDate, Date endDate) {
	return checkExpireDate(startDate, endDate, ID_NUM_EXPIRE_YEARS);
}

public static int getDiffYears(Date first, Date last) {
	Calendar a = getCalendar(first);
	Calendar b = getCalendar(last);
	int diff = b.get(Calendar.YEAR) - a.get(Calendar.YEAR);
	if (a.get(Calendar.MONTH) > b.get(Calendar.MONTH)
			|| (a.get(Calendar.MONTH) == b.get(Calendar.MONTH) && a.get(Calendar.DATE) > b.get(Calendar.DATE))) {
		diff--;
	}
	return diff;
}

public static Calendar getCalendar(Date date) {
	Calendar cal = Calendar.getInstance(Locale.US);
	cal.setTime(date);
	return cal;
}

}