DateUtil工具类
常用日期操作工具类：
package projectForEclipse.day01;
import java.math.BigDecimal;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.List;
import java.util.Locale;
import java.util.regex.Pattern;
public class DateUtil {
/**
* 将 Date原始格式"EEE MMM dd HH:mm:ss Z yyyy"转成指定格式 "yyyy-MM-dd HH:mm:ss"
*
* @param str 待解析字符串 一般是执行Date的toString方法获得
* @return 返回的字符串 yyyy-MM-dd HH:mm:ss格式
*/
public static String parseOriTime(String str) {
String sDate = "";
SimpleDateFormat sdf1 = new SimpleDateFormat("EEE MMM dd HH:mm:ss Z yyyy", Locale.UK);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
try {
Date date = sdf1.parse(str);
sDate = sdf.format(date);
} catch (Exception e) {
System.out.println("日期转换失败:" + str);
}
return sDate;
}
// public static void main(String[] args) {
// Date date = new Date();
// System.out.println(parseOriTime(date.toString()));
// }
/**
* 将传入的Date格式化为"yyyy-MM-dd HH:mm:ss"形式，Date没有非空判断
*
* @param dateDate
* @return
*/
public static String dateToStrLong(Date date) {
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String dateString = formatter.format(date);
return dateString;
}
/**
* 将Date类型转换为字符串 "yyyy-MM-dd HH:mm:ss"形式 Date有非空判断
*
* @param date 日期类型
* @return 日期字符串
*/
public static String format(Date date) {
if (date == null) {
return "";
}
return format(date, "yyyy-MM-dd HH:mm:ss");
}
/**
* 将Calendar类型的时间转换为字符串 "yyyy-MM-dd HH:mm:ss"形式 Calendar有非空判断
*
* @param date
* @return
*/
public static String format(Calendar date) {
if (date == null) {
return "";
}
return format(date.getTime(), "yyyy-MM-dd HH:mm:ss");
}
/**
* 将Date类型时间转换为指定格式的字符串，
*
* @param date 日期类型
* @param pattern 日期格式化的字符串格式 可以不输入，不输入 默认是"yyyy-MM-dd HH:mm:ss"
* @return 返回的日期字符串
*/
public static String format(Date date, String pattern) {
if (date == null) {
return "";
}
if (pattern == null || pattern.equals("") || pattern.equals("null")) {
pattern = "yyyy-MM-dd HH:mm:ss";
}
return new SimpleDateFormat(pattern).format(date);
}
/**
* 将字符串类型时间转换为Date类型 字符串格式为"yyyy-MM-dd HH:mm:ss"
*
* @param date 字符串类型 格式为"yyyy-MM-dd HH:mm:ss"
* @return 日期类型
*/
public static Date format(String date) {
return format(date, null);
}
/**
* 将指定格式的字符串时间类型转换为Date类型
*
* @param date 字符串类型 时间字符串 不输入默认返回当前时间
* @param pattern 时间字符串格式 不输入默认是yyyy-MM-dd HH:mm:ss
* @return 日期类型
*/
public static Date format(String date, String pattern) {
if (pattern == null || pattern.equals("") || pattern.equals("null")) {
pattern = "yyyy-MM-dd HH:mm:ss";
}
if (date == null || date.equals("") || date.equals("null")) {
return new Date();
}
Date d = null;
try {
d = new SimpleDateFormat(pattern).parse(date);
} catch (ParseException pe) {
System.out.println("日期解析失败 date:" + date + " pattern:" + pattern);
}
return d;
}
/**
* 返回当前时间的格式化字符串 字符串格式为："yyyy-MM-dd HH:mm:ss"
*
* @return
*/
public static String getCurrDate() {
return format(new Date(), "yyyy-MM-dd HH:mm:ss");
}
/**
* 根据传入的日期 解析出 该用何种SimpleDateFormat并返回对应的SimpleDateFormat
*
* @param dateStr 传入的日期字符串
* @return
*/
public static SimpleDateFormat getSimpleDateFormatPattern(String dateStr) {
SimpleDateFormat format = null;
if (Pattern.matches("\\d{4}-\\d{1,2}-\\d{1,2}", dateStr)) {
format = new SimpleDateFormat("yyyy-MM-dd");
} else if (Pattern.matches("\\d{4}\\d{2}\\d{2}", dateStr)) {
format = new SimpleDateFormat("yyyyMMdd");
} else if (Pattern.matches("\\d{4}年\\d{2}月\\d{2}日", dateStr)) {
format = new SimpleDateFormat("yyyy年MM月dd日", Locale.CHINA);
} else if (Pattern.matches("\\d{4}年\\d{1,2}月\\d{1,2}日", dateStr)) {
format = new SimpleDateFormat("yyyy年M月d日", Locale.CHINA);
} else if (Pattern.matches("\\d{1,2}\\w{3}\\d{4}", dateStr)) {
format = new SimpleDateFormat("dMMMyyyy", Locale.ENGLISH);
} else if (Pattern.matches("\\d{1,2}-\\w{3}-\\d{4}", dateStr)) {
format = new SimpleDateFormat("d-MMM-yyyy", Locale.ENGLISH);
} else if (Pattern.matches("\\d{4}-\\d{1,2}-\\d{1,2} \\d{1,2}:\\d{1,2}", dateStr)) {
format = new SimpleDateFormat("yyyy-MM-dd HH:mm");
} else if (dateStr.length() > 20) {
format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
} else {
format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
}
return format;
}
/**
* 根据传入的日期字符串自动转化为Date类型的时间 不需要自己输入格式化方式字符串
*
* @param dateStr @return @throws
*
*/
public static Date parseDateByPattern(String dateStr) {
SimpleDateFormat format = null;
try {
if (Pattern.matches("\\d{4}-\\d{2}-\\d{2}", dateStr)) {
format = new SimpleDateFormat("yyyy-MM-dd");
return format.parse(dateStr);
} else if (Pattern.matches("\\d{4}/\\d{2}/\\d{2}", dateStr)) {
format = new SimpleDateFormat("yyyy/MM/dd");
return format.parse(dateStr);
} else if (Pattern.matches("\\d{4}\\d{2}\\d{2}", dateStr)) {
format = new SimpleDateFormat("yyyyMMdd");
return format.parse(dateStr);
} else if (Pattern.matches("\\d{4}年\\d{2}月\\d{2}日", dateStr)) {
format = new SimpleDateFormat("yyyy年MM月dd日", Locale.CHINA);
return format.parse(dateStr);
} else if (Pattern.matches("\\d{4}年\\d{1,2}月\\d{1,2}日", dateStr)) {
format = new SimpleDateFormat("yyyy年M月d日", Locale.CHINA);
return format.parse(dateStr);
} else if (Pattern.matches("\\d{4}/\\d{1,2}/\\d{1,2} \\d{2}:\\d{2}", dateStr)) {
format = new SimpleDateFormat("yyyy/M/d HH:mm", Locale.CHINA);
return format.parse(dateStr);
} else if (Pattern.matches("\\d{4}\\.\\d{2}\\.\\d{2}", dateStr)) {
format = new SimpleDateFormat("yyyy.MM.dd", Locale.CHINA);
return format.parse(dateStr);
} else if (Pattern.matches("\\d{4}年\\d{2}月", dateStr)) {
format = new SimpleDateFormat("yyyy年MM月", Locale.CHINA);
return format.parse(dateStr);
} else if (Pattern.matches("\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}", dateStr)) {
format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.CHINA);
return format.parse(dateStr);
} else if (Pattern.matches("\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}", dateStr)) {
format = new SimpleDateFormat("yyyy-MM-dd HH:mm", Locale.CHINA);
return format.parse(dateStr);
} else if (Pattern.matches("\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}\\.\\d{3}", dateStr)) {
format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS", Locale.CHINA);
return format.parse(dateStr);
} else if (Pattern.matches("\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}\\.\\d{2}", dateStr)) {
format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SS", Locale.CHINA);
return format.parse(dateStr);
} else if (Pattern.matches("\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}\\.\\d{1}", dateStr)) {
format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.S", Locale.CHINA);
return format.parse(dateStr);
} else if (Pattern.matches("\\d{2}:\\d{2}", dateStr)) {
format = new SimpleDateFormat("HH:mm", Locale.CHINA);
return format.parse(dateStr);
}
} catch (Exception e) {
System.out.println("日期字符串：<<" + dateStr + ">>转换为Date失败......");
}
return null;
}
// public static void main(String[] args) {
// System.out.println(parseDateByPattern("2020/01/01"));
// }
/**
* 根据传入的long数据给出这个数据有几天，几小时，几分和几秒
*
* 示例 输入 343039300 返回 3天23小时17分钟19秒
*
* @param milliSeconds long形数据
* @return
*/
public static String getTimeMilisecondDesc(long milliSeconds) {
long days = milliSeconds / (1000 * 60 * 60 * 24);
milliSeconds = milliSeconds - (days * 24 * 60 * 60 * 1000);
long hours = milliSeconds / (1000 * 60 * 60);
milliSeconds = milliSeconds - (hours * 60 * 60 * 1000);
long minutes = milliSeconds / (1000 * 60);
milliSeconds = milliSeconds - (minutes * 60 * 1000);
long seconds = milliSeconds / (1000);
StringBuffer sb = new StringBuffer();
if (days != 0) {
sb.append(days + "天");
}
if (hours != 0) {
sb.append(hours + "小时");
}
if (minutes != 0) {
sb.append(minutes + "分钟");
}
if (seconds != 0) {
sb.append(seconds + "秒");
}
return sb.toString();
}
// public static void main(String[] args) {
// System.out.println(getTimeMilisecondDesc(343039300l));
// }
/**
* 取得指定日期所在周的第一天 此处认为星期一是一周的第一天 时间是00:00:00
*
* @param date
* @return
*/
public static Date getFirstDayOfWeek(Date date) {
Calendar c = clearDate(date, 4);
c.setFirstDayOfWeek(Calendar.MONDAY);
c.set(Calendar.DAY_OF_WEEK, c.getFirstDayOfWeek()); // Monday
return c.getTime();
}
// public static void main(String[] args) {
// System.out.println(getFirstDayOfWeek(new Date()));
// }
/**
* 取得指定日期所在周的最后一天 此处认为星期日是最后一天 时间到23:59:59 示例： 输入：20210225 返回：Sun Feb 28
* 23:59:59 CST 2021
*
*
* @param date
* @return
*/
public static Date getLastDayOfWeek(Date date) {
Calendar c = clearDate(date, 4);
c.setFirstDayOfWeek(Calendar.MONDAY);
c.set(Calendar.DAY_OF_WEEK, c.getFirstDayOfWeek() + 6);
c.set(Calendar.HOUR_OF_DAY, 23);
c.set(Calendar.MINUTE, 59);
c.set(Calendar.SECOND, 59);
c.set(Calendar.MILLISECOND, 000);
return c.getTime();
}
// public static void main(String[] args) {
// System.out.println(getLastDayOfWeek(new Date()));
// }
/**
* 取得指定日期所在周的起始时间 开始时间从00:00:00 结束时间是 23:59:59 此处认为星期一是一周第一天 星期日是一周最后一天 示例 传入
* 20210225 返回 Mon Feb 22 00:00:00 CST 2021 Sun Feb 28 23:59:59 CST 2021
*
*
* @param date 传入的日期
*
*
* @return
*/
public static Date[] getWeekLimit(Date date) {
Date date1 = getFirstDayOfWeek(date);
Date date2 = getLastDayOfWeek(date);
return new Date[] { date1, date2 };
}
// public static void main(String[] args) {
// System.out.println(getWeekLimit(new Date())[0]+" "+getWeekLimit(new Date())[1]);
// }
/**
* 取得指定日期的当月起始时间 从00:00:00开始 到23:59:59 为止
*
* 示例 输入 20210225 输出 Mon Feb 01 00:00:00 CST 2021 Sun Feb 28 23:59:59 CST 2021
*
* @param date 指定日期时间
* @return
*/
public static Date[] getMonthLimit(Date date) {
Calendar cal = clearDate(date, 5);
Date date1 = cal.getTime();
cal.add(Calendar.MONTH, 1);
cal.add(Calendar.SECOND, -1);
Date date2 = cal.getTime();
return new Date[] { date1, date2 };
}
// public static void main(String[] args) {
// System.out.println(getMonthLimit(new Date())[0]+" "+getMonthLimit(new Date())[1]);
// }
/**
* 取得指定日期的当年起始时间 从00:00:00开始 到23:59:59 为止
*
* 示例：输入：20210225 输出：Fri Jan 01 00:00:00 CST 2021 Fri Dec 31 23:59:59 CST 2021
*
* @param date 指定日期时间
* @return
*/
public static Date[] getYearLimit(Date date) {
Calendar cal = clearDate(date, 6);
Date date1 = cal.getTime();
cal.add(Calendar.YEAR, 1);
cal.add(Calendar.SECOND, -1);
Date date2 = cal.getTime();
return new Date[] { date1, date2 };
}
// public static void main(String[] args) {
// System.out.println(getYearLimit(new Date())[0]+" "+getYearLimit(new Date())[1]);
// }
/**
* 取得指定日期当月的起始时间字符串 格式是：yyyy-MM-dd HH:mm:ss
*
* @param date
* @return
*/
public static String[] getMonthLimitStr(Date date) {
Date[] rtDateArray = getMonthLimit(date);
return new String[] { getDateTimeStr(rtDateArray[0]), getDateTimeStr(rtDateArray[1]) };
}
// public static void main(String[] args) {
// System.out.println(getMonthLimitStr(new Date())[0]+" "+getMonthLimitStr(new Date())[1]);
// }
/**
* 取得指定日期当年的起始时间串 格式是：yyyy-MM-dd HH:mm:ss
*
* @param date
* @return
*/
public static String[] getYearLimitStr(Date date) {
Date[] rtDateArray = getYearLimit(date);
return new String[] { getDateTimeStr(rtDateArray[0]), getDateTimeStr(rtDateArray[1]) };
}
// public static void main(String[] args) {
// System.out.println(getYearLimitStr(new Date())[0]+" "+getYearLimitStr(new Date())[1]);
// }
/**
* 给定的日期字符串，得出该日期字符串偏移多少天后的日期时间
*
* @param dateStr 日期字符串
* @param dayCnt 偏移天数
* @return 偏移后日期
*/
public static Date getDayAfter(String dateStr, int dayCnt) {
return getDayAfter(parseDate(dateStr), dayCnt);
}
// public static void main(String[] args) {
// System.out.println(getDayAfter("2020-01-01",3));
// }
/**
* 给定日期，得出该日期偏移多少天后的日期
*
* @param date 给定日期
* @param dayCnt 偏移天数
* @return
*/
public static Date getDayAfter(Date date, int dayCnt) {
GregorianCalendar cal = new GregorianCalendar();
cal.setTime(date);
cal.add(Calendar.DATE, dayCnt);
return cal.getTime();
}
/**
* 给定日期，设置偏移多少秒后日期
*
* @param date 给定的日期
* @param secondCnt 偏移秒数
* @return 具体偏移后日期
*/
public static Date getSecondAfter(Date date, int secondCnt) {
GregorianCalendar cal = new GregorianCalendar();
cal.setTime(date);
cal.add(Calendar.SECOND, secondCnt);
return cal.getTime();
}
/**
* 指定日期偏移指定小时后的日期
*
* @param date 指定日期时间
* @param hourCnt 指定小时数
* @return 偏移后时间
*/
public static Date getDayHourAfter(Date date, int hourCnt) {
GregorianCalendar cal = new GregorianCalendar();
cal.setTime(date);
cal.add(Calendar.HOUR, hourCnt);
return cal.getTime();
}
/**
* 取得后多少月的时间
*
* @param date
* @param monthCnt
* @return
*/
public static Date getMonthAfter(Date date, int monthCnt) {
GregorianCalendar cal = new GregorianCalendar();
cal.setTime(date);
cal.add(Calendar.MONTH, monthCnt);
return cal.getTime();
}
/**
* 取得后多少年的时间
*
* @param date
* @return
*/
public static Date getYearAfter(Date date, int yearCnt) {
GregorianCalendar cal = new GregorianCalendar();
cal.setTime(date);
cal.add(Calendar.YEAR, yearCnt);
return cal.getTime();
}
/**
* 取得指定日期多少天后所有日期的集合 不 包含指定日期的时间
*
* 比如 输入 20210225 2 输出：[Fri Feb 26 16:04:06 CST 2021, Sat Feb 27 16:04:06 CST
* 2021]
*
* @param date 指定日期
* @param dayCnt 指定天数
* @return 日期集合
*/
public static List<Date> getDayListAfter(Date date, int dayCnt) {
List<Date> list = new ArrayList<Date>();
GregorianCalendar cal = new GregorianCalendar();
for (int i = 1; i <= dayCnt; i++) {
cal.setTime(date);
cal.add(Calendar.DATE, i);
list.add(cal.getTime());
}
return list;
}
// public static void main(String[] args) {
// System.out.println(getDayListAfter(new Date(),2).toString());
// }
/**
* 根据传入的日期字符串，给出该日期指定天数后的日期 实际就是日期相加减
*
* @param dateStr 日期字符串
* @param dayCnt 指定天数
* @return
*/
public static Date getDayDiff(String dateStr, int dayCnt) {
return getDayDiff(parseDate(dateStr), dayCnt);
}
// public static void main(String[] args) {
// System.out.println(getDayDiff("20200111",2));
// }
/**
* 根据传入的指定日期，给出该日期指定天数后的日期
*
* @param date 指定日期
* @param dayCnt 指定天数
* @return
*/
public static Date getDayDiff(Date date, int dayCnt) {
GregorianCalendar cal = new GregorianCalendar();
cal.setTime(date);
cal.add(Calendar.DATE, dayCnt);
return cal.getTime();
}
// public static void main(String[] args) {
// System.out.println(getDayDiff(new Date(),2));
// }
/**
* 取得今天开始时间 00:00:00
*
* @param date
* @return
*/
public static Date getStartToday() {
Calendar todayStart = Calendar.getInstance();
todayStart.set(Calendar.HOUR_OF_DAY, 0);
todayStart.set(Calendar.MINUTE, 0);
todayStart.set(Calendar.SECOND, 0);
todayStart.set(Calendar.MILLISECOND, 0);
return todayStart.getTime();
}
// public static void main(String[] args) {
// System.out.println(getStartToday());
// }
/**
* 取得今天23:59:59秒时间
*
* @param date
* @return
*/
public static Date getEndToday() {
Calendar todayEnd = Calendar.getInstance();
todayEnd.set(Calendar.HOUR_OF_DAY, 23);
todayEnd.set(Calendar.MINUTE, 59);
todayEnd.set(Calendar.SECOND, 59);
todayEnd.set(Calendar.MILLISECOND, 999);
return todayEnd.getTime();
}
// public static void main(String[] args) {
// System.out.println(getEndToday());
// }
/**
* 取得昨天的开始时间 00:00:00
*
* @param date
* @return
*/
public static Date getStatusYestday() {
Calendar tempStart = Calendar.getInstance();
Date start = new Date();
tempStart.setTime(start);
tempStart.set(Calendar.HOUR_OF_DAY, 0);
tempStart.set(Calendar.MINUTE, 0);
tempStart.set(Calendar.SECOND, 0);
tempStart.set(Calendar.MILLISECOND, 0);
tempStart.add(Calendar.DAY_OF_YEAR, -1);
Date time = tempStart.getTime();
return time;
}
// public static void main(String[] args) {
// System.out.println(getStatusYestday());
// }
/**
* 取得昨天结束时间 23:59:59
*
* @param date
* @return
*/
public static Date getEndYestday() {
Calendar tempEnd = Calendar.getInstance();
Date end = new Date();
tempEnd.setTime(end);
tempEnd.set(Calendar.HOUR_OF_DAY, 0);
tempEnd.set(Calendar.MINUTE, 0);
tempEnd.set(Calendar.SECOND, 0);
tempEnd.set(Calendar.MILLISECOND, 0);
tempEnd.add(Calendar.SECOND, -1);
Date time = tempEnd.getTime();
return time;
}
// public static void main(String[] args) {
// System.out.println(getEndYestday());
// }
/**
* 取得前7天开始时间 包含今天 比如 20210303 返回 20210225 00:00:00
*
*
* @param date
* @return
*/
public static Date getStatus7Days() {
Calendar tempEnd = Calendar.getInstance();
Date end = new Date();
tempEnd.setTime(end);
tempEnd.set(Calendar.HOUR_OF_DAY, 0);
tempEnd.set(Calendar.MINUTE, 0);
tempEnd.set(Calendar.SECOND, 0);
tempEnd.set(Calendar.MILLISECOND, 0);
tempEnd.add(Calendar.DAY_OF_YEAR, -6);
Date time = tempEnd.getTime();
return time;
}
// public static void main(String[] args) {
// System.out.println(getStatus7Days());
// }
/**
* 取得前7天结束时间 包含今天 比如 20210303 返回 20210225 23:59:59
*
* @param date
* @return
*/
public static Date getEnd7Days() {
Calendar tempEnd = Calendar.getInstance();
Date end = new Date();
tempEnd.setTime(end);
tempEnd.set(Calendar.HOUR_OF_DAY, 0);
tempEnd.set(Calendar.MINUTE, 0);
tempEnd.set(Calendar.SECOND, 0);
tempEnd.set(Calendar.MILLISECOND, 0);
tempEnd.add(Calendar.DAY_OF_YEAR, -5);
tempEnd.add(Calendar.SECOND, -1);
Date time = tempEnd.getTime();
return time;
}
// public static void main(String[] args) {
// System.out.println(getEnd7Days());
// }
/**
* 取得前30天的开始时间 包含今天 比如 20210304 返回 20210203 00:00:00
*
* @param date
* @return
*/
public static Date getStatus30Days() {
Calendar tempEnd = Calendar.getInstance();
Date end = new Date();
tempEnd.setTime(end);
tempEnd.set(Calendar.HOUR_OF_DAY, 0);
tempEnd.set(Calendar.MINUTE, 0);
tempEnd.set(Calendar.SECOND, 0);
tempEnd.set(Calendar.MILLISECOND, 0);
tempEnd.add(Calendar.DAY_OF_YEAR, -29);
Date time = tempEnd.getTime();
return time;
}
// public static void main(String[] args) {
// System.out.println(getStatus30Days());
// }
/**
* 取得指定日期 23:59:59的时间 解析失败返回当前时间
*
* @param date 指定日期
* @return 指定日期 23:59:59的时间
*/
public static Date getMongoDate(Date date) {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Calendar ca = Calendar.getInstance();
ca.setTime(date);
ca.set(Calendar.HOUR_OF_DAY, 23);
ca.set(Calendar.MINUTE, 59);
ca.set(Calendar.SECOND, 59);
ca.set(Calendar.MILLISECOND, 999);
try {
return sdf.parse(sdf.format(ca.getTime()));
} catch (ParseException e) {
System.out.println("日期解析错误......");
}
return new Date();
}
// public static void main(String[] args) {
// System.out.println(getMongoDate(new Date()));
// }
/**
* 根据传入的日期字符串取得前一天的时间字符串 例如：传入 20200102 返回 2020-01-01 00:00:00 传入2020-01-02
* 10:23:43 返回2020-01-01 10:23:43 字符串格式为：yyyy-MM-dd HH:mm:ss
*
* @param dateStr
* @return
*/
public static String getYestdayStr(String dateStr) {
return getYestdayStr(parseDate(dateStr));
}
//
// public static void main(String[] args) {
// System.out.println(getYestdayStr("2020-01-02 10:23:43"));
// }
/**
* 取得指定日期 前一天的时间字符串 字符串格式为：yyyy-MM-dd HH:mm:ss
*
* @param date
* @return
*/
public static String getYestdayStr(Date date) {
GregorianCalendar cal = new GregorianCalendar();
cal.setTime(date);
cal.add(Calendar.DATE, -1);
return getDateTimeStr(cal.getTime());
}
// public static void main(String[] args) {
// System.out.println(getYestdayStr(new Date()));
// }
/**
* 根据传入的日期和参数将日期对应字段后面所有日期字段清零 参数对应字段说明：1=毫秒, 2=秒, 3=分钟, 4=小时, 5=天, 6=月份
* 返回的是Calendar类型
*
* 样例: 1 Thu Mar 04 10:38:25 CST 2021 2 Thu Mar 04 10:38:00 CST 2021 3 Thu Mar
* 04 10:00:00 CST 2021 4 Thu Mar 04 00:00:00 CST 2021 5 Mon Mar 01 00:00:00 CST
* 2021 6 Fri Jan 01 00:00:00 CST 2021
*
* @param date 传入的日期时间
* @param clearNum 1=毫秒, 2=秒, 3=分钟, 4=小时, 5=天, 6=月份
* @return
*/
public static Calendar clearDate(Date date, int clearNum) {
Calendar cal = new GregorianCalendar();
cal.setTime(date);
// 毫秒
if (clearNum > 0) {
cal.set(Calendar.MILLISECOND, 0);
}
// 秒
if (clearNum > 1) {
cal.set(Calendar.SECOND, 0);
}
// 分钟
if (clearNum > 2) {
cal.set(Calendar.MINUTE, 0);
}
// 小时
if (clearNum > 3) {
cal.set(Calendar.HOUR_OF_DAY, 0);
}
// 天
if (clearNum > 4) {
cal.set(Calendar.DATE, 1);
}
// 月份
if (clearNum > 5) {
cal.set(Calendar.MONTH, 0);
}
return cal;
}
// public static void main(String[] args) {
// System.out.println(clearDate(new Date(),6).getTime());
// }
/**
* 根据传入的字符串和字符串格式化类型将字符串转化为Date时间
*
* @param dateStr 日期字符串
* @param formatStr 格式化形式
* @return
*/
public static Date parseDate(String formatStr, String dateStr) throws ParseException {
SimpleDateFormat format = new SimpleDateFormat(formatStr);
return format.parse(dateStr);
}
// public static void main(String[] args) {
// try {
// System.out.println(parseDate("yyyy-MM-dd","2020-01-01"));
// } catch (ParseException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// }
// }
/**
* 根据传入的字符串和字符串格式化类型将字符串转化为Calendar时间
*
* @param formatStr 格式化形式
* @param dateStr 日期字符串
* @return
*/
public static Calendar parseCalendar(String formatStr, String dateStr) {
Calendar c = Calendar.getInstance();
try {
c.setTime(parseDate(formatStr, dateStr));
} catch (Exception e) {
return null;
}
return c;
}
/**
*
* 根据传入的字符串将字符串转化为Calendar时间
*
* @param dateStr 传入的时间字符串
* @return
*/
public static Calendar parseCalendar(String dateStr) {
Calendar c = Calendar.getInstance();
try {
c.setTime(parseDateByPattern(dateStr));
} catch (Exception e) {
return null;
}
return c;
}
/**
* 把指定字符串转化为Date
*
* @param dateStr 指定的字符串
* @return
*/
public static Date parseDate(String dateStr) {
if (dateStr == null || "".equals(dateStr)) {
return null;
}
SimpleDateFormat format = null;
if (Pattern.matches("\\d{4}-\\d{1,2}-\\d{1,2}", dateStr)) {
format = new SimpleDateFormat("yyyy-MM-dd");
} else if (Pattern.matches("\\d{4}\\d{2}\\d{2}", dateStr)) {
format = new SimpleDateFormat("yyyyMMdd");
} else if (Pattern.matches("\\d{4}年\\d{2}月\\d{2}日", dateStr)) {
format = new SimpleDateFormat("yyyy年MM月dd日", Locale.CHINA);
} else if (Pattern.matches("\\d{4}年\\d{1,2}月\\d{1,2}日", dateStr)) {
format = new SimpleDateFormat("yyyy年M月d日", Locale.CHINA);
} else if (Pattern.matches("\\d{1,2}\\w{3}\\d{4}", dateStr)) {
format = new SimpleDateFormat("dMMMyyyy", Locale.ENGLISH);
} else if (Pattern.matches("\\d{1,2}-\\w{3}-\\d{4}", dateStr)) {
format = new SimpleDateFormat("d-MMM-yyyy", Locale.ENGLISH);
} else if (dateStr.length() > 20) {
format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS");
} else {
format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
}
try {
return format.parse(dateStr);
} catch (ParseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
// public static void main(String[] args) {
// System.out.println(parseDate("2020-01-23"));
// }
/**
* 取得指定时间的时间串，格式为 yyyy-MM-dd HH:mm:ss
*
* @param date 指定时间
* @return 格式化后时间字符串
*/
public static String getDateTimeStr(Date date) {
if (date == null) {
return getCurDateTimeStr();
}
return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(date);
}
/**
* 取得当前的时间，格式为 yyyy-MM-dd HH:mm:ss
*
* @return
*/
public static String getCurDateTimeStr() {
return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
}
/**
* 根据传入的年份，给出该年的最大周
*
* @param year
* @return
*/
public static int getMaxWeekOfYear(int year) {
Calendar c = new GregorianCalendar();
c.set(year, Calendar.DECEMBER, 31, 23, 59, 59);
return getWeekOfYear(c.getTime());
}
// public static void main(String[] args) {
// System.out.println(getMaxWeekOfYear(2021));
// }
/**
* 获取指定日期当前周
*
* @param date
* @return
*/
public static int getWeekOfYear(Date date) {
Calendar c = new GregorianCalendar();
c.setFirstDayOfWeek(Calendar.MONDAY); // 星期一为一周第一天
c.setMinimalDaysInFirstWeek(7); // 设置在一年中第一个星期所需最少天数为7天 这样设置时如果新年第一周不满7天，则归属去年最后一周，以满足7天的时间作为第一周
c.setTime(date);
return c.get(Calendar.WEEK_OF_YEAR);
}
/**
*
* 返回值说明:返回一个Calendar数组，长度为2 分别是开始日期和结束日期 星期一作为一周的开始 第一周是完整周 不完整的几天算去年最后一周
*
* @param year 年分 例如 2014
* @param weeknum 第几周 例如33
* @return
*
*/
public static Calendar[] getStartAndEndDate(int year, int weeknum) {
Calendar cal = Calendar.getInstance();
cal.set(Calendar.YEAR, year);
cal.set(Calendar.WEEK_OF_YEAR, weeknum);
cal.setFirstDayOfWeek(Calendar.MONDAY); // 星期一为一周第一天
cal.setMinimalDaysInFirstWeek(7); // 设置在一年中第一个星期所需最少天数为7天 这样设置时如果新年第一周不满7天，则归属去年最后一周，以满足7天的时间作为第一周
int nw = cal.get(Calendar.DAY_OF_WEEK);
Calendar start = (Calendar) cal.clone();
Calendar end = (Calendar) cal.clone();
start.add(Calendar.DATE, 1 - nw + 1);
end.add(Calendar.DATE, 7 - nw + 1);
Calendar[] darr = { start, end };
return darr;
}
// public static void main(String[] args) {
// System.out.println(getStartAndEndDate(2021,1)[0].getTime()+" "+getStartAndEndDate(2021,1)[1].getTime());
// }
/**
* 获取当期日期的一周 开始和结束日期 返回一个Calendar数组，长度为2 分别是开始日期和结束日期 星期一作为一周的开始
*
* @return
*/
public static Calendar[] getCurrStartEndDate() {
Calendar cal = Calendar.getInstance();
// 向后推一天（从星期一到周末）
cal.add(Calendar.DATE, -1);
int nw = cal.get(Calendar.DAY_OF_WEEK);
Calendar start = (Calendar) cal.clone();
Calendar end = (Calendar) cal.clone();
start.add(Calendar.DATE, 1 - nw + 1);
end.add(Calendar.DATE, 7 - nw + 1);
Calendar[] darr = { start, end };
return darr;
}
// public static void main(String[] args) {
// System.out.println(getCurrStartEndDate()[0].getTime() + " " + getCurrStartEndDate()[1].getTime());
// }
/**
* 获取当期日期的一周 开始至结束日期 返回一个Calendar数组，长度为7 星期一作为一周的开始
*
* @return
*/
public static Calendar[] getCurrStartAndEndOfWeek() {
Calendar cal = Calendar.getInstance();
// 向后推一天（从星期一到周末）
cal.add(Calendar.DATE, -1);
int nw = cal.get(Calendar.DAY_OF_WEEK);
Calendar start = (Calendar) cal.clone();
start.add(Calendar.DATE, 1 - nw + 1);
Calendar tuesday = (Calendar) cal.clone();// 周二
tuesday.add(Calendar.DATE, 2 - nw + 1);
Calendar wednesday = (Calendar) cal.clone();// 周三
wednesday.add(Calendar.DATE, 3 - nw + 1);
Calendar thursday = (Calendar) cal.clone();// 周四
thursday.add(Calendar.DATE, 4 - nw + 1);
Calendar friday = (Calendar) cal.clone();// 周五
friday.add(Calendar.DATE, 5 - nw + 1);
Calendar saturday = (Calendar) cal.clone();// 周六
saturday.add(Calendar.DATE, 6 - nw + 1);
Calendar end = (Calendar) cal.clone();
end.add(Calendar.DATE, 7 - nw + 1);
Calendar[] darr = { start, tuesday, wednesday, thursday, friday, saturday, end };
return darr;
}
// public static void main(String[] args) {
// Calendar[] tests = getCurrStartAndEndOfWeek();
// for(Calendar calendar:tests) {
// System.out.println(calendar.getTime());
// }
// }
/**
* 获取指定日期的一周 开始至结束日期 返回一个Calendar数组，长度为7 星期一作为一周的开始
* @param date 指定日期
* @return
*/
public static Calendar[] getStartAndEndOfWeekByDate(Date date) {
Calendar cal = Calendar.getInstance();
cal.setTime(date);
// 向后推一天（从星期一到周末）
cal.add(Calendar.DATE, -1);
int nw = cal.get(Calendar.DAY_OF_WEEK);
Calendar start = (Calendar) cal.clone();
start.add(Calendar.DATE, 1 - nw + 1);
Calendar tuesday = (Calendar) cal.clone();// 周二
tuesday.add(Calendar.DATE, 2 - nw + 1);
Calendar wednesday = (Calendar) cal.clone();// 周三
wednesday.add(Calendar.DATE, 3 - nw + 1);
Calendar thursday = (Calendar) cal.clone();// 周四
thursday.add(Calendar.DATE, 4 - nw + 1);
Calendar friday = (Calendar) cal.clone();// 周五
friday.add(Calendar.DATE, 5 - nw + 1);
Calendar saturday = (Calendar) cal.clone();// 周六
saturday.add(Calendar.DATE, 6 - nw + 1);
Calendar end = (Calendar) cal.clone();
end.add(Calendar.DATE, 7 - nw + 1);
Calendar[] darr = { start, tuesday, wednesday, thursday, friday, saturday, end };
return darr;
}
// public static void main(String[] args) {
// Calendar[] tests = getStartAndEndOfWeekByDate(parseDate("2021-01-01"));
// for(Calendar calendar:tests) {
// System.out.println(calendar.getTime());
// }
// }
/**
* 算出俩个时间，所间隔的多少天
*
* @param startDate
* @param endDate
* @return
*/
public static Long getDaysBetween(Date startDate, Date endDate) {
Calendar fromCalendar = Calendar.getInstance();
fromCalendar.setTime(startDate);
fromCalendar.set(Calendar.HOUR_OF_DAY, 0);
fromCalendar.set(Calendar.MINUTE, 0);
fromCalendar.set(Calendar.SECOND, 0);
fromCalendar.set(Calendar.MILLISECOND, 0);
Calendar toCalendar = Calendar.getInstance();
toCalendar.setTime(endDate);
toCalendar.set(Calendar.HOUR_OF_DAY, 0);
toCalendar.set(Calendar.MINUTE, 0);
toCalendar.set(Calendar.SECOND, 0);
toCalendar.set(Calendar.MILLISECOND, 0);
return (toCalendar.getTime().getTime() - fromCalendar.getTime().getTime()) / (1000 * 60 * 60 * 24);
}
// public static void main(String[] args) {
// System.out.println(getDaysBetween(parseDate("2020-01-01"),parseDate("2020-01-08")));
// }
/**
* 两个时间相差多少天多少小时多少分多少秒
*
* @param startDate 时间参数 1 格式：1990-01-01 12:00:00
* @param endDate 时间参数 2 格式：2009-01-01 12:00:00
* @return long[] 返回值为：{天, 时, 分, 秒}
*/
public static long[] getDaysBetweenmm(String startDate, String endDate) {
DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date one;
Date two;
long day = 0;
long hour = 0;
long min = 0;
long sec = 0;
try {
one = df.parse(startDate);
two = df.parse(endDate);
long time1 = one.getTime();
long time2 = two.getTime();
long diff;
if (time1 < time2) {
diff = time2 - time1;
} else {
diff = time1 - time2;
}
day = diff / (24 * 60 * 60 * 1000);
hour = (diff / (60 * 60 * 1000) - day * 24);
min = ((diff / (60 * 1000)) - day * 24 * 60 - hour * 60);
sec = (diff / 1000 - day * 24 * 60 * 60 - hour * 60 * 60 - min * 60);
} catch (ParseException e) {
e.printStackTrace();
}
long[] times = { day, hour, min, sec };
return times;
}
// public static void main(String[] args) {
// long [] s = getDaysBetweenmm("2020-01-01 20:01:02","2020-02-01 10:20:20");
// for(long l:s) {
// System.out.println(l);
// }
// }
/**
* 根据指定的月字符串算出月初和月未的时间，精确到秒
* 实例：输入：2020-01
* 输出：Wed Jan 01 00:00:00 CST 2020 Fri Jan 31 23:59:59 CST 2020
*
*
* @param monthStr 格式为:2020-01形式
* @return 月初和月末时间数组
*/
public static Date[] getDatetimeMonthLimit(String monthStr) {
String start = monthStr + "-01 00:00:00";
Date startTime = DateUtil.format(start);
Calendar cal = Calendar.getInstance();
cal.setTime(startTime);
cal.set(Calendar.DATE, cal.getActualMaximum(Calendar.DATE)+1);
cal.add(Calendar.SECOND, -1);
Date endTime = cal.getTime();
return new Date[] { startTime, endTime };
}
// public static void main(String[] args) {
// System.out.println(getDatetimeMonthLimit("2020-02")[0]+" "+getDatetimeMonthLimit("2020-02")[1]);
// }
/**
* 根据指定的月字符串算出上月月初和月未的时间，精确到秒
*
* @param monthStr 格式为:2020-01形式
* @return 上月月初和月未的时间
*/
public static Date[] getDatetimePreMonthLimit(String monthStr) {
String start = monthStr + "-01 00:00:00";
Date startTime = DateUtil.format(start);
Calendar cal = Calendar.getInstance();
cal.setTime(startTime);
cal.add(Calendar.MONTH, -1);
startTime = cal.getTime();
cal.set(Calendar.DATE, cal.getActualMaximum(Calendar.DATE));
Date endTime = new Date(cal.getTime().getTime() + 24 * 60 * 60 * 1000l - 1l);
return new Date[] { startTime, endTime };
}
// public static void main(String[] args) {
// System.out.println(getDatetimePreMonthLimit("2020-02")[0]+" "+getDatetimePreMonthLimit("2020-02")[1]);
// }
/**
* 根据指定的天字符串算出天开始和天结束的时间，精确到秒
* @param day 指定的天字符串 格式为：2020-01-01
* @return 算出天开始和天结束的时间
*/
public static Date[] getDatetimeDayLimit(String day) {
String startStr = day + " 00:00:00";
Date start = DateUtil.parseDate(startStr);
return new Date[] { start, new Date(start.getTime() + 24 * 60 * 60 * 1000l - 1l) };
}
// public static void main(String[] args) {
// System.out.println(getDatetimeDayLimit("2020-02-01")[0] + " " + getDatetimeDayLimit("2020-02-01")[1]);
// }
/**
* 根据指定的天字符串算出昨天开始和昨天结束的时间，精确到秒
* @param day 指定的天字符串 格式为：2020-01-01
* @return 算出昨天开始和昨天结束的时间
*/
public static Date[] getDatetimePreDayLimit(String day) {
String startStr = day + " 00:00:00";
Date start = new Date(DateUtil.parseDate(startStr).getTime() - 24 * 60 * 60 * 1000l);
return new Date[] { start, new Date(start.getTime() + 24 * 60 * 60 * 1000l - 1l) };
}
/**
*
* 根据传入的日期，判断日期是第几季度 1 第一季度 2 第二季度 3 第三季度 4 第四季度
*
* @param date 传入的日期
* @return 季度数
*/
public static int getSeason(Date date) {
int season = 0;
Calendar c = Calendar.getInstance();
c.setTime(date);
int month = c.get(Calendar.MONTH);
switch (month) {
case Calendar.JANUARY:
case Calendar.FEBRUARY:
case Calendar.MARCH:
season = 1;
break;
case Calendar.APRIL:
case Calendar.MAY:
case Calendar.JUNE:
season = 2;
break;
case Calendar.JULY:
case Calendar.AUGUST:
case Calendar.SEPTEMBER:
season = 3;
break;
case Calendar.OCTOBER:
case Calendar.NOVEMBER:
case Calendar.DECEMBER:
season = 4;
break;
default:
break;
}
return season;
}
// public static void main(String[] args) {
// System.out.println(getSeason(parseDate("2020-03-01")));
// }
/**
* 根据指定的年份和季度 算出季度初和季度未的时间，精确到秒
*
* @param year 年份
* @param nSeason 第几季度
* @return 季度开始和结束时间
*/
public static Date[] getDatetimeSeasonLimit(int year, int nSeason) {
Calendar c = Calendar.getInstance();
Date[] season = new Date[2];
c.set(year, Calendar.JANUARY, 1, 0, 0, 0);
c.set(Calendar.MILLISECOND, 0);
if (nSeason == 1) {// 第一季度
c.set(Calendar.MONTH, Calendar.JANUARY);
season[0] = c.getTime();
c.set(Calendar.MONTH, Calendar.MARCH);
c.set(Calendar.DATE, c.getActualMaximum(Calendar.DATE));
season[1] = new Date(c.getTime().getTime() + 24 * 60 * 60 * 1000l - 1l);
} else if (nSeason == 2) {// 第二季度
c.set(Calendar.MONTH, Calendar.APRIL);
season[0] = c.getTime();
c.set(Calendar.MONTH, Calendar.JUNE);
c.set(Calendar.DATE, c.getActualMaximum(Calendar.DATE));
season[1] = new Date(c.getTime().getTime() + 24 * 60 * 60 * 1000l - 1l);
} else if (nSeason == 3) {// 第三季度
c.set(Calendar.MONTH, Calendar.JULY);
season[0] = c.getTime();
c.set(Calendar.MONTH, Calendar.SEPTEMBER);
c.set(Calendar.DATE, c.getActualMaximum(Calendar.DATE));
season[1] = new Date(c.getTime().getTime() + 24 * 60 * 60 * 1000l - 1l);
} else if (nSeason == 4) {// 第四季度
c.set(Calendar.MONTH, Calendar.OCTOBER);
season[0] = c.getTime();
c.set(Calendar.MONTH, Calendar.DECEMBER);
c.set(Calendar.DATE, c.getActualMaximum(Calendar.DATE));
season[1] = new Date(c.getTime().getTime() + 24 * 60 * 60 * 1000l - 1l);
}
return season;
}
// public static void main(String[] args) {
// System.out.println(getDatetimeSeasonLimit(2021,4)[0]+" "+getDatetimeSeasonLimit(2021,4)[1]);
// }
/**
* 根据指定的年份和季度 算出上一季度 季度初和季度未的时间，精确到秒
*
* @param year 年份
* @param nSeason 第几季度
* @return
*/
public static Date[] getDatetimePreSeasonLimit(int year, int nSeason) {
if (nSeason == 1) {
nSeason = 4;
year = year - 1;
} else {
nSeason = nSeason - 1;
}
return getDatetimeSeasonLimit(year, nSeason);
}
/**
* 根据指定的年份数据算出年初和年未的时间，精确到秒
*
* @param year 年份
* @return
*/
public static Date[] getDatetimeYearLimit(int year) {
Calendar c = Calendar.getInstance();
Date[] res = new Date[2];
c.set(Calendar.YEAR, year);
c.set(Calendar.MONTH, Calendar.JANUARY);
res[0] = clearDate(c.getTime(), 5).getTime();
c.setTime(res[0]);
c.set(Calendar.MONTH, Calendar.DECEMBER);
c.set(Calendar.DATE, c.getActualMaximum(Calendar.DATE));
res[1] = new Date(c.getTime().getTime() + 24 * 60 * 60 * 1000l - 1l);
return res;
}
// public static void main(String[] args) {
// System.out.println(getDatetimeYearLimit(2020)[0]+" "+getDatetimeYearLimit(2020)[1]);
// }
/**
* 根据指定的年份数据算出去年年初和年未的时间，精确到秒
*
* @param year 年份
* @return
*/
public static Date[] getDatetimePreYearLimit(int year) {
return getDatetimeYearLimit(year - 1);
}
// public static void main(String[] args) {
// System.out.println(getDatetimePreYearLimit(2020)[0] + " " + getDatetimePreYearLimit(2020)[1]);
// }
/**
* 日期相加减
*
* @param date
* @param number 天数数量
* @return
*/
public static Date getNextDay(Date date, int number) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
calendar.add(Calendar.DAY_OF_MONTH, number);// +1今天的时间加一天
date = calendar.getTime();
return date;
}
/**
* 计算俩个时间差多少天多少小时
*
* @param endDate 结束时间
* @param nowDate 开始时间
* @return 差几天的字符串
*/
public static String getDatePoorHour(Date nowDate, Date endDate) {
long nd = 1000 * 24 * 60 * 60l;
long nh = 1000 * 60 * 60l;
long nm = 1000 * 60l;
// long ns = 1000;
// 获得两个时间的毫秒时间差异
long diff = endDate.getTime() - nowDate.getTime();
// 计算差多少天
long day = diff / nd;
// 计算差多少小时
long hour = (diff % nd) / nh;
// 计算差多少分钟
long min = (diff % nd % nh) / nm;
// 计算差多少秒//输出结果
// long sec = diff % nd % nh % nm / ns;
return day + "天" + hour + "小时";
}
// public static void main(String[] args) {
// System.out.println(getDatePoorHour(parseDate("2020-01-01 10:01:00"),parseDate("2020-01-03 10:00:00")));
// }
/**
* 计算俩个时间差多少天多少小时多少分钟
*
* @param endDate 结束时间
* @param nowDate 开始时间
* @return
*/
public static String getDatePoorMinute(Date nowDate, Date endDate) {
long nd = 1000 * 24 * 60 * 60l;
long nh = 1000 * 60 * 60l;
long nm = 1000 * 60l;
// long ns = 1000;
// 获得两个时间的毫秒时间差异
long diff = endDate.getTime() - nowDate.getTime();
// 计算差多少天
long day = diff / nd;
// 计算差多少小时
long hour = (diff % nd) / nh;
// 计算差多少分钟
long min = (diff % nd % nh) / nm;
// 计算差多少秒//输出结果
// long sec = diff % nd % nh % nm / ns;
String tempStr = "";
if (day > 0) {
tempStr = day + "天";
}
if (hour > 0) {
tempStr += hour + "小时";
}
if (min > 0) {
tempStr += min + "分钟";
}
return tempStr;
}
// public static void main(String[] args) {
// System.out.println(getDatePoorMinute(parseDate("2020-01-01 10:01:00"),parseDate("2020-01-03 10:00:00")));
// }
/**
* 计算俩个时间相差多少分钟
*
* @param endDate 结束时间
* @param nowDate 开始时间
* @return
*/
public static long getDatePoorTotalMinute(Date nowDate, Date endDate) {
long nm = 1000 * 60l;
// long ns = 1000;
// 获得两个时间的毫秒时间差异
long diff = endDate.getTime() - nowDate.getTime();
Long tempLong = diff / nm;
return tempLong;
}
/**
* 获取当前季度的开始时间
*
* @return
*/
public static Date getCurrentQuarterStartTime() {
Calendar c = Calendar.getInstance();
int currentMonth = c.get(Calendar.MONTH) + 1;
Date now = null;
try {
if (currentMonth >= 1 && currentMonth <= 3)
c.set(Calendar.MONTH, 0);
else if (currentMonth >= 4 && currentMonth <= 6)
c.set(Calendar.MONTH, 3);
else if (currentMonth >= 7 && currentMonth <= 9)
c.set(Calendar.MONTH, 6);
else if (currentMonth >= 10 && currentMonth <= 12)
c.set(Calendar.MONTH, 9);
} catch (Exception e) {
e.printStackTrace();
}
return clearDate(c.getTime(), 5).getTime();
}
// public static void main(String[] args) {
// System.out.println(getCurrentQuarterStartTime());
// }
/**
* 获取当前季度的结束时间
*
* @return
*/
public static Date getCurrentQuarterEndTime() {
Calendar c = Calendar.getInstance();
int currentMonth = c.get(Calendar.MONTH) + 1;
try {
if (currentMonth >= 1 && currentMonth <= 3) {
c.set(Calendar.MONTH, 2);
c.set(Calendar.DATE, 31);
} else if (currentMonth >= 4 && currentMonth <= 6) {
c.set(Calendar.MONTH, 5);
c.set(Calendar.DATE, 30);
} else if (currentMonth >= 7 && currentMonth <= 9) {
c.set(Calendar.MONTH, 8);
c.set(Calendar.DATE, 30);
} else if (currentMonth >= 10 && currentMonth <= 12) {
c.set(Calendar.MONTH, 11);
c.set(Calendar.DATE, 31);
}
} catch (Exception e) {
e.printStackTrace();
}
c.set(Calendar.HOUR_OF_DAY, 23);
c.set(Calendar.MINUTE, 59);
c.set(Calendar.SECOND, 59);
c.set(Calendar.MILLISECOND, 000);
return c.getTime();
}
// public static void main(String[] args) {
// System.out.println(getCurrentQuarterEndTime());
// }
/**
* 输入指定日期，给出该日期为星期几的字符串说明
* @param date
* @return
*/
public static String getWeek(Date date) {
String[] weeks = { "星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六" };
Calendar cal = Calendar.getInstance();
cal.setTime(date);
int week_index = cal.get(Calendar.DAY_OF_WEEK) - 1;
if (week_index < 0) {
week_index = 0;
}
return weeks[week_index];
}
// public static void main(String[] args) {
// System.out.println(getWeek(parseDate("2020-02-29")));
// }
/**
* 获取两个日期相隔天数 去掉时分秒，直接比对日
*
* @param fDate 开始时间
* @param oDate 结束时间
* @return 返回相差几天
*/
public static int getIntervalOfDays(Date fDate, Date oDate) {
if (null == fDate || null == oDate) {
return -1;
}
fDate = DateUtil.clearDate(fDate, 4).getTime();
oDate = DateUtil.clearDate(oDate, 4).getTime();
long intervalMilli = oDate.getTime() - fDate.getTime();
return (int) (intervalMilli / (24 * 60 * 60 * 1000));
}
/**
* 获取指定时间的月份数据
* @param date 指定时间
* @return 月份数据
*/
public static int getMonth(Date date) {
Calendar cal = Calendar.getInstance();
cal.setTime(date);
return cal.get(Calendar.MONTH) + 1;
}
/**
* 获取指定时间的年份数据
* @param date
* @return
*/
public static int getYear(Date date) {
Calendar now = Calendar.getInstance();
now.setTime(date);
return now.get(Calendar.YEAR);
}
/**
* 获取指定时间几分钟后的时间字符串
* @param date 指定时间
* @param minute 几分钟后数据
* @return
*/
public static String getTimeByMinute(Date date, int minute) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
calendar.add(Calendar.MINUTE, minute);
return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(calendar.getTime());
}
// public static void main(String[] args) {
// System.out.println(getTimeByMinute(new Date(),2));
// }
/**
*
* 根据指定规则输出指定日期字符串的中文表示
* 接收日期格式字符转化为中文+日期格式
* 规则：
* 刚刚（5分钟前）
* ①如果开课时间为当天的日期，显示“今天+时+分”
* ②如果开课时间为昨天的日期，显示“昨天+时+分”
* ③如果开课时间为前天的日期，显示“前天+时+分”
* ④如果开课时间为明天的日期，显示“明天+时+分”
* ⑤如果开课时间为后天的日期，显示“后天+时+分”
* ⑥如果开课时间超出后天，并且还在当前周内，显示“本周X+时+分”
* ⑦其余日期均显示“月-日 时：分”
* ⑧如果开课时间不是当前年，显示“年-月-日 时：分”
*
* @param date 指定日期字符串 格式为：yyyy-MM-dd HH:mm:ss
* @return 指定日期字符串的中文表示
*/
public static String transFinalFormationStringDate(String date) {
long[] daysBetweenmm = getDaysBetweenmm(date, format(new Date()));
if (daysBetweenmm[0] == 0 && daysBetweenmm[1] == 0 && daysBetweenmm[2] < 6) {
return "刚刚";
}
return transFormationStringDate(date);
}
// public static void main(String[] args) {
// System.out.println(transFinalFormationStringDate("2021-02-09 16:18:00"));
// }
/**
*
* @param date
* @return
*/
public static String transFormationStringDate(String date) {
Date now = new Date();
SimpleDateFormat sss = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
return transFormationStringDate(date, now, sss.format(now));
}
/**
* 接收日期格式字符转化为中文+日期格式 规则：①如果开课时间为当天的日期，显示“今天+时+分” ②如果开课时间为昨天的日期，显示“昨天+时+分”
* ③如果开课时间为前天的日期，显示“前天+时+分” ④如果开课时间为明天的日期，显示“明天+时+分” ⑤如果开课时间为后天的日期，显示“后天+时+分”
* ⑥如果开课时间超出后天，并且还在当前周内，显示“本周X+时+分” ⑦其余日期均显示“月-日 时：分” ⑧如果开课时间不是当前年，显示“年-月-日 时：分”
*
* @param date
* @return
*/
public static String transFormationStringDate(String date, Date newDate, String newDateStr) {
SimpleDateFormat sss = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
try {
String yyyyStr = date.substring(0, 4);
String mmStr = date.substring(5, 7);
String ddStr = date.substring(8, 10);
String hhStr = date.substring(11, 13);
String MMStr = date.substring(14, 16);
String ssStr = date.substring(17, 19);
int yyyy = Integer.parseInt(yyyyStr);
int mm = Integer.parseInt(mmStr);
int dd = Integer.parseInt(ddStr);
int hh = Integer.parseInt(hhStr);
int MM = Integer.parseInt(MMStr);
int ss = Integer.parseInt(ssStr);
int yyyy1 = Integer.parseInt(newDateStr.substring(0, 4));
int mm1 = Integer.parseInt(newDateStr.substring(5, 7));
int dd1 = Integer.parseInt(newDateStr.substring(8, 10));
if (yyyy != yyyy1) {// 如果开课时间不是当前年，显示“年-月-日 时：分”
return yyyyStr + "-" + mmStr + "-" + ddStr + " " + hhStr + ":" + MMStr;
}
if (mm == mm1 && dd == dd1) {// 如果开课时间为当天的日期，显示“今天+时+
return "今天" + " " + hhStr + ":" + MMStr;
}
Date allDate = sss.parse(date);
Long daysBetween = getDaysBetween(newDate, allDate);
if (daysBetween == -1) {// 如果开课时间为昨天的日期，显示“昨天+时+分”
return "昨天" + " " + hhStr + ":" + MMStr;
}
if (daysBetween == -2) {// 如果开课时间为前天的日期，显示“前天+时+分”
return "前天" + " " + hhStr + ":" + MMStr;
}
if (daysBetween == 1) {// 如果开课时间为明天的日期，显示“明天+时+分”
return "明天" + " " + hhStr + ":" + MMStr;
}
if (daysBetween == 2) {// 如果开课时间为后天的日期，显示“后天+时+分”
return "后天" + " " + hhStr + ":" + MMStr;
}
if (daysBetween > 2 || daysBetween < -2) {// 如果开课时间超出后天
Date firstDayOfWeek1 = getFirstDayOfWeek(newDate);// 当前日期所在周的第一天
Date firstDayOfWeek2 = getFirstDayOfWeek(allDate);// 传入日期所在周的第一天
if (firstDayOfWeek1.getTime() == firstDayOfWeek2.getTime()) {// 并且还在当前周内，显示“本周X+时+分”
Long ad = getDaysBetween(firstDayOfWeek1, allDate);
switch (ad.intValue()) {
case 0:
return "本周一" + " " + hhStr + ":" + MMStr;
case 1:
return "本周二" + " " + hhStr + ":" + MMStr;
case 2:
return "本周三" + " " + hhStr + ":" + MMStr;
case 3:
return "本周四" + " " + hhStr + ":" + MMStr;
case 4:
return "本周五" + " " + hhStr + ":" + MMStr;
case 5:
return "本周六" + " " + hhStr + ":" + MMStr;
case 6:
return "本周日" + " " + hhStr + ":" + MMStr;
}
}
}
// 其余日期均显示“月-日 时：分”
return mmStr + "-" + ddStr + " " + hhStr + ":" + MMStr;
// format(allDate,"MM-dd HH:mm");
} catch (Exception e) {
return "日期格式字符转化错误";
}
}
/**
* 获取指定时间根据格式化方式获取的各组成部分
*
*
* @param date 指定时间
* @param format 获取的部分 yyyy 年份 MM 月份 dd 日
* @return
*/
public static int getYMDDate(Date date, String format) {
SimpleDateFormat sdf = null;
try {
if (format != null && format.length() > 0) {
if ("yyyy".equals(format)) {
sdf = new SimpleDateFormat("yyyy");
String formatY = sdf.format(date);
return Integer.parseInt(formatY);
} else if ("MM".equals(format)) {
sdf = new SimpleDateFormat("MM");
String formatY = sdf.format(date);
return Integer.parseInt(formatY);
} else if ("dd".equals(format)) {
sdf = new SimpleDateFormat("dd");
String formatY = sdf.format(date);
return Integer.parseInt(formatY);
}
}
return 0;
} catch (Exception e) {
return 0;
}
}
// public static void main(String[] args) {
// System.out.println(getYMDDate(new Date(),"yyyy")); //2021
// System.out.println(getYMDDate(new Date(),"MM")); //3
// System.out.println(getYMDDate(new Date(),"dd")); //4
//
// }
/**
*
* 传入天、时、份、秒 获取当月指定天数后的指定时间
* @param hour 小时数
* @param minute 分钟数
* @param second 秒钟数
* @param day 指定天数后
* @return 指定时间
*/
public static Date getNeedTime(int hour, int minute, int second, int day) {
Calendar calendar = Calendar.getInstance();
if (day != 0) {
calendar.add(Calendar.DATE, day);
}
calendar.set(Calendar.HOUR_OF_DAY, hour);
calendar.set(Calendar.MINUTE, minute);
calendar.set(Calendar.SECOND, second);
return calendar.getTime();
}
// public static void main(String[] args) {
// System.out.println(getNeedTime(23,22,34,9));
// }
}
