一、Java项目开发中常见的日期操作工具类封装
代码如下（示例）：
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.sql.Time;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.time.temporal.TemporalAccessor;
import java.time.temporal.TemporalField;
import java.time.temporal.WeekFields;
import java.util.*;
/**
* @author hhlm
* @description: Java日期类型相关操作类；该类负责对日期格式化转换、日期比较、日期加减、润年判断、获
* 取相关的日期信息等。
* * @date 2022年03月02日 16:24
*/
public class DateUtil {
private static final Logger LOGGER = LoggerFactory.getLogger(DateUtil.class);
public static final long ONE_MINUTE_MILLISECOND = 60 * 1000L;
public static final long ONE_HOUR_MILLISECOND = 60 * ONE_MINUTE_MILLISECOND;
/**
* 一天所对应的毫秒数
*/
public static final long ONE_DAY_MILLISECOND = 24 * ONE_HOUR_MILLISECOND;
/**
* 一周所对应的毫秒数
*/
public static final long ONE_WEEK_MILLISECOND = 7 * ONE_DAY_MILLISECOND;
public static final long ONE_MONTH_MILLISECOND = 30 * ONE_DAY_MILLISECOND;
public static final long ONE_YEAR_MILLISECOND = 365 * ONE_DAY_MILLISECOND;
private static String defaultDatePattern = null;
/**
* 从配置文件中返回配置项"date.format",默认的日期格式符 (yyyy-MM-dd)，
*
* @return a string representing the date pattern on the UI
*/
public static synchronized String getDatePattern() {
defaultDatePattern = "yyyy-MM-dd";
return defaultDatePattern;
}
/**
* 校验日期入参是否正确,如防止sql注入
* @author linjx 2018-12-24
* @param desc 入参的描述
* @param format
* @param dateStr notEmptyString
* @return
*/
public static Date validDate(String desc, String format, String dateStr) {
LOGGER.debug("validDate.desc={}, format={}, dateStr={}", desc, format, dateStr);
Date parse = DateUtil2.parse(dateStr, format, desc);
/**
format='yyyy-MM-dd',dateStr='2019-12-15' or '1'='1'是不会有ParseException的
所以需要将parse重新格式化成字符串,和dateStr比较
*/
AssertApp.isTrue(dateStr.equals(DateUtil2.format(parse, format)), desc + "异常");
return parse;
}
/**
* 获取日期的年份
*
* @return 日期的年份
*/
public static int getYear(Date date) {
return getCalendar(date).get(Calendar.YEAR);
}
/**
* 获取日期的月份（0-11）
*
* @param date
* @return 日期的月份（0-11）
*/
public static int getMonth(Date date) {
return getCalendar(date).get(Calendar.MONTH);
}
/**
* 获取日期的一个月中的某天
*
* @param date
* @return 日期的一个月中的某天(1-31)
*/
public static int getDay(Date date) {
return getCalendar(date).get(Calendar.DATE);
}
/**
* 获取日期的一个星期中的某天
*
* @param date
* @return 日期的星期中日期(1:sunday-7:SATURDAY)
*/
public static int getWeek(Date date) {
return getCalendar(date).get(Calendar.DAY_OF_WEEK);
}
/**
* 将日期字符串按指定的格式转为Date类型
*
* @param strDate 待解析的日期字符串
* @param format 日期格式
* @return 字符串对应的日期对象
*/
public static final Date parseDate(String strDate, String format) {
return DateUtil2.parse(strDate, format, strDate);
}
/**
* 将日期字符串按系统配置中指定默认格式(getDatePattern()返回的格式)转为Date类型
*
* @param strDate 待解析的日期字符串
* @return 字符串对应的日期对象
*/
public static Date parseDate(String strDate) {
return parseDate(strDate, getDatePattern());
}
/**
* <p>检查所给的年份是否是闰年</p>
*
* @param year 年
* @return 检查结果: true - 是闰年; false - 是平年
*/
public static boolean isLeapYear(int year) {
if (year / 4 * 4 != year) {
return false; //不能被4整除
} else if (year / 100 * 100 != year) {
return true; //能被4整除，不能被100整除
} else if (year / 400 * 400 != year) {
return false; //能被100整除，不能被400整除
} else {
return true; //能被400整除
}
}
/**
* 按照默认格式化样式格式化当前系统时间
*
* @return 日期字符串
*/
public static String getCurrentTime() {
return formatDate(new Date());
}
/**
* 按照默认格式化样式格式化当前系统时间
*
* @param format String 日期格式化标准
* @return String 日期字符串。
*/
public static String getCurrentTime(String format) {
return formatDate(new Date(), format);
}
/**
* 按照指定格式化样式格式化指定的日期
*
* @param date 待格式化的日期
* @param format 日期格式
* @return 日期字符串
*/
public static String formatDate(Date date, String format) {
if (date == null) return "";
if (format == null) format = getDatePattern();
SimpleDateFormat formatter = new SimpleDateFormat(format);
return formatter.format(date);
}
/**
* 按照默认格式化样式格式化指定的日期
*
* @param date 待格式化的日期
* @return 日期字符串
*/
public static String formatDate(Date date) {
long offset = System.currentTimeMillis() - date.getTime();
String pos = "前";
if (offset < 0) {
pos = "后";
offset = -offset;
}
if (offset >= ONE_YEAR_MILLISECOND)
return formatDate(date, getDatePattern());
StringBuilder sb = new StringBuilder();
if (offset >= 2 * ONE_MONTH_MILLISECOND) {
return sb.append((offset + ONE_MONTH_MILLISECOND / 2) / ONE_MONTH_MILLISECOND).append("个月").append(pos).toString();
}
if (offset > ONE_WEEK_MILLISECOND) {
return sb.append((offset + ONE_WEEK_MILLISECOND / 2) / ONE_WEEK_MILLISECOND).append("周").append(pos).toString();
}
if (offset > ONE_DAY_MILLISECOND) {
return sb.append((offset + ONE_DAY_MILLISECOND / 2) / ONE_DAY_MILLISECOND).append("天").append(pos).toString();
}
if (offset > ONE_HOUR_MILLISECOND) {
return sb.append((offset + ONE_HOUR_MILLISECOND / 2) / ONE_HOUR_MILLISECOND).append("小时").append(pos).toString();
}
if (offset > ONE_MINUTE_MILLISECOND) {
return sb.append((offset + ONE_MINUTE_MILLISECOND / 2) / ONE_MINUTE_MILLISECOND).append("分钟").append(pos).toString();
}
return sb.append(offset / 1000).append("秒").append(pos).toString();
}
/**
* 将date的时间部分清零
*
* @param day
* @return 返回Day将时间部分清零后对应日期
*/
public static Date getCleanDay(Date day) {
return getCleanDay(getCalendar(day));
}
/**
* 设置当天最后时间
*
* @param day
* @return 返回当天最后时间
*/
public static Date getEndDay(Date day) {
Calendar c = Calendar.getInstance();
c.setTime(day);
c.set(Calendar.HOUR_OF_DAY, 23);
c.set(Calendar.MINUTE, 59);
c.set(Calendar.SECOND, 59);
c.set(Calendar.MILLISECOND, 999);
return c.getTime();
}
/**
* 获取day对应的Calendar对象
*
* @param day
* @return 返回date对应的Calendar对象
*/
public static Calendar getCalendar(Date day) {
Calendar c = Calendar.getInstance();
if (day != null)
c.setTime(day);
return c;
}
public static Date getCleanDay(Calendar c) {
c.set(Calendar.HOUR_OF_DAY, 0);
c.clear(Calendar.MINUTE);
c.clear(Calendar.SECOND);
c.clear(Calendar.MILLISECOND);
return c.getTime();
}
/**
* 根据year，month，day构造日期对象
*
* @param year 年份（4位长格式）
* @param month 月份（1-12)
* @param day 天（1-31）
* @return 日期对象
*/
public static Date makeDate(int year, int month, int day) {
Calendar c = Calendar.getInstance();
getCleanDay(c);
c.set(Calendar.YEAR, year);
c.set(Calendar.MONTH, month - 1);
c.set(Calendar.DAY_OF_MONTH, day);
return c.getTime();
}
private static Date getFirstCleanDay(int datePart, Date date) {
Calendar c = Calendar.getInstance();
if (date != null)
c.setTime(date);
c.set(datePart, 1);
return getCleanDay(c);
}
/**
* Calendar.YEAR :1则代表的是对年份操作，
* Calendar.MONTH :2是对月份操作;
* Calendar.DATE : 5是对日期操作;
* @param datePart
* @param detal
* @param date
* @return
*/
public static Date add(int datePart, int detal, Date date) {
Calendar c = Calendar.getInstance();
if (date != null)
c.setTime(date);
c.add(datePart, detal);
return c.getTime();
}
/**
* 日期date所在星期的第一天00:00:00对应日期对象
*
* @param date
* @return 日期所在星期的第一天00:00:00对应日期对象
*/
public static Date getFirstDayOfWeek(Date date) {
return getFirstCleanDay(Calendar.DAY_OF_WEEK, date);
}
/**
* 当前日期所在星期的第一天00:00:00对应日期对象
*
* @return 当前日期所在星期的第一天00:00:00对应日期对象
*/
public static Date getFirstDayOfWeek() {
return getFirstDayOfWeek(null);
}
/**
* 日期date所在月份的第一天00:00:00对应日期对象
*
* @param date
* @return 日期所在月份的第一天00:00:00对应日期对象
*/
public static Date getFirstDayOfMonth(Date date) {
return getFirstCleanDay(Calendar.DAY_OF_MONTH, date);
}
/**
* 当前日期所在月份的第一天00:00:00对应日期对象
*
* @return 当前日期所在月份的第一天00:00:00对应日期对象
*/
public static Date getFirstDayOfMonth() {
return getFirstDayOfMonth(null);
}
/**
* 日期date所在月份的最后一天23, 59, 59对应日期对象
*
* @param date
* @return 日期date所在月份的最后一天23, 59, 59对应日期对象
*/
public static Date getLastDayOfMonth(Date date) {
Calendar cal = Calendar.getInstance();
cal.setTime(date);
int MaxDay = cal.getActualMaximum(Calendar.DAY_OF_MONTH);
cal.set(cal.get(Calendar.YEAR), cal.get(Calendar.MONTH), MaxDay, 23, 59, 59);
return cal.getTime();
}
/**
* 日期date所在季度的第一天00:00:00对应日期对象
*
* @param date
* @return 日期date所在季度的第一天00:00:00对应日期对象
*/
public static Date getFirstDayOfSeason(Date date) {
Date d = getFirstDayOfMonth(date);
int delta = DateUtil.getMonth(d) % 3;
if (delta > 0)
d = DateUtil.getDateAfterMonths(d, -delta);
return d;
}
/**
* 当前日期所在季度的第一天00:00:00对应日期对象
*
* @return 当前日期所在季度的第一天00:00:00对应日期对象
*/
public static Date getFirstDayOfSeason() {
return getFirstDayOfMonth(null);
}
/**
* 日期date所在年份的第一天00:00:00对应日期对象
*
* @param date
* @return 日期date所在年份的第一天00:00:00对应日期对象
*/
public static Date getFirstDayOfYear(Date date) {
return makeDate(getYear(date), 1, 1);
}
/**
* 获取某年的第一天
* @param year
* @return 日期date所在年份的第一天00:00:00对应日期对象
*/
public static Date getFirstDaylOfYear(int year){
return makeDate(year, 1, 1);
}
/**
* 当前日期年度的第一天00:00:00对应日期对象
*
* @return 当前日期年度第一天00:00:00对应日期对象
*/
public static Date getFirstDayOfYear() {
return getFirstDayOfYear(new Date());
}
/**
* 当前日期年度的最后一天23:59:59对应日期对象
*
* @return 当前日期年度的最后一天23:59:59对应日期对象
*/
public static Date getLastDayOfYear() {
return parseDate(getYear(new Date()) + "-12-31 23:59:59", "yyyy-MM-dd HH:mm:ss");
}
/**
* 获取某年最后一天
* @return 传入年份的最后一天23:59:59对应日期对象
*/
public static Date getLastDayOfYear(int year){
return DateUtil2.parse(year + "-12-31 23:59:59", "yyyy-MM-dd HH:mm:ss", "");
}
/**
* 计算N周后的日期
*
* @param start 开始日期
* @param weeks 可以为负，表示前N周
* @return 新的日期
*/
public static Date getDateAfterWeeks(Date start, int weeks) {
return getDateAfterMs(start, weeks * ONE_WEEK_MILLISECOND);
}
/**
* 计算N月后的日期, 特殊情况:如果是'2016-1-31'一个月后是 '2017-2-28'
*
* @param start 开始日期
* @param months 可以为负，表示前N月
* @return 新的日期
*/
public static Date getDateAfterMonths(Date start, int months) {
return add(Calendar.MONTH, months, start);
}
/**
* 计算N年后的日期, 特殊情况:如果是'2016-2-29'一年后是'2017-2-28'
*
* @param start 开始日期
* @param years 可以为负，表示前N年
* @return 新的日期
*/
public static Date getDateAfterYears(Date start, int years) {
return add(Calendar.YEAR, years, start);
}
/**
* 计算N天后的日期
*
* @param start 开始日期
* @param days 可以为负，表示前N天
* @return 新的日期
*/
public static Date getDateAfterDays(Date start, int days) {
return getDateAfterMs(start, days * ONE_DAY_MILLISECOND);
}
/**
* 计算N毫秒后的日期
*
* @param start 开始日期
* @param ms 可以为负，表示前N毫秒
* @return 新的日期
*/
public static Date getDateAfterMs(Date start, long ms) {
return new Date(start.getTime() + ms);
}
/**
* 计算2个日期之间的间隔的周期数
*
* @param start 开始日期
* @param end 结束日期
* @param msPeriod 单位周期的毫秒数
* @return 周期数
*/
public static long getPeriodNum(Date start, Date end, long msPeriod) {
return getIntervalMs(start, end) / msPeriod;
}
/**
* 计算2个日期之间的毫秒数
*
* @param start 开始日期
* @param end 结束日期
* @return 毫秒数
*/
public static long getIntervalMs(Date start, Date end) {
return end.getTime() - start.getTime();
}
/**
* 计算2个日期之间的天数
*
* @param start 开始日期
* @param end 结束日期
* @return 天数
*/
public static int getIntervalDays(Date start, Date end) {
return (int) getPeriodNum(start, end, ONE_DAY_MILLISECOND);
}
/**
* 计算2个日期之间的周数
*
* @param start 开始日期
* @param end 结束日期
* @return 周数
*/
public static int getIntervalWeeks(Date start, Date end) {
return (int) getPeriodNum(start, end, ONE_WEEK_MILLISECOND);
}
/**
* 比较日期前后关系
*
* @param base 基准日期
* @param date 待比较的日期
* @return 如果date在base之前或相等返回true，否则返回false
*/
public static boolean before(Date base, Date date) {
return date.before(base) || date.equals(base);
}
/**
* 比较日期前后关系
*
* @param base 基准日期
* @param date 待比较的日期
* @return 如果date在base之后或相等返回true，否则返回false
*/
public static boolean after(Date base, Date date) {
return date.after(base) || date.equals(base);
}
/**
* 返回对应毫秒数大的日期
*
* @param date1
* @param date2
* @return 返回对应毫秒数大的日期
*/
public static Date max(Date date1, Date date2) {
if (date1.getTime() > date2.getTime())
return date1;
else
return date2;
}
/**
* 返回对应毫秒数小的日期
*
* @param date1
* @param date2
* @return 返回对应毫秒数小的日期
*/
public static Date min(Date date1, Date date2) {
if (date1.getTime() < date2.getTime())
return date1;
else
return date2;
}
/**
* 判断date是否在指定的时期范围（start~end）内
*
* @param start 时期开始日期
* @param end 时期结束日期
* @param date 待比较的日期
* @return 如果date在指定的时期范围内，返回true，否则返回false
*/
public static boolean inPeriod(Date start, Date end, Date date) {
return (end.after(date) || end.equals(date)) && (start.before(date) || start.equals(date));
}
/**
* 获取当前日期是星期几<br>
*
* @param dt
* @return 当前日期是星期几
*/
public static String getWeekOfDate(Date dt) {
String[] weekDays = {"星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"};
Calendar cal = Calendar.getInstance();
cal.setTime(dt);
int w = cal.get(Calendar.DAY_OF_WEEK) - 1;
if (w < 0)
w = 0;
return weekDays[w];
}
private static final DateTimeFormatter SHORT_DATETIME_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd");
private static final DateTimeFormatter LONG_DATETIME_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
private static final TemporalField CHINA_DAY_OF_WEEK = WeekFields.of(Locale.CHINA).dayOfWeek();
/**
* 获取指定日期所在周的第一天
*
* @param date
* @return
*/
public static LocalDate firstDayOfWeek(TemporalAccessor date) {
return LocalDate.from(date).with(CHINA_DAY_OF_WEEK, 1);
}
/**
* 获取指定日期所在周的最后一天
*
* @param date
* @return
*/
public static LocalDate lastDayOfWeek(TemporalAccessor date) {
return LocalDate.from(date).with(CHINA_DAY_OF_WEEK, 7);
}
/**
* 获取指定日期所在月的第一天
*
* @param date
* @return
*/
public static LocalDate firstDayOfMonth(TemporalAccessor date) {
return LocalDate.from(date).withDayOfMonth(1);
}
/**
* 获取指定日期所在周的最后一天
*
* @param date
* @return
*/
public static LocalDate lastDayOfMonth(TemporalAccessor date) {
return LocalDate.from(date).plusMonths(1).withDayOfMonth(1).plusDays(-1);
}
/**
* 短日期格式
*
* @param date
* @return
*/
public static String shortString(TemporalAccessor date) {
return SHORT_DATETIME_FORMATTER.format(date);
}
/**
* 长日期格式
*
* @param date
* @return
*/
public static String longString(TemporalAccessor date) {
return LONG_DATETIME_FORMATTER.format(date);
}
/**
* 将指定定的日期转换成LocalDateTime
*
* @param date
* @return
*/
public static LocalDateTime asLocalDateTime(Date date) {
return LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault());
}
/**
* 将指定定的日期转换成LocalDate
*
* @param date
* @return
*/
public static LocalDate asLocalDate(Date date) {
return asLocalDateTime(date).toLocalDate();
}
/**
* LocalDate 转为 Date
*
* @param localDate
* @return
*/
public static Date asDate(LocalDate localDate) {
return Date.from(localDate.atStartOfDay().atZone(ZoneId.systemDefault()).toInstant());
}
/**
* LocalDateTime 转为 Date
*
* @param localDateTime
* @return
*/
public static Date asDate(LocalDateTime localDateTime) {
return Date.from(localDateTime.atZone(ZoneId.systemDefault()).toInstant());
}
/**
* 按照“年-月”生成当月的工作日
* @param yearMonth [yyyy-MM]
* @return
*/
public static List<Date> getWorkdayOfMonth(String yearMonth){
int year;
int month ;
List<Date> results = new ArrayList<>();
Calendar cal = Calendar.getInstance();
String[] splitStr = yearMonth.split("-");
year = Integer.parseInt(splitStr[0]);
month = Integer.parseInt(splitStr[1]);
cal.set(Calendar.YEAR, year);
cal.set(Calendar.MONTH, month - 1);
cal.set(Calendar.DATE, 1);
while(cal.get(Calendar.YEAR) == year &&
cal.get(Calendar.MONTH) < month){
int day = cal.get(Calendar.DAY_OF_WEEK);
if(!(day == Calendar.SUNDAY || day == Calendar.SATURDAY)){
results.add((Date) cal.getTime().clone());
}
cal.add(Calendar.DATE, 1);
}
return results;
}
/**
* 按照年份生成一年内的工作日
* @param year
* @return
*/
public static List<Date> getWorkdayOfYear(int year){
List<Date> results = new ArrayList<>();
Calendar cal = Calendar.getInstance();
cal.set(Calendar.YEAR, year);
cal.set(Calendar.MONTH, 0);
cal.set(Calendar.DATE, 1);
while(cal.get(Calendar.YEAR) == year){
int day = cal.get(Calendar.DAY_OF_WEEK);
if(!(day == Calendar.SUNDAY || day == Calendar.SATURDAY)){
results.add((Date) cal.getTime().clone());
}
cal.add(Calendar.DATE, 1);
}
return results;
}
/**
* 获取上一个月的第一天时间
*/
public static Date getFirstDayOfLastMonth(){
Calendar cal = Calendar.getInstance();//获取当前日期
/*
* 2018-03-31时通过测试:
* 不设置cal.set(Calendar.DAY_OF_MONTH, 1)时,得到的日期是2018-02-28而不是3月
*/
cal.add(Calendar.MONTH, -1);
cal.set(Calendar.DAY_OF_MONTH, 1);//设置为1号,当前日期既为本月第一天
cal.set(Calendar.HOUR_OF_DAY, 0);
cal.clear(Calendar.MINUTE);
cal.clear(Calendar.SECOND);
cal.clear(Calendar.MILLISECOND);
return cal.getTime();
}
/**
* 获取指定日期的上月一号
* @param date
* @return
*/
public static Date getLastMonthFirst(Date date) {
Calendar c = Calendar.getInstance();//获取当前日期
c.setTime(date);
c.add(Calendar.MONTH, -1);
c.set(Calendar.DAY_OF_MONTH, 1);// 设置为1号
return getCleanDay(c);
}
/**
* 获取上月月末
* @param date
* @return
*/
public static Date getLastMonthEnd(Date date) {
Calendar c = Calendar.getInstance();//获取当前日期
c.setTime(date);
c.add(Calendar.MONTH, -1);
int maxDay = c.getActualMaximum(Calendar.DAY_OF_MONTH);
c.set(c.get(Calendar.YEAR), c.get(Calendar.MONTH), maxDay, 23, 59, 59);
return getCleanDay(c);
}
public static Date getLastMonthDay(Date date, int day) {
Calendar c = Calendar.getInstance();//获取当前日期
c.setTime(date);
c.add(Calendar.MONTH, -1);
c.set(Calendar.DAY_OF_MONTH, day);// 设置为1号
return getCleanDay(c);
}
/**
* 本月月末
* @param date
* @return
*/
public static Date getMonthEnd(Date date) {
Calendar c = Calendar.getInstance();//获取当前日期
c.setTime(date);
int maxDay = c.getActualMaximum(Calendar.DAY_OF_MONTH);
c.set(c.get(Calendar.YEAR), c.get(Calendar.MONTH), maxDay, 23, 59, 59);
return getCleanDay(c);
}
/**
* 获取下月1号
* @param date
* @return
*/
public static Date getNextMonthFirst(Date date) {
Calendar c = Calendar.getInstance();//获取当前日期
c.setTime(date);
c.add(Calendar.MONTH, 1);
c.set(Calendar.DAY_OF_MONTH, 1);// 设置为1号
return getCleanDay(c);
}
/**
* 获取下月 月末
* @param date
* @return
*/
public static Date getNextMonthEnd(Date date) {
Calendar c = Calendar.getInstance();//获取当前日期
c.setTime(date);
c.add(Calendar.MONTH, 1);
int maxDay = c.getActualMaximum(Calendar.DAY_OF_MONTH);
c.set(c.get(Calendar.YEAR), c.get(Calendar.MONTH), maxDay, 23, 59, 59);
return getCleanDay(c);
}
/**
* 判断两个日期之间是否为一整年
* @param start
* @param end
* @return
*/
public static boolean isOneYear(Date start, Date end) {
Calendar startday = Calendar.getInstance();
Calendar endday = Calendar.getInstance();
startday.setTime(start);
endday.setTime(end);
if (startday.after(endday)) {
return false;
}
long sl = startday.getTimeInMillis();
long el = endday.getTimeInMillis();
long days = ((el - sl) / (1000 * 60 * 60 * 24));
if (days == 365 || days == 366) {
if (startday.get(Calendar.MONTH) <= 1) {
startday.set(Calendar.MONTH, 1);
int lastDay = startday.getActualMaximum(Calendar.DAY_OF_MONTH);
return (lastDay == 28 && days == 365) || (lastDay == 29 && days == 366);
} else {
endday.set(Calendar.MONTH, 1);
int lastDay = endday.getActualMaximum(Calendar.DAY_OF_MONTH);
return (lastDay == 28 && days == 365) || (lastDay == 29 && days == 366);
}
} else {
return false;
}
}
/**
* @return 上一天Date
*/
public static Date getPreviousDate(Date date) {
Calendar c = Calendar.getInstance();
c.setTime(date);
int day = c.get(Calendar.DATE);
c.set(Calendar.DATE, day - 1);
return c.getTime();
}
/**
* @return 后一天Date
*/
public static Date getNextDate(Date date) {
Calendar c = Calendar.getInstance();
c.setTime(date);
int day = c.get(Calendar.DATE);
c.set(Calendar.DATE, day + 1);
return c.getTime();
}
/**
* 判断两个时间是否在同一天
* @param date1
* @param Date2
* @return
*/
public static boolean inSameDay(Date date1, Date Date2) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date1);
int year1 = calendar.get(Calendar.YEAR);
int day1 = calendar.get(Calendar.DAY_OF_YEAR);
calendar.setTime(Date2);
int year2 = calendar.get(Calendar.YEAR);
int day2 = calendar.get(Calendar.DAY_OF_YEAR);
if ((year1 == year2) && (day1 == day2)) {
return true;
}
return false;
}
/**
* 传入多少分钟
* 获取两个时间的差值，有多少个小时，用于计算请了多少小时假
* 尾数不足0.5小时按0.5小时计，超过0.5小时按1小时计
* * ((int) diff / 30) 有n个半小时要转int
* 最后 如果余数不为0 就要补上0.5
* return 单位：小时
*/
public static double getLeaveValue(double differenceValue){
double needLeaveTs = ((int)(differenceValue / 30))*0.5;
if(differenceValue % 30 != 0) needLeaveTs+= 0.5;
return needLeaveTs;
}
/**
* 传入一个日期
* 打卡开始时间在下午，开始时间与14:00上班时间请多少个小时
*/
public static double getLeaveValue(Date startTime){
double hour = startTime.getHours();
double minute = startTime.getMinutes();
double needLeaveTs = ((int)(minute / 30))*0.5;
if(minute % 30 != 0) needLeaveTs += 0.5;
needLeaveTs += hour - 14;
return needLeaveTs;
}
/**
* 获取指定日期下午上班时间
* @param date
* @return
*/
public static Date getGotoWorkAfternoon(Date date){
return parseDate(getYear(date) + "-"+ (getMonth(date)+1) +"-" + getDay(date)+" 14:00:00", "yyyy-MM-dd HH:mm:ss");
}
/**
* 根据传进来的Time和Date，获取到那天对应完成日期
* @param date
* @param time
* @return
*/
public static Date getDateByTime(Date date, Time time){
int hour = time.getHours();
int minutes = time.getMinutes();
int seconds = time.getSeconds();
String timeStr = " " + hour + ":" + minutes + ":" + seconds;
return parseDate(getYear(date) + "-"+ (getMonth(date)+1) +"-" + getDay(date) + timeStr, "yyyy-MM-dd HH:mm:ss");
}
/**
* 获取XX:XX:XX的时间字符串
* @param t 秒
* @return [XX:XX:XX],[XX:XX]
*/
public static String getTimeSpanStr(int t) {
StringBuilder sb = new StringBuilder();
if(t >= 3600) {
int h = t / 3600;
if(h < 10) sb.append("0");
sb.append(h + ":");
}
if(t >= 60) {
int m = t%3600/60;
if(m < 10) sb.append("0");
sb.append(m + ":");
}
int s = t%60;
if(s < 10) sb.append("0");
sb.append(s);
return sb.toString();
}
/**
* 根据传入日期获取目标日期
* @param date nullable 原始日期
* @param monthDiff nullable 月份偏移量
* @param dayOfMonth nullable 当月几号
* @return null if date is null
*/
public static Date getDiffDate(Date date, Integer monthDiff, Integer dayOfMonth) {
if(date == null)
return null;
Calendar c = Calendar.getInstance();
c.setTime(date);
if(monthDiff == null)
monthDiff = 0;
int month = c.get(Calendar.MONTH) + monthDiff;
c.set(Calendar.MONTH, month);
if(dayOfMonth != null)
c.set(Calendar.DAY_OF_MONTH, dayOfMonth);
return c.getTime();
}
/**
* 获取n天[前/后]的日期
* @return
*/
public static Date getDiffDay(Date date, Integer diffDay) {
Calendar c = Calendar.getInstance();
c.setTime(date);
c.add(Calendar.DAY_OF_YEAR, diffDay);
return c.getTime();
}
/**
* @param d1 notNull
* @param d2 notNull
* @return 是否是同一个月
*/
public static boolean isSameMonth(Date d1, Date d2) {
Calendar c = Calendar.getInstance();
c.setTime(d1);
int y1 = c.get(Calendar.YEAR);
int m1 = c.get(Calendar.MONTH);
c.setTime(d2);
int y2 = c.get(Calendar.YEAR);
int m2 = c.get(Calendar.MONTH);
return y1 == y2 && m1 == m2;
}
/**
* @param d1 notNull
* @param d2 notNull
* @return 是否是同一天
*/
public static boolean isSameDay(Date d1, Date d2) {
Calendar c = Calendar.getInstance();
c.setTime(d1);
int y1 = c.get(Calendar.YEAR);
int m1 = c.get(Calendar.MONTH);
int day1 = c.get(Calendar.DAY_OF_MONTH);
c.setTime(d2);
int y2 = c.get(Calendar.YEAR);
int m2 = c.get(Calendar.MONTH);
int day2 = c.get(Calendar.DAY_OF_MONTH);
return y1 == y2 && m1 == m2 && day1 == day2;
}
/**
* @return d1>=d2
*/
public static boolean greaterThanOrEqualTo(Date d1, Date d2) {
return d1.compareTo(d2) >= 0;
}
/**
* @return d1<=d2
*/
public static boolean lessThanOrEqualTo(Date d1, Date d2) {
return d1.compareTo(d2) <= 0;
}
/**
* @return d1>d2
*/
public static boolean greaterThan(Date d1, Date d2) {
return d1.compareTo(d2) > 0;
}
/**
* 获取某个月的实际最大天数, 如2016-02, 最大天数为29
*/
public static int getMaximum(Date date) {
Calendar c = Calendar.getInstance();
c.setTime(date);
return c.getActualMaximum(Calendar.DAY_OF_MONTH);
}
public static Date getFirstDayOfWeek(int year, int week) {
Calendar c = Calendar.getInstance();
c.set(year, Calendar.JANUARY, 1, 0, 0, 0);//定到第一天
c.add(Calendar.DATE, (week - 1) * 7);//直接add天数
c.setFirstDayOfWeek(Calendar.SUNDAY);
c.setTime(c.getTime());//必须先set一次time,否则是错误的!
c.set(Calendar.DAY_OF_WEEK, 1);
return c.getTime();
}
public static Date getHalfPastNineDateTime(Date date){
return parseDate(getYear(date) + "-"+ (getMonth(date)+1) +"-" + getDay(date)+" 9:30:00", "yyyy-MM-dd HH:mm:ss");
}
public static Date getTenOClockDateTime(Date date){
return parseDate(getYear(date) + "-"+ (getMonth(date)+1) +"-" + getDay(date)+" 9:30:00", "yyyy-MM-dd HH:mm:ss");
}
}
998
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
