miduo_server/gamecommon/src/main/java/util/TimeUtils.java

1412 lines
42 KiB
Java
Raw Blame History

This file contains ambiguous Unicode characters!

This file contains ambiguous Unicode characters that may be confused with others in your current locale. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to highlight these characters.

package util;
/**
* Created by admin on 2014/11/17.
*/
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.sql.Timestamp;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Locale;
import java.util.TimeZone;
import java.util.concurrent.TimeUnit;
//import com.google.common.collect.Lists;
/**
* 时间的工具类
*/
public class TimeUtils {
private static final Logger LOGGER = LoggerFactory.getLogger(TimeUtils.class);
static {
//TimeZone.setDefault(TimeZone.getTimeZone("GMT+8")); 直接使用操作系统的时区
TIME_ZONE = TimeZone.getDefault();
}
/**
* 一毫秒
*/
public static final long ONE_MILLSECOND = 1L;
/**
* 一秒的毫秒数
*/
public static final long ONE_SECOND = ONE_MILLSECOND * 1000;
/**
* 一分的毫秒数
*/
public static final long ONE_MINUTE = ONE_SECOND * 60;
/**
* 一时的毫秒数
*/
public static final long ONE_HOUR = ONE_MINUTE * 60;
/**
* 一天的毫秒数
*/
public static final long ONE_DAY = ONE_HOUR * 24;
/**
* 毫秒
*/
public static final long MILLI_SECOND = TimeUnit.MILLISECONDS.toMillis(1);
/**
* 秒
*/
public static final long SECOND = TimeUnit.SECONDS.toMillis(1);
/**
* 分
*/
public static final long MIN = TimeUnit.MINUTES.toMillis(1);
/**
* 时
*/
public static final long HOUR = TimeUnit.HOURS.toMillis(1);
/**
* 天
*/
public static final long DAY = TimeUnit.DAYS.toMillis(1);
/**
* 每分钟秒数
*/
public static final int SECONDS_MIN = (int) (MIN / SECOND);
/**
* 每小时秒数
*/
public static final int SECONDS_HOUR = (int) (HOUR / SECOND);
/**
* 每小时分钟数
*/
public static final int MIN_HOUR = (int) (HOUR / MIN);
/**
* 每天小时数
*/
public static final int HOUR_DAY = (int) (DAY / HOUR);
/**
* 一周的天数
*/
private static final int DAYOFWEEK_CARDINALITY = 7;
/**
* 周
*/
public static final long WEEK = DAYOFWEEK_CARDINALITY * DAY;
/**
* 年月日 时分秒, 格式如: 2011-01-11 01:10:59
*/
//private static final DateFormat ymdhmsFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
/**
* 年月日 时分秒, 格式如: 20110111011059
*/
private static final String ymdhmsFormat_new = "yyyyMMddHHmmss";
/**
* 年月日 时分, 格式如: 2011-01-11 01:10
*/
// private static final DateFormat ymdhmFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm");
/**
* 年月日格式如1970-07-10
*/
//private static final DateFormat ymdFormat = new SimpleDateFormat("yyyy-MM-dd");
/**
* 年月日格式如19700710
*/
private static final String ymdFormat = "yyyyMMdd";
/**
* 年月日格式如1970年07月10日
*/
// private static final DateFormat ymdChineseFormat = new SimpleDateFormat("yyyy年MM月dd日");
/**
* 小时和分钟数格式如10:20
*/
// private static final DateFormat hmFormat = new SimpleDateFormat("HH:mm");
// private static final DateFormat hmsFormat = new SimpleDateFormat("HH:mm:ss");
//private static final Calendar calendar = Calendar.getInstance();
public static final TimeZone TIME_ZONE;
public static final String Stand_CeHua_Data_format = "yyyyMMdd HHmmss";
public static void main(String[] args) {
int lastHour = getOverTimeCount(1599602400000L,1600462810000L,5);
System.out.println(lastHour);
}
/**
* 判断是否合法的时间格式(HH:mm:ss)
*
* @param dayTime
* @return
*/
public static boolean isValidDayTime(String dayTime) {
try {
String[] _timeStr = dayTime.split(":");
int _hour = Integer.parseInt(_timeStr[0]);
int _minute = Integer.parseInt(_timeStr[1]);
int _second = Integer.parseInt(_timeStr[2]);
if (_hour < 0 || _hour > 23) {
return false;
}
if (_minute < 0 || _minute > 59) {
return false;
}
if (_second < 0 || _second > 59) {
return false;
}
return true;
} catch (Exception e) {
LOGGER.error("isValidDayTime->msg={}", e.getMessage(), e);
return false;
}
}
/**
* 判断是否合法的时间格式(HH:mm)
*
* @param hhmm
* @return
*/
public static boolean isValidHhMmTime(String hhmm) {
try {
String[] _timeStr = hhmm.split(":");
int _hour = Integer.parseInt(_timeStr[0]);
int _minute = Integer.parseInt(_timeStr[1]);
if (_hour < 0 || _hour > 23) {
return false;
}
if (_minute < 0 || _minute > 59) {
return false;
}
return true;
} catch (Exception e) {
LOGGER.error("isValidHhMmTime->msg={}", e.getMessage(), e);
return false;
}
}
/**
* 根据创建时间和有效时间计算截止时间
*
* @param start 物品的创建时间
* @param validTime 物品的有效时间长度
* @param timeUnit 有效时间的单位 {@link TimeUtils#MILLI_SECOND} ~ {@link TimeUtils#DAY}
* @return 物品的截止时间
*/
public static long getDeadLine(Timestamp start, long validTime,
long timeUnit) {
return TimeUtils.getDeadLine(start.getTime(), validTime, timeUnit);
}
/**
* 根据创建时间和有效时间计算截止时间
*
* @param start 物品的创建时间
* @param validTime 物品的有效时间长度
* @param timeUnit 有效时间的单位 {@link TimeUtils#MILLI_SECOND} ~ {@link TimeUtils#DAY}
* @return 物品的截止时间
*/
public static long getDeadLine(long start, long validTime, long timeUnit) {
return start + validTime * timeUnit;
}
public static long now() {
return System.currentTimeMillis();
}
public static int nowInt(){
return (int)(now()/1000);
}
// /**
// * 获取当天零点时间
// *
// * @return
// */
// public static long getTodayBegin(TimeService timeService) {
// Calendar _calendar = Calendar.getInstance();
// _calendar.setTimeInMillis(timeService.now());
// _calendar.set(Calendar.HOUR_OF_DAY, 0);
// _calendar.set(Calendar.MINUTE, 0);
// _calendar.set(Calendar.SECOND, 0);
// _calendar.set(Calendar.MILLISECOND, 0);
// return _calendar.getTimeInMillis();
// }
/**
* 获取特定日期当天的零点时间
*
* @return
*/
public static long getBeginOfDay(long time) {
Calendar _calendar = Calendar.getInstance();
_calendar.setTimeInMillis(time);
_calendar.set(Calendar.HOUR_OF_DAY, 0);
_calendar.set(Calendar.MINUTE, 0);
_calendar.set(Calendar.SECOND, 0);
_calendar.set(Calendar.MILLISECOND, 0);
return _calendar.getTimeInMillis();
}
/**
* 获取时间戳字符串
*
* @param date
* @return
*/
public static String getUrlTimeStamp(Date date) {
DateFormat _format = new SimpleDateFormat("yyyyMMddHHmmss");
return _format.format(date);
}
/**
* 获取时间戳字符串yyyyMMDDHHmmss
*/
public static String getTimeStamp(Long time) {
return new SimpleDateFormat(ymdhmsFormat_new).format(new Date(time));
}
/**
* 获取时间戳字符串yyyyMMdd
*/
public static String getTimeStampYMD(Long time) {
return new SimpleDateFormat(ymdFormat).format(new Date(time));
}
// /**
// * 是否是同一天
// *
// * @param src
// * @param target
// * @return
// */
// public static boolean isSameDay(long src, long target) {
// int offset = TIME_ZONE.getRawOffset(); // 只考虑了时区,没考虑夏令时
// return (src + offset) / DAY == (target + offset) / DAY;
// }
/**
* 将分钟数转换为小时数和分钟数的数组 如80分钟转换为1小时20分
*
* @param mins
* @return
*/
public static int[] toTimeArray(int mins) {
int[] _result = new int[2];
_result[0] = (int) (mins * MIN / HOUR);
_result[1] = (int) (mins - _result[0] * HOUR / MIN);
return _result;
}
/**
* 解析ISO8601格式的时间
*
* @param source
* @return
* @throws ParseException
*/
public static Date getISO8601Time(String source) throws ParseException {
Calendar calendar = javax.xml.bind.DatatypeConverter.parseDateTime(source);
return calendar.getTime();
}
/**
* 返回按时间单位计算后的ms时间该时间必须足够小以致可用整型表示
*
* @param time
* @param fromTimeUnit
* @return
*/
public static long translateTime(int time, long fromTimeUnit) {
return TimeUtils.translateTime(time, fromTimeUnit, MILLI_SECOND);
}
/**
* 将指定的时间值转化为期望单位的时间值
*
* @param time
* @param fromTimeUnit
* @param toTimeUnit
* @return
*/
public static long translateTime(long time, long fromTimeUnit,
long toTimeUnit) {
long milliTime = time * fromTimeUnit / toTimeUnit;
return milliTime;
}
/**
* 设置指定时间的设置为给定的时间数(不改变的时间数可填-1)
*
* @param time
* @param year
* @param month
* @param day
* (月中的天数)
* @param hour
* @param minute
* @param second
* @return
*/
// public static long getTime(long time, int year, int month, int day,
// int hour, int minute, int second) {
// calendar.setTimeInMillis(time);
// int _unChange = -1;
// if (year != _unChange) {
// calendar.set(Calendar.YEAR, year);
// }
// if (month != _unChange) {
// calendar.set(Calendar.MONTH, month);
// }
// if (day != _unChange) {
// calendar.set(Calendar.DAY_OF_MONTH, day);
// }
// if (hour != _unChange) {
// calendar.set(Calendar.HOUR_OF_DAY, hour);
// }
// if (minute != _unChange) {
// calendar.set(Calendar.MINUTE, minute);
// }
// if (second != _unChange) {
// calendar.set(Calendar.SECOND, second);
// }
// return calendar.getTimeInMillis();
// }
/**
* 获得修正后的时间
*
* @param originTime
* @param changeYear
* @param changeMonth
* @param changeDay
* @param changeHour
* @param changeMinute
* @param changeSecond
* @return
*/
// public static long getChangeTime(long originTime, int changeYear,
// int changeMonth, int changeDay, int changeHour, int changeMinute,
// int changeSecond) {
// calendar.setTimeInMillis(originTime);
// int _unChange = 0;
// if (changeYear != _unChange) {
// calendar.add(Calendar.YEAR, changeYear);
// }
// if (changeMonth != _unChange) {
// calendar.add(Calendar.MONTH, changeMonth);
// }
// if (changeDay != _unChange) {
// calendar.add(Calendar.DAY_OF_MONTH, changeDay);
// }
// if (changeHour != _unChange) {
// calendar.add(Calendar.HOUR_OF_DAY, changeHour);
// }
// if (changeMinute != _unChange) {
// calendar.add(Calendar.MINUTE, changeMinute);
// }
// if (changeSecond != _unChange) {
// calendar.add(Calendar.SECOND, changeSecond);
// }
// return calendar.getTimeInMillis();
// }
/**
* 判断start和end是否在同一个星期内(周一为一周开始)
*
* @param start
* @param end
* @return
* @author GuoHuang
* @date 2009-02-04
*/
public static boolean isInSameWeek(long start, long end) {
Calendar st = Calendar.getInstance();
st.setTimeInMillis(start);
Calendar et = Calendar.getInstance();
et.setTimeInMillis(end);
int days = Math.abs(TimeUtils.getSoFarWentDays(st, et));
if (days < TimeUtils.DAYOFWEEK_CARDINALITY) {
// 设置Monday为一周的开始
st.setFirstDayOfWeek(Calendar.MONDAY);
et.setFirstDayOfWeek(Calendar.MONDAY);
if (st.get(Calendar.WEEK_OF_YEAR) == et.get(Calendar.WEEK_OF_YEAR)) {
return true;
}
}
return false;
}
/**
* 得到start和end相差几周
*/
public static int getDiffWeeks(long start, long end) {
Calendar st = Calendar.getInstance();
st.setTimeInMillis(start);
//设置周一为一周开始
st.setFirstDayOfWeek(Calendar.MONDAY);
st.set(Calendar.DAY_OF_WEEK,Calendar.MONDAY);
Calendar et = Calendar.getInstance();
et.setFirstDayOfWeek(Calendar.MONDAY);
et.setTimeInMillis(end);
et.set(Calendar.DAY_OF_WEEK,Calendar.MONDAY);
int days = Math.abs(TimeUtils.getSoFarWentDays(st, et));
return days/7;
}
/**
* 根据两个long 得到相隔天数
*
* @param start
* @param end
* @return
*/
public static int getSoFarWentDays(long start, long end) {
Calendar st = Calendar.getInstance();
st.setTimeInMillis(start);
Calendar et = Calendar.getInstance();
et.setTimeInMillis(end);
int days = Math.abs(TimeUtils.getSoFarWentDays(st, et));
return days;
}
/**
* 以日期中的日为实际计算单位,计算两个时间点实际日的差距 比如 12-1 23:00 和12-2 01:00相差1天而不是小于24小时就算做0天
* 如果(now - st)为正则表示now在st之后
*
* @param st
* @param now
* @return
*/
public static int getSoFarWentDays(Calendar st, Calendar now) {
int sign = st.before(now) ? 1 : -1;
if (now.before(st)) {
Calendar tmp = now;
now = st;
st = tmp;
}
int days = now.get(Calendar.DAY_OF_YEAR) - st.get(Calendar.DAY_OF_YEAR);
if (st.get(Calendar.YEAR) != now.get(Calendar.YEAR)) {
Calendar cloneSt = (Calendar) st.clone();
while (cloneSt.get(Calendar.YEAR) != now.get(Calendar.YEAR)) {
days += cloneSt.getActualMaximum(Calendar.DAY_OF_YEAR);
cloneSt.add(Calendar.YEAR, 1);
}
}
return days * sign;
}
public static int getSoFarWentHours(long time1, long time2) {
Calendar st = Calendar.getInstance();
st.setTimeInMillis(time1);
Calendar now = Calendar.getInstance();
now.setTimeInMillis(time2);
if (now.before(st)) {
Calendar tmp = now;
now = st;
st = tmp;
}
st.clear(Calendar.MILLISECOND);
st.clear(Calendar.SECOND);
st.clear(Calendar.MINUTE);
int diffHour = 0;
Calendar cloneSt = (Calendar) st.clone();
while (cloneSt.before(now)) {
cloneSt.add(Calendar.HOUR, 1);
diffHour++;
}
if (diffHour != 0) {
return diffHour - 1;
} else {
return diffHour;
}
}
public static long stringToTimeLong2(String dateStr) {
try {
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
return dateFormat.parse(dateStr).getTime();
} catch (ParseException e) {
LOGGER.error("", e);
}
return now();
}
/**
* specTime is in [st,now] or not?
*
* @param st
* @param now
* @param specTime
* @return
*/
private static boolean hasSpecTimeBetween(long st, long now, long specTime) {
if (st <= specTime && specTime <= now) {
return true;
}
return false;
}
/**
* 得到从time1 到time2 中,specTime所指定的时分秒的时刻,有几次
*
* @param time1
* @param time2
* @param specTime
* @return
*/
public static int getSpecTimeCountBetween(long time1, long time2, long specTime) {
Calendar st = Calendar.getInstance();
st.setTimeInMillis(time1);
Calendar now = Calendar.getInstance();
now.setTimeInMillis(time2);
Calendar spec = Calendar.getInstance();
spec.setTimeInMillis(specTime);
if (now.before(st)) {
Calendar tmp = now;
now = st;
st = tmp;
}
//第一个时间的年月日和被比较时间的时间部分合成
Calendar st_spec = mergeDateAndTime(st, spec);
if (isSameDay(time1, time2)) {
if (hasSpecTimeBetween(time1, time2, st_spec.getTimeInMillis())) {
return 1;
} else {
return 0;
}
}
int diffDay = 0;
Calendar cloneSt = (Calendar) st_spec.clone();
while (cloneSt.before(now)) {
cloneSt.add(Calendar.DATE, 1);
diffDay++;
}
if (st.after(st_spec)) {
diffDay--;
}
return diffDay;
}
/**
* 获取指定日期星期内的星期几的0点
*
* @param time
* @param week 0星期天 1 星期一类推
* @return
*/
public static long getWeekZero(long time, int week) {
Calendar _calendar = Calendar.getInstance();
_calendar.setTimeInMillis(time);
int w = _calendar.get(Calendar.DAY_OF_WEEK) - 1;
long addTime = (week - w) * 24L * 3600 * 1000;
_calendar.set(Calendar.HOUR_OF_DAY, 0);
_calendar.set(Calendar.MINUTE, 0);
_calendar.set(Calendar.SECOND, 0);
_calendar.set(Calendar.MILLISECOND, 0);
return _calendar.getTimeInMillis() + addTime;
}
/**
* 获取指定日期星期内的星期几的0点
*
* @param time
* @param week 0星期天 1 星期一类推
* @return
*/
public static long getWeekEnd(long time, int week) {
Calendar _calendar = Calendar.getInstance();
_calendar.setTimeInMillis(time);
int w = _calendar.get(Calendar.DAY_OF_WEEK) - 1;
long addTime = (week - w) * 24L * 3600 * 1000;
_calendar.set(Calendar.HOUR_OF_DAY, 23);
_calendar.set(Calendar.MINUTE, 59);
_calendar.set(Calendar.SECOND, 59);
_calendar.set(Calendar.MILLISECOND, 0);
return _calendar.getTimeInMillis() + addTime;
}
public static long getDayTimeWithHour(long time,int hour, int mintue) {
Calendar _calendar = Calendar.getInstance();
_calendar.setTimeInMillis(time);
_calendar.set(Calendar.HOUR_OF_DAY, hour);
_calendar.set(Calendar.MINUTE, mintue);
_calendar.set(Calendar.SECOND, 0);
_calendar.set(Calendar.MILLISECOND, 0);
return _calendar.getTimeInMillis();
}
// public static void main(String[] args) throws Exception {
// Date now = new Date();
// LOGGER.info("date:" + now);
// Date target = new Date(getLastWeekdayStartTime(now.getTime(), 6));
// LOGGER.info("last:" + target);
//
// LOGGER.info(SECOND);
// LOGGER.info(System.currentTimeMillis());
// LOGGER.info(getWeekZero(System.currentTimeMillis(), 1));
// }
/**
* 把日期和时间合并
*
* @param date 代表一个日期,方法其只取日期部分
* @param time 代表一个时间,方法其只取时间部分
* @return
*/
public static Calendar mergeDateAndTime(Calendar date, Calendar time) {
Calendar cal = Calendar.getInstance();
cal.set(date.get(Calendar.YEAR), date.get(Calendar.MONTH), date
.get(Calendar.DATE), time.get(Calendar.HOUR_OF_DAY), time
.get(Calendar.MINUTE), time.get(Calendar.SECOND));
cal.set(Calendar.MILLISECOND, 0);
return cal;
}
/**
* 获取几天后的当前时间点
*
* @param day
* @return
*/
public static Date getAfterToday(int day) {
Calendar c = Calendar.getInstance();
c.add(Calendar.DATE, day);
return c.getTime();
}
/**
* 设置几分钟之后的时间点
*
* @param minutes
* @return
*/
public static Date getAfterMinutes(int minutes) {
Calendar c = Calendar.getInstance();
c.set(Calendar.MINUTE, c.get(Calendar.MINUTE) + minutes);
return c.getTime();
}
/**
* 是否为同一个月
*
* @param src
* @param target
* @return
*/
public static boolean isSameMonth(long src, long target) {
Calendar st = Calendar.getInstance();
st.setTimeInMillis(src);
Calendar et = Calendar.getInstance();
et.setTimeInMillis(target);
return st.get(Calendar.MONTH) == et.get(Calendar.MONTH);
}
/**
* 是否为同一周
*
* @param src
* @param target
* @return
*/
public static boolean isSameWeek(long src, long target) {
Calendar st = Calendar.getInstance();
st.setTimeInMillis(src);
Calendar et = Calendar.getInstance();
et.setTimeInMillis(target);
return st.get(Calendar.WEEK_OF_YEAR) == et.get(Calendar.WEEK_OF_YEAR);
}
/**
* 是否为同一周周一算第一天
*
* @return
*/
public static boolean isSameWeWeek(long hour, long lastTime) {
lastTime = lastTime - ONE_DAY - (hour) * 3600 * 1000;
long now = now() - ONE_DAY - (hour) * 3600 * 1000;
Calendar st = Calendar.getInstance();
st.setTimeInMillis(lastTime);
Calendar et = Calendar.getInstance();
et.setTimeInMillis(now);
return st.get(Calendar.WEEK_OF_YEAR) == et.get(Calendar.WEEK_OF_YEAR);
}
/**
* 获得一天中特定时间相对0点的毫秒数
*
* @param hour
* @param min
* @param sec
* @return
*/
public static long getRelativeTimeOfDay(int hour, int min, int sec) {
return hour * HOUR + min * MIN + sec * SECOND;
}
/**
* 获得当前时间之前上一个星期几的0点时间
*
* @param now
* @param targetWeekday
* @return
*/
public static long getLastWeekdayStartTime(long now, int targetWeekday) {
Calendar calendar = Calendar.getInstance();
calendar.setTimeInMillis(now);
int dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK);
int daysDiffer = dayOfWeek - targetWeekday;
if (daysDiffer < 0) {
daysDiffer = daysDiffer + DAYOFWEEK_CARDINALITY;
}
long dayBegin = getBeginOfDay(now);
return dayBegin - daysDiffer * DAY;
}
/**
* 获得当前周星期几的0点时间
* @param now
* @param targetWeekday
* @return
*/
public static long getCurWeekdayStartTime(int targetWeekday,int hour) {
if(targetWeekday<1||targetWeekday>7){
return -1;
}
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 + targetWeekday);
c.set(Calendar.HOUR_OF_DAY,hour);
c.set(Calendar.SECOND,0);
c.set(Calendar.MINUTE,0);
return c.getTimeInMillis();
}
/**
* 获取距离现在最早的下一个周几的时间
* @param targetWeekday
* @param hour
* @return
* @throws Exception
*/
public static long getNextWeekendStartTime(int targetWeekday,int hour) {
long cur = getCurWeekdayStartTime(targetWeekday, hour);
if(cur>now()){
return cur;
}else{
return cur + WEEK;
}
}
/**
* 获取系统当前默认时区与指定时区的时间差.(单位:毫秒)
*
* @param
* @return 系统当前默认时区与指定时区的时间差.(单位:毫秒)
*/
public static double getUTCDifference() {
return TIME_ZONE.getRawOffset() * 1.0d / HOUR;
}
/**
* 判断两个日期是否同一天
*
* @param r1
* @param r2
* @return
*/
public static boolean isSameDay(long r1, long r2) {
Calendar c1 = Calendar.getInstance();
c1.setTimeInMillis(r1);
int y1 = c1.get(Calendar.YEAR);
int m1 = c1.get(Calendar.MONTH) + 1;
int d1 = c1.get(Calendar.DAY_OF_MONTH);
Calendar c2 = Calendar.getInstance();
c2.setTimeInMillis(r2);
int y2 = c2.get(Calendar.YEAR);
int m2 = c2.get(Calendar.MONTH) + 1;
int d2 = c2.get(Calendar.DAY_OF_MONTH);
return (y1 == y2) && (m1 == m2) && (d1 == d2);
}
public static boolean isSameDayWithNow(long r1) {
long r2 = now();
return isSameDay(r1, r2);
}
// 是否同一周是否过了周一早上5点
public static boolean isSameWeekWithNow(long r1) {
Calendar c1 = Calendar.getInstance();
c1.setTimeInMillis(r1 - 104400000);
int y1 = c1.get(Calendar.YEAR);
int m1 = c1.get(Calendar.MONTH) + 1;
int w1 = c1.get(Calendar.WEEK_OF_YEAR);
// int d1 = c1.get(Calendar.DAY_OF_MONTH);
Calendar c2 = Calendar.getInstance();
c2.setTimeInMillis(now() - 104400000);
int y2 = c2.get(Calendar.YEAR);
int m2 = c2.get(Calendar.MONTH) + 1;
int w2 = c2.get(Calendar.WEEK_OF_YEAR);
// int d2 = c2.get(Calendar.DAY_OF_MONTH);
return (y1 == y2) && (m1 == m2) && (w1 == w2);
}
// 是否同一月
public static boolean isSameMonthWithNow(long r1) {
Calendar c1 = Calendar.getInstance();
c1.setTimeInMillis(r1);
int y1 = c1.get(Calendar.YEAR);
int m1 = c1.get(Calendar.MONTH) + 1;
Calendar c2 = Calendar.getInstance();
c2.setTimeInMillis(now());
int y2 = c2.get(Calendar.YEAR);
int m2 = c2.get(Calendar.MONTH) + 1;
// int d2 = c2.get(Calendar.DAY_OF_MONTH);
return (y1 == y2) && (m1 == m2);
}
// 是否5点月刷新
public static boolean isSameMonthFiveWithNow(long r1) {
Calendar c1 = Calendar.getInstance();
c1.setTimeInMillis(r1-5*ONE_HOUR);
int y1 = c1.get(Calendar.YEAR);
int m1 = c1.get(Calendar.MONTH) + 1;
Calendar c2 = Calendar.getInstance();
c2.setTimeInMillis(now()-5*ONE_HOUR);
int y2 = c2.get(Calendar.YEAR);
int m2 = c2.get(Calendar.MONTH) + 1;
// int d2 = c2.get(Calendar.DAY_OF_MONTH);
return (y1 == y2) && (m1 == m2);
}
/**
* 获得当天指定时间
*/
public static long getAppointTime(int hour) {
Calendar calendar = Calendar.getInstance();
calendar.setTimeInMillis(now());
calendar.set(Calendar.HOUR_OF_DAY, hour);
calendar.set(Calendar.MINUTE, 0);
calendar.set(Calendar.SECOND, 0);
calendar.set(Calendar.MILLISECOND, 0);
return calendar.getTimeInMillis();
}
public static long getAppointTimeInXDay(long date, int hour) {
Calendar calendar = Calendar.getInstance();
calendar.setTimeInMillis(date);
calendar.set(Calendar.HOUR_OF_DAY, hour);
calendar.set(Calendar.MINUTE, 0);
calendar.set(Calendar.SECOND, 0);
calendar.set(Calendar.MILLISECOND, 0);
return calendar.getTimeInMillis();
}
/**
* 获得当天指定时间
*/
public static long getAppointTime(int hour, int minute) {
Calendar calendar = Calendar.getInstance();
calendar.setTimeInMillis(now());
calendar.set(Calendar.HOUR_OF_DAY, hour);
calendar.set(Calendar.MINUTE, minute);
calendar.set(Calendar.SECOND, 0);
return calendar.getTimeInMillis();
}
/**
* @param time 00:00:00
* @return
*/
public static long getAppointTimeWithString(String time) {
String[] times = time.split(":");
if (times.length < 3) {
return 0;
}
Calendar calendar = Calendar.getInstance();
calendar.setTimeInMillis(now());
calendar.set(Calendar.HOUR_OF_DAY, Integer.parseInt(times[0]));
calendar.set(Calendar.MINUTE, Integer.parseInt(times[1]));
calendar.set(Calendar.SECOND, Integer.parseInt(times[2]));
calendar.set(Calendar.MILLISECOND, 0);
return calendar.getTimeInMillis();
}
/**
* 现在时间是否超过当天指定时间
* hour:24
*/
public boolean isOverTime(int hour) {
return now() - getAppointTime(hour) >= (long) (hour) * 3600 * 1000;
}
public static int getMounth() {
Calendar c1 = Calendar.getInstance();
c1.setTimeInMillis(now());
return c1.get(Calendar.MONTH) + 1;
}
public static int getMounthOfDay() {
Calendar c1 = Calendar.getInstance();
c1.setTimeInMillis(now());
return c1.get(Calendar.DAY_OF_MONTH);
}
public static long getInterval(long sometime) {
return sometime - now();
}
/**
* 获得目标时间是今天的几点(整点)
*
* @param time
* @return
*/
public static int getHourOfDay(long time) {
Calendar calendar = Calendar.getInstance();
calendar.setTimeInMillis(time);
int hour = calendar.get(Calendar.HOUR_OF_DAY);
return hour;
}
/**
* date2比date1多的天数
*
* @param date1
* @param date2
* @return
*/
public static int differentDays(long date1, long date2) {
Calendar cal1 = Calendar.getInstance();
cal1.setTimeInMillis(date1);
Calendar cal2 = Calendar.getInstance();
cal2.setTimeInMillis(date2);
int day1 = cal1.get(Calendar.DAY_OF_YEAR);
int day2 = cal2.get(Calendar.DAY_OF_YEAR);
int year1 = cal1.get(Calendar.YEAR);
int year2 = cal2.get(Calendar.YEAR);
if (year1 != year2) { //不同年
int timeDistance = 0;
for (int i = year1; i < year2; i++) {
if (i % 4 == 0 && i % 100 != 0 || i % 400 == 0) { ////闰年
timeDistance += 366;
} else { //不是闰年
timeDistance += 365;
}
}
return timeDistance + (day2 - day1);
} else { //同一年
return day2 - day1;
}
}
/**
* date1是否跨过达date2过hour刷新
* @param nowTime
* @param refreshTime
* @param refreshHour
* @return
*/
public static boolean isOverAppointRefreshTime(long nowTime,long refreshTime,int refreshHour){
int days = differentDays(refreshTime,nowTime);
boolean canRefresh = false;
if(days <= 1 ){
Calendar instance = Calendar.getInstance();
instance.setTimeInMillis(nowTime);
if(instance.get(Calendar.HOUR_OF_DAY)>=refreshHour){
if(days==0){
instance.setTimeInMillis(refreshTime);
if(instance.get(Calendar.HOUR_OF_DAY)<refreshHour){
canRefresh = true;
}
}else{
canRefresh = true;
}
}
}else {
canRefresh = true;
}
return canRefresh;
}
public static int differentDaysByHour(long date1, long date2, int hour) {
Calendar cal1 = Calendar.getInstance();
cal1.setTimeInMillis(date1);
Calendar cal2 = Calendar.getInstance();
cal2.setTimeInMillis(date2);
int day1 = cal1.get(Calendar.DAY_OF_YEAR);
int day2 = cal2.get(Calendar.DAY_OF_YEAR);
int hour1 = cal1.get(Calendar.HOUR_OF_DAY);
int hour2 = cal2.get(Calendar.HOUR_OF_DAY);
int days = 0;
int year1 = cal1.get(Calendar.YEAR);
int year2 = cal2.get(Calendar.YEAR);
if (year1 != year2) { //不同年
int timeDistance = 0;
for (int i = year1; i < year2; i++) {
if (i % 4 == 0 && i % 100 != 0 || i % 400 == 0) { ////闰年
timeDistance += 366;
} else { //不是闰年
timeDistance += 365;
}
}
days = timeDistance + (day2 - day1);
} else { //同一年
days = day2 - day1;
}
if (days == 0 && hour1 < hour && hour2 >= hour) {
days++;
} else if (days > 0 && hour1 < hour && hour2 >= hour) {
days++;
} else if (days > 0 && hour1 >= hour && hour2 < hour) {
days--;
}
return days;
}
/**
* 获得当前时间是今天的几点(整点)
*
* @return
*/
public static int getHourOfDay() {
Calendar calendar = Calendar.getInstance();
calendar.setTimeInMillis(System.currentTimeMillis());
int hour = calendar.get(Calendar.HOUR_OF_DAY);
return hour;
}
/**
* 获得当前时间是今天的几点(整点)
*
* @return
*/
public static int getMiunte() {
Calendar calendar = Calendar.getInstance();
calendar.setTimeInMillis(System.currentTimeMillis());
int minute = calendar.get(Calendar.MINUTE);
return minute;
}
// /**
// * 获取的一个月的最大的天数
// *
// * @return
// */
// public int getDayOfMonth() {
// Calendar aCalendar = Calendar.getInstance(Locale.CHINA);
// int day = aCalendar.getActualMaximum(Calendar.DATE);
// return day;
// }
/**
* 获取的一个月的最大的天数
*
* @return
*/
public static long getFirstDayOfNextMonth() {
Calendar cal = Calendar.getInstance();
cal.setTimeInMillis(now());
cal.set(Calendar.MONTH, cal.get(Calendar.MONTH) + 1);
cal.set(Calendar.DAY_OF_MONTH, 1);
cal.set(Calendar.HOUR_OF_DAY, 0);
cal.set(Calendar.MINUTE, 0);
cal.set(Calendar.SECOND, 0);
cal.set(Calendar.MILLISECOND, 0);
return cal.getTimeInMillis();
}
/**
* 获取周几, 周日 0 其他正常
*
* @return
*/
public static int getDayOfWeek() {
Calendar calendar = Calendar.getInstance();
calendar.setTimeInMillis(now());
int week = calendar.get(Calendar.DAY_OF_WEEK) - 1;
return week==0?7:week;
}
/**
* 获取指定时间 周几, 周日 0 其他正常
*
* @return
*/
public static int getDayOfWeek(long time) {
Calendar calendar = Calendar.getInstance();
calendar.setTimeInMillis(time);
return calendar.get(Calendar.DAY_OF_WEEK) - 1;
}
public static boolean isOverTime(int hour, long lastTime) {
return !isSameDay(lastTime - (long) (hour) * 3600 * 1000, now() - (long) (hour) * 3600 * 1000);
}
public static boolean isOverTimeNow(int hour, long lastTime) {
return !isSameDay(lastTime - (long) (hour) * 3600, now() - (long) (hour) * 3600);
}
// 距离下周几(周日为 1 周一为 2 ... 零点时间
public static long getFirstDayOfWeek(int firstDayOfWeek) {
Calendar cal = Calendar.getInstance();
cal.setTimeInMillis(now());
cal.setFirstDayOfWeek(firstDayOfWeek);
cal.set(Calendar.DAY_OF_WEEK, firstDayOfWeek);
cal.set(Calendar.HOUR_OF_DAY, 0);
cal.set(Calendar.MINUTE, 0);
cal.set(Calendar.SECOND, 0);
cal.set(Calendar.MILLISECOND, 0);
return cal.getTimeInMillis() + 604800 * 1000;
}
/**
* 获取上(下)周周几的日期
*
* @param firstDayOfWeek {@link Calendar}
* 值范围 <code>SUNDAY</code>,
* <code>MONDAY</code>, <code>TUESDAY</code>, <code>WEDNESDAY</code>,
* <code>THURSDAY</code>, <code>FRIDAY</code>, and <code>SATURDAY</code>
* @param dayOfWeek {@link Calendar} 周日为1 周一为2 --- 周六为7
* @param weekOffset 周偏移,上周为-1本周为0下周为1以此类推
* @return
*/
public static Date getDayOfWeek(int firstDayOfWeek, int dayOfWeek, int weekOffset) {
if (dayOfWeek > Calendar.SATURDAY || dayOfWeek < Calendar.SUNDAY) {
return null;
}
if (firstDayOfWeek > Calendar.SATURDAY || firstDayOfWeek < Calendar.SUNDAY) {
return null;
}
Calendar date = Calendar.getInstance(Locale.CHINA);
date.setFirstDayOfWeek(firstDayOfWeek);
//周数减一,即上周
date.add(Calendar.WEEK_OF_MONTH, weekOffset);
//日子设为周几
date.set(Calendar.DAY_OF_WEEK, dayOfWeek);
//时分秒全部置0
date.set(Calendar.HOUR_OF_DAY, 5);
date.set(Calendar.MINUTE, 0);
date.set(Calendar.SECOND, 0);
date.set(Calendar.MILLISECOND, 0);
return date.getTime();
}
public static int getWeekOfYear(long time) {
Calendar calendar = Calendar.getInstance();
calendar.setFirstDayOfWeek(Calendar.MONDAY);
calendar.setTimeInMillis(time);
return calendar.get(Calendar.WEEK_OF_YEAR);
}
/**
* 返回上个月某天某时
*
* @param year 0为当前年
* @param month
* @param dayOfMonth
* @param timeInDay 00:00:00
* @return
*/
public static long getDayOfMonthTime(int year, int month, int dayOfMonth, String timeInDay) {
String[] times = timeInDay.split(":");
if (times.length < 3) {
return 0;
}
Calendar cal = Calendar.getInstance();
cal.setTimeInMillis(now());
cal.set(Calendar.YEAR, cal.get(Calendar.YEAR) + year);
cal.set(Calendar.MONTH, month);
cal.set(Calendar.DAY_OF_MONTH, dayOfMonth);
cal.set(Calendar.HOUR_OF_DAY, Integer.parseInt(times[0]));
cal.set(Calendar.MINUTE, Integer.parseInt(times[1]));
cal.set(Calendar.SECOND, Integer.parseInt(times[2]));
cal.set(Calendar.MILLISECOND, 0);
return cal.getTimeInMillis();
}
public static void sleep(long millis) {
try {
Thread.sleep(millis);
} catch (Exception e) {
LOGGER.error("sleep->msg=null", e.getMessage(), e);
}
}
public static long parseTimeToMiles(String date, String datePattern) throws ParseException {
SimpleDateFormat simpleDateFormat = new SimpleDateFormat(datePattern);
return simpleDateFormat.parse(date).getTime();
}
public static long stringToTimeLong(String dateStr,String pattern) {
try {
SimpleDateFormat dateFormat = new SimpleDateFormat(pattern);
return dateFormat.parse(dateStr).getTime();
} catch (ParseException e) {
LOGGER.error("", e);
}
return now();
}
public static long differMintFromLast(Object object){
try {
String time;
if(null!=object){
try {
time = String.valueOf(object);
}catch (Exception e1){
return 1;
}
}else {
return 1;
}
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
return (simpleDateFormat.parse(time).getTime()-now())/(60*1000);
} catch (ParseException e) {
LOGGER.error("", e);
}
return 1;
}
/**
* 判断两个时间是否隔开周几的几点
* @param lastTime
* @param curTime
* @param dayOfWeek
* @param hourOfDay
* @return
*/
public static boolean isSpanTime(long lastTime,long curTime,int dayOfWeek,int hourOfDay){
long curWeekdayStartTime = getCurWeekdayStartTime(dayOfWeek, hourOfDay);
if(lastTime>=curWeekdayStartTime){
return false;
}
if(curTime>=curWeekdayStartTime){
return true;
}else{
curWeekdayStartTime=curWeekdayStartTime-WEEK;
if(lastTime<curWeekdayStartTime){
return true;
}else{
return false;
}
}
}
/**
*获取传入时间的上个几时几分或下个几时几分
* @param hour
* @param lastOrUnder true为上个false为下个
* @return
*/
public static long getLastOrUnderHour(long time,int hour,int minute,boolean lastOrUnder){
Calendar cal = Calendar.getInstance();
cal.setTimeInMillis(time);
int i = cal.get(Calendar.HOUR_OF_DAY);
cal.set(Calendar.HOUR_OF_DAY,hour);
cal.set(Calendar.MINUTE,minute);
cal.set(Calendar.SECOND,0);
cal.set(Calendar.MILLISECOND,0);
long result = cal.getTimeInMillis();
if(i<hour){
result = result -TimeUtils.DAY;
}
if(!lastOrUnder){
result = result + TimeUtils.DAY;
}
return result;
}
/**
* 返回Integer最大值-now()之后变成小于一的小数;
* @return
*/
public static double getDoubleTime(){
return (Integer.MAX_VALUE-now()/1000)/Math.pow(10,9);
}
/**
* 返回两个事件中间过了几个hour时
* @param time1
* @param time2
* @param hour
* @return
*/
public static int getOverTimeCount(long time1,long time2,int hour){
long last = getLastOrUnderHour(time1, hour, 0, true);
long under = getLastOrUnderHour(time2, hour, 0, true);
if(last>under){
return 0;
}
if(last==under){
return 0;
}
return (int) Math.floor((under-last)/(HOUR*24D));
}
}