日期时间操作的工具类_*description: <时间工具类>-CSDN博客

本文链接：https://blog.csdn.net/qq_34410726/article/details/127814843

import com.shine.common.constant.Constant;
import org.apache.commons.lang3.StringUtils;

import java.math.BigDecimal;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.*;
import java.time.temporal.TemporalAdjusters;
import java.time.temporal.WeekFields;
import java.util.*;

/**
* Description:日期时间操作的工具类
*
*/
public class DateUtil {
/**
* 日期格式(yyyy-MM-dd)
*/
public static final String YYYY_MM_DD = "yyyy-MM-dd";
/**
* 日期格式(yyyy-MM-dd HH:mm:ss)
*/
public static final String YYYY_MM_DD_HH_MM_SS = "yyyy-MM-dd HH:mm:ss";
/**
* 日期格式(yyyy年MM月dd日)
*/
public static final String YYYY_MM_DD_CN = "yyyy年MM月dd日";

/**
* 日期格式(yyyy-MM)
*/
public static final String YYYY_MM = "yyyy-MM";
/**
* 日期格式(yyyy-MM)
*/
public static final String YYYY_MM_CN = "yyyy年MM月";

/**
* 日期格式(MM/dd)
*/
public static final String MM_DD = "MM/dd";

/**
* 日期格式(yyyyMMddHHmm)
*/
public static final String YYYY_MM_DDS = "yyyy/MM/dd";

/**
* DateFormat缓存
*/
private static Map<String, DateFormat> dateFormatMap = new HashMap<String, DateFormat>();

/**
* 获取DateFormat
*
* @param formatStr
* @return
*/
public static DateFormat getDateFormat(String formatStr) {
synchronized (dateFormatMap) {
DateFormat df = dateFormatMap.get(formatStr);
if (df == null) {
df = new SimpleDateFormat(formatStr);
dateFormatMap.put(formatStr, df);
}
return df;
}
}

public static Date getDate() {
return Calendar.getInstance().getTime();
}

public static LocalDateTime getLocalDateTime(Date date){
LocalDateTime localDateTime = null;
if(date!=null){
localDateTime = date.toInstant().atZone( ZoneId.systemDefault() ).toLocalDateTime();
}
return localDateTime;

}

/**
* 按照默认formatStr的格式，转化dateTimeStr为Date类型 dateTimeStr必须是formatStr的形式
*
* @param dateTimeStr
* @param formatStr
* @return
*/
public static Date getDate(String dateTimeStr, String formatStr) {
try {
if (dateTimeStr == null || dateTimeStr.equals("")) {
return null;
}
synchronized (dateFormatMap) {
DateFormat df = dateFormatMap.get(formatStr);
if (df == null) {
df = new SimpleDateFormat(formatStr);
dateFormatMap.put(formatStr, df);
}
return df.parse(dateTimeStr);
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}

/**
* 转化dateTimeStr为Date类型
*
* @param dateTimeStr
* @return
*/
public static Date convertDate(String dateTimeStr) {
try {
if (dateTimeStr == null || dateTimeStr.equals("")) {
return null;
}
DateFormat sdf = DateUtil.getDateFormat(YYYY_MM_DD_HH_MM_SS);
Date d = sdf.parse(dateTimeStr);
return d;
} catch (ParseException e) {
throw new RuntimeException(e);
}
}

/**
* 转化dateTimeStr为Date类型
*
* @param dateTimeStr
* @return
*/
public static Date convertDateMonth(String dateTimeStr) {
try {
if (dateTimeStr == null || dateTimeStr.equals("")) {
return null;
}
DateFormat sdf = DateUtil.getDateFormat(YYYY_MM);
Date d = sdf.parse(dateTimeStr);
return d;
} catch (ParseException e) {
throw new RuntimeException(e);
}
}

/**
* 按照默认显示日期时间的格式"yyyy-MM-dd"，转化dateTimeStr为Date类型 dateTimeStr必须是"yyyy-MM-dd"的形式
*
* @param dateTimeStr
* @return
*/
public static Date getDate(String dateTimeStr) {
return getDate(dateTimeStr, YYYY_MM_DD);
}

/**
* 将YYYYMMDD转换成Date日期
*
* @param date
* @return
* @throws Exception
*/
public static Date transferDate(String date) throws Exception {
if (date == null || date.length() < 1) {
return null;
}

if (date.length() != 8) {
throw new Exception("日期格式错误");
}
String con = "-";

String yyyy = date.substring(0, 4);
String mm = date.substring(4, 6);
String dd = date.substring(6, 8);

int month = Integer.parseInt(mm);
int day = Integer.parseInt(dd);
if (month < 1 || month > 12 || day < 1 || day > 31) {
throw new Exception("日期格式错误");
}

String str = yyyy + con + mm + con + dd;
return DateUtil.getDate(str, DateUtil.YYYY_MM_DD);
}

/**
* 将Date转换成字符串“yyyy-mm-dd”的字符串
*
* @param date
* @return
*/
public static String dateToString(Date date) {
return dateToDateString(date, YYYY_MM_DD);
}

/**
* 将Date转换成字符串“yyyy-mm-dd hh:mm:ss”的字符串
*
* @param date
* @return
*/
public static String dateToDateString(Date date) {
return dateToDateString(date, YYYY_MM_DD_HH_MM_SS);
}

/**
* 将Date转换成formatStr格式的字符串
*
* @param date
* @param formatStr
* @return
*/
public static String dateToDateString(Date date, String formatStr) {
DateFormat df = getDateFormat(formatStr);
return df.format(date);
}

/**
* 将String转换成formatStr格式的字符串
*
* @param date
* @param formatStr1
* @param formatStr2
* @return
*/
public static String stringToDateString(String date, String formatStr1, String formatStr2) {
Date d = getDate(date, formatStr1);
DateFormat df = getDateFormat(formatStr2);
return df.format(d);
}

/**
* 获取当前日期yyyy-MM-dd的形式
*
* @return
*/
public static String getCurDate() {
return dateToDateString(new Date(), YYYY_MM_DD);
}

/**
* 获取当前日期
*
* @return
*/
public static String getCurDate(String formatStr) {
return dateToDateString(new Date(), formatStr);
}

/**
* 获取当前日期yyyy年MM月dd日的形式
*
* @return
*/
public static String getCurCNDate() {
return dateToDateString(new Date(), YYYY_MM_DD);
}

/**
* 获取当前日期时间yyyy-MM-dd HH:mm:ss的形式
*
* @return
*/
public static String getCurDateTime() {
return dateToDateString(new Date(), YYYY_MM_DD_HH_MM_SS);
}

/**
* 获取当前日期时间yyyy/MM/dd HH:mm:ss的形式
*
* @return
*/
public static String getCurDateTimeOracle() {
return dateToDateString(new Date(), YYYY_MM_DD_HH_MM_SS);
}

/**
* 获取当前日期时间yyyy年MM月dd日HH时mm分ss秒的形式
*
* @return
*/
public static String getCurZhCNDateTime() {
return dateToDateString(new Date(), YYYY_MM_DD_HH_MM_SS);
}

/**
* 比较两个"yyyy-MM-dd HH:mm:ss"格式的日期，之间相差多少毫秒,time2-time1
*
* @param time1
* @param time2
* @return
*/
public static long compareDateStr(String time1, String time2) {
Date d1 = getDate(time1);
Date d2 = getDate(time2);
return d2.getTime() - d1.getTime();
}

/**
* 比较任意格式时间相差毫秒数
*
* @param time1
* @param time2
* @param format
* @return
*/
public static long compareDateStr(String time1, String time2, String format) {
Date d1 = getDate(time1, format);
Date d2 = getDate(time2, format);
return d2.getTime() - d1.getTime();
}

/**
* 比较起始时间与当前时间相差毫秒数
*
* @param time
* @param format
* @return
*/
public static long compareDateNow(String time, String format) {
Date date = getDate(time, format);
return getCurrentTimeMillis() - date.getTime();
}

/**
* 比较两个"yyyy-MM-dd HH:mm:ss"格式的日期，之间相差多少毫秒,time2-time1
*
* @param time1
* @param time2
* @return
*/
public static long compareDateStr(Date time1, Date time2) {
return time2.getTime() - time1.getTime();
}

/**
* nows时间大于date时间为true
*
* @param nows
* @param date
* @return
*/
public static boolean isTimeBefor(Date nows, Date date) {
long hous = nows.getTime() - date.getTime();
if (hous > 0) {
return true;
} else {
return false;
}
}

/**
* 将小时数换算成返回以毫秒为单位的时间
*
* @param hours
* @return
*/
public static long getMicroSec(BigDecimal hours) {
BigDecimal bd;
bd = hours.multiply(new BigDecimal(3600 * 1000));
return bd.longValue();
}

/**
* 获取当前日期years年后的一个(formatStr)的字符串
*
* @param formatStr
* @return
*/
public static String getDateStringOfYear(int years, String formatStr) {
Calendar now = Calendar.getInstance(TimeZone.getDefault());
now.setTime(new Date());
now.add(Calendar.YEAR, years);
return dateToDateString(now.getTime(), formatStr);
}

/**
* 获取当前日期mon月后的一个(formatStr)的字符串
*
* @param months
* @param formatStr
* @return
*/
public static String getDateStringOfMon(int months, String formatStr) {
Calendar now = Calendar.getInstance(TimeZone.getDefault());
now.setTime(new Date());
now.add(Calendar.MONTH, months);
return dateToDateString(now.getTime(), formatStr);
}

/**
* 获取当前日期days天后的一个(formatStr)的字符串
*
* @param days
* @param formatStr
* @return
*/
public static String getDateStringOfDay(int days, String formatStr) {
Calendar now = Calendar.getInstance(TimeZone.getDefault());
now.setTime(new Date());
now.add(Calendar.DATE, days);
return dateToDateString(now.getTime(), formatStr);
}

/**
* 获取当前日期hours小时后的一个(formatStr)的字符串
*
* @param hours
* @param formatStr
* @return
*/
public static String getDateStringOfHour(int hours, String formatStr) {
Calendar now = Calendar.getInstance(TimeZone.getDefault());
now.setTime(new Date());
now.add(Calendar.HOUR_OF_DAY, hours);
return dateToDateString(now.getTime(), formatStr);
}

/**
* 获取指定日期mon月后的一个(formatStr)的字符串
*
* @param date
* @param formatStr
* @return
*/
public static String getDateOfMon(String date, int mon, String formatStr) {
Calendar now = Calendar.getInstance(TimeZone.getDefault());
now.setTime(DateUtil.getDate(date, formatStr));
now.add(Calendar.MONTH, mon);
return dateToDateString(now.getTime(), formatStr);
}

/**
* 获取指定日期day天后的一个(formatStr)的字符串
*
* @param date
* @param formatStr
* @return
*/
public static String getDateOfDay(String date, int day, String formatStr) {
Calendar now = Calendar.getInstance(TimeZone.getDefault());
now.setTime(DateUtil.getDate(date, formatStr));
now.add(Calendar.DATE, day);
return dateToDateString(now.getTime(), formatStr);
}

public static Date getDate(Date beginDate, int ds) {
if (ds == 0) {
return new Date();
}
try {
SimpleDateFormat dft = new SimpleDateFormat("yyyy-MM-dd");
Calendar date = Calendar.getInstance();
date.setTime(beginDate);
date.set(Calendar.DATE, date.get(Calendar.DATE) - ds);
Date endDate = dft.parse(dft.format(date.getTime()));
return endDate;
} catch (ParseException e) {
e.printStackTrace();
}
return new Date();
}

public static String getAfterNDays(Date date, int n, String formateStr) {
SimpleDateFormat sdf = new SimpleDateFormat(formateStr);
Calendar calendar = new GregorianCalendar();
calendar.setTime(date);
calendar.add(Calendar.DATE, n);
return sdf.format(calendar.getTime());
}

public static Date getAfterNDays4Date(Date date, int n) {
Calendar calendar = new GregorianCalendar();
calendar.setTime(date);
calendar.add(Calendar.DATE, n);
return calendar.getTime();
}

/**
* 获取指定日期mins分钟后的一个(formatStr)的字符串
*
* @param date
* @param mins
* @param formatStr
* @return
*/
public static String getDateOfMin(String date, int mins, String formatStr) {
Calendar now = Calendar.getInstance(TimeZone.getDefault());
now.setTime(DateUtil.getDate(date, formatStr));
now.add(Calendar.SECOND, mins * 60);
return dateToDateString(now.getTime(), formatStr);
}

/**
* 获取指定日期mins分钟后的一个日期
*
* @param date
* @param mins
* @return
*/
public static Date getDateOfMin(Date date, int mins) {
Calendar now = Calendar.getInstance(TimeZone.getDefault());
now.setTime(date);
now.add(Calendar.SECOND, mins * 60);
return now.getTime();
}

/**
* 获取当前日期mins分钟后的一个(formatStr)的字符串
*
* @param mins
* @param formatStr
* @return
*/
public static String getDateStringOfMin(int mins, String formatStr) {
Calendar now = Calendar.getInstance(TimeZone.getDefault());
now.setTime(new Date());
now.add(Calendar.MINUTE, mins);
return dateToDateString(now.getTime(), formatStr);
}

/**
* 获取当前日期mins分钟后的一个日期
*
* @param mins
* @return
*/
public static Date getDateOfMin(int mins) {
Calendar now = Calendar.getInstance(TimeZone.getDefault());
now.setTime(new Date());
now.add(Calendar.MINUTE, mins);
return now.getTime();
}

/**
* 获取当前日期sec秒后的一个(formatStr)的字符串
*
* @param sec
* @param formatStr
* @return
*/
public static String getDateStringOfSec(int sec, String formatStr) {
Calendar now = Calendar.getInstance(TimeZone.getDefault());
now.setTime(new Date());
now.add(Calendar.SECOND, sec);
return dateToDateString(now.getTime(), formatStr);
}

/**
* 获得指定日期月份的天数
*
* @return
*/
public static int getMonthDay(Date date) {
Calendar c = Calendar.getInstance();
c.setTime(date);
return c.getActualMaximum(Calendar.DAY_OF_MONTH);

}

/**
* 获得系统当前月份的天数
*
* @return
*/
public static int getCurentMonthDay() {
Date date = Calendar.getInstance().getTime();
return getMonthDay(date);
}

/**
* 获得指定日期月份的天数 yyyy-mm-dd
*
* @return
*/
public static int getMonthDay(String date) {
Date strDate = getDate(date, YYYY_MM_DD);
return getMonthDay(strDate);
}

/**
* 获取19xx,20xx形式的年
*
* @param d
* @return
*/
public static int getYear(Date d) {
Calendar now = Calendar.getInstance(TimeZone.getDefault());
now.setTime(d);
return now.get(Calendar.YEAR);
}

/**
* 获取月份，1-12月
*
* @param d
* @return
*/
public static int getMonth(Date d) {
Calendar now = Calendar.getInstance(TimeZone.getDefault());
now.setTime(d);
return now.get(Calendar.MONTH) + 1;
}

/**
* 获取xxxx-xx-xx的日
*
* @param d
* @return
*/
public static int getDay(Date d) {
Calendar now = Calendar.getInstance(TimeZone.getDefault());
now.setTime(d);
return now.get(Calendar.DAY_OF_MONTH);
}

/**
* 获取Date中的小时(24小时)
*
* @param d
* @return
*/
public static int getHour(Date d) {
Calendar now = Calendar.getInstance(TimeZone.getDefault());
now.setTime(d);
return now.get(Calendar.HOUR_OF_DAY);
}

/**
* 获取Date中的分钟
*
* @param d
* @return
*/
public static int getMin(Date d) {
Calendar now = Calendar.getInstance(TimeZone.getDefault());
now.setTime(d);
return now.get(Calendar.MINUTE);
}

/**
* 获取Date中的秒
*
* @param d
* @return
*/
public static int getSecond(Date d) {
Calendar now = Calendar.getInstance(TimeZone.getDefault());
now.setTime(d);
return now.get(Calendar.SECOND);
}

/**
* 得到本周周一
*
* @return yyyy-MM-dd
*/
public static String getMondayOfThisWeek() {
Calendar c = Calendar.getInstance();
int day_of_week = c.get(Calendar.DAY_OF_WEEK) - 1;
if (day_of_week == 0) {
day_of_week = 7;
}
c.add(Calendar.DATE, -day_of_week + 1);
return dateToDateString(c.getTime(), YYYY_MM_DD);
}

/**
* 得到本周周日
*
* @return yyyy-MM-dd
*/
public static String getSundayOfThisWeek() {
Calendar c = Calendar.getInstance();
int day_of_week = c.get(Calendar.DAY_OF_WEEK) - 1;
if (day_of_week == 0) {
day_of_week = 7;
}
c.add(Calendar.DATE, -day_of_week + 7);
return dateToDateString(c.getTime());
}

/**
* 得到本周周(*)
*
* @return yyyy-MM-dd
*/
public static String getDayOfThisWeek(int num) {
Calendar c = Calendar.getInstance();
int day_of_week = c.get(Calendar.DAY_OF_WEEK) - 1;
if (day_of_week == 0) {
day_of_week = 7;
}
c.add(Calendar.DATE, -day_of_week + num);
return dateToDateString(c.getTime(), YYYY_MM_DD);
}

/**
* 得到本月指定天
*
* @return yyyy-MM-dd
*/
public static String getDayOfThisMoon(String num) {
String date = dateToDateString(new Date(), YYYY_MM);
date = date + "-" + num;
return date;
}

/**
* 获取两个日期相差的天数
*
* @param beginDate
* @param endDate
* @return
*/
public static long getQuotByDays(String beginDate, String endDate) {
long quot = 0;
DateFormat df = getDateFormat(YYYY_MM_DD);
try {
Date d1 = df.parse(beginDate);
Date d2 = df.parse(endDate);
quot = d2.getTime() - d1.getTime();
quot = quot / 1000 / 60 / 60 / 24;
} catch (ParseException e) {
throw new RuntimeException(e);
}
return quot;
}

/**
* 根据日期追加的天数，得到一个新日期
*
* @param date
* @param days
* @return
*/
public static String getDateAddDay(String date, int days, String format) {
DateFormat df = getDateFormat(format);
try {
Calendar cal = Calendar.getInstance();
cal.setTime(df.parse(date));
cal.set(Calendar.DAY_OF_YEAR, cal.get(Calendar.DAY_OF_YEAR) + days);

date = df.format(cal.getTime());
} catch (ParseException e) {
throw new RuntimeException(e);
}
return date;
}

/**
* 获取当前月的最后一天
*
* @return
*/
public static Date getLastDayOfCurrMonth() {
Calendar cal = Calendar.getInstance();
cal.add(Calendar.MONTH, 1);
cal.set(Calendar.DAY_OF_MONTH, 0);

return cal.getTime();
}

/**
* 获取指定年月的第一天
*
* @param year
* @param month
* @return
*/
public static String getFirstDayOfMonth(int year, int month) {
Calendar cal = Calendar.getInstance();
// 设置年份
cal.set(Calendar.YEAR, year);
// 设置月份
cal.set(Calendar.MONTH, month - 1);
// 获取某月最小天数
int lastDay = cal.getActualMinimum(Calendar.DAY_OF_MONTH);
// 设置日历中月份的最大天数
cal.set(Calendar.DAY_OF_MONTH, lastDay);
// 格式化日期
DateFormat df = getDateFormat(YYYY_MM_DD);
return df.format(cal.getTime());
}

/**
* 获取指定年月的第一天
*
* @param year
* @param month
* @return
*/
public static String getLastDayOfMonth(int year, int month) {
Calendar cal = Calendar.getInstance();
// 设置年份
cal.set(Calendar.YEAR, year);
// 设置月份
cal.set(Calendar.MONTH, month - 1);
// 获取某月最大天数
int lastDay = cal.getActualMaximum(Calendar.DAY_OF_MONTH);
// 设置日历中月份的最大天数
cal.set(Calendar.DAY_OF_MONTH, lastDay);
// 格式化日期
DateFormat df = getDateFormat(YYYY_MM_DD);
return df.format(cal.getTime());
}

/**
* 获取昨天日期
*
* @param date
* @return
* @throws ParseException
*/
public static String getYesterday(Date date) throws ParseException {
DateFormat df = getDateFormat(YYYY_MM_DD);
Calendar calendar = Calendar.getInstance();
calendar.setTime(df.parse(df.format(date)));
calendar.add(Calendar.DAY_OF_MONTH, -1);
return df.format(calendar.getTime());
}

/**
* 10位时间戳转时间
*
* @param dateInt
* @return
*/
public static String getIntToStr(String dateInt, String format) {
DateFormat df = getDateFormat(format);
long times = Integer.parseInt(dateInt) * 1000L;
Date date = new Date(times);
return df.format(date);
}

/**
* 获取 10位时间戳
*
* @return
*/
public static Integer getDateInt() {
return (int) (getCurrentTimeMillis() / 1000);
}

/**
* 获得系统的时间,单位为毫秒
*
* @return
*/
public static long getCurrentTimeMillis() {
return System.currentTimeMillis();
}

/**
* 13位时间戳转时间
*
* @param time
* @param format
* @return
*/
public static String getLongToStr(long time, String format) {
Date date = new Date(time);
return dateToDateString(date, format);
}

/**
* 获取两个小时间的间隔秒杀
*
* @param start
* @param end
* @return
*/
public static int getIntervalSec(int start, int end) {
return (end - start) * 60 * 60;
}

/**
* 毫秒时间戳毫秒加小数点
*
* @param time
* @return
*/
public static String getMillsStr(long time) {
String timeStr = String.valueOf(time);
String suffix = timeStr.substring(0, timeStr.length() - 3);
String prefix = timeStr.substring(timeStr.length() - 3, timeStr.length());
return suffix + "." + prefix;
}

/**
* 带小数点的毫秒时间戳转时间格式
*
* @param timeStr
* @param formatStr
* @return
*/
public static String longToString(String timeStr, String formatStr) {
long times = Long.parseLong(timeStr.replace(".", ""));
Date date = new Date(times);
return dateToDateString(date, formatStr);
}

/**
* 获取当天起始时间
*
* @return
*/
public static Long getTodayTime() {
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().getTime();
}

public static Integer getTodayInt() {
return (int) (getTodayTime() / 1000);
}

/**
* 获取当天结束时间
*
* @return
*/
public static Long getEndTime() {
Calendar todayEnd = Calendar.getInstance();
todayEnd.set(Calendar.HOUR, 23);
todayEnd.set(Calendar.MINUTE, 59);
todayEnd.set(Calendar.SECOND, 59);
todayEnd.set(Calendar.MILLISECOND, 999);
return todayEnd.getTime().getTime();
}

public static Integer getTomorrowInt() {
return (int) (getTomorrowTime() / 1000);
}

/**
* 获取第二天起始时间
*
* @return
*/
public static Long getTomorrowTime() {
Calendar cal = Calendar.getInstance();
cal.setTime(new Date());
cal.set(Calendar.HOUR_OF_DAY, 0);
cal.set(Calendar.MINUTE, 0);
cal.set(Calendar.SECOND, 0);
cal.set(Calendar.MILLISECOND, 0);
cal.add(Calendar.DAY_OF_MONTH, 1);
return cal.getTime().getTime();
}

/**
* 获取当天指定小时的时间
*
* @param hour
* @return
*/
public static Long getPointHourTime(int hour) {
Calendar todayStart = Calendar.getInstance();
todayStart.set(Calendar.HOUR_OF_DAY, hour);
todayStart.set(Calendar.MINUTE, 0);
todayStart.set(Calendar.SECOND, 0);
todayStart.set(Calendar.MILLISECOND, 0);
return todayStart.getTime().getTime();
}

/**
* 获取当天n天后的h小时
*
* @param days
* @param hour
* @return
*/
public static Long getPointDateHourTime(int days, int hour) {
Calendar todayStart = Calendar.getInstance();
todayStart.add(Calendar.DATE, days);
todayStart.set(Calendar.HOUR_OF_DAY, hour);
todayStart.set(Calendar.MINUTE, 0);
todayStart.set(Calendar.SECOND, 0);
todayStart.set(Calendar.MILLISECOND, 0);
return todayStart.getTime().getTime();
}

/**
* 时分秒转成秒数
*
* @param time
* @return
*/
public static Integer minTosec(String time) {
if (time.length() <= 5) {
time += ":00";
}
int index1 = time.indexOf(":");
int index2 = time.indexOf(":", index1 + 1);
int mi = Integer.parseInt(time.substring(0, index1));
int ss = Integer.parseInt(time.substring(index1 + 1, index2));
return mi * 60 + ss;
}

public static boolean isDate(String dateTimeStr, String formatStr) {
DateFormat df = getDateFormat(formatStr);
try {
df.parse(dateTimeStr);
return true;
} catch (Exception e) {
return false;
}
}

/**
*
* @param strDate
* @param strDateBegin
* @param strDateEnd
* @return
*/
public static boolean isInDate(String strDate, String strDateBegin, String strDateEnd) {
// 截取当前时间时分秒
int strDateH = Integer.parseInt(strDate.substring(11, 13));
int strDateM = Integer.parseInt(strDate.substring(14, 16));
int strDateS = Integer.parseInt(strDate.substring(17, 19));
// 截取开始时间时分秒
int strDateBeginH = Integer.parseInt(strDateBegin.substring(0, 2));
int strDateBeginM = Integer.parseInt(strDateBegin.substring(3, 5));
int strDateBeginS = Integer.parseInt(strDateBegin.substring(6, 8));
// 截取结束时间时分秒
int strDateEndH = Integer.parseInt(strDateEnd.substring(0, 2));
int strDateEndM = Integer.parseInt(strDateEnd.substring(3, 5));
int strDateEndS = Integer.parseInt(strDateEnd.substring(6, 8));
if ((strDateH >= strDateBeginH && strDateH <= strDateEndH)) {
// 当前时间小时数在开始时间和结束时间小时数之间
if (strDateH > strDateBeginH && strDateH < strDateEndH) {
return true;
// 当前时间小时数等于开始时间小时数，分钟数在开始和结束之间
} else if (strDateH == strDateBeginH && strDateM >= strDateBeginM && strDateM <= strDateEndM) {
return true;
// 当前时间小时数等于开始时间小时数，分钟数等于开始时间分钟数，秒数在开始和结束之间
} else if (strDateH == strDateBeginH && strDateM == strDateBeginM && strDateS >= strDateBeginS && strDateS <= strDateEndS) {
return true;
}
// 当前时间小时数大等于开始时间小时数，等于结束时间小时数，分钟数小等于结束时间分钟数
else if (strDateH >= strDateBeginH && strDateH == strDateEndH && strDateM <= strDateEndM) {
return true;
// 当前时间小时数大等于开始时间小时数，等于结束时间小时数，分钟数等于结束时间分钟数，秒数小等于结束时间秒数
} else if (strDateH >= strDateBeginH && strDateH == strDateEndH && strDateM == strDateEndM && strDateS <= strDateEndS) {
return true;
} else {
return false;
}
} else {
return false;
}
}

/**
* 判断时间是否在时间段内
*
* @param date 当前时间 yyyy-MM-dd HH:mm:ss
* @param strDateBegin 开始时间 00:00:00
* @param strDateEnd 结束时间 00:05:00
* @return
*/
public static boolean isInDate(Date date, String strDateBegin, String strDateEnd) {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String strDate = sdf.format(date);
// 截取当前时间时分秒
int strDateH = Integer.parseInt(strDate.substring(11, 13));
int strDateM = Integer.parseInt(strDate.substring(14, 16));
int strDateS = Integer.parseInt(strDate.substring(17, 19));
// 截取开始时间时分秒
int strDateBeginH = Integer.parseInt(strDateBegin.substring(0, 2));
int strDateBeginM = Integer.parseInt(strDateBegin.substring(3, 5));
int strDateBeginS = Integer.parseInt(strDateBegin.substring(6, 8));
// 截取结束时间时分秒
int strDateEndH = Integer.parseInt(strDateEnd.substring(0, 2));
int strDateEndM = Integer.parseInt(strDateEnd.substring(3, 5));
int strDateEndS = Integer.parseInt(strDateEnd.substring(6, 8));
if ((strDateH >= strDateBeginH && strDateH <= strDateEndH)) {
// 当前时间小时数在开始时间和结束时间小时数之间
if (strDateH > strDateBeginH && strDateH < strDateEndH) {
return true;
// 当前时间小时数等于开始时间小时数，分钟数在开始和结束之间
} else if (strDateH == strDateBeginH && strDateM >= strDateBeginM && strDateM <= strDateEndM) {
return true;
// 当前时间小时数等于开始时间小时数，分钟数等于开始时间分钟数，秒数在开始和结束之间
} else if (strDateH == strDateBeginH && strDateM == strDateBeginM && strDateS >= strDateBeginS && strDateS <= strDateEndS) {
return true;
}
// 当前时间小时数大等于开始时间小时数，等于结束时间小时数，分钟数小等于结束时间分钟数
else if (strDateH >= strDateBeginH && strDateH == strDateEndH && strDateM <= strDateEndM) {
return true;
// 当前时间小时数大等于开始时间小时数，等于结束时间小时数，分钟数等于结束时间分钟数，秒数小等于结束时间秒数
} else if (strDateH >= strDateBeginH && strDateH == strDateEndH && strDateM == strDateEndM && strDateS <= strDateEndS) {
return true;
} else {
return false;
}
} else {
return false;
}
}

public static boolean isInTime(int time, int begin, int end) {
if (time >= begin && time < end) {
return true;
}
return false;
}

public static int getMinutest(String begin, String format) {
String nowMinutes = DateUtil.getCurDate("HH:mm");
long time = DateUtil.compareDateStr("09:00", nowMinutes, "HH:mm");
return (int) time;
}

/**
* 取得到当前时间的整点时间段
*
* @param
* @return List<String>
*/
public static List<String> getTiemSection(int step) {
// 1分钟一次1天有24次
int Ahoursmin = 24 / step;
// 开始时间为0秒，第一次循环为900秒
int AecondValueZero = 0;
// 开始时间为-3600秒，第一次循环为0秒 ,控制步长(半个小时-1800，一个小时-3600)
int AecondValueNineHundred = -3600 * step;
// Map<String,String> map = new HashMap<String,String>();
List<String> timeList = new ArrayList<String>();
// 循环时间为00：00~23：30
for (int i = 0; i < Ahoursmin; i++) {

// 每次循环之前加60分钟控制步长(半个小时+1800，一个小时+3600)
AecondValueZero = AecondValueZero + 3600 * step;
// 每次循环之前加60分钟控制步长(半个小时+1800，一个小时+3600)
AecondValueNineHundred = AecondValueNineHundred + 3600 * step;
// 初始时间都为00：00
String ATimeInitialFront = "00:00";
String ATimeInitialAfter = "00:00";

// 判断初始秒树是否为0
if (AecondValueZero != 0) {
// 换算成小时
int AHourst = (Integer.valueOf(AecondValueZero) / 3600);
// 换算成分钟
int Aminute = (Integer.valueOf(AecondValueZero) % 3600 / 60);
// 换算成秒
// int Asecond = ((Integer.valueOf(AecondValueZero) % 3600 % 60 / 2));
// 把生成的时间转化成字符串
String hourst = String.valueOf(AHourst);
String minute = String.valueOf(Aminute);
// 如果小时的长度等于1个，在其前面加个0
if (hourst.length() == 1) {
hourst = "0" + hourst;
}
// 如果小时的到达24点让其初始化为00
if ("24".equals(hourst)) {
hourst = "00";
}
// 如果分钟的长度等于1个，在其前面加个0
if (minute.length() == 1) {
minute = "0" + minute;
}
// 拼接小时和分钟
ATimeInitialAfter = hourst + ":" + minute; // + ":" + Asecond;
}
// 循环时间为00：30~00：00
if (AecondValueNineHundred != 0) {
// 换算成小时
int AHourst = (Integer.valueOf(AecondValueNineHundred) / 3600);
// 换算成分钟
int Aminute = (Integer.valueOf(AecondValueNineHundred) % 3600 / 60);
// 换算成秒
// int Asecond = ((Integer.valueOf(AecondValueNineHundred) % 3600 % 60 / 2));
// 把生成的时间转化成字符串
String hourst = String.valueOf(AHourst);
String minute = String.valueOf(Aminute);
// 如果小时的长度等于1个，在其前面加个0
if (hourst.length() == 1) {
hourst = "0" + hourst;
}
// 如果小时的到达24点让其初始化为00
if (("24").equals(hourst)) {
hourst = "00";
}
// 如果分钟的长度等于1个，在其前面加个0
if (minute.length() == 1) {
minute = "0" + minute;
}
// 拼接小时和分钟
ATimeInitialFront = hourst + ":" + minute; // + ":" + Asecond;
}
// 将时间和所有字段放入map中初始为0
Calendar now = Calendar.getInstance();
int hour = now.get(Calendar.HOUR_OF_DAY);
// map.put("section", ATimeInitialFront+"~"+ATimeInitialAfter);
timeList.add(ATimeInitialFront + "~" + ATimeInitialAfter);
if (hour == i * step + 1) {
break;
}
}

return timeList;
}

/**
* 检查时间是否符合格式
*
* @param dateStr 时间字符串
* @param formatStr 时间格式字符串
* @return
*/
public static boolean checkStringFormat(String dateStr, String formatStr) {
if (StringUtils.isEmpty(dateStr) || StringUtils.isEmpty(formatStr)) {
return false;
}
DateFormat df = getDateFormat(formatStr);
try {
df.setLenient(false);
df.parse(dateStr);
} catch (ParseException e) {
return false;
}
return true;
}

/**
* 检查时间是否符合格式（默认yyyy-MM-dd）
*
* @param dateStr
* @return
*/
public static boolean checkStringFormat(String dateStr) {
return checkStringFormat(dateStr, YYYY_MM_DD);
}

/**
* 日期转换对应周几
*
* @param datetime 日期
* @return
*/
public static String dateToWeek(String datetime) {
SimpleDateFormat f = new SimpleDateFormat(YYYY_MM_DD);
String[] weekDays = {"星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"};
Calendar cal = Calendar.getInstance(); // 获得一个日历
Date datet = null;
try {
datet = f.parse(datetime);
} catch (java.text.ParseException e) {
e.printStackTrace();
}
cal.setTime(datet);
int w = cal.get(Calendar.DAY_OF_WEEK) - 1; // 指示一个星期中的某天。
if (w < 0) {
w = 0;
}
return weekDays[w];
}

/**
* 计算到期时间
*
* @param date
* @param step
* @return
*/
public static Date reckonDate(Date date, int step) {
return new Date(date.getTime() + (-step) * 24 * 60 * 60 * 1000L);
}

public static String getNextMonth() {
Calendar calendar = Calendar.getInstance();
calendar.setTime(new Date());
calendar.set(Calendar.DAY_OF_MONTH, 1);
calendar.add(Calendar.MONTH, 1);
return dateToDateString(calendar.getTime(), YYYY_MM);

}

public static String getThistMonth() {
Calendar calendar = Calendar.getInstance();
calendar.setTime(new Date());
calendar.set(Calendar.DAY_OF_MONTH, 1);
return dateToDateString(calendar.getTime(), YYYY_MM);
}

public static String getPrecedingMonth() {
Calendar calendar = Calendar.getInstance();
calendar.setTime(new Date());
calendar.set(Calendar.DAY_OF_MONTH, 1);
calendar.add(Calendar.MONTH, -1);
return dateToDateString(calendar.getTime(), YYYY_MM);
}

public static String getPrecedingMonthCN() {
Calendar calendar = Calendar.getInstance();
calendar.setTime(new Date());
calendar.set(Calendar.DAY_OF_MONTH, 1);
calendar.add(Calendar.MONTH, -1);
return dateToDateString(calendar.getTime(), YYYY_MM_CN);
}

public static boolean isValidDate(String str, String formatStr) {
boolean convertSuccess = true;
// 指定日期格式
SimpleDateFormat format = new SimpleDateFormat(formatStr);
try {
format.setLenient(false);
format.parse(str);
} catch (ParseException e) {
convertSuccess = false;
}
return convertSuccess;
}

public static Date getWorkingDay(String monthly, int num) {
Date date = DateUtil.getDate(monthly, DateUtil.YYYY_MM);
Calendar cal = Calendar.getInstance();
cal.setTime(date);
cal.add(Calendar.MONTH, 1);
int i = 0;
while (i < num) {
int day = cal.get(Calendar.DAY_OF_WEEK);
if (!(day == Calendar.SUNDAY || day == Calendar.SATURDAY)) {
i++;
}
cal.add(Calendar.DATE, 1);// 日期加1
}
return cal.getTime();
}

public static Date getThisMonthWorkingDay(String monthly, int num) {
Date date = DateUtil.getDate(monthly, DateUtil.YYYY_MM);
Calendar cal = Calendar.getInstance();
cal.setTime(date);
int i = 0;
while (i < num) {
int day = cal.get(Calendar.DAY_OF_WEEK);
if (!(day == Calendar.SUNDAY || day == Calendar.SATURDAY)) {
i++;
}
cal.add(Calendar.DATE, 1);// 日期加1
}
return cal.getTime();
}

/*
*功能描述每个月十号
* @param monthly
* @param num
* @return java.util.Date
*/
public static Date getNextMonthDay(String monthly, int num) {
Date date = DateUtil.getDate(monthly, DateUtil.YYYY_MM);
Calendar cal = Calendar.getInstance();
cal.setTime(date);
cal.add(Calendar.DATE, num);// 日期加10
return cal.getTime();
}

public static Date getNextMonth(String monthly) {
Date date = DateUtil.getDate(monthly, DateUtil.YYYY_MM);
Calendar cal = Calendar.getInstance();
cal.setTime(date);
cal.add(Calendar.MONTH, 1);
return cal.getTime();
}

public static Date getThistMonth4Date() {
Calendar calendar = Calendar.getInstance();
calendar.setTime(new Date());
calendar.set(Calendar.DAY_OF_MONTH, 1);
return calendar.getTime();
}

public static int differentDaysByMillisecond(Date date1, Date date2) {
return Math.abs((int) ((date2.getTime() - date1.getTime()) / (1000 * 3600 * 24)));
}

public static String convert(String time) {
try {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM");
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd");
Date date = sdf.parse(time);
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
calendar.add(Calendar.MONTH, 0);
return sdf2.format(calendar.getTime());
} catch (ParseException e) {
e.printStackTrace();
}
return "";
}

public static List<String> getpreceding12months(String monthly, int i) {
if (StringUtils.isBlank(monthly)) {
monthly = dateToDateString(new Date(), YYYY_MM);
}
Date date = DateUtil.getDate(monthly, DateUtil.YYYY_MM);
List<String> list = new ArrayList<String>();
while (i > 0) {
Calendar cal = Calendar.getInstance();
cal.setTime(date);
cal.add(Calendar.MONTH, -i + 1);
list.add(dateToDateString(cal.getTime(), YYYY_MM));
i--;
}
return list;
}

/**
* 获取上个月的时间
*
* @return
*/
public static Date getPrecedingDate() {
Calendar calendar = Calendar.getInstance();
calendar.setTime(new Date());
calendar.set(Calendar.DAY_OF_MONTH, 1);
calendar.add(Calendar.MONTH, -1);
return Calendar.getInstance().getTime();
}

/**
* 通过Calendar类正确计算两日期之间的间隔
*
* @param beginDate
* @param endDate
* @return
*/
public static int getTimeDistance(Date beginDate, Date endDate) {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
try {
beginDate = sdf.parse(sdf.format(beginDate));
endDate = sdf.parse(sdf.format(endDate));
} catch (ParseException e) {
e.printStackTrace();
}
Calendar cal = Calendar.getInstance();
cal.setTime(beginDate);
long time1 = cal.getTimeInMillis();
cal.setTime(endDate);
long time2 = cal.getTimeInMillis();
long between_days = (time2 - time1) / (1000 * 3600 * 24);
return Integer.parseInt(String.valueOf(between_days));
}

/**
* 计算两个时间差多少分钟
*
* @param beginDate
* @param endDate
* @return
*/
public static Integer getTimeMinutes(LocalDateTime beginDate, LocalDateTime endDate) {
Duration duration = Duration.between(beginDate, endDate);
long minutes = duration.toMinutes();//相差的分钟数
System.out.println(minutes);
return Integer.valueOf(String.valueOf(minutes));
}

public static List<String> getStatetime(Integer day) throws ParseException {
SimpleDateFormat mmdd = new SimpleDateFormat(MM_DD);
//SimpleDateFormat mmdd = new SimpleDateFormat(yyyy_MM_dd);
List<String> preDayList = new ArrayList<>();
for (int i = 0; i < day; i++) {
Calendar c = Calendar.getInstance();
c.add(Calendar.DATE, -i);
Date time = c.getTime();
preDayList.add(mmdd.format(time));
}
return preDayList;
}

/**
* @描述:LocalDate转换成Date
* @参数 [localDate]
* @返回值 java.util.Date
* @创建时间 2020/4/15
*/
public static Date localDate2Date(LocalDate localDate) {

if (null == localDate) {
return null;
}
ZonedDateTime zonedDateTime = localDate.atStartOfDay(ZoneId.systemDefault());
return Date.from(zonedDateTime.toInstant());
}

/**
* @描述: flag:1 返回给前端 yyyy/mm/dd 2 :后台调用返回格式 yyyy-mm-dd
* 时间计算默认获取从周日开始的本周所有日期
* @创建时间2020/4/21
*/
public static List<String> preDayList(String flag, String time) {
List<String> preDayList = new ArrayList<>();
for (int i = 0; i < 7; i++) {
Calendar c = Calendar.getInstance();
if (StringUtils.isNotEmpty(time)) {
c.setTime(DateUtil.getDate(time));
}
c.set(Calendar.DAY_OF_WEEK, 1);
c.add(Calendar.DATE, +i);
if (Constant.GENERAL_1.equals(flag)) {
SimpleDateFormat mmdd = new SimpleDateFormat(YYYY_MM_DDS);
preDayList.add(mmdd.format(c.getTime()));
} else {
Instant instant = c.getTime().toInstant();
ZoneId zoneId = ZoneId.systemDefault();
LocalDate localDate = instant.atZone(zoneId).toLocalDate();
preDayList.add(String.valueOf(localDate));
}
}
return preDayList;
}

/**
* @描述: 调用返回格式LocalDate格式 yyyy-mm-dd
* 时间计算默认获取从周日开始的本周所有日期
* @创建时间2020/4/21
*/
public static List<LocalDate> preDayLocalDateList(String time) {
List<LocalDate> preDayList = new ArrayList<>();
for (int i = 0; i < 7; i++) {
Calendar c = Calendar.getInstance();
if (StringUtils.isNotEmpty(time)) {
c.setTime(DateUtil.getDate(time));
}
c.set(Calendar.DAY_OF_WEEK, 1);
c.add(Calendar.DATE, +i);
Instant instant = c.getTime().toInstant();
ZoneId zoneId = ZoneId.systemDefault();
LocalDate localDate = instant.atZone(zoneId).toLocalDate();
preDayList.add(localDate);
}
return preDayList;
}

/**
* 得到本周周(*)
*
* @return yyyy-MM-dd
*/
public static LocalDate getDayOfThisWeekByNum(int num) {
Calendar c = Calendar.getInstance();
int day_of_week = c.get(Calendar.DAY_OF_WEEK) - 1;
if (day_of_week == 0) {
day_of_week = 7;
}
c.add(Calendar.DATE, -day_of_week + num);
Instant instant = c.getTime().toInstant();
ZoneId zoneId = ZoneId.systemDefault();
return instant.atZone(zoneId).toLocalDate();
}

/**
* @描述: 获取本周时间段范围
* @创建时间2020/4/21
*/
public static String reportDate(String time) {
Calendar c = Calendar.getInstance();
Calendar c1 = Calendar.getInstance();
if (StringUtils.isNotEmpty(time)) {
c.setTime(DateUtil.getDate(time));
c1.setTime(DateUtil.getDate(time));
}
c.set(Calendar.DAY_OF_WEEK, 1);
c.add(Calendar.DATE, +6);
c1.set(Calendar.DAY_OF_WEEK, 1);
c1.add(Calendar.DATE, +0);
SimpleDateFormat mmdd = new SimpleDateFormat(YYYY_MM_DDS);
String beginSunDay = mmdd.format(c1.getTime());
String endSaturday = mmdd.format(c.getTime());
return beginSunDay + "-" + endSaturday;
}

/**
* @描述:yyyy/MM/dd 转"yyyy-MM-dd
* @创建时间2020/4/26
*/
public static String StringToString(String time) {
SimpleDateFormat sdfx = new SimpleDateFormat("yyyy/MM/dd");
SimpleDateFormat sdfh = new SimpleDateFormat("yyyy-MM-dd");
String nowTime2 = "";
try {
nowTime2 = sdfh.format(sdfx.parse(time));
} catch (Exception e) {
e.printStackTrace();
}
return nowTime2;
}

/**
* @描述:获取本年度所有周六周日时间
* @创建时间2020/4/27
*/
public static List<LocalDate> getHolidays(Integer year) {
if (year == null) {
year = LocalDate.now().getYear();
}
List<LocalDate> localDates = new ArrayList<>();
Calendar calendar = new GregorianCalendar(year, 0, 1);
int i = 1;
while (calendar.get(Calendar.YEAR) < year + 1) {
calendar.set(Calendar.WEEK_OF_YEAR, i++);
calendar.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY);
if (calendar.get(Calendar.YEAR) == year) {
Instant instant = calendar.getTime().toInstant();
ZoneId zoneId = ZoneId.systemDefault();
localDates.add(instant.atZone(zoneId).toLocalDate());
}
calendar.set(Calendar.DAY_OF_WEEK, Calendar.SATURDAY);
if (calendar.get(Calendar.YEAR) == year) {
Instant instant = calendar.getTime().toInstant();
ZoneId zoneId = ZoneId.systemDefault();
localDates.add(instant.atZone(zoneId).toLocalDate());
}
}
return localDates;
}

/**
* @描述:根据年月日取出当前月从第一周 - 最后一周的所有时间（从本月第一个周周日开始）
* @创建时间2020/4/28
*/
public static List<LocalDate> getLocalDateByYearMonth(String time) {
// Java8 LocalDate
LocalDate date = LocalDate.parse(time);
List<LocalDate> list = new ArrayList<>();
// 该月最后一天
LocalDate lastDay = date.with(TemporalAdjusters.lastDayOfMonth());
// 该月的第一个周日
LocalDate start = date.with(TemporalAdjusters.firstInMonth(DayOfWeek.SUNDAY));
LocalDate beginFisrtDate=LocalDate.of(date.getYear(),date.getMonth(),1);
if(!start.equals(beginFisrtDate)){
for (int i=7;i>0;i--){
list.add(start.plusDays(-i));
System.out.println(start.plusDays(-i));
}
}
// 根据year年的第week周，查询本周的起止时间
Calendar calendar = Calendar.getInstance();
WeekFields weekFields = WeekFields.SUNDAY_START;
int week=lastDay.get(weekFields.weekOfWeekBasedYear());
// ①.设置该年份的开始日期：第一个月的第一天
calendar.set(lastDay.getYear(), 0, 1);
// ②.计算出第一周还剩几天：+1是因为1号是1天
int dayOfWeek = 7 - calendar.get(Calendar.DAY_OF_WEEK) + 1;
// ③.周数减去第一周再减去要得到的周
week = week - 2;
// ④.计算起止日期
calendar.add(Calendar.DAY_OF_YEAR, week * 7 + dayOfWeek);
calendar.add(Calendar.DAY_OF_YEAR, 6);
Date date1=calendar.getTime();
lastDay=date1.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
while (start.isBefore(lastDay)) {
start = start.plusWeeks(1);
}
LocalDate end = start;
LocalDate begin = date.with(TemporalAdjusters.firstInMonth(DayOfWeek.SUNDAY));
for (int i = 0; i < 40; i++) {
if (begin.isBefore(end.plusDays(-1))) {
if (i == 0) {
list.add(begin.plusDays(0));
begin = begin.plusDays(0);
} else {
list.add(begin.plusDays(1));
begin = begin.plusDays(1);
}
} else {
break;
}

}
return list;
}

/**
* @描述:根据年度和周计算当前周所在时间段
* @创建时间2020/4/28
*/
public static String getLocalDateByWeek(int year, int week) {
// 根据year年的第week周，查询本周的起止时间
SimpleDateFormat mmdd = new SimpleDateFormat(YYYY_MM_DDS);
Calendar calendar = Calendar.getInstance();
// ①.设置该年份的开始日期：第一个月的第一天
calendar.set(year, 0, 1);
// ②.计算出第一周还剩几天：+1是因为1号是1天
int dayOfWeek = 7 - calendar.get(Calendar.DAY_OF_WEEK) + 1;
// ③.周数减去第一周再减去要得到的周
week = week - 2;
// ④.计算起止日期
calendar.add(Calendar.DAY_OF_YEAR, week * 7 + dayOfWeek);
String beginSunDay = mmdd.format(calendar.getTime());
calendar.add(Calendar.DAY_OF_YEAR, 6);
String endSaturday = mmdd.format(calendar.getTime());
return beginSunDay + "-" + endSaturday;
}
}