一个 TimerTask 的拓展封装
import java.util.Calendar;
import java.util.TimerTask;
public abstract class ComplexTimerTask extends TimerTask {
protected ComplexTimerTask() {
super();
}
/**
* 计算从当前时间 currentDate 开始,
* 满足条件 secondOfMinute 的最近时间
*
* @param current
* @param secondOfMinute [0 - 59]
* @return
*/
public Calendar getNearMinute(Calendar current,
int secondOfMinute) {
// 计算当前时间的 MINUTE, SECOND 等各个字段值
int current_mm = current.get(Calendar.MINUTE);
int current_ss = current.get(Calendar.SECOND);
// 如果输入条件中的 secondOfMinute 小于当前日期的 secondOfMinute, 则 MINUTE 需要推迟一分钟
boolean isMinuteLater = false;
if (secondOfMinute < current_ss) {
isMinuteLater = true;
}
// 拷贝一个副本，避免改变传入的 Calendar
Calendar mirror = (Calendar) current.clone();
if (isMinuteLater) {
// 设置当前日期中的 MINUTE 为当前分钟推迟一分钟
mirror.set(Calendar.MINUTE, current_mm + 1);
}
// 设置当前日期中的 SECOND 为输入条件中的值
mirror.set(Calendar.SECOND, secondOfMinute);
return mirror;
}
/**
* 计算从当前时间 currentDate 开始,
* 满足条件 minuteOfHour, secondOfMinute 的最近时间
*
* @param current
* @param minuteOfHour [0 - 59]
* @param secondOfMinute [0 - 59]
* @return
*/
public Calendar getNearHour(Calendar current,
int minuteOfHour,
int secondOfMinute) {
// 计算当前时间的 HOUR_OF_DAY, MINUTE, SECOND 等各个字段值
int current_HH = current.get(Calendar.HOUR_OF_DAY);
int current_mm = current.get(Calendar.MINUTE);
int current_ss = current.get(Calendar.SECOND);
// 如果输入条件中的 minuteOfHour 小于当前日期的 minuteOfHour, 则 HOUR_OF_DAY 需要推迟一小时
boolean isHourLater = false;
if (minuteOfHour < current_mm) {
isHourLater = true;
} else if (minuteOfHour == current_ss) {
// 当输入条件与当前日期的 minuteOfHour 相等时,
// 如果输入条件中的 secondOfMinute 小于当前日期的 secondOfMinute,
// 则 HOUR_OF_DAY 需要推迟一小时
if (secondOfMinute < current_ss) {
isHourLater = true;
}
}
// 拷贝一个副本，避免改变传入的 Calendar
Calendar mirror = (Calendar) current.clone();
if (isHourLater) {
// 设置当前日期中的 HOUR_OF_DAY 为当前小时推迟一小时
mirror.set(Calendar.HOUR_OF_DAY, current_HH + 1);
}
// 设置当前日期中的 MINUTE, SECOND 为输入条件中的值
mirror.set(Calendar.MINUTE, minuteOfHour);
mirror.set(Calendar.SECOND, secondOfMinute);
return mirror;
}
/**
* 计算从当前时间 currentDate 开始,
* 满足条件 hourOfDay, minuteOfHour, secondOfMinute 的最近时间
*
* @param current
* @param hourOfDay [0 - 23]
* @param minuteOfHour [0 - 59]
* @param secondOfMinute [0 - 59]
* @return
*/
public Calendar getNearDay(Calendar current,
int hourOfDay,
int minuteOfHour,
int secondOfMinute) {
// 计算当前时间的 DAY_OF_MONTH, HOUR_OF_DAY, MINUTE, SECOND 等各个字段值
int current_dd = current.get(Calendar.DAY_OF_MONTH);
int current_HH = current.get(Calendar.HOUR_OF_DAY);
int current_mm = current.get(Calendar.MINUTE);
int current_ss = current.get(Calendar.SECOND);
// 如果输入条件中的 hourOfDay 小于当前日期的 hourOfDay, 则 DAY_OF_MONTH 需要推迟一天
boolean isDayLater = false;
if (hourOfDay < current_HH) {
isDayLater = true;
} else if (hourOfDay == current_HH) {
// 当输入条件与当前日期的 hourOfDay 相等时,
// 如果输入条件中的 minuteOfHour 小于当前日期的 minuteOfHour,
// 则 DAY_OF_MONTH 需要推迟一天
if (minuteOfHour < current_mm) {
isDayLater = true;
} else if (minuteOfHour == current_ss) {
// 当输入条件与当前日期的 hourOfDay, minuteOfHour 相等时,
// 如果输入条件中的 secondOfMinute 小于当前日期的 secondOfMinute,
// 则 DAY_OF_MONTH 需要推迟一天
if (secondOfMinute < current_ss) {
isDayLater = true;
}
}
}
// 拷贝一个副本，避免改变传入的 Calendar
Calendar mirror = (Calendar) current.clone();
if (isDayLater) {
// 设置当前日期中的 DAY_OF_MONTH 为当前天推迟一天
mirror.set(Calendar.DAY_OF_MONTH, current_dd + 1);
}
// 设置当前日期中的 HOUR_OF_DAY, MINUTE, SECOND 为输入条件中的值
mirror.set(Calendar.HOUR_OF_DAY, hourOfDay);
mirror.set(Calendar.MINUTE, minuteOfHour);
mirror.set(Calendar.SECOND, secondOfMinute);
return mirror;
}
/**
* 计算从当前时间 currentDate 开始,
* 满足条件 dayOfWeek, hourOfDay, minuteOfHour, secondOfMinute 的最近时间
*
* @param current
* @param dayOfWeek [0 - 6]
* @param hourOfDay [0 - 23]
* @param minuteOfHour [0 - 59]
* @param secondOfMinute [0 - 59]
* @return
*/
public Calendar getNearWeek(Calendar current,
int dayOfWeek,
int hourOfDay,
int minuteOfHour,
int secondOfMinute) {
// 计算当前时间的 WEEK_OF_YEAR, DAY_OF_WEEK, HOUR_OF_DAY, MINUTE, SECOND 等各个字段值
int current_wy = current.get(Calendar.WEEK_OF_YEAR);
int current_dw = current.get(Calendar.DAY_OF_WEEK);
int current_HH = current.get(Calendar.HOUR_OF_DAY);
int current_mm = current.get(Calendar.MINUTE);
int current_ss = current.get(Calendar.SECOND);
// 纠正跨年问题
int current_MM = current.get(Calendar.MONTH);
if (current_wy == 1 && current_MM == Calendar.DECEMBER) { current_wy = 53; };
// 如果输入条件中的 dayOfWeek 小于当前日期的 dayOfWeek, 则 WEEK_OF_YEAR 需要推迟一周
boolean isWeekLater = false;
if (dayOfWeek < current_dw) {
isWeekLater = true;
} else if (dayOfWeek == current_dw) {
// 当输入条件与当前日期的 dayOfWeek 相等时,
// 如果输入条件中的 hourOfDay 小于当前日期的 hourOfDay,
// 则 WEEK_OF_YEAR 需要推迟一周
if (hourOfDay < current_HH) {
isWeekLater = true;
} else if (hourOfDay == current_HH) {
// 当输入条件与当前日期的 dayOfWeek, hourOfDay 相等时,
// 如果输入条件中的 minuteOfHour 小于当前日期的 minuteOfHour,
// 则 WEEK_OF_YEAR 需要推迟一周
if (minuteOfHour < current_mm) {
isWeekLater = true;
} else if (minuteOfHour == current_ss) {
// 当输入条件与当前日期的 dayOfWeek, hourOfDay, minuteOfHour 相等时,
// 如果输入条件中的 secondOfMinute 小于当前日期的 secondOfMinute,
// 则 WEEK_OF_YEAR 需要推迟一周
if (secondOfMinute < current_ss) {
isWeekLater = true;
}
}
}
}
// 拷贝一个副本，避免改变传入的 Calendar
Calendar mirror = (Calendar) current.clone();
if (isWeekLater) {
// 设置当前日期中的 WEEK_OF_YEAR 为当前周推迟一周
mirror.set(Calendar.WEEK_OF_YEAR, current_wy + 1);
}
// 设置当前日期中的 DAY_OF_WEEK, HOUR_OF_DAY, MINUTE, SECOND 为输入条件中的值
mirror.set(Calendar.DAY_OF_WEEK, dayOfWeek);
mirror.set(Calendar.HOUR_OF_DAY, hourOfDay);
mirror.set(Calendar.MINUTE, minuteOfHour);
mirror.set(Calendar.SECOND, secondOfMinute);
return mirror;
}
/**
* 计算从当前时间 currentDate 开始,
* 满足条件 dayOfMonth, hourOfDay, minuteOfHour, secondOfMinute 的最近时间
*
* @param current
* @param dayOfMonth [1 - 28/29/30/31]
* @param hourOfDay [0 - 23]
* @param minuteOfHour [0 - 59]
* @param secondOfMinute [0 - 59]
* @return
*/
public Calendar getNearMonth(Calendar current,
int dayOfMonth,
int hourOfDay,
int minuteOfHour,
int secondOfMinute) {
// 计算当前时间的 MONTH, DAY_OF_MONTH, HOUR_OF_DAY, MINUTE, SECOND 等各个字段值
int current_MM = current.get(Calendar.MONTH);
int current_dd = current.get(Calendar.DAY_OF_MONTH);
int current_HH = current.get(Calendar.HOUR_OF_DAY);
int current_mm = current.get(Calendar.MINUTE);
int current_ss = current.get(Calendar.SECOND);
// 如果输入条件中的 dayOfMonth 小于当前日期的 dayOfMonth, 则 MONTH 需要推迟一个月
boolean isMonthLater = false;
if (dayOfMonth < current_dd) {
isMonthLater = true;
} else if (dayOfMonth == current_dd) {
// 当输入条件与当前日期的 dayOfMonth 相等时,
// 如果输入条件中的 hourOfDay 小于当前日期的 hourOfDay,
// 则 MONTH 需要推迟一个月
if (hourOfDay < current_HH) {
isMonthLater = true;
} else if (hourOfDay == current_HH) {
// 当输入条件与当前日期的 dayOfMonth, hourOfDay 相等时,
// 如果输入条件中的 minuteOfHour 小于当前日期的 minuteOfHour,
// 则 MONTH 需要推迟一个月
if (minuteOfHour < current_mm) {
isMonthLater = true;
} else if (minuteOfHour == current_mm) {
// 当输入条件与当前日期的 dayOfMonth, hourOfDay, minuteOfHour 相等时,
// 如果输入条件中的 secondOfMinute 小于当前日期的 secondOfMinute,
// 则 MONTH 需要推迟一个月
if (secondOfMinute < current_ss) {
isMonthLater = true;
}
}
}
}
// 拷贝一个副本，避免改变传入的 Calendar
Calendar mirror = (Calendar) current.clone();
if (isMonthLater) {
// 设置当前日期中的 MONTH 为当前月推迟一个月
mirror.set(Calendar.MONTH, current_MM + 1);
}
// 设置当前日期中的 DAY_OF_MONTH, HOUR_OF_DAY, MINUTE, SECOND 为输入条件中的值
mirror.set(Calendar.DAY_OF_MONTH, dayOfMonth);
mirror.set(Calendar.HOUR_OF_DAY, hourOfDay);
mirror.set(Calendar.MINUTE, minuteOfHour);
mirror.set(Calendar.SECOND, secondOfMinute);
return mirror;
}
/**
* 计算从当前时间 currentDate 开始,
* 满足条件 dayOfMonth, hourOfDay, minuteOfHour, secondOfMinute 的最近时间<br>
* <br>
* <tt> Quarter = (Month - 1) / 3 + 1 </tt><br>
* <tt> Month = (Quarter - 1) * 3 + 1 </tt>
*
* @param current
* @param dayOfMonth [1 - 28/29/30/31]
* @param hourOfDay [0 - 23]
* @param minuteOfHour [0 - 59]
* @param secondOfMinute [0 - 59]
* @return
*/
public Calendar getNearQuarter(Calendar current,
int dayOfMonth,
int hourOfDay,
int minuteOfHour,
int secondOfMinute) {
// 计算当前时间的 MONTH, DAY_OF_MONTH, HOUR_OF_DAY, MINUTE, SECOND 等各个字段值
int current_MM = current.get(Calendar.MONTH);
int current_dd = current.get(Calendar.DAY_OF_MONTH);
int current_HH = current.get(Calendar.HOUR_OF_DAY);
int current_mm = current.get(Calendar.MINUTE);
int current_ss = current.get(Calendar.SECOND);
// 如果输入条件中的 dayOfMonth 小于当前日期的 dayOfMonth, 则 MONTH 需要推迟一季度
boolean isQuarterLater = false;
if (dayOfMonth < current_dd) {
isQuarterLater = true;
} else if (dayOfMonth == current_dd) {
// 当输入条件与当前日期的 dayOfMonth 相等时,
// 如果输入条件中的 hourOfDay 小于当前日期的 hourOfDay,
// 则 MONTH 需要推迟一季度
if (hourOfDay < current_HH) {
isQuarterLater = true;
} else if (hourOfDay == current_HH) {
// 当输入条件与当前日期的 dayOfMonth, hourOfDay 相等时,
// 如果输入条件中的 minuteOfHour 小于当前日期的 minuteOfHour,
// 则 MONTH 需要推迟一季度
if (minuteOfHour < current_mm) {
isQuarterLater = true;
} else if (minuteOfHour == current_mm) {
// 当输入条件与当前日期的 dayOfMonth, hourOfDay, minuteOfHour 相等时,
// 如果输入条件中的 secondOfMinute 小于当前日期的 secondOfMinute,
// 则 MONTH 需要推迟一季度
if (secondOfMinute < current_ss) {
isQuarterLater = true;
}
}
}
}
// 拷贝一个副本，避免改变传入的 Calendar
Calendar mirror = (Calendar) current.clone();
if (isQuarterLater) {
// 设置当前日期中的 MONTH 为当前月推迟一季度
int current_QQ = (current_MM) / 3 + 1;
if (current_QQ >= 4) {
int current_YY = current.get(Calendar.YEAR);
mirror.set(Calendar.YEAR, current_YY + 1);
mirror.set(Calendar.MONTH, Calendar.JANUARY);
} else {
mirror.set(Calendar.MONTH, current_QQ * 3);
}
}
// 设置当前日期中的 DAY_OF_MONTH, HOUR_OF_DAY, MINUTE, SECOND 为输入条件中的值
mirror.set(Calendar.DAY_OF_MONTH, dayOfMonth);
mirror.set(Calendar.HOUR_OF_DAY, hourOfDay);
mirror.set(Calendar.MINUTE, minuteOfHour);
mirror.set(Calendar.SECOND, secondOfMinute);
return mirror;
}
/**
* 计算从当前时间 currentDate 开始,
* 满足条件 monthOfYear, dayOfMonth, hourOfDay, minuteOfHour, secondOfMinute 的最近时间
*
* @param current
* @param monthOfYear [0 - 11]
* @param dayOfMonth [1 - 28/29/30/31]
* @param hourOfDay [0 - 23]
* @param minuteOfHour [0 - 59]
* @param secondOfMinute [0 - 59]
* @return
*/
public Calendar getNearYear(Calendar current,
int monthOfYear,
int dayOfMonth,
int hourOfDay,
int minuteOfHour,
int secondOfMinute) {
// 计算当前时间的 YEAR, MONTH, DAY_OF_MONTH, HOUR_OF_DAY, MINUTE, SECOND 等各个字段值
int current_YY = current.get(Calendar.YEAR);
int current_MM = current.get(Calendar.MONTH);
int current_dd = current.get(Calendar.DAY_OF_MONTH);
int current_HH = current.get(Calendar.HOUR_OF_DAY);
int current_mm = current.get(Calendar.MINUTE);
int current_ss = current.get(Calendar.SECOND);
// 如果输入条件中的 monthOfYear 小于当前日期的 monthOfYear, 则 YEAR 需要推迟一年
boolean isYearLater = false;
if (monthOfYear < current_MM) {
isYearLater = true;
} else if (monthOfYear == current_MM) {
// 当输入条件与当前日期的 monthOfYear 相等时,
// 如果输入条件中的 dayOfMonth 小于当前日期的 dayOfMonth,
// 则 YEAR 需要推迟一年
if (dayOfMonth < current_dd) {
isYearLater = true;
} else if (dayOfMonth == current_dd) {
// 当输入条件与当前日期的 monthOfYear, dayOfMonth 相等时,
// 如果输入条件中的 hourOfDay 小于当前日期的 hourOfDay,
// 则 YEAR 需要推迟一年
if (hourOfDay < current_HH) {
isYearLater = true;
} else if (hourOfDay == current_HH) {
// 当输入条件与当前日期的 monthOfYear, dayOfMonth, hourOfDay 相等时,
// 如果输入条件中的 minuteOfHour 小于当前日期的 minuteOfHour,
// 则 YEAR 需要推迟一年
if (minuteOfHour < current_mm) {
isYearLater = true;
} else if (minuteOfHour == current_mm) {
// 当输入条件与当前日期的 monthOfYear, dayOfMonth, hourOfDay, minuteOfHour 相等时,
// 如果输入条件中的 secondOfMinute 小于当前日期的 secondOfMinute,
// 则 YEAR 需要推迟一年
if (secondOfMinute < current_ss) {
isYearLater = true;
}
}
}
}
}
// 拷贝一个副本，避免改变传入的 Calendar
Calendar mirror = (Calendar) current.clone();
if (isYearLater) {
// 设置当前日期中的 YEAR 为当前年推迟一年
mirror.set(Calendar.YEAR, current_YY + 1);
}
// 设置当前日期中的 MONTH, DAY_OF_MONTH, HOUR_OF_DAY, MINUTE, SECOND 为输入条件中的值
mirror.set(Calendar.MONTH, monthOfYear);
mirror.set(Calendar.DAY_OF_MONTH, dayOfMonth);
mirror.set(Calendar.HOUR_OF_DAY, hourOfDay);
mirror.set(Calendar.MINUTE, minuteOfHour);
mirror.set(Calendar.SECOND, secondOfMinute);
return mirror;
}
@Override
public abstract void run();
/*
public static void main(String[] args) throws Exception {
ComplexTimerTask task = new ComplexTimerTask() {
@Override
public void run() {}
};
java.text.SimpleDateFormat sdf = new java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
// 获取当前时间
Calendar current = Calendar.getInstance();
current.set(Calendar.YEAR, 2018);
current.set(Calendar.MONTH, Calendar.DECEMBER);
current.set(Calendar.DAY_OF_MONTH, 31);
System.out.println("Current Date = " + sdf.format(current.getTime()));
// 计算满足条件的最近一次执行时间
// Calendar earliest = task.getNearMinute(current, 45);
// Calendar earliest = task.getNearHour(current, 30, 45);
// Calendar earliest = task.getNearDay(current, 15, 30, 45);
// Calendar earliest = task.getNearWeek(current, Calendar.SUNDAY, 15, 30, 45);
// Calendar earliest = task.getNearMonth(current, 1, 15, 30, 45);
Calendar earliest = task.getNearQuarter(current, 1, 15, 30, 45);
// Calendar earliest = task.getNearYear(current, Calendar.OCTOBER, 1, 15, 30, 45);
System.out.println("Earliest Date = " + sdf.format(earliest.getTime()));
// 计算从当前时间到最近一次执行时间的时间间隔
long delay = earliest.getTimeInMillis() - current.getTimeInMillis();
System.out.println("Delay = " + delay + " milliseconds");
}
*/
}