本文深入探讨了Java中`SimpleDateFormat`非线程安全原因，`Calendar`类`roll`与`add`方法的区别，提供了一个详尽的时间操作工具类，涵盖了日期格式转换、获取指定日期信息、日期比较等功能，并演示了如何设置和获取日期时间的多种方法。
标题
- SimpleDateFormat类到底为啥不是线程安全的？
- Calendar类roll和add的区别
- 我的时间操作工具类
- 判断日期是否是今天，本周，本月，本季度，本年
- 获取手动设置指定日期
- 返回当前或者指定时间的年月日时分秒毫秒任意一位值
- 工作记录 获得某年某个月最大天数、判断日期是否在指定时间段内等
- 关于Calendar类使用
- "EEE, dd MMM yyyy HH:mm:ss z" 与 "yyyy-MM-dd HH:mm:ss"互转
- 日期对应星座及法定节假日
- java获取法定节假日网址推荐
- 日期的比较
- 年月周(本月)求日期 这个周是本月的第几周
- 获取时间戳的几种方式
- 关于不一样的格式化日期
- yyyy-MM-dd HH:mm:ss G E D F w W a E F含义
- "yyyy-MM-ddTHH:mm:ss.SSSZ" 与 "yyyy-MM-dd HH:mm:ss"互转
- Java 实现日期的格式化，月份和天不足两位时补上0
- Java如何获取系统时间
- LocalDateTime.now()时间处理jdk1.8日期便捷处理类java.time.LocalDateTime;
SimpleDateFormat类到底为啥不是线程安全的？
Calendar类roll和add的区别
Calendar类roll和add的区别
这块注意一下呦，不同功能选用不同方法
/**
* roll方法只是对相应时间属性的域内做变化
* 例如,对月份使用roll方法，它会在1-12的范围内变化，不会影响的年
* 2017-1-15 roll(Calendar.MONTH, -1) 后是2017-12-15
*/
/**
* add方法会产生其他相关时间属性的连动变化
* 2018-1-15 add(Calendar.MONTH, -1) 后是2017-12-15
*/
我的时间操作工具类
package datetime;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
/**
* 方法目录：
* 1、日期格式互转
* 获得 java.text.SimpleDateFormat：getSimpleDateFormat()
* 字符串转日期：stringToDate() 日期转字符串：dateToString()
* 以指定的格式格式化日期字符串：formatDate()
* 2、获取周得相关方法
* 给定日期对应的周日日期：getSundayOfWeek() 给定日期对应的周一日期：getMondayOfWeek()
* 当然也可以实现任意周几 获得一个日期所在的周的星期几的日期，getWeekDateNow()
* 给定日期对应的周一到周日日期区间：getWeekBeginAndEndDate() 2021-12-06 - 2021-12-12
* 获得当前(指定)日期与本周一相差的天数：getMondayPlus()
* 指定日期是周几(数值及文字模式)：getWeekDay() 7 及：getFormatWeekDay() 周日 及：getStringWeekDay() 星期日
* 指定日期一年中的第几周：getWeekOfYear() 判断二个时间是否在同一个周：isSameWeekDates()
* 3、年
* 获取指定日期所属年份：getYear()
* 获取某年第一天日期：getYearFirst()
* 获取某年最后一天日期：getYearLast()
* 判断两个日期的跨度是否超过一年（12个月）： checkIsOneYear()
* 给定一个年份，判断是否为闰年:isLeapYear()
* 判断两个日期间是否超过指定的年数:DateCompareBefourYear
* 4、月
* 获取指定日期所属月份：getMonth()
* 取得月已经过的天数：getPassDayOfMonth() 获取月的天数：getDayOfMonth() 取得月的剩余天数：getRemainDayOfMonth()
* 取得月第一天：getFirstDateOfMonth() 取得月最后一天：getLastDateOfMonth()
* 返回指定日期上月末日期（yyyy年mmdd日格式）getLastDate
* 返回指定日期下一月月初凌晨时间：getNextFirstMonth()
* 将月份加几个月：addMonthsToDate()
* 获取月份所属季度 返回数值：getMonthQuarterInt()
* 获取月份所属季度 返回文字：getMonthQuarterString
* Java 实现日期的格式化，月份和天不足两位时补上0
* 5、日
* 获取指定日期所属日：getDay()
* 获取指定日期在本年已过多少天 getDays() 从某个日期到现在的天数：getBetweenNowDays()
* 获取两个日期之间的天数差：getBetweenDays()
* 返回的是两个日期相差的天数，如果日期一致返回的是0:differentDays()
* 判断两个时间是否相隔一天 是返回0不是返回间隔天数:daysBetween()
* Java判断两个时间是不是同一天: isSameDay()
* 获取指定年月的第一天:getMonthFirstDay()
* 获取指定年月的最后一天:getMonthLastDay()
* 7、季度篇幅
* 获得季度开始时间：getCurrentQuarterStartTime()
* 当前季度的结束时间: getCurrentQuarterEndTime()
* 取得季度第一天：getFirstDateOfSeason() 取得季度最后一天：getLastDateOfSeason()
* 取得季度天数：getDayOfSeason()
* 取得季度已过天数：getPassDayOfSeason() 取得季度剩余天数：getRemainDayOfSeason()
* 指定日期当前所属季度：getSeason() 返回数值类型 指定日期当前所属季度：getStringSeason() 返回文字类型
* 获取当前时间的所在季度开始结束日期：getSeasonStartDate()、getSeasonEndDate()
* 获取当前日期上一(几)季度开始结束日期时间:getStartQuarter()、getLastQuarter()
* 返回日期所属季度的几个年月：getQuarterMonth()
* 年份跟该日期是年份的第几周结合 可推出对应周一到周日的日期：getDateByYearAndWEEKOFYEAR()
* 获取季节--春夏秋冬：getSeason()
* 8、日期操作
* 对指定日期进行加减年、月、日、时、分、秒的操作 :updateTime()
* 获得指定日期当天 几点时间：getTimesMorning() 可扩展
* 从某个日期到现在的小时数：pastHour() 从某个日期到现在的分钟数：pastMinutes()
* 根据当前系统时间戳获取零点和二十四点的时间：getZeroDateAndTwelveDate()
* 获取两个日期字符串之间的日期集合：getBetweenDateList()
* todo 日期转为中文汉字形式：formatChineseDate()
* Java判断日期相差几个月：getDifMonth()、getMonth()
* 如何确定日期是否在Java中的两个日期之间：isTodayBetween()
* 最小时间: System.out.println(sdf1.format(setMinTime(sdf.parse("2021-11-01")))); 2021-11-01 00:00:00
* 最大时间: System.out.println(sdf1.format(setMaxTime(sdf.parse("2021-11-01")))); 2021-11-01 23:59:59
* Java计算两个日期相差的年数、月数、天数
* 这块特点是 你多一天少一天我就认为你两个时间段间隔不到一年、一月、一日。
* 9、日期、时间戳之间的关系
* 获取当前时间戳-秒级：getCurrentTime()
* 日期转换成时间戳：getCurrentTimeMillis() 时间戳转为日期类型：currentTimeMillisToDate()
* 年月周(本月)求日期 这个周是本月的第几周
* 两个指定日期进行比较：FirstCompareToSecondDate()
* 判断指定日期是否闰年：ifLeapYear()
* 返回两个时间相差的天小时分钟秒 2天23小时12分钟59秒 可扩展
* 10 返回日期区间
* 获取指定年份 指定季度 的日期区间：getCurrQuarter()、推荐使用：getTemporalInterval()
* 获取指定时间段内所有季度：getSeasonList()
* 获取时间段内所有季度 、获取两个日期之间的所有月份 (年月)
* Java判断当前时间是否在两个时间段内：belongCalendar()
*/
public class MyDateUtils {
public static final String YYYYMMDD = "yyyy-MM-dd";
public static final String YYYYMM = "yyyy-MM";
public static final String YYYYMMDDHHMMSS = "yyyy-MM-dd HH:mm:ss";
public static final String YYYYMMDDHHMMSSSSS = "yyyy-MM-dd HH:mm:ss:SSS";
public static final String YYYYMMDD_ZH = "yyyy年MM月dd日";
public static final String YYYYMM_ZH = "yyyy年MM月";
public static final String OTHER = "yyyy-MM-dd HH:mm:ss G E D F w W a E F";//2021-12-09 22:38:11 公元 周四 343 2 50 2 下午 周四 2
public static final int FIRST_DAY_OF_WEEK = Calendar.MONDAY; // 中国周一是一周的第一天
/**
* 获得 java.text.SimpleDateFormat
* 可以定义想要的格式，默认：yyyy-MM-dd
*
* @param pattern
* @return
*/
public static SimpleDateFormat getSimpleDateFormat(String pattern) {
if (pattern == null || "".equals(pattern)) {
pattern = YYYYMMDD;
}
return new SimpleDateFormat(pattern);
}
/**
* parseDate
* 字符串转日期
* 日期为空默认当前时间
*
* @param strDate
* @param pattern
* @return
*/
public static Date stringToDate(String strDate, String pattern) {
Date date = null;
if (strDate == null) {
strDate = dateToString(new Date(), YYYYMMDDHHMMSS);
}
try {
if (pattern == null || "".equals(pattern)) {
pattern = YYYYMMDD;
}
SimpleDateFormat format = new SimpleDateFormat(pattern);
date = format.parse(strDate);
} catch (ParseException e) {
e.printStackTrace();
}
return date;
}
/**
* format date
* 日期转字符串
* 日期为空默认当前时间
*
* @param date
* @param pattern
* @return
*/
public static String dateToString(Date date, String pattern) {
String strDate = null;
if (date == null) {
date = new Date();
}
try {
if (pattern == null || "".equals(pattern)) {
pattern = YYYYMMDD;
}
SimpleDateFormat format = new SimpleDateFormat(pattern);
strDate = format.format(date);
} catch (Exception e) {
e.printStackTrace();
}
return strDate;
}
/**
* 根据日期取得对应周周一日期
*
* @param date
* @return
*/
public static Date getMondayOfWeek(Date date) {
Calendar monday = Calendar.getInstance();
monday.setTime(date);
monday.setFirstDayOfWeek(FIRST_DAY_OF_WEEK);
monday.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
return monday.getTime();
}
/**
* 根据日期取得对应周周日日期
*
* @param date
* @return
*/
public static Date getSundayOfWeek(Date date) {
Calendar sunday = Calendar.getInstance();
sunday.setTime(date);
sunday.setFirstDayOfWeek(FIRST_DAY_OF_WEEK);
sunday.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY);
return sunday.getTime();
}
/**
* 取得当天日期是周几 中文式 1-7
* 0是周日这里给赋值7
* 数值类型
*
* @param date
* @return
*/
public static int getWeekDay(Date date) {
Calendar c = Calendar.getInstance();
c.setTime(date);
int week_of_year = c.get(Calendar.DAY_OF_WEEK);
int weekNo = 0;
if (week_of_year - 1 == 0) {
weekNo = 7;
} else {
weekNo = week_of_year - 1;
}
return weekNo;
}
/**
* 取得当天日期是周几 中文式 1-7
* 汉字模式
*
* @param date
* @return
*/
public static String getStringWeekDay(Date date) {
String weekNo = null;
int weekDay = getWeekDay(date);
switch (weekDay) {
case 1:
weekNo = "星期一";
break;
case 2:
weekNo = "星期二";
break;
case 3:
weekNo = "星期三";
break;
case 4:
weekNo = "星期四";
break;
case 5:
weekNo = "星期五";
break;
case 6:
weekNo = "星期六";
break;
case 7:
weekNo = "星期日";
break;
default:
break;
}
return weekNo;
}
/**
* 求指定日期是周几
* 周日
*/
public static String getFormatWeekDay(Date date) {
SimpleDateFormat format = new SimpleDateFormat("E");
String weekNow = format.format(date);
return weekNow;
}
/**
* 取得一年的第几周
*
* @param date
* @return
*/
public static int getWeekOfYear(Date date) {
Calendar c = Calendar.getInstance();
c.setTime(date);
int week_of_year = c.get(Calendar.WEEK_OF_YEAR);
return week_of_year;
}
/**
* 判断二个时间是否在同一个周
*
* @param date1
* @param date2
* @return
*/
public static boolean isSameWeekDates(Date date1, Date date2) {
Calendar cal1 = Calendar.getInstance();
Calendar cal2 = Calendar.getInstance();
cal1.setTime(date1);
cal2.setTime(date2);
int subYear = cal1.get(Calendar.YEAR) - cal2.get(Calendar.YEAR);
if (0 == subYear) {
if (cal1.get(Calendar.WEEK_OF_YEAR) == cal2.get(Calendar.WEEK_OF_YEAR))
return true;
} else if (1 == subYear && 11 == cal2.get(Calendar.MONTH)) {
// 如果12月的最后一周横跨来年第一周的话则最后一周即算做来年的第一周
if (cal1.get(Calendar.WEEK_OF_YEAR) == cal2.get(Calendar.WEEK_OF_YEAR))
return true;
} else if (-1 == subYear && 11 == cal1.get(Calendar.MONTH)) {
if (cal1.get(Calendar.WEEK_OF_YEAR) == cal2.get(Calendar.WEEK_OF_YEAR))
return true;
}
return false;
}
/**
* 获得一个日期所在的周的星期几的日期
*
* @param sdate
* @param num
* @return
*/
public static String getWeekDateNow(Date sdate, String num) {
// 再转换为时间
Calendar c = Calendar.getInstance();
c.setTime(sdate);
if (num.equals("1")) // 返回星期一所在的日期
{
c.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
} else if (num.equals("2")) // 返回星期二所在的日期
{
c.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);
} else if (num.equals("3")) // 返回星期三所在的日期
{
c.set(Calendar.DAY_OF_WEEK, Calendar.WEDNESDAY);
} else if (num.equals("4")) // 返回星期四所在的日期
{
c.set(Calendar.DAY_OF_WEEK, Calendar.THURSDAY);
} else if (num.equals("5")) // 返回星期五所在的日期
{
c.set(Calendar.DAY_OF_WEEK, Calendar.FRIDAY);
} else if (num.equals("6")) // 返回星期六所在的日期
{
c.set(Calendar.DAY_OF_WEEK, Calendar.SATURDAY);
} else if (num.equals("7")) // 返回星期日所在的日期
{
c.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY);
c.add(Calendar.DAY_OF_MONTH, 7);
}
return new SimpleDateFormat("yyyy-MM-dd").format(c.getTime());
}
/**
* getWeekBeginAndEndDate
* 周一到周日的日期区间
*
* @param date
* @param pattern
* @return
*/
public static String getWeekBeginAndEndDate(Date date, String pattern) {
Date monday = getMondayOfWeek(date);
Date sunday = getSundayOfWeek(date);
return dateToString(monday, pattern) + " - "
+ dateToString(sunday, pattern);
}
/**
* 获得当前(指定)日期与本周一相差的天数
* 这个天数需不需要加1看具体业务 这里没加1
*
* @return
*/
private static int getMondayPlus(Date date) {
Calendar cd = Calendar.getInstance();
if (date != null) {
cd.setTime(date);
}
int dayOfWeek = cd.get(Calendar.DAY_OF_WEEK);
if (dayOfWeek == 1) {
return 6;
} else {
return dayOfWeek - 2;
}
}
/**
* 取得日期：年
*
* @param date
* @return
*/
public static int getYear(Date date) {
Calendar c = Calendar.getInstance();
c.setTime(date);
int year = c.get(Calendar.YEAR);
return year;
}
/**
* 取得日期：月
*
* @param date
* @return
*/
public static int getMonth(Date date) {
Calendar c = Calendar.getInstance();
c.setTime(date);
int month = c.get(Calendar.MONTH);
return month + 1;
}
/**
* 取得月已经过的天数
*
* @param date
* @return
*/
public static int getPassDayOfMonth(Date date) {
Calendar c = Calendar.getInstance();
c.setTime(date);
return c.get(Calendar.DAY_OF_MONTH);
}
/**
* 取得月天数
*
* @param date
* @return
*/
public static int getDayOfMonth(Date date) {
Calendar c = Calendar.getInstance();
c.setTime(date);
return c.getActualMaximum(Calendar.DAY_OF_MONTH);
}
/**
* 取得日期：日
*
* @param date
* @return
*/
public static int getDay(Date date) {
Calendar c = Calendar.getInstance();
c.setTime(date);
int da = c.get(Calendar.DAY_OF_MONTH);
return da;
}
/**
* 取得月的剩余天数
*
* @param date
* @return
*/
public static int getRemainDayOfMonth(Date date) {
int dayOfMonth = getDayOfMonth(date);
int day = getPassDayOfMonth(date);
return dayOfMonth - day;
}
/**
* 取得月第一天
*
* @param date
* @return
*/
public static Date getFirstDateOfMonth(Date date) {
Calendar c = Calendar.getInstance();
c.setTime(date);
c.set(Calendar.DAY_OF_MONTH, c.getActualMinimum(Calendar.DAY_OF_MONTH));
return c.getTime();
}
/**
* 取得月最后一天
*
* @param date
* @return
*/
public static Date getLastDateOfMonth(Date date) {
Calendar c = Calendar.getInstance();
c.setTime(date);
c.set(Calendar.DAY_OF_MONTH, c.getActualMaximum(Calendar.DAY_OF_MONTH));
return c.getTime();
}
/**
* 获取一个月的最后一天
* 低端写法
*
* @param dat
* @return
*/
public static String getEndDateOfMonth(String dat) {// yyyy-MM-dd
String str = dat.substring(0, 8);
String month = dat.substring(5, 7);
String year = dat.substring(0, 4);
int mon = Integer.parseInt(month);
if (mon == 1 || mon == 3 || mon == 5 || mon == 7 || mon == 8 || mon == 10 || mon == 12) {
str += "31";
} else if (mon == 4 || mon == 6 || mon == 9 || mon == 11) {
str += "30";
} else {
if (ifLeapYear(Integer.parseInt(year))) {
str += "29";
} else {
str += "28";
}
}
return str;
}
/**
* 返回指定日期下一月月初凌晨时间
*
* @param date
* @return
*/
public static String getNextFirstMonth(Date date) {
Calendar cal = Calendar.getInstance();
cal.setTime(date);
cal.set(Calendar.DAY_OF_MONTH, cal.getActualMaximum(Calendar.DAY_OF_MONTH));
cal.set(Calendar.HOUR_OF_DAY, 24);
cal.set(Calendar.MINUTE, 0);
cal.set(Calendar.SECOND, 0);
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date time = cal.getTime();
System.out.println(format.format(time));
return format.format(time);
}
/**
* 将月份加几个月
*
* @param date
* @param months
* @return
*/
public final static String addMonthsToDate(Date date, int months) {
Calendar c = Calendar.getInstance();
c.setTime(date);
c.add(Calendar.MONTH, months);// 加几个月
c.set(Calendar.DAY_OF_MONTH, 1);// 设置月份的月初
// c.set(Calendar.HOUR_OF_DAY, 0);// 设置月份的小时
// c.set(Calendar.MINUTE, 0);// 设置月份的分钟
// c.set(Calendar.SECOND, 0);// 设置月份的秒数
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); //设置时间格式
String defaultStartDate = sdf.format(c.getTime());
return defaultStartDate;
}
/**
* 取得季度第一天
*
* @param date
* @return
*/
public static Date getFirstDateOfSeason(Date date) {
return getFirstDateOfMonth(getSeasonDate(date)[0]);
}
/**
* 取得季度最后一天
*
* @param date
* @return
*/
public static Date getLastDateOfSeason(Date date) {
return getLastDateOfMonth(getSeasonDate(date)[2]);
}
/**
* 所在季度的几个月份
*
* @param date
* @return
*/
public static String getQuarterMonth(Date date, String format) {
String quarter = "";
if (format == null || "".equals(format)) {
format = YYYYMM_ZH;
}
quarter = dateToString(getSeasonDate(date)[0], format) + "/"
+ dateToString(getSeasonDate(date)[1], format) + "/"
+ dateToString(getSeasonDate(date)[2], format);
return quarter;
}
/**
* 取得季度天数
*
* @param date
* @return
*/
public static int getDayOfSeason(Date date) {
int day = 0;
Date[] seasonDates = getSeasonDate(date);
for (Date date2 : seasonDates) {
day += getDayOfMonth(date2);
}
return day;
}
/**
* 取得季度剩余天数
*
* @param date
* @return
*/
public static int getRemainDayOfSeason(Date date) {
return getDayOfSeason(date) - getPassDayOfSeason(date);
}
/**
* 取得季度已过天数
*
* @param date
* @return
*/
public static int getPassDayOfSeason(Date date) {
int day = 0;
Date[] seasonDates = getSeasonDate(date);
Calendar c = Calendar.getInstance();
c.setTime(date);
int month = c.get(Calendar.MONTH);
if (month == Calendar.JANUARY || month == Calendar.APRIL
|| month == Calendar.JULY || month == Calendar.OCTOBER) {// 季度第一个月
day = getPassDayOfMonth(seasonDates[0]);
} else if (month == Calendar.FEBRUARY || month == Calendar.MAY
|| month == Calendar.AUGUST || month == Calendar.NOVEMBER) {// 季度第二个月
day = getDayOfMonth(seasonDates[0])
+ getPassDayOfMonth(seasonDates[1]);
} else if (month == Calendar.MARCH || month == Calendar.JUNE
|| month == Calendar.SEPTEMBER || month == Calendar.DECEMBER) {// 季度第三个月
day = getDayOfMonth(seasonDates[0]) + getDayOfMonth(seasonDates[1])
+ getPassDayOfMonth(seasonDates[2]);
}
return day;
}
/**
* 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 date
* @return
*/
public static String getStringSeason(Date date) {
int season = getSeason(date);
String stringSeason = null;
switch (season) {
case 1:
stringSeason = "第一季度";
break;
case 2:
stringSeason = "第二季度";
break;
case 3:
stringSeason = "第三季度";
break;
case 4:
stringSeason = "第四季度";
break;
default:
break;
}
return stringSeason;
}
/**
* 计算某日期所在季度结束日期
* 季度划分：1、2、3， 4、5、6， 7、8、9， 10、11、12
*/
public static Date getSeasonStartDate (Date date) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
int month = calendar.get(Calendar.MONTH);
calendar.set(Calendar.MONTH, month / 3 * 3);
calendar.set(Calendar.DATE, 1);
return calendar.getTime();
}
/**
* 计算某日期所在季度开始日期
* 季度划分：1、2、3， 4、5、6， 7、8、9， 10、11、12
*/
public static Date getSeasonEndDate (Date date) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
int month = calendar.get(Calendar.MONTH);
calendar.set(Calendar.MONTH, (month + 3) / 3 * 3);
calendar.set(Calendar.DATE, 1);
return new Date(calendar.getTime().getTime() - 24 * 60 * 60 *1000);
}
/**
* 获取当前日期上一季度 开始时间
*
* @return
*/
public static Date getStartQuarter(Date date) {
Calendar startCalendar = Calendar.getInstance();
startCalendar.setTime(date);
//上个季度 -1 上两个季度 -2即可
startCalendar.set(Calendar.MONTH, ((int) startCalendar.get(Calendar.MONTH) / 3 - 1) * 3);
startCalendar.set(Calendar.DAY_OF_MONTH, 1);
// setMinTime(startCalendar);
return startCalendar.getTime();
}
/**
* 获取当前日期上一季度 结束时间
*
* @return
*/
public static Date getLastQuarter(Date date) {
Calendar endCalendar = Calendar.getInstance();
endCalendar.setTime(date);
endCalendar.set(Calendar.MONTH, ((int) endCalendar.get(Calendar.MONTH) / 3 - 1) * 3 + 2);
endCalendar.set(Calendar.DAY_OF_MONTH, endCalendar.getActualMaximum(Calendar.DAY_OF_MONTH));
// setMaxTime(endCalendar);
return endCalendar.getTime();
}
/**
* 取得季度月
*
* @param date
* @return
*/
public static Date[] getSeasonDate(Date date) {
Date[] season = new Date[3];
Calendar c = Calendar.getInstance();
c.setTime(date);
int nSeason = getSeason(date);
if (nSeason == 1) {// 第一季度
c.set(Calendar.MONTH, Calendar.JANUARY);
season[0] = c.getTime();
c.set(Calendar.MONTH, Calendar.FEBRUARY);
season[1] = c.getTime();
c.set(Calendar.MONTH, Calendar.MARCH);
season[2] = c.getTime();
} else if (nSeason == 2) {// 第二季度
c.set(Calendar.MONTH, Calendar.APRIL);
season[0] = c.getTime();
c.set(Calendar.MONTH, Calendar.MAY);
season[1] = c.getTime();
c.set(Calendar.MONTH, Calendar.JUNE);
season[2] = c.getTime();
} else if (nSeason == 3) {// 第三季度
c.set(Calendar.MONTH, Calendar.JULY);
season[0] = c.getTime();
c.set(Calendar.MONTH, Calendar.AUGUST);
season[1] = c.getTime();
c.set(Calendar.MONTH, Calendar.SEPTEMBER);
season[2] = c.getTime();
} else if (nSeason == 4) {// 第四季度
c.set(Calendar.MONTH, Calendar.OCTOBER);
season[0] = c.getTime();
c.set(Calendar.MONTH, Calendar.NOVEMBER);
season[1] = c.getTime();
c.set(Calendar.MONTH, Calendar.DECEMBER);
season[2] = c.getTime();
}
return season;
}
/**
* 根据年份跟周计算 该周周一日期 有了周一日期自然能知道周一到周日的日期
*
* @param YEAR
* @param WEEK_OF_YEAR
* @return
*/
public static String getDateByYearAndWEEKOFYEAR(Integer YEAR, Integer WEEK_OF_YEAR) {
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
Calendar cal = Calendar.getInstance();
cal.set(Calendar.YEAR, YEAR);
cal.set(Calendar.WEEK_OF_YEAR, WEEK_OF_YEAR);
cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
String dateTime = df.format(cal.getTime());
return dateTime;
}
/**
* 获取两个日期之间的天数
* 返回时需要加1才是真正的天数 业务上是这样
* 因为加1了所以哪怕两个日期相同返回的是1不是0 主要根据自己需求
*
* @param begin
* @param end
* @return
*/
public static long getBetweenDays(Date begin, Date end) {
long beforeTime = begin.getTime();
long afterTime = end.getTime();
long l = (afterTime - beforeTime) / (1000 * 60 * 60 * 24);
return l + 1;
}
/**
* date2比date1多的天数
* todo 这个只看年月日跟时分秒无关
*
* @param date1 小时间
* @param date2 大时间
* @return 返回的是两个日期相差的天数，如果日期一致返回的是0:differentDays()
*/
private static int differentDays(Date date1, Date date2) {
if (date1.compareTo(date2) == 1) {
Date tem = date1;
date1 = date2;
date2 = tem;
}
Calendar cal1 = Calendar.getInstance();
cal1.setTime(date1);
Calendar cal2 = Calendar.getInstance();
cal2.setTime(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;
}
}
/**
* 判断两个时间是否相隔一天 是返回0不是返回间隔天数:daysBetween()
*/
public static final int daysBetween(Date early, Date late) {
java.util.Calendar calst = java.util.Calendar.getInstance();
java.util.Calendar caled = java.util.Calendar.getInstance();
calst.setTime(early);
caled.setTime(late);
//设置时间为0时
calst.set(java.util.Calendar.HOUR_OF_DAY, 0);
calst.set(java.util.Calendar.MINUTE, 0);
calst.set(java.util.Calendar.SECOND, 0);
caled.set(java.util.Calendar.HOUR_OF_DAY, 0);
caled.set(java.util.Calendar.MINUTE, 0);
caled.set(java.util.Calendar.SECOND, 0);
//得到两个日期相差的天数
int days = ((int) (caled.getTime().getTime() / 1000) - (int) (calst
.getTime().getTime() / 1000)) / 3600 / 24;
return days;
}
/**
* Java判断两个时间是不是同一天: isSameDay()
*/
public static boolean isSameDay(final Date date1, final Date date2) {
if (date1 == null || date2 == null) {
throw new IllegalArgumentException("The date must not be null");
}
final Calendar cal1 = Calendar.getInstance();
cal1.setTime(date1);
final Calendar cal2 = Calendar.getInstance();
cal2.setTime(date2);
return isSameDay(cal1, cal2);
}
public static boolean isSameDay(final Calendar cal1, final Calendar cal2) {
if (cal1 == null || cal2 == null) {
throw new IllegalArgumentException("The date must not be null");
}
return (cal1.get(Calendar.ERA) == cal2.get(Calendar.ERA) &&
cal1.get(Calendar.YEAR) == cal2.get(Calendar.YEAR) &&
cal1.get(Calendar.DAY_OF_YEAR) == cal2.get(Calendar.DAY_OF_YEAR));
}
//获取指定年月的第一天:getMonthFirstDay()
public static String getMonthFirstDay(int year, int month) {
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
//获取Calendar类的实例
Calendar c = Calendar.getInstance();
c.clear();
//设置年份
c.set(Calendar.YEAR, year);
//设置月份，因为月份从0开始，所以用month-1
c.set(Calendar.MONTH, month - 1);
//获取当前时间下，该月的最小日期的数字
int firstDay = c.getActualMinimum(Calendar.DAY_OF_MONTH);
//将获取的最小日期数设置为Calendar实例的日期数
c.set(Calendar.DAY_OF_MONTH, firstDay);
return dateFormat.format(c.getTime());
}
//获取指定年月的最后一天:getMonthLastDay()
public static String getMonthLastDay(int year, int month) {
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
//获取Calendar类的实例
Calendar c = Calendar.getInstance();
c.clear();
//设置年份
c.set(Calendar.YEAR, year);
//设置月份，因为月份从g开始，所以用month-1
c.set(Calendar.MONTH, month - 1);
//获取当前时间下，该月的最大日期的数字
int lastDay = c.getActualMaximum(Calendar.DAY_OF_MONTH);
//将获取的最大日期数设置为Calendar实例的日期数
c.set(Calendar.DAY_OF_MONTH, lastDay);
return dateFormat.format(c.getTime());
}
/**
* 局限性 算的是该日期在本年已过去天数
*
* @param date
* @return
*/
public static long getDays(Date date) {
SimpleDateFormat sf = new SimpleDateFormat("D");
String days = sf.format(date);
return Long.parseLong(days);
}
/**
* 从某个日期到现在的天数
* 今天到今天也是一天 加一操作
*
* @param date
* @return
*/
public static long getBetweenNowDays(Date date) {
long t = new Date().getTime() - date.getTime();
return t / (24 * 60 * 60 * 1000) + 1;
}
/**
* 日期转换成时间戳
*
* @param d
* @return
*/
public static long getCurrentTimeMillis(Date d) {
long l = 0;
if (null != d) {
l = d.getTime();
}
return l;
}
/**
* 时间戳转为日期类型 必须除以1000
* 本来这个是需要时间戳除以1000得到秒数的 TODO 我在这里处理过了 直接填写时间戳即可
*
* @param currentTime 时间戳
* @param patterns
* @return
*/
public static String currentTimeMillisToDate(Long currentTime, String patterns) {
if (patterns == null || patterns.isEmpty()) {
patterns = "yyyy-MM-dd HH:mm:ss";
}
SimpleDateFormat sdf = new SimpleDateFormat(patterns);
return sdf.format(new Date(Long.valueOf((currentTime / 1000) + "000")));
}
/**
* 当前时间戳 单位秒 1000 分钟是成*60 小时是成*60*60
* 必须除以1000
*
* @return
*/
public static Long getCurrentTime() {
return System.currentTimeMillis() / 1000;
}
/**
* 获得当天（指定时间）0点时间
*
* @return
*/
public static String getTimesMorning(String stringDate, int hour) {
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date parse = null;
Calendar cal = Calendar.getInstance();
if (stringDate != null && !"".equals(stringDate)) {
try {
parse = format.parse(stringDate);
cal.setTime(parse);
} catch (ParseException e) {
e.printStackTrace();
}
}
cal.set(Calendar.HOUR_OF_DAY, hour);//hour为 /获得当天几点时间
cal.set(Calendar.SECOND, 0);
cal.set(Calendar.MINUTE, 0);
cal.set(Calendar.MILLISECOND, 0);
Date time = cal.getTime();
String format1 = format.format(time);
return format1;
}
/**
* 从某个日期到现在的小时数
*
* @param date
* @return
*/
public static long pastHour(Date date) {
long t = new Date().getTime() - date.getTime();
return t / (60 * 60 * 1000);
}
/**
* 从某个日期到现在的分钟数
*
* @param date
* @return
*/
public static long pastMinutes(Date date) {
long t = new Date().getTime() - date.getTime();
return t / (60 * 1000);
}
/**
* 根据当前系统时间戳获取零点和二十四点的时间
* 这个意义不大 就是获取指定日期的零点和二十四点的时间 采用字符串拼接更快
*
* @param current 时间戳
* @param ifMoring 这个参数为true 另一个参数必须为 false
* @param ifNeight 这个参数为true 另一个参数必须为 false
* System.out.println(dateToString(getZeroDateAndTwelveDate
* (1638506096000L, false, true), YYYYMMDDHHMMSS));
* @return
*/
public static Date getZeroDateAndTwelveDate(long current, boolean ifMoring, boolean ifNeight) {
long zero = current / (1000 * 3600 * 24) * (1000 * 3600 * 24)
- TimeZone.getDefault().getRawOffset();// 今天零点零分零秒的毫秒数
long twelve = zero + 24 * 60 * 60 * 1000 - 1;// 今天23点59分59秒的毫秒数
Date date = null;
if (ifMoring && !ifNeight) {
date = new Date(zero);
} else {
date = new Date(twelve);
}
return date;
}
/**
* 获取两个日期字符串之间的日期集合
* []闭区间
*
* @param startTime 开始时间
* @param endTime 结束时间
* @return list
*/
public static List<String> getBetweenDateList(String startTime, String endTime) {
SimpleDateFormat sdf = new SimpleDateFormat(YYYYMMDD);
//声明保存日期的集合
ArrayList<String> list = new ArrayList<>();
try {
//转化日期类型
Date startDate = sdf.parse(startTime);
Date endDate = sdf.parse(endTime);
//用Calendar 进行日期比较判断
Calendar calendar = Calendar.getInstance();
while (startDate.getTime() <= endDate.getTime()) {
//把日期添加到集合
list.add(sdf.format(startDate));
//设置日期
calendar.setTime(startDate);
//把日期增加一天
calendar.add(Calendar.DATE, 1);
//获取增加后的一天
startDate = calendar.getTime();
}
} catch (ParseException e) {
e.printStackTrace();
}
return list;
}
/**
* 指定日期 年月日时分秒 增加减少操作
*
* @param date
* @param YEAR
* @param MONTH
* @param DAY_OF_MONTH
* @param HOUR
* @param MINUTE
* @param SECOND
* @return
*/
public static Date updateTime(Date date, Integer YEAR, Integer MONTH, Integer DAY_OF_MONTH,
Integer HOUR, Integer MINUTE, Integer SECOND) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
if (YEAR != null || YEAR != 0) {
calendar.add(Calendar.YEAR, YEAR);
}
if (MONTH != null || MONTH != 0) {
calendar.add(Calendar.MONTH, MONTH);
}
if (DAY_OF_MONTH != null || DAY_OF_MONTH != 0) {
calendar.add(Calendar.DAY_OF_MONTH, DAY_OF_MONTH);
}
if (HOUR != null || HOUR != 0) {
calendar.add(Calendar.HOUR, HOUR);
}
if (MINUTE != null || MINUTE != 0) {
calendar.add(Calendar.MINUTE, MINUTE);
}
if (SECOND != null || SECOND != 0) {
calendar.add(Calendar.SECOND, SECOND);
}
return calendar.getTime();
}
/**
* 日期比较
* 两个日期相等时，为 0
* dateString_01>dateString_02 为1
* dateString_01<dateString_02 为-1
*/
public static int FirstCompareToSecondDate(String dateString_01, String dateString_02) {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
if (dateString_01 != null || !"".equals(dateString_01)) {
if (dateString_01.length() == 10) {
dateString_01 = dateString_01 + " 00:00:00";
}
}
if (dateString_02 != null || !"".equals(dateString_02)) {
if (dateString_02.length() == 10) {
dateString_02 = dateString_02 + " 00:00:00";
}
}
Date date_01 = null;
Date date_02 = null;
try {
date_01 = sdf.parse(dateString_01);
date_02 = sdf.parse(dateString_02);
} catch (ParseException e) {
e.printStackTrace();
}
return date_01.compareTo(date_02);
}
/**
* 日期比较
* 两个日期相等时，为 0
* dateString_01>dateString_02 为1
* dateString_01<dateString_02 为-1
*/
public static int FirstCompareToSecondDate(Date dateString_01, Date dateString_02) {
return dateString_01.compareTo(dateString_02);
}
/**
* 判断指定日期是否闰年
* 闰年的判断规则如下：
* （1）若某个年份能被4整除但不能被100整除，则是闰年。
* （2）若某个年份能被400整除，则也是闰年。
*
* @param date
* @return
*/
public static boolean ifLeapYear(Date date) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
int year = calendar.get(Calendar.YEAR);
if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
return true;
} else {
return false;
}
}
/**
* GregorianCalendar 类有是否闰年判断的方法
* 补充平年、闰年小知识
* 平年 2月 28天 闰年则是29天 也就是说平年365天 闰年 366天
* 公历年份是单数的一定是平年 是双数的 则看年份后两位是否能被4整除 整百年的 则看前两位是否被4整除
*
* @param year
* @return
*/
public static boolean ifLeapYear(int year) {
GregorianCalendar cal = (GregorianCalendar) GregorianCalendar.getInstance();
return cal.isLeapYear(year);
}
/**
* 返回两个时间相差的天小时分钟秒 可扩展
* 2天23小时12分钟59秒
*
* @param date1
* @param date2
*/
public static String needDate(String date1, String date2) {
DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date d1 = null;
Date d2 = null;
try {
d1 = df.parse(date1);
d2 = df.parse(date2);
long nd = 1000 * 24 * 60 * 60;
long nh = 1000 * 60 * 60;
long nm = 1000 * 60;
long ns = 1000;
// 获得两个时间的毫秒时间差异
long diff = d2.getTime() - d1.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 + "小时" + min + "分钟" + sec + "秒";
} catch (ParseException e) {
e.printStackTrace();
return null;
}
}
/**
* 日期转为中文汉字形式
* 其中0目前转的是〇 具体业务时可修改
*
* @param da
* @return
*/
public static String formatChineseDate(Date da) {
String chineseDate = "";
String datestr = getSimpleDateFormat(null).format(da);
String[] strs = datestr.split("-");
// 年
for (int i = 0; i < strs[0].length(); i++) {
chineseDate += formatChinese(strs[0].charAt(i));
}
// chineseDate = chineseDate+"年";
// 月
char c1 = strs[1].charAt(0);
char c2 = strs[1].charAt(1);
String newmonth = "";
if (c1 == '0') {
newmonth = String.valueOf(formatChinese(c2));
} else if (c1 == '1' && c2 == '0') {
newmonth = "十";
} else if (c1 == '1' && c2 != '0') {
newmonth = "十" + formatChinese(c2);
}
chineseDate = chineseDate + "年" + newmonth + "月";
// 日
char d1 = strs[2].charAt(0);
char d2 = strs[2].charAt(1);
String newday = "";
if (d1 == '0') {//单位数天
newday = String.valueOf(formatChinese(d2));
} else if (d1 != '1' && d2 == '0') {//几十
newday = String.valueOf(formatChinese(d1)) + "十";
} else if (d1 != '1' && d2 != '0') {//几十几
newday = formatChinese(d1) + "十" + formatChinese(d2);
} else if (d1 == '1' && d2 != '0') {//十几
newday = "十" + formatChinese(d2);
} else {//10
newday = "十";
}
chineseDate = chineseDate + newday + "日";
return chineseDate;
}
public static char formatChinese(char sign) {
if (sign == '0')
sign = '〇';
if (sign == '1')
sign = '一';
if (sign == '2')
sign = '二';
if (sign == '3')
sign = '三';
if (sign == '4')
sign = '四';
if (sign == '5')
sign = '五';
if (sign == '6')
sign = '六';
if (sign == '7')
sign = '七';
if (sign == '8')
sign = '八';
if (sign == '9')
sign = '九';
return sign;
}
/**
* JAVA 计算两个日期的相差月份
* 这个有局限性 比如说同一年两个日期之间的相差月份 它是拿两两个日期的月份相减
* 如 2022-01-31 到 2022-02-01 实际间隔一天 这里间隔是一个月 ，
* （或者根据实际间隔天数来控制间隔月份 这里的根据具体业务变更不做赘述）
*
* @param startDate
* @param endDate
* @return
*/
public static Integer getDifMonth(Date startDate, Date endDate) {
Calendar start = Calendar.getInstance();
Calendar end = Calendar.getInstance();
start.setTime(startDate);
end.setTime(endDate);
int result = end.get(Calendar.MONTH) - start.get(Calendar.MONTH);
int month = (end.get(Calendar.YEAR) - start.get(Calendar.YEAR)) * 12;
return Math.abs(month + result);
}
/**
* Java判断日期相差几个月
* 效果上跟：getDifMonth()别无二致
*
* @param start
* @param end
* @return
*/
public static int getMonth(Date start, Date end) {
if (start.after(end)) {
Date t = start;
start = end;
end = t;
}
Calendar startCalendar = Calendar.getInstance();
startCalendar.setTime(start);
Calendar endCalendar = Calendar.getInstance();
endCalendar.setTime(end);
Calendar temp = Calendar.getInstance();
temp.setTime(end);
temp.add(Calendar.DATE, 1);
int year = endCalendar.get(Calendar.YEAR)
- startCalendar.get(Calendar.YEAR);
int month = endCalendar.get(Calendar.MONTH)
- startCalendar.get(Calendar.MONTH);
if ((startCalendar.get(Calendar.DATE) == 1)
&& (temp.get(Calendar.DATE) == 1)) {
return year * 12 + month + 1;
} else if ((startCalendar.get(Calendar.DATE) != 1)
&& (temp.get(Calendar.DATE) == 1)) {
return year * 12 + month;
} else if ((startCalendar.get(Calendar.DATE) == 1)
&& (temp.get(Calendar.DATE) != 1)) {
return year * 12 + month;
} else {
return (year * 12 + month - 1) < 0 ? 0 : (year * 12 + month);
}
}
/**
* 参数：Date类型
* 如何确定日期是否在Java中的两个日期之间
* 如果您希望范围包含在内直接使用 默认包含 不包含请去掉等于
*/
public static boolean isTodayBetween(final Date min, final Date max, final Date targetDate) {
//以下四种写法
//return min.compareTo(targetDate) * targetDate.compareTo(max) >= 0;
// // return targetDate.after(min) && targetDate.before(max);//日期之间不包括终点
//return !(targetDate.before(min) || targetDate.after(max));//日期之间包括终点可以写成
//return targetDate.compareTo(min) >= 0 && targetDate.compareTo(max) <= 0;
return min.getTime() <= targetDate.getTime() && targetDate.getTime() <= max.getTime();
}
/**
* 参数：String类型
* 如何确定日期是否在Java中的两个日期之间
* 如果您希望范围包含在内直接使用 默认包含 不包含请去掉等于
*/
public static boolean isTodayBetween(final String min1, final String max1, final String targetDate1) {
SimpleDateFormat sf = null;
if (min1.length() > 10 && max1.length() > 10 && targetDate1.length() > 10) {
sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
} else {
sf = new SimpleDateFormat("yyyy-MM-dd");
}
final Date min, max, targetDate;
try {
min = sf.parse(min1);
System.out.println(sf.format(min));
max = sf.parse(max1);
targetDate = sf.parse(targetDate1);
//以下四种写法
//return min.compareTo(targetDate) * targetDate.compareTo(max) >= 0;
// // return targetDate.after(min) && targetDate.before(max);//日期之间不包括终点
//return !(targetDate.before(min) || targetDate.after(max));//日期之间包括终点可以写成
//return targetDate.compareTo(min) >= 0 && targetDate.compareTo(max) <= 0;
return min.getTime() <= targetDate.getTime() && targetDate.getTime() <= max.getTime();
} catch (ParseException e) {
e.printStackTrace();
}
return true;
}
/**
* 最小时间
* SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
* SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:ss:mm");
* System.out.println(sdf1.format(setMinTime(sdf.parse("2021-11-01"))));
*/
private static Date setMinTime(Date date) {
Calendar calendar = Calendar.getInstance();
calendar.clear();
calendar.setTime(date);
calendar.set(Calendar.HOUR_OF_DAY, 0);
calendar.set(Calendar.MINUTE, 0);
calendar.set(Calendar.SECOND, 0);
calendar.set(Calendar.MILLISECOND, 0);
return calendar.getTime();
}
/**
* 最大时间
*/
private static Date setMaxTime(Date date) {
Calendar calendar = Calendar.getInstance();
calendar.clear();
calendar.setTime(date);
calendar.set(Calendar.HOUR_OF_DAY, calendar.getActualMaximum(Calendar.HOUR_OF_DAY));
calendar.set(Calendar.MINUTE, calendar.getActualMaximum(Calendar.MINUTE));
calendar.set(Calendar.SECOND, calendar.getActualMaximum(Calendar.SECOND));
calendar.set(Calendar.MILLISECOND, calendar.getActualMaximum(Calendar.MILLISECOND));
return calendar.getTime();
}
/**
* 测试
*
* @param args
*/
public static void main(String[] args) {
// System.out.println(getStringWeekDay(stringToDate("2021-02-15", "")));
// System.out.println(getStringWeekDay(new Date()));
//
// System.out.println(getStringSeason(stringToDate("2021-02-01", "")));
// System.out.println(getStringWeekDay(stringToDate("2021-12-12", "")));
//
// System.out.println(getBetweenDays(stringToDate("2021-01-01", ""), stringToDate("2021-12-08", "")));
// Date[] seasonDate = getSeasonDate(stringToDate("2021-02-01", ""));
// for (Date date : seasonDate) {
// System.out.println(dateToString(date, null));
// }
// System.out.println(dateToString(getLastDateOfSeason(new Date()), null));
// System.out.println(dateToString(getLastDateOfSeason(stringToDate("2021-04-31", "")), null));
Date date = updateTime(stringToDate("2021-12-09 22:55:56", YYYYMMDDHHMMSS), 1, 1, 1, 1, 6, 5);
// System.out.println(dateToString(date, YYYYMM_ZH));//2023-01-11 00:02:01
// System.out.println(getNextFirstMonth(stringToDate("2021-02-09 22:55:56", YYYYMMDDHHMMSS)));
// System.out.println(FirstCompareToSecondDate(stringToDate("2021-12-09 23:59:59", YYYYMMDDHHMMSS),stringToDate("2021-12-09 23:59:57", null)));
// System.out.println(FirstCompareToSecondDate("2021-12-09", "2021-12-09"));
// System.out.println(getQuarterMonth(new Date(),null));
}
}
/**
* 以指定的格式格式化日期字符串：formatDate()
* 获取指定年份 指定季度 的日期区间：getCurrQuarter()、推荐使用：getTemporalInterval()
* 获取某年第一天日期：getYearFirst()
* 获取某年最后一天日期：getYearLast()
* 获取季节 春夏秋冬：getSeason()
* 获取月份所属季度 返回数值：getMonthQuarterInt()
* 获取月份所属季度 返回文字：getMonthQuarterString
*/
/**
* 用途：以指定的格式格式化日期字符串
*
* @param pattern 字符串的格式
* @param currentDate 被格式化日期
* @return String 已格式化的日期字符串
* @throws NullPointerException 如果参数为空
*/
public static String formatDate(Date currentDate, String pattern) {
if (currentDate == null || "".equals(pattern) || pattern == null) {
return null;
}
SimpleDateFormat sdf = new SimpleDateFormat(pattern);
return sdf.format(currentDate);
}
/**
* 获取指定年份 指定季度 的日期区间
*
* @param year
* @param num
* @return
*/
public static String[] getCurrQuarter(int year, int num) {
String[] s = new String[2];
String str = "";
// 设置本年的季
Calendar quarterCalendar = Calendar.getInstance();
quarterCalendar.set(Calendar.YEAR, year);
switch (num) {
case 1: // 本年到现在经过了一个季度，在加上前4个季度
quarterCalendar.set(Calendar.MONTH, 3);
quarterCalendar.set(Calendar.DATE, 1);
quarterCalendar.add(Calendar.DATE, -1);
str = DateUtils.formatDate(quarterCalendar.getTime(), "yyyy-MM-dd");
s[0] = str.substring(0, str.length() - 5) + "01-01";
s[1] = str;
break;
case 2: // 本年到现在经过了二个季度，在加上前三个季度
quarterCalendar.set(Calendar.MONTH, 6);
quarterCalendar.set(Calendar.DATE, 1);
quarterCalendar.add(Calendar.DATE, -1);
str = DateUtils.formatDate(quarterCalendar.getTime(), "yyyy-MM-dd");
s[0] = str.substring(0, str.length() - 5) + "04-01";
s[1] = str;
break;
case 3:// 本年到现在经过了三个季度，在加上前二个季度
quarterCalendar.set(Calendar.MONTH, 9);
quarterCalendar.set(Calendar.DATE, 1);
quarterCalendar.add(Calendar.DATE, -1);
str = DateUtils.formatDate(quarterCalendar.getTime(), "yyyy-MM-dd");
s[0] = str.substring(0, str.length() - 5) + "07-01";
s[1] = str;
break;
case 4:// 本年到现在经过了四个季度，在加上前一个季度
// quarterCalendar.add(Calendar.YEAR, -1);
quarterCalendar.set(Calendar.MONTH, 12);
quarterCalendar.set(Calendar.DATE, 1);
quarterCalendar.add(Calendar.DATE, -1);
str = DateUtils.formatDate(quarterCalendar.getTime(), "yyyy-MM-dd");
s[0] = str.substring(0, str.length() - 5) + "10-01";
s[1] = str;
break;
}
return s;
}
/**
* 获取指定年份 指定季度 的日期区间
* 我自己写的一个简单办法，感觉更容易理解
* @param year
* @param num
* @return
*/
public static Map<String, Object> getTemporalInterval(int year, int num) {
Map<String, Object> map = new HashMap<>();
String startDate = "";
String endDate = "";
switch (num) {
case 1:
startDate = "01-01";
endDate = "03-31";
break;
case 2:
startDate = "04-01";
endDate = "06-30";
break;
case 3:
startDate = "07-01";
endDate = "09-30";
break;
case 4:
startDate = "10-01";
endDate = "12-31";
break;
}
map.put("startDate", year +"-"+ startDate);
map.put("endDate", year + "-"+endDate);
return map;
}
/**
* 获取某年第一天日期
* 这里没有精确到时分秒毫秒，需要的自己加即可
*
* @param year 年份
* @return Date
*/
public static Date getYearFirst(int year) {
Calendar calendar = Calendar.getInstance();
calendar.clear();
calendar.set(Calendar.YEAR, year);
Date currYearFirst = calendar.getTime();
return currYearFirst;
}
/**
* 获取某年最后一天日期
* 这里没有精确到时分秒毫秒，需要的自己加即可
*
* @param year 年份
* @return Date
*/
public static Date getYearLast(int year) {
Calendar calendar = Calendar.getInstance();
calendar.clear();
calendar.set(Calendar.YEAR, year);
calendar.roll(Calendar.DAY_OF_YEAR, -1);
Date currYearLast = calendar.getTime();
return currYearLast;
}
/**
* 判断两个日期的跨度是否超过一年（12个月）： checkIsOneYear
* 校验日期区间时间跨度是否在一年之内
* 参数日期格式应为 yyyy-MM-dd，例如：2020-12-31
*
* @param beginDate 开始日期
* @param dueDate 结束日期
*/
public static boolean checkIsOneYear(String beginDate, String dueDate) {
//365天的毫秒数
long ms = 31536000000L;
try {
//规定需要转换的日期格式
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
//文本转日期
Date due = sdf.parse(dueDate);
Date begin = sdf.parse(beginDate);
long time = due.getTime() - begin.getTime();
// System.out.println(time + "=" + due.getTime() + "-" + begin.getTime());
//天数大于366天或者小于一天一定属于不合理输入，返回false
if (time > 31622400000L || time < 0L) {
// System.out.println("查询时间期间不合法。");
return false;
}
//对字符串截取，取出年份和月份
Integer beginYear = Integer.valueOf(beginDate.substring(0, 4));
Integer beginMonth = Integer.valueOf(beginDate.substring(5, 7));
Integer dueYear = Integer.valueOf(dueDate.substring(0, 4));
Integer dueMonth = Integer.valueOf(dueDate.substring(5, 7));
//判断是否为闰年，并跨过2月，如果是则增加一天的毫秒数
if (isLeapYear(beginYear) && beginMonth <= 2) {
ms += 86400000;
} else if (isLeapYear(dueYear) && dueMonth >= 2) {
ms += 86400000;
}
return time <= ms;
} catch (Exception e) {
e.printStackTrace();
}
return false;
}
/**
* 给定一个年份，判断是否为闰年:isLeapYear
*
* @param year
* @return
*/
public static boolean isLeapYear(Integer year) {
if (year % 100 == 0) {
if (year % 400 == 0) {
return true;
}
} else if (year % 4 == 0) {
return true;
}
return false;
}
/**
* 判断两个日期间是否超过指定的年数:DateCompareBefourYear
*
* @param date1
* @param date2
* @param numYear
* @return 两个日期间相差一秒都不算超过
*/
public static Boolean DateCompareBefourYear(Date date1, Date date2, int numYear) {
if (date1.compareTo(date2) == 1) {
Date tem = date1;
date1 = date2;
date2 = tem;
}
Date time3 = add(date1, Calendar.YEAR, numYear);
if (time3.getTime() < date2.getTime()) {
return true;
}
return false;
}
/**
* 时间加减
*
* @param date
* @param calendarField ：Calendar.YEAR/ Calendar.MONTH /Calendar.DAY
* @param amount
* @return
*/
public static Date add(final Date date, final int calendarField, final int amount) {
if (date == null) {
return null;
}
final Calendar c = Calendar.getInstance();
c.setTime(date);
c.add(calendarField, amount);
return c.getTime();
}
/**
* 获取季节 春夏秋冬：getSeason()
* @param month
* @return
*/
public static String getSeason(int month) {
String season = "";
switch (month) {
case 12:
case 1:
case 2:
season = "冬季";
break;
case 3:
case 4:
case 5:
season = "春季";
break;
case 6:
case 7:
case 8:
season = "夏季";
break;
case 9:
case 10:
case 11:
season = "秋季";
break;
}
return season;
}
/**
* 获取月份所属季度 返回文字：getMonthQuarterString
*/
public static String getMonthQuarterString(int month) {
int quarter = (month + 2) / 3;
String result = "";
switch (quarter) {
case 1: result = "第一季度"; break;
case 2: result = "第二季度"; break;
case 3: result = "第三季度"; break;
case 4: result = "第四季度"; break;
}
return result;
}
/**
* 获取月份所属季度 返回数值：getMonthQuarterInt()
*/
public static int getMonthQuarterInt(int month) {
return ((month + 2) / 3);
}
/**
* 获取指定时间段内所有季度：getSeasonList()
* @param startTime 开始时间
* @param endTime 结束时间
*/
public static List<String> getSeasonList(LocalDate startTime, LocalDate endTime) {
// 取当月第一天, 避免startTime的日期大于endTime计算不出来的情况
startTime = LocalDate.of(startTime.getYear(), startTime.getMonthValue(), 1);
endTime = LocalDate.of(endTime.getYear(), endTime.getMonthValue(), 1);
Set<String> set = new HashSet<>();
LocalDate mark = startTime;
while (true) {
if (mark.isBefore(endTime) || mark.isEqual(endTime)) {
String season = String.valueOf(mark.getYear())+"-" + String.valueOf((mark.getMonthValue() + 2) / 3);
set.add(season);
// 加一个月
mark = mark.plusMonths(1);
} else {
break;
}
}
// System.out.println(set);
// set中是倒序, 重新排序
return set.stream().sorted().collect(Collectors.toList());
}
/**
* Java判断当前时间是否在两个时间段内
*
* @param nowTime 当前目标时间
* @param beginTime 开始时间
* @param endTime 结束时间
* @param includeHourMinuteSecond 是否包含时分秒 true 包含 false 不包含时分秒
* @return
*/
public static boolean belongCalendar(Date nowTime, Date beginTime, Date endTime, boolean includeHourMinuteSecond) {
if (!includeHourMinuteSecond) {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
String nowTimeString = sdf.format(nowTime);
String beginTimeString = sdf.format(beginTime);
String endTimeTimeString = sdf.format(endTime);
try {
nowTime = sdf.parse(nowTimeString);
beginTime = sdf.parse(beginTimeString);
endTime = sdf.parse(endTimeTimeString);
} catch (ParseException e) {
throw new RuntimeException(e);
}
}
if (nowTime.getTime() == beginTime.getTime()
|| nowTime.getTime() == endTime.getTime()) {
return true;
}
Calendar date = Calendar.getInstance();
date.setTime(nowTime);
Calendar begin = Calendar.getInstance();
begin.setTime(beginTime);
Calendar end = Calendar.getInstance();
end.setTime(endTime);
if (date.after(begin) && date.before(end)) {
return true;
} else {
return false;
}
}
public static void main(String[] args) {
//[2021-01-01, 2021-03-31]
//[2021-04-01, 2021-06-30]
//[2021-07-01, 2021-09-30]
//[2021-10-01, 2021-12-31]
for (int i = 1; i <= 4; i++) {
String[] currQuarter = getCurrQuarter(2020, i);
System.out.println(Arrays.toString(currQuarter));
}
for (int i = 1; i <= 4; i++) {
Map<String, Object> temporalInterval = getTemporalInterval(2020, i);
System.out.println("["+temporalInterval.get("startDate")+", "+temporalInterval.get("endDate")+"] ");
}
//2022-01-01
System.out.println(formatDate(getYearFirst(2022), "yyyy-MM-dd"));
//2022-12-31
System.out.println(formatDate(getYearLast(2022), "yyyy-MM-dd"));
LocalDate startTime = LocalDate.of(2021, 1, 10);
LocalDate endTime = LocalDate.of(2022, 7, 1);
List<String> set = getSeasonList(startTime, endTime);
//[2021-1, 2021-2, 2021-3, 2021-4, 2022-1, 2022-2, 2022-3]
System.out.println(set);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date nowTime= sdf.parse("2022-12-29 11:12:52");
Date beginTime=sdf.parse("2022-12-28 10:12:53");
Date endTime = sdf.parse("2022-12-31 10:12:56");
boolean includeHourMinuteSecond = false;
System.out.println(belongCalendar(nowTime, beginTime, endTime, false));
}
获取时间段内所有季度 、获取两个日期之间的所有月份 (年月)、
返回指定日期上月末日期（yyyy年mmdd日格式）、
Java计算两个日期相差的年数、月数、天数（这块特点是 你多一天少一天我就认为你两个时间段间隔不到一年、一月、一日）
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.util.*;
import java.util.stream.Collectors;
/**
* @version 1.0
* @date 2022/8/31 11:05
*/
public class DateTest {
/**
* 获取时间段内所有季度
*
* @param startTime 开始时间
* @param endTime 结束时间
*/
public static List<String> getSeasonList(LocalDate startTime, LocalDate endTime) {
// 取当月第一天, 避免startTime的日期大于endTime计算不出来的情况
startTime = LocalDate.of(startTime.getYear(), startTime.getMonthValue(), 1);
endTime = LocalDate.of(endTime.getYear(), endTime.getMonthValue(), 1);
Set<String> set = new HashSet<>();
LocalDate mark = startTime;
while (true) {
if (mark.isBefore(endTime) || mark.isEqual(endTime)) {
String season = String.valueOf(mark.getYear()) +"第"+ String.valueOf((mark.getMonthValue() + 2) / 3)+"季度";
set.add(season);
// 加一个月
mark = mark.plusMonths(1);
} else {
break;
}
}
// System.out.println(set);
// set中是倒序, 重新排序
return set.stream().sorted().collect(Collectors.toList());
}
public static void main(String[] args) {
LocalDate startTime = LocalDate.of(2021, 2, 28);
LocalDate endTime = LocalDate.of(2022, 3, 31);
List<String> set = getSeasonList(startTime, endTime);
//[2021第1季度, 2021第2季度, 2021第3季度, 2021第4季度, 2022第1季度]
System.out.println(set);
//[2021-02, 2021-03, 2021-04, 2021-05, 2021-06, 2021-07, 2021-08, 2021-09, 2021-10, 2021-11, 2021-12, 2022-01, 2022-02, 2022-03]
String startStr = "2021-02-26";
String endStr = "2022-03-09";
List<String> list = getMonthBetweenDate(startStr, endStr);
System.out.println(list);
//Java计算两个日期相差的年数、月数、天数
//这块特点是 你多一天少一天我就认为你两个时间段间隔不到一年、一月、一日
// String text1 = "2019-05-30";//3
// String text1 = "2019-05-31";//2
// String text1 = "2019-05-29";//3
// String text1 = "2019-01-01";//3
// String text1 = "2018-05-31";//3
String text1 = "2018-05-30";//4
Temporal startDate = LocalDate.parse(text1);
String text2 = "2022-05-30";
Temporal endDate = LocalDate.parse(text2);
System.out.println("------- year --------------");
// 方法返回为相差年数
long years = ChronoUnit.YEARS.between(startDate, endDate);
System.out.println(years);
System.out.println("------- month --------------");
// 方法返回为相差月数
long months = ChronoUnit.MONTHS.between(startDate, endDate);
System.out.println(months);
System.out.println("------- day --------------");
// 方法返回为相差天数
long days = ChronoUnit.DAYS.between(startDate, endDate);
System.out.println(days);
}
/**
* 获取两个日期之间的所有月份 (年月)
*
* @param startTime
* @param endTime
* @return：YYYY-MM
*/
public static List<String> getMonthBetweenDate(String startTime, String endTime){
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM");
// 声明保存日期集合
List<String> list = new ArrayList<String>();
try {
// 转化成日期类型
Date startDate = sdf.parse(startTime);
Date endDate = sdf.parse(endTime);
//用Calendar 进行日期比较判断
Calendar calendar = Calendar.getInstance();
while (startDate.getTime()<=endDate.getTime()){
// 把日期添加到集合
list.add(sdf.format(startDate));
// 设置日期
calendar.setTime(startDate);
//把日期增加一天
calendar.add(Calendar.MONTH, 1);
// 获取增加后的日期
startDate=calendar.getTime();
}
} catch (ParseException e) {
e.printStackTrace();
}
return list;
}
/**
* 返回指定日期上月末日期（yyyy年mmdd日格式）getLastDate
* @param date
* @return
*/
public static String getLastDate(Date date) {
Calendar c = Calendar.getInstance();
c.clear();
c.setTime(date);
c.add(Calendar.MONTH, -1);
c.set(Calendar.DAY_OF_MONTH, c.getActualMaximum(Calendar.DAY_OF_MONTH));
Date time = c.getTime();
SimpleDateFormat sf = new SimpleDateFormat("yyyy年MM月dd日");
return sf.format(c.getTime());
}
}
判断日期是否是今天，本周，本月，本季度，本年
package com.bmsoft.smart.utils;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
public class FindDateStatusUtil {
//判断选择的日期是否是本周
public static boolean isThisWeek(Date time) {
Calendar calendar = Calendar.getInstance();
int currentWeek = calendar.get(Calendar.WEEK_OF_YEAR);
calendar.setTime(time);
int paramWeek = calendar.get(Calendar.WEEK_OF_YEAR);
if (paramWeek == currentWeek) {
return true;
}
return false;
}
//判断选择的日期是否是今天
public static boolean isToday(Date time) {
return isThisTime(time, "yyyy-MM-dd");
}
//判断选择的日期是否是本月
public static boolean isThisMonth(Date time) {
return isThisTime(time, "yyyy-MM");
}
//判断选择的日期是否是本年
public static boolean isThisYear(Date time) {
return isThisTime(time, "yyyy");
}
//判断选择的日期是否是本季度
public static boolean isThisQuarter(Date time) {
Date QuarterStart = getCurrentQuarterStartTime();
Date QuarterEnd = getCurrentQuarterEndTime();
return time.after(QuarterStart) && time.before(QuarterEnd);
}
private static boolean isThisTime(Date time, String pattern) {
SimpleDateFormat sdf = new SimpleDateFormat(pattern);
String param = sdf.format(time);//参数时间
String now = sdf.format(new Date());//当前时间
if (param.equals(now)) {
return true;
}
return false;
}
/**
* 获得季度开始时间：getCurrentQuarterStartTime()
* @return
*/
public static Date getCurrentQuarterStartTime() {
Calendar c = Calendar.getInstance();
int currentMonth = c.get(Calendar.MONTH) + 1;
SimpleDateFormat longSdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
SimpleDateFormat shortSdf = new SimpleDateFormat("yyyy-MM-dd");
Date now = null;
try {
if (currentMonth >= 1 && currentMonth <= 3)
c.set(Calendar.MONTH, 0);
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);
now = longSdf.parse(shortSdf.format(c.getTime()) + " 00:00:00");
} catch (Exception e) {
e.printStackTrace();
}
return now;
}
/**
* 当前季度的结束时间: getCurrentQuarterEndTime()
* @return
*/
public static Date getCurrentQuarterEndTime() {
Calendar cal = Calendar.getInstance();
cal.setTime(getCurrentQuarterStartTime());
cal.add(Calendar.MONTH, 3);
return cal.getTime();
}
}
获取手动设置指定日期
/**
* 功能获取手动设置指定日期(要有意义的日期呦)，这个原本是用来获取上月出末日期的，现在更加灵活
* 第一位参数是获取当前设置月的最后一天 true的话day那里的值都不会使用
* 这块设置的可变参数，总共7个参数，必须有值，如果不想设置的值请输入0 注意day那里不能为0
* year, month, day, hour, minute, second, millisecond
* @param year
* @return
*/
public static Long setDateTime1(boolean LastMonth,Integer ...year) {
Long currentTime = System.currentTimeMillis();
String timeZone = "GMT+8:00";
Calendar calendar = Calendar.getInstance();// 获取当前日期
calendar.setTimeZone(TimeZone.getTimeZone(timeZone));
calendar.setTimeInMillis(currentTime);
calendar.add(Calendar.YEAR, year[0]);
calendar.add(Calendar.MONTH, year[1]);
if (LastMonth) {
// 获取当前月最后一天
calendar.set(Calendar.DAY_OF_MONTH, calendar.getActualMaximum(Calendar.DAY_OF_MONTH));
}else {
// 获取当前月天
calendar.set(Calendar.DAY_OF_MONTH, year[2]);
}
calendar.set(Calendar.HOUR_OF_DAY, year[3]);
calendar.set(Calendar.MINUTE, year[4]);
calendar.set(Calendar.SECOND, year[5]);
calendar.set(Calendar.MILLISECOND, year[6]);
return calendar.getTimeInMillis();
}
public static void main(String[] args) {
Long aLong = setDateTime1(false,0,-1,1,0,0,0,0);
Long aLong2 = setDateTime1(true,0,-1,0,23,59,59,999);
DateTimeFormatter ftf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String startTimeStr = ftf.format(LocalDateTime.ofInstant(Instant.ofEpochMilli(aLong), ZoneId.systemDefault()));
String endTimeStr = ftf.format(LocalDateTime.ofInstant(Instant.ofEpochMilli(aLong2), ZoneId.systemDefault()));
System.out.println(startTimeStr);//2022-04-01 00:00:00
System.out.println(endTimeStr);//2022-04-30 23:59:59
}
返回当前或者指定时间的年月日时分秒毫秒任意一位值
作用：这样就能快速得到 上一年 前年时间的数值、至于获取上个月还得分析年的情况 如1月 上个月就是上年12月
/**
* 获取当前时间的年月日：getTargetNumber
* @param flag 1表示年依次往后推
* @return
*/
public static int getTargetNumber(String flag){
String numStr ="";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd-HH-mm-ss-SSS");
String format = sdf.format(new Date());
String[] numStrArr = format.split("-");
switch (flag) {
case "1":numStr=numStrArr[0];break;
case "2":numStr=numStrArr[1];break;
case "3":numStr=numStrArr[2];break;
case "4":numStr=numStrArr[3];break;
case "5":numStr=numStrArr[4];break;
case "6":numStr=numStrArr[5];break;
case "7":numStr=numStrArr[6];break;
default :numStr="0";
}
return Integer.parseInt(numStr);
}
/**
* 获取指定时间的年月日：getTargetNumber1
* @param date 如果为空则取当前时间
* @param flag
* @return
*/
public static int getTargetNumber1(Date date,String flag){
// Calendar 取得当前时间的方法
Calendar calendar = Calendar.getInstance(); // 初始化 (重置) Calendar 对象
if (date != null) {
calendar.clear();
calendar.setTime(date);//todo 通过此方法设置任意想要的时间点
}
Date calendarTime = calendar.getTime();//通过getTime获取时间
// String format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS").format(calendarTime);
String format = new SimpleDateFormat("yyyy-MM-dd-HH-mm-ss-SSS").format(calendarTime);
String numStr ="";
String[] numStrArr = format.split("-");
switch (flag) {
case "1":numStr=numStrArr[0];break;
case "2":numStr=numStrArr[1];break;
case "3":numStr=numStrArr[2];break;
case "4":numStr=numStrArr[3];break;
case "5":numStr=numStrArr[4];break;
case "6":numStr=numStrArr[5];break;
case "7":numStr=numStrArr[6];break;
default :numStr="0";
}
return Integer.parseInt(numStr);
}
工作记录 获得某年某个月最大天数、判断日期是否在指定时间段内等
获取指定日期的前后一天(几天、几年、几月)后的日期
/**
* 获得某年某个月最大天数
* @param year 年份
* @param month 月份 (1-12)
* @return 某个月最大天数
*/
public static int getMaxDayByYearMonth(int year, int month) {
Calendar calendar = Calendar.getInstance();
calendar.clear();
calendar.set(Calendar.YEAR, year);
calendar.set(Calendar.MONTH, month - 1);
return calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
}
/**
* 取得月最后一天 返回String 类型的年月日
* @param date
* @return
*/
public static String getLastDateOfMonth(String date) {
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
Date parse = null;
try {
parse = df.parse(date);
} catch (ParseException e) {
e.printStackTrace();
}
Calendar c = Calendar.getInstance();
c.setTime(parse);
c.set(Calendar.DAY_OF_MONTH, c.getActualMaximum(Calendar.DAY_OF_MONTH));
return df.format(c.getTime());
}
/**
* todo 根据我的需求改写你的需求
* 需求：用户选择一个日期，判断是否在当前日期的前一天，年末的最后一天
* 即：今天是22年6月21日 则合格日期应该在 [2022-06-22,2022-12-31] 否则的进行错误提醒
* 因为给的是String格式日期所以才写了此方法，日期类型的直接比较即可没啥好说的。
* todo 这里时间要不要到时分秒级别、要不要等于的情况 根据自己需求改改格式化条件及要不要等于的情况即可
*
* @param targetDate 你选择的时间
* @param startDate 你所能选择的最小结束时间 我这里取的是当前时间 也就是 2022-06-21 所以compareTo时候不能取等于
* @param endDate 你所能选择的最大结束时间 也就是所谓的2022-12-31
* @param stringFormat
* @return
*/
public static boolean dateCompare(String targetDate, String startDate, String endDate, String stringFormat) {
Date tarDa = null;
Date strD = null;
Date endD = null;
if ("".equals(stringFormat) || null == stringFormat) {
stringFormat = "yyyy-MM-dd";
}
SimpleDateFormat df = new SimpleDateFormat(stringFormat);
try {
tarDa = df.parse(targetDate);
strD = df.parse(startDate);
endD = df.parse(endDate);
if (tarDa.compareTo(strD) <= 0 || tarDa.compareTo(endD) > 0) {
return false;
}
} catch (ParseException e) {
e.printStackTrace();
}
return true;
}
/**
* 获取指定日期的前后一天(几天、几年、几月)后的日期
*/
public static String getTargetDate(String targetDate, Integer year, Integer month, Integer day) {
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
Date tarDa = null;
try {
tarDa = df.parse(targetDate);
Calendar calendar = Calendar.getInstance(); // 初始化 (重置) Calendar 对象
calendar.clear();
calendar.setTime(tarDa);
if (year != null || year != 0) {
calendar.add(Calendar.YEAR, year);
}
if (month != null || month != 0) {
calendar.add(Calendar.MONTH, month);
}
if (day != null || day != 0) {
calendar.add(Calendar.DAY_OF_MONTH, day);
}
tarDa = calendar.getTime();
} catch (ParseException e) {
e.printStackTrace();
}
return df.format(tarDa);
}
public static void main(String[] args) {
System.out.println(dateCompare("2022-06-21", "2022-06-21", "2022-12-31", null));//false
System.out.println(dateCompare("2022-06-22", "2022-06-21", "2022-12-31", null));//true
System.out.println(dateCompare("2022-12-31", "2022-06-21", "2022-12-31", null));//true
System.out.println(dateCompare("2023-01-01", "2022-06-21", "2022-12-31", null));//false
}
关于Calendar类使用
Calendar 1、可以设置某个时间
2、可以获取年、月、日、时、分、秒、毫秒、周、天、星期等
3、还可以加年月日时分秒等等 还可以比较日期间
package datetime.time.util.dateUtil;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
public class Cal {
public static void main(String[] args) {
// Calendar 取得当前时间的方法
Calendar calendar = Calendar.getInstance(); // 初始化 (重置) Calendar 对象
Date calendarTime = calendar.getTime();//通过getTime获取时间
System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS").format(calendarTime));
// 或者用 Date 来初始化 Calendar 对象
calendar.clear();
calendar.setTime(new Date());//todo 通过此方法设置任意想要的时间点
System.out.println((new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS")).format(calendar.getTime()));
//还可以设置时间戳 两者等价
calendar.clear();
calendar.setTimeInMillis(System.currentTimeMillis());
calendar.setTime(new Date(System.currentTimeMillis()));
System.out.println((new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS")).format(calendar.getTime()));
//2021-12-09 20:42:08:879
//获取年月日等 注意月份的时候要加1
int year = calendar.get(Calendar.YEAR); // 显示年份 2021
int month = calendar.get(Calendar.MONTH); //12 todo 显示月份 (从0开始, 实际显示要加1)
int week = calendar.get(Calendar.DAY_OF_WEEK); //5 todo 本周几 这个不是走的中国结果的处理 通过上面工具类获取周即可
int DAY_OF_YEAR = calendar.get(Calendar.DAY_OF_YEAR);//343 todo 今年的第 N 天 真是的天数 不需要加一
int DAY_OF_MONTH = calendar.get(Calendar.DAY_OF_MONTH); //9 本月第 N 天
//把日期年月日时分秒进行加减操作
calendar.add(Calendar.HOUR_OF_DAY, 3); // 3小时以后
int HOUR_OF_DAY = calendar.get(Calendar.HOUR_OF_DAY);//23
int MINUTE = calendar.get(Calendar.MINUTE); //42 当前分钟数
calendar.add(Calendar.MINUTE, 15); // 15 分钟以后
MINUTE = calendar.get(Calendar.MINUTE);//57
calendar.add(Calendar.MINUTE, -30); // 30分钟前
MINUTE = calendar.get(Calendar.MINUTE);//27
calendar.add(Calendar.DAY_OF_YEAR, -7); // 7天前
int day_of_month = calendar.get(Calendar.DAY_OF_MONTH); //2 显示当月 x 号
calendar.clear();
calendar.setTime(new Date());
// 创建一个 Calendar 用于比较时间
//结论 用compareTo比较时 相等返回0 前面大于后面得 1 否则负1
Calendar calendarNew = Calendar.getInstance();
System.out.println("时间比较：" + calendarNew.compareTo(calendar));//0
// 设定为 5 小时以前，后者大，显示 -1
calendarNew.add(Calendar.HOUR, -5);
System.out.println("时间比较：" + calendarNew.compareTo(calendar));//-1
// 设定7小时以后，前者大，显示 1
calendarNew.add(Calendar.HOUR, +7);
System.out.println("时间比较：" + calendarNew.compareTo(calendar));//1
// 退回 2 小时，时间相同，显示 0
calendarNew.add(Calendar.HOUR, -2);
System.out.println("时间比较：" + calendarNew.compareTo(calendar));//0
//TODO 上面是通过setTime一次性设置一个格式为Date时间 也可以通过set一个个设置
//注：使用set设置月的时候 要用目标月减去1
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
SimpleDateFormat df1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS");
Calendar cal = Calendar.getInstance();
cal.clear();
//一个一个设置
cal.set(Calendar.YEAR, 2021);
cal.set(Calendar.MONTH, 12 - 1);//你想要几月就用几月减去1
cal.set(Calendar.DAY_OF_MONTH, 9);
Date date = cal.getTime();
System.out.println(df.format(date));//2021-12-09
cal.add(Calendar.MONTH, 2);//增加2月
date = cal.getTime();
System.out.println(df.format(date));//2022-02-09
cal.clear();
cal.set(2021, 12 - 1, 9);//一次性设置年月日
date = cal.getTime();
System.out.println(df.format(date));//2021-12-09
cal.clear();
cal.set(2021, 12 - 1, 9, 21, 18, 54);//一次性设置年月日时分秒
date = cal.getTime();
System.out.println(df1.format(date));//2021-12-09 21:18:54:000
cal.clear();
cal.set(2021, 12 - 1, 9, 21, 18);//一次性设置年月日时分
date = cal.getTime();
System.out.println(df1.format(date));//2021-12-09 21:18:00:000
}
}
Calendar 来设置年月日时分秒毫秒
/**
* (new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS")).format(createDate)
* getCreateDate(2022,6,1,0,0,0,0) ==> 2022-06-01 00:00:00:000
* getCreateDate(2022,6,30,23,59,59,999) ==> 2022-06-30 23:59:59:999
* @param no
* @return
*/
public static Date getCreateDate(int ...no) {
Calendar c = Calendar.getInstance();
c.set(Calendar.YEAR, no[0]);
c.set(Calendar.MONTH, no[1]-1);
c.set(Calendar.DAY_OF_MONTH, no[2]);
//将小时至0
c.set(Calendar.HOUR_OF_DAY, no[3]);//24小时制
//c.set(Calendar.HOUR, 0); //12小时制
//将分钟至0
c.set(Calendar.MINUTE, no[4]);
//将秒至0
c.set(Calendar.SECOND, no[5]);
//将毫秒至0
c.set(Calendar.MILLISECOND, no[6]);
return c.getTime();
}
“EEE, dd MMM yyyy HH:mm:ss z” 与 "yyyy-MM-dd HH:mm:ss"互转
参考最后的互转都一样的思路，这里不赘述。
要求将格林尼治时间Tue Jun 06 03:17:21 GMT 2006 转化成20060702031721的格式 EEE MMM dd HH:mm:ss zzz yyyy 格式 GMT时区
注意格式千篇一律，重要的是学思路，你的通过Debug来确认它的日期格式，才能往你目标格式靠
package datetime.time;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
import java.util.TimeZone;
public class Play {
/**
* 关于一个Java时间函数的转换方法
* ,要求将格林尼治时间Tue Jun 06 03:17:21 GMT 2006 转化成20060702031721的格式
* 需要注意的问题:
* 1,SimpleDateFormat的构造函数接受一个Locale参数,必须将这个Locale参数定制为美国(英国)时区才能解析英文时间参数.
* 2,为了防止Java国际化带来的时区问题,要将TimeZone设置为GMT.
*/
public static void main(String[] args) {
SimpleDateFormat format = new SimpleDateFormat("EEE MMM dd HH:mm:ss zzz yyyy", Locale.US);
String inPutStr = "Tue Jun 06 03:17:21 GMT 2006";
Date parseDate = null;
try {
parseDate = format.parse(inPutStr);
} catch (ParseException e) {
e.printStackTrace();
}
SimpleDateFormat formatOut = new SimpleDateFormat("yyyyMMddHHmmss");
formatOut.setTimeZone(TimeZone.getTimeZone("GMT"));
String outPutStr = formatOut.format(parseDate);
System.out.println(outPutStr);
}
}
工作使用按例
//这个Date格式是："EEE, MMM dd HH:mm:ss z yyyy"
public static String targetDate(Date date){
String date1 = String.valueOf(date);
SimpleDateFormat sdf1 = new SimpleDateFormat("EEE MMM dd HH:mm:ss z yyyy", Locale.US);
TimeZone tz1 = TimeZone.getTimeZone("GMT+8");
sdf1.setTimeZone(tz1);
Date s1;
String loanDate = null;
try {
s1 = sdf1.parse(date1);
sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
loanDate = sdf1.format(s1);
} catch (ParseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
String loan = loanDate.substring(0,10)+" 00:00:00";
return loan;
}
日期对应星座及法定节假日
节假日不对慎用、
java获取法定节假日网址推荐
package datetime.time.util.dateUtil;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Hashtable;
public class util {
public static Object dateinfo(String s) {
String a[] = s.split("-", 2);
Hashtable fest = new Hashtable();
fest.put("01-01", "元旦节");
fest.put("02-14", "情人节");
fest.put("03-12", "植树节");
fest.put("03-15", "消费者节");
fest.put("04-01", "愚人节");
fest.put("04-05", "清明节");
fest.put("05-01", "劳动节");
fest.put("06-01", "儿童节");
fest.put("07-01", "建党节");
fest.put("08-01", "建军节");
fest.put("09-10", "教师节");
fest.put("10-01", "国庆节");
fest.put("12-25", "圣诞节");
if (fest.containsKey(a[1])) {
return fest.get(a[1]);
} else {
return "无节日";
}
}
public static String getXingZuo(String s) {
Calendar cal = Calendar.getInstance();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Date parse = null;
try {
parse = sdf.parse(s);
} catch (ParseException e) {
e.printStackTrace();
}
cal.setTime(parse);
String xingzuo = "无";
int day = cal.get(Calendar.DAY_OF_YEAR);
if ((cal.get(Calendar.YEAR) % 4 == 0) && (cal.get(Calendar.YEAR) % 100 != 0) || (cal.get(Calendar.YEAR) % 400 == 0)) {
if ((day >= 1 && day <= 19) || (day >= 357 && day <= 366)) {
xingzuo = "魔蝎座";
} else if (day >= 20 && day <= 49) {
xingzuo = "水瓶座";
} else if (day >= 50 && day <= 80) {
xingzuo = "双鱼座";
} else if (day >= 81 && day <= 110) {
xingzuo = "白羊座";
} else if (day >= 111 && day <= 141) {
xingzuo = "金牛座";
} else if (day >= 142 && day <= 173) {
xingzuo = "双子座";
} else if (day >= 174 && day <= 203) {
xingzuo = "巨蟹座";
} else if (day >= 204 && day <= 235) {
xingzuo = "狮子座";
} else if (day >= 236 && day <= 266) {
xingzuo = "处女座";
} else if (day >= 267 && day <= 296) {
xingzuo = "天秤座";
} else if (day >= 297 && day <= 326) {
xingzuo = "天蝎座";
} else if (day >= 327 && day <= 356) {
xingzuo = "射手座";
}
} else {
if ((day >= 1 && day <= 19) || (day >= 357 && day <= 366)) {
xingzuo = "魔蝎座";
} else if (day >= 20 && day <= 48) {
xingzuo = "水瓶座";
} else if (day >= 49 && day <= 79) {
xingzuo = "双鱼座";
} else if (day >= 80 && day <= 109) {
xingzuo = "白羊座";
} else if (day >= 110 && day <= 140) {
xingzuo = "金牛座";
} else if (day >= 141 && day <= 172) {
xingzuo = "双子座";
} else if (day >= 173 && day <= 202) {
xingzuo = "巨蟹座";
} else if (day >= 203 && day <= 234) {
xingzuo = "狮子座";
} else if (day >= 235 && day <= 265) {
xingzuo = "处女座";
} else if (day >= 266 && day <= 295) {
xingzuo = "天秤座";
} else if (day >= 296 && day <= 325) {
xingzuo = "天蝎座";
} else if (day >= 326 && day <= 355) {
xingzuo = "射手座";
}
}
return xingzuo;
}
public static void main(String[] args) {
System.out.println(dateinfo("2021-12-25"));
System.out.println(getXingZuo("1998-04-28"));
}
}
日期的比较
日期比较一般有两种方法，对于 java.util.Date 或者 java.util.Calendar都是通用的。
一种是通过 after() 与 before() 方法进行比较，一种是通过 compareTo() 方法进行比较。还可以通过.getTime()
Date date_01 = new Date();
Date date_02 = new Date();
System.out.println(date_01.before(date_02)); //true，当 date_01 小于 date_02 时，为 true，否则为 false
System.out.println(date_02.after(date_01)); //true，当 date_02 大于 date_01 时，为 true，否则为 false
System.out.println(date_01.compareTo(date_02)); //-1，当 date_01 小于 date_02 时，为 -1
System.out.println(date_02.compareTo(date_01)); //1，当 date_02 大于 date_01 时，为 1
System.out.println(date_02.compareTo(date_02)); //0，当两个日期相等时，为 0
年月周(本月)求日期 这个周是本月的第几周
SimpleDateFormat formatter2 = new SimpleDateFormat("yyyy-MM F E");
Date date2 = null;
try {
date2 = formatter2.parse("2021-12 2 星期四");
} catch (ParseException e) {
e.printStackTrace();
}
SimpleDateFormat formatter3 = new SimpleDateFormat("yyyy-MM-dd");
String mydate2 = formatter3.format(date2);//2021-12-09
获取时间戳的几种方式
//方法 一
long l1 = System.currentTimeMillis();
//方法 二
long l2 = Calendar.getInstance().getTimeInMillis();
//方法 三
long l3 = new Date().getTime();
关于不一样的格式化日期
了解即可，一般不常用
DateFormat 是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并分析日期或时间。
不过DateFormat的格式化Date的功能有限，没有SimpleDateFormat强大；但DateFormat是SimpleDateFormat的父类。
SimpleDateFormat 使得可以选择任何用户定义的日期-时间格式的模式。但是，仍然建议通过 DateFormat
中的 getTimeInstance、getDateInstance 或 getDateTimeInstance 来新的创建日期-时间格式化程序。
String针对日期的的format方法
package datetime;
import java.text.ParseException;
import java.util.Date;
public class TimeTest {
public static void main(String[] args) throws ParseException {
// 通过Date类来获取当前时间
Date nowDate = new Date();
String yearNo = String.format("%tY", nowDate);
String monthNo = String.format("%tb", nowDate);
String dayNo = String.format("%te", nowDate);
String hourNo = String.format("%tH", nowDate);
String minuteNo = String.format("%tM", nowDate);
String secondNo = String.format("%tS", nowDate);
//2021-11月-30 20:09:05
System.out.println(yearNo + "-" + monthNo + "-" + dayNo + " " + hourNo + ":" + minuteNo + ":" + secondNo);
String begin = String.format("%tF", nowDate);
String end = String.format("%tT", nowDate);
System.out.println(begin + " " + end);//2021-11-30 20:09:05
}
}
DateFormat方法
package datetime;
import java.text.DateFormat;
import java.text.ParseException;
import java.util.Date;
public class Test {
public static void main(String[] args) throws ParseException {
Date date = new Date();
DateFormat df1 = DateFormat.getDateInstance();//日期格式，精确到日
System.out.println(df1.format(date));//2021年12月10日
DateFormat df2 = DateFormat.getDateTimeInstance();//可以精确到时分秒
System.out.println(df2.format(date));//2021年12月10日下午10:31:22
DateFormat df3 = DateFormat.getTimeInstance();//只显示出时分秒
System.out.println(df3.format(date));//下午10:31:22
DateFormat df4 = DateFormat.getDateTimeInstance(DateFormat.FULL, DateFormat.FULL); //显示日期，周，上下午，时间(精确到秒)
System.out.println(df4.format(date));//2021年12月10日星期五中国标准时间 下午10:31:22
DateFormat df5 = DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.LONG); //显示日期,上下午，时间(精确到秒)
System.out.println(df5.format(date));//2021年12月10日 CST 下午10:31:22
DateFormat df6 = DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT); //显示日期，上下午,时间(精确到分)
System.out.println(df6.format(date));//2021/12/10 下午10:31
DateFormat df7 = DateFormat.getDateTimeInstance(DateFormat.MEDIUM, DateFormat.MEDIUM); //显示日期，时间(精确到分)
System.out.println(df7.format(date));//2021年12月10日下午10:31:22
}
}
yyyy-MM-dd HH:mm:ss G E D F w W a E F含义
package datetime.time.util.dateUtil;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
public class Play {
public static void main(String[] args) {
SimpleDateFormat sdf = new SimpleDateFormat("M/dd/yyyy hh:mm:ss a", java.util.Locale.US);
Date d = null;
try {
d = sdf.parse("12/02/2021 10:31:37 AM");
} catch (ParseException e) {
e.printStackTrace();
}
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String mDateTime1 = formatter.format(d);
System.out.println(mDateTime1);//2021-12-02 10:31:37
System.out.println("------------------------------------");
Calendar cal2 = Calendar.getInstance();
SimpleDateFormat formatter1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss G E D F w W a E F");//这个天数才是准的
String mDateTime = formatter1.format(new Date());
System.out.println(mDateTime);//2021-12-09 22:38:11 公元 周四 343 2 50 2 下午 周四 2
//y 年分 2015 //M 年中的月份 12 //w 年中的周数 50 //W 月份中的周数 02
//D 年中的天数 344 //d 月份中的天数 10 //F 只看此月份>=7 加1
//a AM/PM标记 上午、下午 //H 一天中的小时数(0~23) 整数 //k 一天中的小时数(1~24) 21
//K am/pm中的小时数(0~11) 09 //h am/pm中的小时数(1~12) 09 //m 小时中的分钟数 31
//s 分钟中的秒数 08 //S 毫秒数 716 //E 星期中的天数 星期四、Thu
//如果你设置Locale的话，会有不同的显示格式，比如如果设置Locale.ENGLISH，E会显示为英文格式，a显示为AM或PM
//注：在00点的时候 H是0点 h是12点 K是0点 k是24点 01-11点的时候都是1-11点 12点的时候只有K是0点
// 13-00点 h是1-12 // 13-23点H、k为13-23 //13-23点K是1-11
//即K、h是12小时制 不同在于00点 K为0点 h为12点 12点的时候K为0点 h为12点 记：K无12点 h无0点
//H、k是24小时制 不同在于00点 H为0点 k为24点 记：k无0点 H无24点
}
}
UTC时间格式化（JAVA） 时间带T Z
互转全是一个套路格式
“yyyy-MM-ddTHH:mm:ss.SSSZ” 与 "yyyy-MM-dd HH:mm:ss"互转
将2017-05-18T10:26:10.488Z转化为yyyy-MM-dd HH:mm:ss
/**
* 将2017-05-18T10:26:10.488Z转化为yyyy-MM-dd HH:mm:ss
* "2017-05-18T10:26:10.488Z" ===> 2017-05-18 10:26:10
*
* @param dateStr
* @return
*/
public static String dataToFormat(String dateStr) {
//输入的被转化的时间格式
SimpleDateFormat dff = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS", Locale.ENGLISH);
//需要转化成的时间格式
SimpleDateFormat df1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date date1 = null;
try {
date1 = dff.parse(dateStr);
} catch (ParseException e) {
e.printStackTrace();
}
return df1.format(date1);
}
将日期转成 yyyy-MM-dd’T’HH:mm:ss.SSSZ
/**
* 将日期转成 yyyy-MM-dd'T'HH:mm:ss.SSSZ
* 后面的三个SSS指的是毫秒，Z代表的时区，中间的T代表可替换的任意字符。
*
* @param
* @return 2022-02-27T13:07:36.778+0800
*/
public static String dataToFormat2(Date date) {
if (date == null) {
date = new Date();
}
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZ");
return df.format(date);//2022-02-27T12:56:50.330+0800
}
将dd/MMM/yyyy:hh:mm:ss 时间格式转化为yyyy-MM-dd HH:mm:ss
String dtime = "18/Sep/2013:06:49:18 +0000";
SimpleDateFormat sdf1 = new SimpleDateFormat("dd/MMM/yyyy:hh:mm:ss Z", Locale.US);
Date date = null;
try {
date = sdf1.parse(dtime);
} catch (ParseException e) {
e.printStackTrace();
}
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String sDt = sdf2.format(date);
System.out.println(sDt);//2013-09-18 14:49:18
将dd/MM/yyyy:hh:mm:ss 时间格式转化为yyyy-MM-dd HH:mm:ss
SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy:hh:mm:ss", Locale.US);
String strDate ="20/04/2022:17:58:37";
Date date1 = null;
try {
date1 = sdf.parse(strDate);
} catch (ParseException e) {
e.printStackTrace();
}
SimpleDateFormat sdftwo = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String dateNow = sdftwo.format(date1);
System.out.println(dateNow);//2022-04-20 17:58:37
工具方法补充：没有亲测验证
/**
*补充方法列表：
*判断二个时间是否在同一个周
* 产生周序列,即得到当前时间所在的年度是第几周
*/
/**
* 判断二个时间是否在同一个周
*JAVA时间类型转换 https://blog.51cto.com/u_15199927/5158374
* @param date1
* @param date2
* @return
*/
public static boolean isSameWeekDates(Date date1, Date date2) {
Calendar cal1 = Calendar.getInstance();
Calendar cal2 = Calendar.getInstance();
cal1.setTime(date1);
cal2.setTime(date2);
int subYear = cal1.get(Calendar.YEAR) - cal2.get(Calendar.YEAR);
if (0 == subYear) {
if (cal1.get(Calendar.WEEK_OF_YEAR) == cal2.get(Calendar.WEEK_OF_YEAR))
return true;
} else if (1 == subYear && 11 == cal2.get(Calendar.MONTH)) {
// 如果12月的最后一周横跨来年第一周的话则最后一周即算做来年的第一周
if (cal1.get(Calendar.WEEK_OF_YEAR) == cal2.get(Calendar.WEEK_OF_YEAR))
return true;
} else if (-1 == subYear && 11 == cal1.get(Calendar.MONTH)) {
if (cal1.get(Calendar.WEEK_OF_YEAR) == cal2.get(Calendar.WEEK_OF_YEAR))
return true;
}
return false;
}
/**
* 产生周序列,即得到当前时间所在的年度是第几周
*
* @return
*/
public static String getSeqWeek() {
Calendar c = Calendar.getInstance(Locale.CHINA);
String week = Integer.toString(c.get(Calendar.WEEK_OF_YEAR));
if (week.length() == 1)
week = "0" + week;
String year = Integer.toString(c.get(Calendar.YEAR));
return year + week;
}
Java 实现日期的格式化，月份和天不足两位时补上0
下面提供两种方法
/**
* 数值类型前面补零（长度共2位）
* 格式化月份为2位数字即1到9前自动补零
* @param num
* @return
*/
public static String getMonth1(String num){
// 0 代表前面补充0， 2 代表长度为2，d 代表参数为正数型
return String.format("%02d", Integer.parseInt(num));
}
/**
* 数字前面自动补零
* @param no 数字
* @return
*/
public static String getMonth2(String no){
int number = Integer.parseInt(no);
NumberFormat formatter = NumberFormat.getNumberInstance();
//数字长度，不够的前面补零
formatter.setMinimumIntegerDigits(2);
formatter.setGroupingUsed(false);
return formatter.format(number);
}
Java如何获取系统时间
//1、通过Date类来获取当前时间
Date day=new Date();
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
System.out.println(df.format(day));
//2、通过System类中的currentTimeMillis方法来获取当前时间
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
System.out.println(df.format(System.currentTimeMillis()));
//3、通过Calendar类来获取当前时间
Calendar c = Calendar.getInstance();//可以对每个时间域单独修改
int year = c.get(Calendar.YEAR);
int month = c.get(Calendar.MONTH);
int date = c.get(Calendar.DATE);
int hour = c.get(Calendar.HOUR_OF_DAY);
int minute = c.get(Calendar.MINUTE);
int second = c.get(Calendar.SECOND);
System.out.println(year + "/" + month + "/" + date + " " +hour + ":" +minute + ":" + second);
// 4、通过Date类来获取当前时间
Date date = new Date();
String year = String.format("%tY", date);
String month = String.format("%tB", date);
String day = String.format("%te", date);
System.out.println("今天是："+year+"-"+month+"-"+day);
LocalDateTime.now()时间处理jdk1.8日期便捷处理类java.time.LocalDateTime;
//获取当前时间
System.out.println(LocalDateTime.now());
//获取当前时间时分秒
System.out.println(LocalDateTime.now().toLocalTime());
//获取当前时间年月日
System.out.println(LocalDateTime.now().toLocalDate());
//获取当前时间20天之前
System.out.println(LocalDateTime.now().minusDays(20));
//获取当前时间20天之后
System.out.println(LocalDateTime.now().plusDays(20));
//获取当前时间60天之前
System.out.println(LocalDateTime.now().minusDays(60));
//所有minus开头都是之前 plus开头都是之后
//比较大小
System.out.println(LocalDateTime.now().compareTo(LocalDateTime.now().plusDays(2)));
//获取当天的开始时间
LocalDateTime.now().toLocalDate().atStartOfDay()
//获取毫秒数
Long milliSecond = LocalDateTime.now().toInstant(ZoneOffset.of("+8")).toEpochMilli();
//获取当前是第几日
System.out.println(LocalDateTime.now().getDayOfMonth());
//获取当前周几
System.out.println(LocalDateTime.now().getDayOfWeek().getValue());
//获取当前是今年第几天
System.out.println(LocalDateTime.now().getDayOfYear());
//实例化方式 以及比较大小
Duration between = Duration.between(LocalDateTime.of(1993,3,14,0,0), LocalDateTime.now());
Duration between2 = Duration.between(LocalDateTime.of(1993,3,14,0,0), LocalDateTime.now());
System.out.println(between.toDays());
System.out.println(between2.toDays());
//.获取当前年月日的字符串
LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"))
String s="yyyy-MM-dd'T'HH:mm:ss.SSS+SSSS";
LocalDateTime parse = LocalDateTime.parse("2022-06-17T07:33:00.000+0000", DateTimeFormatter.ofPattern(s));
System.out.println(parse);
//解析时间
private LocalDateTime getTime(){
DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
LocalDateTime parse = LocalDateTime.parse(startDate, df);
return parse;
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
