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

1742 lines
52 KiB
Java
Raw Normal View History

package util;
2019-01-09 13:58:05 +08:00
/**
* 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;
2021-07-16 17:07:17 +08:00
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
2019-01-09 13:58:05 +08:00
//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
*/
public static final String ymdhmsFormat_new = "yyyyMMddHHmmss";
2019-01-09 13:58:05 +08:00
/**
* , : 2011-01-11 01:10
*/
// private static final DateFormat ymdhmFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm");
/**
* 1970-07-10
*/
2021-07-16 17:07:17 +08:00
//private static final DateFormat ymdFormatN= new SimpleDateFormat("yyyy-MM-dd");
private static final String ymdFormatN = "yyyy-MM-dd";
2019-08-21 14:52:08 +08:00
/**
* 19700710
*/
public static final String ymdFormat = "yyyyMMdd";
2019-01-09 13:58:05 +08:00
/**
* 19700710
*/
// 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;
2021-07-23 13:55:12 +08:00
private static final String ymdhms_Format_new = "yyyy-MM-dd HH:mm:ss";
2019-05-13 16:10:41 +08:00
public static final String Stand_CeHua_Data_format = "yyyyMMdd HHmmss";
2019-11-29 11:19:48 +08:00
public static void main(String[] args) {
2020-03-25 05:01:03 +08:00
2021-07-12 11:31:21 +08:00
long lastOrUnderHour = TimeUtils.getLastOrUnderHour(TimeUtils.now(), 1, 0, 0, true);
lastOrUnderHour+=(2*TimeUtils.WEEK);
2020-03-25 05:01:03 +08:00
2020-12-01 10:55:37 +08:00
System.out.println(lastOrUnderHour);
2019-11-29 11:19:48 +08:00
}
2019-01-09 13:58:05 +08:00
/**
* (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;
}
2019-01-23 18:40:11 +08:00
public static long now() {
2019-01-09 13:58:05 +08:00
return System.currentTimeMillis();
}
2020-01-14 13:41:22 +08:00
public static int nowInt(){
return (int)(now()/1000);
}
2019-01-09 13:58:05 +08:00
// /**
// * 获取当天零点时间
// *
// * @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);
}
2019-08-17 14:16:52 +08:00
/**
* yyyyMMDDHHmmss
*/
public static String getTimeStamp(Long time) {
2020-09-01 10:45:16 +08:00
return new SimpleDateFormat(ymdhmsFormat_new).format(new Date(time));
2019-08-17 14:16:52 +08:00
}
2019-08-21 14:52:08 +08:00
/**
* yyyyMMdd
*/
public static String getTimeStampYMD(Long time) {
2020-09-01 10:45:16 +08:00
return new SimpleDateFormat(ymdFormat).format(new Date(time));
2019-08-21 14:52:08 +08:00
}
2019-08-17 14:16:52 +08:00
2021-07-23 13:55:12 +08:00
/**
* yyyy-MM-dd HH:mm:ss
*/
public static String getTimeStamp2(Long time) {
return new SimpleDateFormat(ymdhms_Format_new).format(new Date(time));
}
2019-08-17 14:16:52 +08:00
2021-10-14 11:12:23 +08:00
public static Date dateFormat(String time) throws ParseException {
DateFormat format1 = new SimpleDateFormat(ymdhms_Format_new);
return format1.parse(time);
}
2019-01-09 13:58:05 +08:00
// /**
// * 是否是同一天
// *
// * @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;
// }
/**
* 80120
*
* @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();
// }
/**
* startend()
*
* @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;
}
/**
* startend
*/
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:001240
* (now - st)nowst
*
* @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;
}
}
2020-08-13 19:26:18 +08:00
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();
}
2019-01-09 13:58:05 +08:00
/**
* 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;
}
2020-10-25 17:00:00 +08:00
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();
}
2019-01-09 13:58:05 +08:00
// 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();
}
/**
2021-10-14 11:12:23 +08:00
*
* @return
*/
public static long getTomorrowZero() {
Calendar c = Calendar.getInstance();
c.add(Calendar.DATE, 1);
c.set(Calendar.HOUR_OF_DAY, 0);
c.set(Calendar.MINUTE, 0);
c.set(Calendar.SECOND, 0);
return c.getTimeInMillis();
}
/**
2021-10-14 11:12:23 +08:00
*
* @return
*/
public static long getTomorrowZero2() {
Calendar c = Calendar.getInstance();
c.set(Calendar.HOUR_OF_DAY, 23);
c.set(Calendar.MINUTE, 59);
c.set(Calendar.SECOND, 30);
return c.getTimeInMillis();
}
2019-01-09 13:58:05 +08:00
/**
*
*
* @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);
2021-11-01 13:18:29 +08:00
return (st.get(Calendar.YEAR) ==et.get(Calendar.YEAR)) && (st.get(Calendar.WEEK_OF_YEAR) == et.get(Calendar.WEEK_OF_YEAR));
2019-01-09 13:58:05 +08:00
}
2021-11-01 13:18:29 +08:00
/**
*
*1
* @param src
* @param target
* @return
*/
public static boolean isSameWeek7(long src) {
long weekStart = getCurWeekdayStartTime(1,0);
long weekEnd = TimeUtils.getCurWeekdayStartTime(1,0) + TimeUtils.WEEK;
if(src>=weekStart && src<=weekEnd){
return true;
}
return false;
}
2019-01-09 13:58:05 +08:00
/**
*
*
* @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;
}
2019-08-29 03:00:31 +08:00
/**
2019-08-31 20:32:37 +08:00
* 0
2019-08-29 03:00:31 +08:00
* @param targetWeekday
* @return
*/
2019-08-31 20:32:37 +08:00
public static long getCurWeekdayStartTime(int targetWeekday,int hour) {
if(targetWeekday<1||targetWeekday>7){
return -1;
2019-08-29 03:00:31 +08:00
}
2019-08-31 20:32:37 +08:00
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();
}
2019-08-29 03:00:31 +08:00
2021-07-21 10:40:24 +08:00
/**
* 0
* @param hour
* @param targetWeekday
* @return
*/
public static long getCurWeekdayByTime(int targetWeekday,int hour,long time) {
if(targetWeekday<1||targetWeekday>7){
return -1;
}
Calendar c = Calendar.getInstance();
c.setTimeInMillis(time);
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();
}
2021-04-20 15:03:50 +08:00
/**
* 0
*/
public static long getCurMonthStartTime(int x){
Calendar c = Calendar.getInstance();
c.setTime(new Date());
c.set(Calendar.DAY_OF_MONTH, x);
c.set(Calendar.HOUR_OF_DAY, 0);
c.set(Calendar.MINUTE, 0);
c.set(Calendar.SECOND,0);
c.set(Calendar.MILLISECOND, 0);
return c.getTimeInMillis();
}
2021-07-16 18:56:13 +08:00
/**
* 235959
*/
public static long getCurMonthEndTime(){
//获取当前月最后一天
Calendar ca = Calendar.getInstance();
ca.set(Calendar.DAY_OF_MONTH, ca.getActualMaximum(Calendar.DAY_OF_MONTH));
//将小时至0
ca.set(Calendar.HOUR_OF_DAY, 23);
//将分钟至0
ca.set(Calendar.MINUTE, 59);
//将秒至0
ca.set(Calendar.SECOND,59);
//将毫秒至0
ca.set(Calendar.MILLISECOND, 1000);
return ca.getTimeInMillis();
}
2021-07-19 15:46:20 +08:00
/**
* 235959
*/
public static long getMonthEndTime(Long time){
//获取当前月最后一天
Calendar ca = Calendar.getInstance();
ca.setTimeInMillis(time);
ca.set(Calendar.DAY_OF_MONTH, ca.getActualMaximum(Calendar.DAY_OF_MONTH));
//将小时至0
ca.set(Calendar.HOUR_OF_DAY, 23);
//将分钟至0
ca.set(Calendar.MINUTE, 59);
//将秒至0
ca.set(Calendar.SECOND,59);
//将毫秒至0
ca.set(Calendar.MILLISECOND, 1000);
return ca.getTimeInMillis();
}
2021-04-22 13:55:20 +08:00
/**
* x:
* next:
* 0
*/
public static long getMonthStartTime(int x,int next){
Calendar c = Calendar.getInstance();
c.setTime(new Date());
c.add(Calendar.MONTH,next);
c.set(Calendar.DAY_OF_MONTH, x);
c.set(Calendar.HOUR_OF_DAY, 0);
c.set(Calendar.MINUTE, 0);
c.set(Calendar.SECOND,0);
c.set(Calendar.MILLISECOND, 0);
return c.getTimeInMillis();
}
2021-07-16 18:56:13 +08:00
/**
* time :
* x:
* next:
* 0
*/
public static long getMonthStartTime(long time,int x,int next){
Calendar c = Calendar.getInstance();
c.setTime(new Date(time));
c.add(Calendar.MONTH,next);
c.set(Calendar.DAY_OF_MONTH, x);
c.set(Calendar.HOUR_OF_DAY, 0);
c.set(Calendar.MINUTE, 0);
c.set(Calendar.SECOND,0);
c.set(Calendar.MILLISECOND, 0);
return c.getTimeInMillis();
}
2019-08-31 20:32:37 +08:00
/**
*
* @param targetWeekday
* @param hour
* @return
* @throws Exception
*/
public static long getNextWeekendStartTime(int targetWeekday,int hour) {
long cur = getCurWeekdayStartTime(targetWeekday, hour);
2020-03-25 05:01:03 +08:00
if(cur>now()){
2019-08-31 20:32:37 +08:00
return cur;
2020-03-25 05:01:03 +08:00
}else{
return cur + WEEK;
2019-08-31 20:32:37 +08:00
}
2019-08-29 03:00:31 +08:00
}
2019-01-09 13:58:05 +08:00
/**
* .(:)
*
* @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);
}
2021-07-30 18:47:44 +08:00
/**
*
*
* @param r1
* @param r2
* @return
*/
public static boolean isSameMonth2(long r1, long r2) {
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(r2);
int y2 = c2.get(Calendar.YEAR);
int m2 = c2.get(Calendar.MONTH) + 1;
return (y1 == y2) && (m1 == m2);
}
2019-01-09 13:58:05 +08:00
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);
}
2019-10-01 05:01:31 +08:00
// 是否5点月刷新
public static boolean isSameMonthFiveWithNow(long r1) {
Calendar c1 = Calendar.getInstance();
2019-08-10 14:34:18 +08:00
c1.setTimeInMillis(r1-5*ONE_HOUR);
2019-10-01 05:01:31 +08:00
int y1 = c1.get(Calendar.YEAR);
int m1 = c1.get(Calendar.MONTH) + 1;
Calendar c2 = Calendar.getInstance();
2019-08-10 14:34:18 +08:00
c2.setTimeInMillis(now()-5*ONE_HOUR);
2019-10-01 05:01:31 +08:00
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);
}
2019-01-09 13:58:05 +08:00
/**
*
*/
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);
2021-12-31 17:33:31 +08:00
2019-01-09 13:58:05 +08:00
return calendar.getTimeInMillis();
}
2021-12-31 17:33:31 +08:00
/**
*
* @return
*/
public static int getAppointTime() {
Calendar calendar = Calendar.getInstance();
calendar.setTimeInMillis(now());
int minute = calendar.get(Calendar.MINUTE);
if(calendar.get(Calendar.SECOND)>0){
calendar.set(Calendar.MINUTE, minute+1);
}
calendar.set(Calendar.SECOND, 0);
return (int)(calendar.getTimeInMillis()/1000);
}
2019-01-09 13:58:05 +08:00
/**
* @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;
}
/**
* date2date1
*
* @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;
}
}
2019-11-11 13:48:18 +08:00
/**
* date1date2hour
* @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;
}
2019-01-09 13:58:05 +08:00
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());
return calendar.get(Calendar.HOUR_OF_DAY);
2019-01-09 13:58:05 +08:00
}
2020-08-17 05:29:48 +08:00
/**
* ()
*
* @return
*/
public static int getMiunte() {
Calendar calendar = Calendar.getInstance();
calendar.setTimeInMillis(System.currentTimeMillis());
return calendar.get(Calendar.MINUTE);
2020-08-17 05:29:48 +08:00
}
2021-02-20 20:13:15 +08:00
/**
* ()
*
* @return
*/
public static int getMiunte(long time) {
Calendar calendar = Calendar.getInstance();
calendar.setTimeInMillis(time);
return calendar.get(Calendar.MINUTE);
2021-02-20 20:13:15 +08:00
}
2019-01-09 13:58:05 +08:00
// /**
// * 获取的一个月的最大的天数
// *
// * @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();
}
/**
*
2019-01-09 13:58:05 +08:00
* @return
*/
public static int getDayOfWeek() {
Calendar calendar = Calendar.getInstance();
calendar.setTimeInMillis(now());
2019-11-24 17:04:07 +08:00
int week = calendar.get(Calendar.DAY_OF_WEEK) - 1;
return week==0?7:week;
2019-01-09 13:58:05 +08:00
}
/**
* 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);
}
2020-04-30 19:57:17 +08:00
public static boolean isOverTimeNow(int hour, long lastTime) {
return !isSameDay(lastTime - (long) (hour) * 3600, now() - (long) (hour) * 3600);
}
2019-01-09 13:58:05 +08:00
// 距离下周几(周日为 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 -101
* @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);
}
}
2019-04-22 19:25:03 +08:00
public static long parseTimeToMiles(String date, String datePattern) throws ParseException {
SimpleDateFormat simpleDateFormat = new SimpleDateFormat(datePattern);
return simpleDateFormat.parse(date).getTime();
}
2019-04-30 11:03:41 +08:00
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();
}
2020-09-01 17:20:57 +08:00
public static long differMintFromLast(Object object){
2019-11-04 18:25:48 +08:00
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;
}
2019-10-25 05:05:31 +08:00
/**
*
* @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;
}
}
}
public static long getNextTimeByDay(long time,int day){
return time+day*24*60*60*1000;
}
2020-12-01 10:55:37 +08:00
public static long getLastOrUnderHour(long time,int week,int hour,int minute,boolean lastOrUnder) {
Calendar cal = Calendar.getInstance();
cal.setTimeInMillis(time);
2021-07-12 11:31:21 +08:00
int offset = 0;
2021-07-12 11:33:45 +08:00
if(cal.get(Calendar.DAY_OF_WEEK)==Calendar.SUNDAY){
2021-07-12 11:31:21 +08:00
offset-=TimeUtils.WEEK;
}
2020-12-01 10:55:37 +08:00
cal.set(Calendar.DAY_OF_WEEK,week==7?0:week+1);
time = cal.getTimeInMillis();
long lastOrUnderHour = getLastOrUnderHour(time, hour, minute, true);
2021-07-12 11:31:21 +08:00
2020-12-01 10:55:37 +08:00
if(!lastOrUnder){
lastOrUnderHour+=TimeUtils.WEEK;
}
2021-07-12 11:31:21 +08:00
return lastOrUnderHour+offset;
2020-12-01 10:55:37 +08:00
}
/**
*
* @param hour
* @param lastOrUnder truefalse
* @return
*/
2020-06-05 10:16:09 +08:00
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);
2020-06-05 10:16:09 +08:00
cal.set(Calendar.MINUTE,minute);
cal.set(Calendar.SECOND,0);
cal.set(Calendar.MILLISECOND,0);
long result = cal.getTimeInMillis();
2020-03-25 05:01:03 +08:00
if(i<hour){
result = result -TimeUtils.DAY;
}
2020-03-25 05:01:03 +08:00
if(!lastOrUnder){
result = result + TimeUtils.DAY;
}
return result;
}
2019-11-29 11:19:48 +08:00
/**
* Integer-now();
* @return
*/
public static double getDoubleTime(){
2021-09-02 15:25:21 +08:00
return (Integer.MAX_VALUE-nowInt())/Math.pow(10,9);
2019-11-29 11:19:48 +08:00
}
/**
* hour
* @param time1
* @param time2
* @param hour
* @return
*/
public static int getOverTimeCount(long time1,long time2,int hour){
2020-09-21 13:24:51 +08:00
long last = getLastOrUnderHour(time1, hour, 0, true);
long under = getLastOrUnderHour(time2, hour, 0, true);
if(last>under){
return 0;
}
if(last==under){
2020-09-21 13:24:51 +08:00
return 0;
}
return (int) Math.floor((under-last)/(HOUR*24D));
}
2021-04-20 15:03:50 +08:00
public static long getTodayZero(){
2021-04-28 00:27:43 +08:00
Calendar calendar = Calendar.getInstance();
calendar.set(Calendar.SECOND, 0);
calendar.set(Calendar.MINUTE, 0);
calendar.set(Calendar.HOUR_OF_DAY, 0);
calendar.set(Calendar.MILLISECOND, 0);
return calendar.getTimeInMillis();
2021-04-20 15:03:50 +08:00
}
2021-11-18 21:08:32 +08:00
//周几的零点
public static long getWeekZero(int weekDay){
if(weekDay ==7){
weekDay =1;
}else {
weekDay +=1;
}
Calendar calendar = Calendar.getInstance();
calendar.set(Calendar.SECOND, 0);
calendar.set(Calendar.MINUTE, 0);
calendar.set(Calendar.HOUR_OF_DAY, 0);
calendar.set(Calendar.MILLISECOND, 0);
calendar.set( Calendar.DAY_OF_WEEK,weekDay);
return calendar.getTimeInMillis();
}
2021-05-08 21:03:29 +08:00
/**
* 56bug
* @return
*/
public static long getFirsatRechargeTime(){
DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date date = new Date();
try{
date = df.parse("2021-05-06 18:00:00");
}catch(Exception e){
e.printStackTrace();
}
Calendar cal = Calendar.getInstance();
cal.setTime(date);
long timestamp = cal.getTimeInMillis();
return timestamp;
2021-05-08 21:03:29 +08:00
}
2021-07-16 17:07:17 +08:00
/**
2021-07-21 10:40:24 +08:00
*
*
* @param before
* @param after
* @param week
* @return
*/
2021-07-28 14:02:13 +08:00
public static boolean isAfterTimeByWeek(long before, long after, int week) {
2021-07-21 10:40:24 +08:00
// 开始时间
long startTime = getCurWeekdayByTime(1, 0, before);
// 当前时间
long nowTime = getCurWeekdayByTime(1, 0, after);
// 间隔时间
long weekTime = week * WEEK;
// 结果
2021-07-28 14:02:13 +08:00
return nowTime - startTime >= weekTime;
}
2021-10-02 18:44:00 +08:00
/**
*
*
* @param before
* @param after
* @return
*/
public static long AfterTimeByWeek(long before, long after) {
// 开始时间
long startTime = getCurWeekdayByTime(1, 0, before);
// 当前时间
long nowTime = getCurWeekdayByTime(1, 0, after);
// 结果
return ((nowTime - startTime)/WEEK)+1;
}
2021-07-28 14:02:13 +08:00
/**
2021-07-16 17:07:17 +08:00
* @return
*/
public static long getGapMonthsByTwoTime(String startTime,String endTime){
DateTimeFormatter form = DateTimeFormatter.ofPattern("yyyy-MM-dd");
LocalDate start = LocalDate.parse(startTime, form);
long mm = ChronoUnit.MONTHS.between(start, LocalDate.parse(endTime, form));
return mm;
}
/**
*
* @return
*/
public static long getGapDaysByTwoTime(String startTime,String endTime){
DateTimeFormatter form = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
LocalDate start = LocalDate.parse(startTime, form);
long mm = ChronoUnit.DAYS.between(start, LocalDate.parse(endTime, form));
return mm;
}
2021-07-16 17:07:17 +08:00
/**
* yyyy-MM-dd
*/
public static String getTimeStampYMDnew(Long time) {
return new SimpleDateFormat(ymdFormatN).format(new Date(time));
}
2019-01-09 13:58:05 +08:00
}