日期封装类
```java
import cn.seenew.future.his.base.domain.DateTimeWrap;
import java.sql.Timestamp;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.*;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import java.util.stream.Stream;
/**
* @Author: caixu
* @Description:日期工具类
* @Date: Created in 13:09 2018/5/25
* @Modified By:
*/
public class BaseDateUtil {
private static final String YYYY_MM_DD = "yyyy-MM-dd";
private static final String YYYY_MM_DD_HH_MM_SS = "yyyy-MM-dd HH:mm:ss";
private static final String YYYY_MM_DD_HH_MM = "yyyy-MM-dd HH:mm";
private static final String YYYYMMDD = "yyyyMMdd";
private static final HashMap<String, String> DATE_REG_FORMAT = new HashMap<String, String>();
static {
DATE_REG_FORMAT.put("[0-9]{4}-[0-9]{2}-[0-9]{2} [0-9]{2}:[0-9]{2}:[0-9]{2}", YYYY_MM_DD_HH_MM_SS);
DATE_REG_FORMAT.put("[0-9]{4}-[0-9]{2}-[0-9]{2}", YYYY_MM_DD);
DATE_REG_FORMAT.put("[0-9]{4}-[0-9]{2}-[0-9]{2} [0-9]{2}:[0-9]{2}", "yyyy-MM-dd HH:mm");
DATE_REG_FORMAT.put("[0-9]{4}[0-9]{2}[0-9]{2}[0-9]{2}[0-9]{2}[0-9]{2}", "yyyyMMddHHmmss");
DATE_REG_FORMAT.put("[0-9]{4}[0-9]{2}[0-9]{2}", YYYYMMDD);
}
/**时间格式化成日期*/
public static class FormatDateString{
/**
* 格式化年-月-日
* @param date
* @return
*/
public static String dateY_M_D(Date date) {
return dateToLocalDateTime(date).format(DateTimeFormatter.ofPattern(YYYY_MM_DD));
}
/**
* 格式化年月日
* @param date
* @return
*/
public static String dateYMD(Date date) {
return dateToLocalDateTime(date).format(DateTimeFormatter.ofPattern(YYYYMMDD));
}
/**
* 格式化年_月_日 时:分:秒
* @param date
* @return
*/
public static String dateY_M_D_H_M_S(Date date) {
return dateToLocalDateTime(date).format(DateTimeFormatter.ofPattern(YYYY_MM_DD_HH_MM_SS));
}
/**
* 格式化年_月_日 时:分
* @param date
* @return
*/
public static String dateY_M_D_H_M(Date date) {
return dateToLocalDateTime(date).format(DateTimeFormatter.ofPattern(YYYY_MM_DD_HH_MM));
}
}
/**
* 格式化常用的日期格式
*/
public static Date formatAll(String dateStr) {
for (Map.Entry<String, String> entry : DATE_REG_FORMAT.entrySet()) {
if (Pattern.compile(entry.getKey()).matcher(dateStr).matches()) {
DateTimeFormatter formatter = DateTimeFormatter.ofPattern(entry.getValue());
if (YYYY_MM_DD.equals(entry.getValue()) || YYYYMMDD.equals(entry.getValue())) {
LocalDate localDate = LocalDate.parse(dateStr, formatter);
return localDate2Date(localDate);
}
LocalDateTime localDateTime = LocalDateTime.parse(dateStr, formatter);
return localDateTime2Date(localDateTime);
}
}
return null;
}
/**
* java.time.LocalTime --> java.util.Date
*/
public static Date localDateTime2Date(LocalDateTime localDateTime) {
ZoneId zone = ZoneId.systemDefault();
Instant instant = localDateTime.atZone(zone).toInstant();
return Date.from(instant);
}
/**
* java.time.LocalDate --> java.util.Date
*/
public static Date localDate2Date(LocalDate localDate) {
ZoneId zone = ZoneId.systemDefault();
Instant instant = localDate.atStartOfDay().atZone(zone).toInstant();
return Date.from(instant);
}
/**
* LocalDate 转 Date,默认时区<br/>
*
* @param localDate
* @return date
* @author zhiqiang.fu
* @date 2018.04.26
*/
public static Date localDateToDate(LocalDate localDate) {
if (localDate != null) {
ZoneId zoneId = ZoneId.systemDefault();
ZonedDateTime zdt = localDate.atStartOfDay(zoneId);
Date date = Date.from(zdt.toInstant());
return date;
}
return null;
}
/**
* Date 转 LocalDate,默认时区<br/>
*
* @param date
* @return LocalDate
* @author zhiqiang.fu
* @date 2018.04.26
*/
public static LocalDate dateToLocalDate(Date date) {
if (date != null) {
Instant instant = date.toInstant();
ZoneId zoneId = ZoneId.systemDefault();
LocalDate localDate = instant.atZone(zoneId).toLocalDate();
return localDate;
}
return null;
}
/**
* Date 转 LocalDate,默认时区<br/>
*
* @param date
* @return LocalDate
* @author zhiqiang.fu
* @date 2018.04.26
*/
public static LocalDateTime dateToLocalDateTime(Date date) {
if (date != null) {
Instant instant = date.toInstant();
ZoneId zoneId = ZoneId.systemDefault();
LocalDateTime localDate = instant.atZone(zoneId).toLocalDateTime();
return localDate;
}
return null;
}
/**
* 循环两个时间之间日期 <br/>
*
* @param queryStartDate 开始时间
* @param queryEndDate 结束时间
* @return 时间集合
* @author zhiqiang.fu
* @date 2018.04.26
*/
public static List<LocalDate> listAllDatesBetweenTwoDate(Date queryStartDate, Date queryEndDate) {
LocalDate startDate = dateToLocalDate(queryStartDate);
LocalDate endDate = dateToLocalDate(queryEndDate);
if (Objects.isNull(startDate) || Objects.isNull(endDate)) {
return new ArrayList<>(2);
}
if (startDate.isAfter(endDate)) {
return new ArrayList<>(2);
}
List<LocalDate> localDateList = Stream.iterate(startDate, localDate -> localDate.plusDays(1))
// 截断无限流，长度为起始时间和结束时间的差+1个
.limit(ChronoUnit.DAYS.between(startDate, endDate) + 1)
.collect(Collectors.toList());
return localDateList;
}
/**
* 循环两个时间之间日期 <br/>
*
* @param startDate 开始时间
* @param endDate 结束时间
* @return 时间集合
* @author zhiqiang.fu
* @date 2018.04.26
*/
public static List<LocalDate> listAllDatesBetweenTwoDate(LocalDate startDate, LocalDate endDate) {
if (Objects.isNull(startDate) || Objects.isNull(endDate)) {
return new ArrayList<>(2);
}
if (startDate.isAfter(endDate)) {
return new ArrayList<>(2);
}
List<LocalDate> localDateList = Stream.iterate(startDate, localDate -> localDate.plusDays(1))
// 截断无限流，长度为起始时间和结束时间的差+1个
.limit(ChronoUnit.DAYS.between(startDate, endDate) + 1)
.collect(Collectors.toList());
return localDateList;
}
//原来service的
// ==格式到年==
/**
* 日期格式，年份，例如：2004，2008
*/
public static final String DATE_FORMAT_YYYY = "yyyy";
// ==格式到年月 ==
/**
* 日期格式，年份和月份，例如：200707，200808
*/
public static final String DATE_FORMAT_YYYYMM = "yyyyMM";
/**
* 日期格式，年份和月份，例如：200707，2008-08
*/
public static final String DATE_FORMAT_YYYY_MM = "yyyy-MM";
// ==格式到年月日==
/**
* 日期格式，年月日，例如：050630，080808
*/
public static final String DATE_FORMAT_YYMMDD = "yyMMdd";
/**
* 日期格式，年月日，用横杠分开，例如：06-12-25，08-08-08
*/
public static final String DATE_FORMAT_YY_MM_DD = "yy-MM-dd";
/**
* 日期格式，年月日，例如：20050630，20080808
*/
public static final String DATE_FORMAT_YYYYMMDD = "yyyyMMdd";
/**
* 日期格式，年月日，用横杠分开，例如：2006-12-25，2008-08-08
*/
public static final String DATE_FORMAT_YYYY_MM_DD = "yyyy-MM-dd";
/**
* 日期格式，年月日，例如：2016.10.05
*/
public static final String DATE_FORMAT_POINTYYYYMMDD = "yyyy.MM.dd";
/**
* 日期格式，年月日，例如：2016年10月05日
*/
public static final String DATE_TIME_FORMAT_YYYYMMDD = "yyyy年MM月dd日";
// ==格式到年月日 时分 ==
/**
* 日期格式，年月日时分，例如：200506301210，200808081210
*/
public static final String DATE_FORMAT_YYYYMMDDHHMM = "yyyyMMddHHmm";
/**
* 日期格式，年月日时分，例如：20001230 12:00，20080808 20:08
*/
public static final String DATE_TIME_FORMAT_YYYYMMDD_HH_MI = "yyyyMMdd HH:mm";
/**
* 日期格式，年月日时分，例如：2000-12-30 12:00，2008-08-08 20:08
*/
public static final String DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI = "yyyy-MM-dd HH:mm";
// ==格式到年月日 时分秒==
/**
* 日期格式，年月日时分秒，例如：20001230120000，20080808200808
*/
public static final String DATE_TIME_FORMAT_YYYYMMDDHHMISS = "yyyyMMddHHmmss";
/**
* 日期格式，年月日时分秒，年月日用横杠分开，时分秒用冒号分开
* 例如：2005-05-10 23：20：00，2008-08-08 20:08:08
*/
public static final String DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI_SS = "yyyy-MM-dd HH:mm:ss";
// ==格式到年月日 时分秒 毫秒==
/**
* 日期格式，年月日时分秒毫秒，例如：20001230120000123，20080808200808456
*/
public static final String DATE_TIME_FORMAT_YYYYMMDDHHMISSSSS = "yyyyMMddHHmmssSSS";
// ==特殊格式==
/**
* 日期格式，月日时分，例如：10-05 12:00
*/
public static final String DATE_FORMAT_MMDDHHMI = "MM-dd HH:mm";
/**
* 获取某日期的年份
* @param date
* @return
*/
public static Integer getYear(Date date) {
Calendar cal = Calendar.getInstance();
cal.setTime(date);
return cal.get(Calendar.YEAR);
}
/**
* 获取某日期的月份
* @param date
* @return
*/
public static Integer getMonth(Date date) {
Calendar cal = Calendar.getInstance();
cal.setTime(date);
return cal.get(Calendar.MONTH) + 1;
}
/**
* 获取某日期的日数
* @param date
* @return
*/
public static Integer getDay(Date date){
Calendar cal = Calendar.getInstance();
cal.setTime(date);
//获取日
int day=cal.get(Calendar.DATE);
return day;
}
/**
* 格式化Date时间
* @param time Date类型时间
* @param timeFromat String类型格式
* @return 格式化后的字符串
*/
public static String parseDateToStr(Date time, String timeFromat){
DateFormat dateFormat=new SimpleDateFormat(timeFromat);
return dateFormat.format(time);
}
/**
* 格式化Timestamp时间
* @param timestamp Timestamp类型时间
* @param timeFromat
* @return 格式化后的字符串
*/
public static String parseTimestampToStr(Timestamp timestamp, String timeFromat){
SimpleDateFormat df = new SimpleDateFormat(timeFromat);
return df.format(timestamp);
}
/**
* 格式化Date时间
* @param time Date类型时间
* @param timeFromat String类型格式
* @param defaultValue 默认值为当前时间Date
* @return 格式化后的字符串
*/
public static String parseDateToStr(Date time, String timeFromat, final Date defaultValue){
try{
DateFormat dateFormat=new SimpleDateFormat(timeFromat);
return dateFormat.format(time);
}catch (Exception e){
if(defaultValue!=null) {
return parseDateToStr(defaultValue, timeFromat);
}
else {
return parseDateToStr(new Date(), timeFromat);
}
}
}
/**
* 格式化Date时间
* @param time Date类型时间
* @param timeFromat String类型格式
* @param defaultValue 默认时间值String类型
* @return 格式化后的字符串
*/
public static String parseDateToStr(Date time, String timeFromat, final String defaultValue){
try{
DateFormat dateFormat=new SimpleDateFormat(timeFromat);
return dateFormat.format(time);
}catch (Exception e){
return defaultValue;
}
}
/**
* 格式化String时间
* @param time String类型时间
* @param timeFromat String类型格式
* @return 格式化后的Date日期
*/
public static Date parseStrToDate(String time, String timeFromat) {
if (time == null || "".equals(time)) {
return null;
}
Date date=null;
try{
DateFormat dateFormat=new SimpleDateFormat(timeFromat);
date=dateFormat.parse(time);
}catch(Exception e){
}
return date;
}
/**
* 格式化String时间
* @param strTime String类型时间
* @param timeFromat String类型格式
* @param defaultValue 异常时返回的默认值
* @return
*/
public static Date parseStrToDate(String strTime, String timeFromat,
Date defaultValue) {
try {
DateFormat dateFormat = new SimpleDateFormat(timeFromat);
return dateFormat.parse(strTime);
} catch (Exception e) {
return defaultValue;
}
}
/**
* 当strTime为2008-9时返回为2008-9-1 00:00格式日期时间，无法转换返回null.
* @param strTime
* @return
*/
public static Date strToDate(String strTime) {
if(strTime==null || strTime.trim().length()<=0) {
return null;
}
Date date = null;
List<String> list = new ArrayList<String>(0);
list.add(DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI_SS);
list.add(DATE_TIME_FORMAT_YYYYMMDDHHMISSSSS);
list.add(DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI);
list.add(DATE_TIME_FORMAT_YYYYMMDD_HH_MI);
list.add(DATE_TIME_FORMAT_YYYYMMDDHHMISS);
list.add(DATE_FORMAT_YYYY_MM_DD);
list.add(DATE_FORMAT_YYYYMMDD);
list.add(DATE_FORMAT_YYYY_MM);
list.add(DATE_FORMAT_YYYYMM);
list.add(DATE_FORMAT_YYYY);
for (Iterator iter = list.iterator(); iter.hasNext();) {
String format = (String) iter.next();
if(strTime.indexOf("-")>0 && format.indexOf("-")<0) {
continue;
}
if(strTime.indexOf("-")<0 && format.indexOf("-")>0) {
continue;
}
if(strTime.length()>format.length()) {
continue;
}
date = parseStrToDate(strTime, format);
if (date != null) {
break;
}
}
return date;
}
/**
* 解析两个日期之间的所有月份
* @param beginDateStr 开始日期，至少精确到yyyy-MM
* @param endDateStr 结束日期，至少精确到yyyy-MM
* @return yyyy-MM日期集合
*/
public static List<String> getMonthListOfDate(String beginDateStr, String endDateStr) {
// 指定要解析的时间格式
SimpleDateFormat f = new SimpleDateFormat("yyyy-MM");
// 返回的月份列表
String sRet = "";
// 定义一些变量
Date beginDate = null;
Date endDate = null;
GregorianCalendar beginGC = null;
GregorianCalendar endGC = null;
List<String> list = new ArrayList<String>();
try {
// 将字符串parse成日期
beginDate = f.parse(beginDateStr);
endDate = f.parse(endDateStr);
// 设置日历
beginGC = new GregorianCalendar();
beginGC.setTime(beginDate);
endGC = new GregorianCalendar();
endGC.setTime(endDate);
// 直到两个时间相同
while (beginGC.getTime().compareTo(endGC.getTime()) <= 0) {
sRet = beginGC.get(Calendar.YEAR) + "-"
+ (beginGC.get(Calendar.MONTH) + 1);
list.add(sRet);
// 以月为单位，增加时间
beginGC.add(Calendar.MONTH, 1);
}
return list;
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 解析两个日期段之间的所有日期
* @param beginDateStr 开始日期 ，至少精确到yyyy-MM-dd
* @param endDateStr 结束日期 ，至少精确到yyyy-MM-dd
* @return yyyy-MM-dd日期集合
*/
public static List<String> getDayListOfDate(String beginDateStr, String endDateStr) {
// 指定要解析的时间格式
SimpleDateFormat f = new SimpleDateFormat("yyyy-MM-dd");
// 定义一些变量
Date beginDate = null;
Date endDate = null;
Calendar beginGC = null;
Calendar endGC = null;
List<String> list = new ArrayList<String>();
try {
// 将字符串parse成日期
beginDate = f.parse(beginDateStr);
endDate = f.parse(endDateStr);
// 设置日历
beginGC = Calendar.getInstance();
beginGC.setTime(beginDate);
endGC = Calendar.getInstance();
endGC.setTime(endDate);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
// 直到两个时间相同
while (beginGC.getTime().compareTo(endGC.getTime()) <= 0) {
list.add(sdf.format(beginGC.getTime()));
// 以日为单位，增加时间
beginGC.add(Calendar.DAY_OF_MONTH, 1);
}
return list;
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 获取当下年份指定前后数量的年份集合
* @param before 当下年份前年数
* @param behind 当下年份后年数
* @return 集合
*/
public static List<Integer> getYearListOfYears(int before,int behind) {
if (before<0 || behind<0) {
return null;
}
List<Integer> list = new ArrayList<Integer>();
Calendar c = null;
c = Calendar.getInstance();
c.setTime(new Date());
int currYear = Calendar.getInstance().get(Calendar.YEAR);
int startYear = currYear - before;
int endYear = currYear + behind;
for (int i = startYear; i < endYear; i++) {
list.add(Integer.valueOf(i));
}
return list;
}
/**
* 获取当前日期是一年中第几周
* @param date
* @return
*/
public static Integer getWeekthOfYear(Date date) {
Calendar c = new GregorianCalendar();
c.setFirstDayOfWeek(Calendar.MONDAY);
c.setMinimalDaysInFirstWeek(7);
c.setTime(date);
return c.get(Calendar.WEEK_OF_YEAR);
}
/**
* 获取某一年各星期的始终时间
* 实例：getWeekList(2016)，第52周(从2016-12-26至2017-01-01)
* @param year
* @return
*/
public static HashMap<Integer,String> getWeekTimeOfYear(int year) {
HashMap<Integer,String> map = new LinkedHashMap<Integer,String>();
Calendar c = new GregorianCalendar();
c.set(year, Calendar.DECEMBER, 31, 23, 59, 59);
int count = getWeekthOfYear(c.getTime());
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
String dayOfWeekStart = "";
String dayOfWeekEnd = "";
for (int i = 1; i <= count; i++) {
dayOfWeekStart = sdf.format(getFirstDayOfWeek(year, i));
dayOfWeekEnd = sdf.format(getLastDayOfWeek(year, i));
map.put(Integer.valueOf(i), "第"+i+"周(从"+dayOfWeekStart + "至" + dayOfWeekEnd+")");
}
return map;
}
/**
* 获取某一年的总周数
* @param year
* @return
*/
public static Integer getWeekCountOfYear(int year){
Calendar c = new GregorianCalendar();
c.set(year, Calendar.DECEMBER, 31, 23, 59, 59);
int count = getWeekthOfYear(c.getTime());
return count;
}
/**
* 获取指定日期所在周的第一天
* @param date
* @return
*/
public static Date getFirstDayOfWeek(Date date) {
Calendar c = new GregorianCalendar();
c.setFirstDayOfWeek(Calendar.MONDAY);
c.setTime(date);
// Monday
c.set(Calendar.DAY_OF_WEEK, c.getFirstDayOfWeek());
return c.getTime();
}
/**
* 获取指定日期所在周的最后一天
* @param date
* @return
*/
public static Date getLastDayOfWeek(Date date) {
Calendar c = new GregorianCalendar();
c.setFirstDayOfWeek(Calendar.MONDAY);
c.setTime(date);
// Sunday
c.set(Calendar.DAY_OF_WEEK, c.getFirstDayOfWeek() + 6);
return c.getTime();
}
/**
* 获取某年某周的第一天
* @param year 目标年份
* @param week 目标周数
* @return
*/
public static Date getFirstDayOfWeek(int year, int week) {
Calendar c = new GregorianCalendar();
c.set(Calendar.YEAR, year);
c.set(Calendar.MONTH, Calendar.JANUARY);
c.set(Calendar.DATE, 1);
Calendar cal = (GregorianCalendar) c.clone();
cal.add(Calendar.DATE, week * 7);
return getFirstDayOfWeek(cal.getTime());
}
/**
* 获取某年某周的最后一天
* @param year 目标年份
* @param week 目标周数
* @return
*/
public static Date getLastDayOfWeek(int year, int week) {
Calendar c = new GregorianCalendar();
c.set(Calendar.YEAR, year);
c.set(Calendar.MONTH, Calendar.JANUARY);
c.set(Calendar.DATE, 1);
Calendar cal = (GregorianCalendar) c.clone();
cal.add(Calendar.DATE, week * 7);
return getLastDayOfWeek(cal.getTime());
}
/**
* 获取某个日期为星期几
* @param date
* @return String "星期*"
*/
public static String getDayWeekOfDate1(Date date) {
String[] weekDays = {"星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"};
Calendar cal = Calendar.getInstance();
cal.setTime(date);
int w = cal.get(Calendar.DAY_OF_WEEK) - 1;
if (w < 0) {
w = 0;
}
return weekDays[w];
}
/**
* 获得指定日期的星期几数
* @param date
* @return int
*/
public static Integer getDayWeekOfDate2(Date date){
Calendar aCalendar = Calendar.getInstance();
aCalendar.setTime(date);
int weekDay = aCalendar.get(Calendar.DAY_OF_WEEK);
return weekDay;
}
/**
* 验证字符串是否为日期
* 验证格式:YYYYMMDD、YYYY_MM_DD、YYYYMMDDHHMISS、YYYYMMDD_HH_MI、YYYY_MM_DD_HH_MI、YYYYMMDDHHMISSSSS、YYYY_MM_DD_HH_MI_SS
* @param strTime
* @return null时返回false;true为日期，false不为日期
*/
public static boolean validateIsDate(String strTime) {
if (strTime == null || strTime.trim().length() <= 0) {
return false;
}
Date date = null;
List<String> list = new ArrayList<String>(0);
list.add(DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI_SS);
list.add(DATE_TIME_FORMAT_YYYYMMDDHHMISSSSS);
list.add(DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI);
list.add(DATE_TIME_FORMAT_YYYYMMDD_HH_MI);
list.add(DATE_TIME_FORMAT_YYYYMMDDHHMISS);
list.add(DATE_FORMAT_YYYY_MM_DD);
list.add(DATE_FORMAT_YYYYMMDD);
for (Iterator iter = list.iterator(); iter.hasNext();) {
String format = (String) iter.next();
if(strTime.indexOf("-")>0 && format.indexOf("-")<0) {
continue;
}
if(strTime.indexOf("-")<0 && format.indexOf("-")>0) {
continue;
}
if(strTime.length()>format.length()) {
continue;
}
date = parseStrToDate(strTime.trim(), format);
if (date != null) {
break;
}
}
if (date != null) {
System.out.println("生成的日期:"+BaseDateUtil.parseDateToStr(date, BaseDateUtil.DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI_SS, "--null--"));
return true;
}
return false;
}
/**
* 将指定日期的时分秒格式为零
* @param date
* @return
*/
public static Date formatHhMmSsOfDate(Date date) {
Calendar cal = Calendar.getInstance();
cal.setTime(date);
cal.set(Calendar.HOUR_OF_DAY, 0);
cal.set(Calendar.MINUTE, 0);
cal.set(Calendar.SECOND, 0);
cal.set(Calendar.MILLISECOND, 0);
return cal.getTime();
}
/**
* 获得指定时间加减参数后的日期(不计算则输入0)
* @param date 指定日期
* @param year 年数，可正可负
* @param month 月数，可正可负
* @param day 天数，可正可负
* @param hour 小时数，可正可负
* @param minute 分钟数，可正可负
* @param second 秒数，可正可负
* @param millisecond 毫秒数，可正可负
* @return 计算后的日期
*/
public static Date addDate(Date date,int year,int month,int day,int hour,int minute,int second,int millisecond){
Calendar c = Calendar.getInstance();
c.setTime(date);
//加减年数
c.add(Calendar.YEAR, year);
//加减月数
c.add(Calendar.MONTH, month);
//加减天数
c.add(Calendar.DATE, day);
//加减小时数
c.add(Calendar.HOUR,hour);
//加减分钟数
c.add(Calendar.MINUTE, minute);
//加减秒
c.add(Calendar.SECOND, second);
//加减毫秒数
c.add(Calendar.MILLISECOND, millisecond);
return c.getTime();
}
/**
* 获得指定时间加减天数
* @param date 指定日期
* @param day 天数，可正可负
* @return 计算后的日期
*/
public static Date addDate(Date date,int day){
Calendar c = Calendar.getInstance();
c.setTime(date);
//加减天数
c.add(Calendar.DATE, day);
return c.getTime();
}
/**
* 获得两个日期的时间戳之差
* @param startDate
* @param endDate
* @return
*/
public static Long getDistanceTimestamp(Date startDate,Date endDate){
long daysBetween=(endDate.getTime()-startDate.getTime())/(3600*24*1000);
return daysBetween;
}
/**
* 判断二个时间是否为同年同月
* @param date1
* @param date2
* @return
*/
public static Boolean compareIsSameMonth(Date date1,Date date2){
boolean flag = false;
int year1 = getYear(date1);
int year2 = getYear(date2);
if(year1 == year2){
int month1 = getMonth(date1);
int month2 = getMonth(date2);
if(month1 == month2) {
flag = true;
}
}
return flag;
}
/**
* 获得两个时间相差距离多少天多少小时多少分多少秒
* @param one 时间参数 1 格式：1990-01-01 12:00:00
* @param two 时间参数 2 格式：2009-01-01 12:00:00
* @return long[] 返回值为：{天, 时, 分, 秒}
*/
public static long[] getDistanceTime(Date one, Date two) {
long day = 0;
long hour = 0;
long min = 0;
long sec = 0;
try {
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 (Exception e) {
e.printStackTrace();
}
long[] times = {day, hour, min, sec};
return times;
}
/**
* 两个时间相差距离多少天多少小时多少分多少秒
* @param str1 时间参数 1 格式：1990-01-01 12:00:00
* @param str2 时间参数 2 格式：2009-01-01 12:00:00
* @return String 返回值为：{天, 时, 分, 秒}
*/
public static long[] getDistanceTime(String str1, String str2) {
DateFormat df = new SimpleDateFormat(DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI_SS);
Date one;
Date two;
long day = 0;
long hour = 0;
long min = 0;
long sec = 0;
try {
one = df.parse(str1);
two = df.parse(str2);
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;
}
/**
* 两个时间之间相差距离多少天
* @param str1 时间参数 1：
* @param str2 时间参数 2：
* @return 相差天数
*/
public static Long getDistanceDays(String str1, String str2) throws Exception{
DateFormat df = new SimpleDateFormat(DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI_SS);
Date one;
Date two;
long days=0;
try {
one = df.parse(str1);
two = df.parse(str2);
long time1 = one.getTime();
long time2 = two.getTime();
long diff ;
if(time1<time2) {
diff = time2 - time1;
} else {
diff = time1 - time2;
}
days = diff / (1000 * 60 * 60 * 24);
} catch (ParseException e) {
e.printStackTrace();
}
return days;
}
/**
* 获取指定时间的那天 00:00:00.000 的时间
* @param date
* @return
*/
public static Date getDayBeginTime(final Date date) {
Calendar c = Calendar.getInstance();
c.setTime(date);
c.set(Calendar.HOUR_OF_DAY, 0);
c.set(Calendar.MINUTE, 0);
c.set(Calendar.SECOND, 0);
c.set(Calendar.MILLISECOND, 0);
return c.getTime();
}
/**
* 获取指定时间的那天 23:59:59.999 的时间
* @param date
* @return
*/
public static Date getDayEndTime(final Date date) {
Calendar c = Calendar.getInstance();
c.setTime(date);
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();
}
/**date转LocalDateTime*/
public static LocalDateTime date2LocalDateTime(Date date){
Instant instant = date.toInstant();
ZoneId zone = ZoneId.systemDefault();
LocalDateTime localDateTime = LocalDateTime.ofInstant(instant, zone);
return localDateTime;
}
/**date转LocalDate */
public static LocalDate date2LocalDate(Date date){
LocalDateTime dateTime = date2LocalDateTime(date);
return dateTime.toLocalDate();
}
/**
* 两个日期之间相差多少天
* @param startDate
* @param endDate
* @return
*/
public static long betweenDays(Date startDate,Date endDate){
return date2LocalDate(startDate).until(date2LocalDate(endDate), ChronoUnit.DAYS);
}
/**
* 计算两个日期之间相差多少分钟
* @param startDate
* @param endDate
* @return
*/
public static long betweenMinutes(Date startDate,Date endDate){
return date2LocalDateTime(startDate).until(date2LocalDateTime(endDate), ChronoUnit.MINUTES);
}
/**
* 计算两个时间相差的日时分
* @param startDate
* @param endDate
* @return
*/
public static DateTimeWrap betweenDateTime(Date startDate , Date endDate){
LocalDateTime time1 = date2LocalDateTime(startDate);
LocalDateTime time2 = date2LocalDateTime(endDate);
Duration duration = Duration.between(time1,time2);
//long m= ChronoUnit.MILLIS.between(time,time1);
DateTimeWrap dateTimeWrap = new DateTimeWrap();
long y = duration.toDays();
dateTimeWrap.setDays(y);
Duration hdur = duration.minusDays(y);
long h = hdur.toHours();
dateTimeWrap.setHours(h);
Duration mDur = hdur.minusHours(h);
long m = mDur.toMinutes();
dateTimeWrap.setMinutes(m);
return dateTimeWrap;
}
/**
* 获取日期当月第一条
* @param date
* @return
*/
public static Date getFirstDayOfMonth(Date date) {
Calendar c = Calendar.getInstance();
c.setTime(date);
c.set(Calendar.DAY_OF_MONTH,1);
return c.getTime();
}
/**
* 计算两个时间相差的小时
* @param startDate
* @param endDate
* @return
*/
public static Long hoursBetweenDate(Date startDate,Date endDate){
if (startDate==null||endDate==null){
return 0L;
}
return (endDate.getTime()-startDate.getTime())/(1000*60*60);
}
/***
* 判断两个时间是否为同一天
* @param date1
* @param date2
* @return
*/
public static boolean sameDay(Date date1, Date date2) {
ZoneId zoneId = ZoneId.systemDefault();
LocalDate localDate1 = date1.toInstant().atZone(zoneId).toLocalDate();
LocalDate localDate2 = date2.toInstant().atZone(zoneId).toLocalDate();
long days = ChronoUnit.DAYS.between(localDate1, localDate2);
return days == 0 ;
}
}
```