public class DateUtil {
public static String parseStr(String str) {
String sDate = "";
SimpleDateFormat sdf1 = new SimpleDateFormat ("EEE MMM dd HH:mm:ss Z yyyy", Locale.UK);
try {
Date date = sdf1.parse (str);
SimpleDateFormat sdf = new SimpleDateFormat ("yyyy-MM-dd HH:mm:ss");
sDate = sdf.format (date);
////System.out.println(sDate);
} catch (Exception e) {
e.printStackTrace ( );
}
return sDate;
}
/**
* 将长时间格式时间转换为字符串 yyyy-MM-dd HH:mm:ss
*
* @param dateDate
* @return
*/
public static String dateToStrLong(java.util.Date dateDate) {
SimpleDateFormat formatter = new SimpleDateFormat ("yyyy-MM-dd HH:mm:ss");
String dateString = formatter.format (dateDate);
return dateString;
}
/**
* 将Date类型转换为字符串
*
* @param date 日期类型
* @return 日期字符串
*/
public static String format(Date date) {
if (date == null) {
return "";
}
return format (date, "yyyy-MM-dd HH:mm:ss");
}
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 字符串格式
* @return 日期字符串
*/
public static String format(Date date, String pattern) {
if (date == null) {
return "null";
}
if (pattern == null || pattern.equals ("") || pattern.equals ("null")) {
pattern = "yyyy-MM-dd HH:mm:ss";
}
return new SimpleDateFormat (pattern).format (date);
}
/**
* 将字符串转换为Date类型
*
* @param date 字符串类型
* @return 日期类型
*/
public static Date format(String date) {
return format (date, null);
}
/**
* 将字符串转换为Date类型
* @param date 字符串类型
* @param pattern 格式
* @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) {
}
return d;
}
public static String getCurrDate() {
return format (new Date ( ), "yyyy-MM-dd HH:mm:ss");
}
/**
* 格局传入的日期 解析出 该用何种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");
////System.out.println("用的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);
// //System.out.println("用的yyyy年MM月dd日");
} 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;
}
/**
* 格局传入的日期 解析出 该用何种SimpleDateFormat
*
* @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) {
}
return null;
}
/**
* 获取时间日期
*
* @param milliSeconds
* @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 ( );
}
/**
* 取得当前日期所在周的第一天
*
* @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 ( );
}
/**
* 取得当前日期所在周的最后一天
*
* @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 ( );
}
/**
* 取得指定日期的当周的起始时间
*
* @param date
* @return
*/
public static Date[] getWeekLimit(Date date) throws Exception {
Date date1 = getFirstDayOfWeek (date);
Date date2 = getLastDayOfWeek (date);
return new Date[]{date1, date2};
}
/**
* 取得指定日期的当月起始时间
*
* @param date
* @return
*/
public static Date[] getMonthLimit(Date date) throws Exception {
Calendar cal = clearDate (date, 5);
cal.set (Calendar.DATE, 1);
Date date1 = cal.getTime ( );
cal.add (Calendar.MONTH, 1);
cal.add (Calendar.SECOND, -1);
Date date2 = cal.getTime ( );
return new Date[]{date1, date2};
}
/**
* 取得指定日期的当年起始时间
*
* @param date
* @return
*/
public static Date[] getYearLimit(Date date) throws Exception {
Calendar cal = clearDate (date, 6);
cal.set (Calendar.MONTH, 0);
cal.set (Calendar.DATE, 1);
Date date1 = cal.getTime ( );
cal.add (Calendar.YEAR, 1);
cal.add (Calendar.SECOND, -1);
Date date2 = cal.getTime ( );
return new Date[]{date1, date2};
}
/**
* 取得指定日期当月的起始时间串
*
* @param date
* @return
*/
public static String[] getMonthLimitStr(Date date) throws Exception {
Date[] rtDateArray = getMonthLimit (date);
return new String[]{getDateTimeStr (rtDateArray[0]), getDateTimeStr (rtDateArray[1])};
}
/**
* 取得指定日期当年的起始时间串
*
* @param date
* @return
*/
public static String[] getYearLimitStr(Date date) throws Exception {
Date[] rtDateArray = getYearLimit (date);
return new String[]{getDateTimeStr (rtDateArray[0]), getDateTimeStr (rtDateArray[1])};
}
/**
* 取得后一天的时间字
*
* @param dateStr
* @return
*/
public static Date getDayAfter(String dateStr, int dayCnt) throws Exception {
return getDayAfter (parseDate (dateStr), dayCnt);
}
/**
* 取得后一天的时间
*
* @param date
* @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
* @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
* @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
* @param monthCnt
* @return
*/
public static Date getMonthbeteen(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 ( );
}
/**
* 取得后N天的时间的所有日期list
*
* @param date
* @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;
}
/**
* 取得指定天数差的时间
*
* @param dateStr
* @return
*/
public static Date getDayDiff(String dateStr, int dayCnt) throws Exception {
return getDayDiff (parseDate (dateStr), dayCnt);
}
/**
* 取得指定天数差的时间
*
* @param date
* @return
*/
public static Date getDayDiff(Date date, int dayCnt) {
GregorianCalendar cal = new GregorianCalendar ( );
cal.setTime (date);
cal.add (Calendar.DATE, dayCnt);
return cal.getTime ( );
}
/**
* 取得前今天0: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();
}
/**
* 取得前今天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();
}
/**
* 取得昨天的开始时间
* @param date
* @return
*/
public static Date getStatusYestday(Date date) {
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;
}
/**
* 取得昨天的结束时间
* @param date
* @return
*/
public static Date getEndYestday(Date date) {
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, -1);
tempEnd.set(Calendar.HOUR_OF_DAY, 23);// 小时
tempEnd.set(Calendar.MINUTE, 59);// 分
tempEnd.set(Calendar.SECOND, 59);// 秒
tempEnd.set(Calendar.MILLISECOND, 0);// 秒
Date time = tempEnd.getTime();
return time;
}
/**
* 取得前7天开始时间
* @param date
* @return
*/
public static Date getStatus7Days(Date date) {
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;
}
/**
* 取得前7天结束时间
* @param date
* @return
*/
public static Date getEnd7Days(Date date) {
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);
tempEnd.set(Calendar.HOUR_OF_DAY, 138);// 小时
tempEnd.set(Calendar.MINUTE, 354);// 分
tempEnd.set(Calendar.SECOND, 359);// 秒
tempEnd.set(Calendar.MILLISECOND, 0);//毫秒
Date time = tempEnd.getTime();
return time;
}
/**
* 取得前30天的开始时间
* @param date
* @return
*/
public static Date getStatus30Days(Date date) {
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;
}
/**
* 东8区时间
* @param date
* @return
*/
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) {
LogMgr.error(" error :" + JSON.toJSONString(e));
}
return new Date();
}
/**
* 取得前一天的时间字符串
*
* @param dateStr
* @return
*/
public static String getYestdayStr(String dateStr) throws Exception {
return getYestdayStr (parseDate (dateStr));
}
/**
* 取得前一天的时间字符串
*
* @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 ( ));
}
/**
* Date清零
*
* @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, 0);
}
//月份
if (clearNum > 5) {
cal.set (Calendar.MONTH, 0);
}
return cal;
}
/**
* 把字符串转化为Date
*
* @param dateStr
* @return
*/
public static Date parseDate(String formatStr, String dateStr) throws ParseException {
SimpleDateFormat format = new SimpleDateFormat (formatStr);
return format.parse (dateStr);
}
public static Calendar parseCalendar(String formatStr, String dateStr) {
Calendar c = Calendar.getInstance ( );
try {
c.setTime (parseDate (formatStr, dateStr));
} catch (Exception e) {
// TODO Auto-generated catch block
// e.printStackTrace();
return null;
}
return c;
}
public static Calendar parseCalendar(String dateStr) {
Calendar c = Calendar.getInstance ( );
try {
c.setTime (parseDateByPattern (dateStr));
} catch (Exception e) {
// TODO Auto-generated catch block
// e.printStackTrace();
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;
}
/**
* 取得的时间串，格式为 yyyy-MM-dd HH:mm:ss
*
* @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
* @return计算一年的最大周
* @author syl
* @date 2014-1-11
*/
public static int getMaxWeekOfYear(int year) {
Calendar c = new GregorianCalendar ( );
c.set (year, Calendar.DECEMBER, 31, 23, 59, 59);
return getWeekOfYear (c.getTime ( ));
}
/**
* 获取日期当前周
*
* @param date
* @return
*/
public static int getWeekOfYear(Date date) {
Calendar c = new GregorianCalendar ( );
c.setFirstDayOfWeek (Calendar.MONDAY);
c.setMinimalDaysInFirstWeek (7);
c.setTime (date);
return c.get (Calendar.WEEK_OF_YEAR);
}
/**
* 参数说明 返回一个Calendar数组，长度为2
* 分别是开始日期和结束日期
*
* @param year 年分 例如 2014 i
* @param weeknum 第几周 例如33
* @return
* @date 2014-1-11
*/
public static Calendar[] getStartAndEndDate(int year, int weeknum) {
Calendar cal = Calendar.getInstance ( );
cal.set (Calendar.YEAR, year);
cal.set (Calendar.WEEK_OF_YEAR, weeknum);
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;
}
/**
* 获取当期日期的一周 开始可结束日期 返回一个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;
}
/**
* 获取当期日期的一周 开始至结束日期 返回一个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;
}
/**
* 获取当期日期的一周 开始至结束日期 返回一个Calendar数组，长度为
* @return
* @date 2014-1-11
*/
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;
}
/**
* 算出俩个时间，所间隔的多少天
* @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);
}
/**
* 两个时间相差距离多少天多少小时多少分多少秒
*
* @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;
}
/**
* 根据指定的月字符串算出月初和月未的时间，精确到秒
*
* @param monthStr
* @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));
Date endTime = new Date (cal.getTime ( ).getTime ( ) + 24 * 60 * 60 * 1000l - 1l);
return new Date[]{startTime, endTime};
}
/**
* 上月
* 根据指定的月字符串算出月初和月未的时间，精确到秒
*
* @param monthStr
* @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};
}
/**
* 根据指定的天字符串算出天开始和天结束的时间，精确到秒
*
* @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)};
}
/**
* 前一天
* 根据指定的天字符串算出天开始和天结束的时间，精确到秒
*
* @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;
}
/**
* 根据指定的季度 算出季度初和季度未的时间，精确到秒
*
* @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;
}
/**
* 上一季度
* 根据指定的季度 算出季度初和季度未的时间，精确到秒
*
* @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] = c.getTime ( );
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;
}
/**
* 去年
* 根据指定的年算出年初和年未的时间，精确到秒
*
* @param year 年份
* @return
*/
public static Date[] getDatetimePreYearLimit(int year) {
return getDatetimeYearLimit (year - 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 getDatePoor(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 + "小时";
}
/**
* 计算俩个时间差多少天多少小时分钟
*
* @param endDate
* @param nowDate
* @return
*/
public static String getDatePoor2(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;
}
/**
* 计算俩个时间差多少分钟
*
* @param endDate
* @param nowDate
* @return
*/
public static long getDatePoor3(Date nowDate, Date endDate) {
long nm = 1000 * 60l;
// long ns = 1000;
// 获得两个时间的毫秒时间差异
long diff = endDate.getTime ( ) - nowDate.getTime ( );
Long tempLong = diff / nm;
return tempLong;
}
public static String getTimes(String date) throws ParseException {
String uu = "上午";
if (Integer.valueOf (date.substring (0, 2)) > 12) {
uu = "下午";
}
DateFormat dateFormat = new SimpleDateFormat ("hh:mm:ss");
Date dates = null;
dates = dateFormat.parse (date);
date = dateFormat.format (dates);
return uu + (date.substring (0, 5));
}
/**
* 当前季度的开始时间
*
* @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, 1);
else if (currentMonth >= 4 && currentMonth <= 6)
c.set (Calendar.MONTH, 3);
else if (currentMonth >= 7 && currentMonth <= 9)
c.set (Calendar.MONTH, 4);
else if (currentMonth >= 10 && currentMonth <= 12)
c.set (Calendar.MONTH, 9);
c.set (Calendar.DATE, 1);
} catch (Exception e) {
e.printStackTrace ( );
}
return c.getTime ( );
}
/**
* 当前季度的结束时间
*
* @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 ( );
}
return c.getTime ( );
}
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];
}
/**
* 获取两个日期相隔天数 去掉时分秒，直接比对日
*
* @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));
}
public static String getStrTime(String cc_time) {
BigDecimal bigDecimal = new BigDecimal (cc_time);
System.out.print (" bigDecimal.longValue()" + bigDecimal.longValue ( ));
String re_StrTime = null;
SimpleDateFormat sdf = new SimpleDateFormat ("HH时mm分");
long lcc_time = Long.valueOf (bigDecimal.longValue ( ));
re_StrTime = sdf.format (new Date (lcc_time * 1000L));
return re_StrTime;
}
public static int getMonth(Date date) {
Calendar cal = Calendar.getInstance ( );
cal.setTime (date);
return cal.get (Calendar.MONTH) + 1;
}
public static int getYear(Date date) {
Calendar now = Calendar.getInstance ( );
now.setTime (date);
return now.get (Calendar.YEAR);
}
public static Date getBeaferTime(Date date) {
GregorianCalendar cal = new GregorianCalendar ( );
cal.setTime (date);
cal.add (Calendar.DATE, -1);
return cal.getTime ( );
}
/*
获取当前时间之前或之后几分钟 minute
*/
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 ( ));
}
/**
* 接收日期格式字符转化为中文+日期格式
* 刚刚（5分钟前）
* 规则：①如果开课时间为当天的日期，显示“今天+时+分”
* <p>
* ②如果开课时间为昨天的日期，显示“昨天+时+分”
* ③如果开课时间为前天的日期，显示“前天+时+分”
* ④如果开课时间为明天的日期，显示“明天+时+分”
* ⑤如果开课时间为后天的日期，显示“后天+时+分”
* ⑥如果开课时间超出后天，并且还在当前周内，显示“本周X+时+分”
* ⑦其余日期均显示“月-日 时：分”
* ⑧如果开课时间不是当前年，显示“年-月-日 时：分”
*
* @param date
* @return
*/
public static String transFormationStringDate2(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 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
* @return
*/
public static int getYMDDate(Date date, String format) {
SimpleDateFormat sdf = null;
try {
if (StringUtils.isEmpty (format)) {
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;
}
}
/**
* 接受开播时间与结束时间 返回播放状态（）
*
* @param startTime
* @param endTime
* @return
*/
public static String getStatusStr(String startTime, String endTime) {
if (!StringUtils.isEmpty (endTime)) {
return "0";
}
Date date = new Date ( );
if (StringUtils.isEmpty (startTime)) {
long time = format (startTime).getTime ( );
if (time > date.getTime ( )) {
return "1";
} else {
return "2";
}
}
return "";
}
public static void main(String[] args) {
String date = "2018-01-12 12:07:06";
int yyyy = Integer.parseInt (date.substring (0, 4));
int mm = Integer.parseInt (date.substring (5, 7));
int dd = Integer.parseInt (date.substring (8, 10));
int hh = Integer.parseInt (date.substring (11, 13));
int MM = Integer.parseInt (date.substring (14, 16));
int ss = Integer.parseInt (date.substring (17, 19));
//System.out.println (yyyy);
//System.out.println (mm);
//System.out.println (dd);
//System.out.println (hh);
//System.out.println (MM);
//System.out.println (ss);
}
/**
* @describe: 获取当天的0点0分0秒的日期和23点59分59秒的日期
* @returnType Date
* @createTime 2018年4月28日下午6:21:28
*/
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();
}
}
