贡献一个比较齐全的日期处理类。
import java.math.BigDecimal;
import java.text.DateFormat;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.YearMonth;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.TimeZone;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.convert.converter.Converter;
public class DateUtil implements Converter<String, Date> {
/**
* DateFormat,格式:yyyy-MM-dd
*/
private static DateFormat dateFormat;
/**
* DateFormat,格式:yyyy-MM-dd HH:mm:ss
*/
private static DateFormat dateTimeFormat;
/**
* DateFormat,格式:yyyyMMddHHmmss
*/
private static DateFormat dateTimeStrFormat;
/**
* DateFormat,格式:yyyy年MM月dd日HH时mm分ss秒
*
*/
private static DateFormat zhcnDateTimeStrFormat;
private static String twoDecimalFormat = "##0.0";
/**
* 显示日期的格式,yyyy
*/
public static final String DATE_YEAE_FORMAT = "yyyy";
/**
* 显示日期的格式,yyyy-MM
*/
public static final String DATE_MONTH_FORMAT = "yyyy-MM";
/**
* 显示日期的格式,yyyy-MM-dd
*/
public static final String DATE_FORMAT = "yyyy-MM-dd";
/**
* 显示日期的格式,yyyy-MM-dd HH
*/
public static final String DATE_HOUR_FORMAT = "yyyy-MM-dd HH";
/**
* 显示日期的格式,yyyy-MM-dd HH:mm
*/
public static final String DATE_MIN_FORMAT = "yyyy-MM-dd HH:mm";
/**
* 显示日期的格式,yyyy-MM-dd HH:mm:ss
*/
public static final String TIMEF_FORMAT = "yyyy-MM-dd HH:mm:ss";
/**
* 显示日期的格式,yyyy-MM-dd HH:mm:ss.SSS
*/
public static final String FULL_TIME_FORMAT = "yyyy-MM-dd HH:mm:ss.SSS";
/**
* 显示日期的格式,yyyy年 *
*/
public static final String ZHCN_YEAR_FORMAT = "yyyy年";
/**
* 显示日期的格式,yyyy年MM月
*
*/
public static final String ZHCN_MONTH_FORMAT = "yyyy年MM月";
/**
* 显示日期的格式,yyyy年MM月dd日 *
*/
public static final String ZHCN_DAY_FORMAT = "yyyy年MM月dd日";
/**
* 显示日期的格式,yyyy年MM月dd日HH时 *
*/
public static final String ZHCN_HOUR_FORMAT = "yyyy年MM月dd日HH时";
/**
* 显示日期的格式,yyyy年MM月dd日HH时mm分 *
*/
public static final String ZHCN_MIN_FORMAT = "yyyy年MM月dd日HH时mm分";
/**
* 显示日期的格式,yyyy年MM月dd日HH时mm分ss秒 *
*/
public static final String ZHCN_TIME_FORMAT = "yyyy年MM月dd日HH时mm分ss秒";
/**
* 显示日期的格式,yyyyMMddHHmmss
*/
public static final String TIME_STR_FORMAT = "yyyyMMddHHmmss";
/**
* 显示日期的格式,yyyyMMddHHmmssSSS
*/
public static final String TIMESSS_STR_FORMAT = "yyyyMMddHHmmssSSS";
/**
* 显示日期的格式,yyyyMMdd
*/
public static final String DATE_STR_FORMAT = "yyyyMMdd";
/**
* 显示日期的格式,yyMMdd
*/
public static final String DATE_SIMPLE_SHORT_FORMAT = "yyMMdd";
/**
* 表示年
*/
public static final int DATE_YEAR = 0;
/**
* 表示季节
*/
public static final int DATE_SEASON = 1;
/**
* 表示月份
*/
public static final int DATE_MONTH = 2;
static {
dateFormat = new SimpleDateFormat(DATE_FORMAT);
dateTimeFormat = new SimpleDateFormat(TIMEF_FORMAT);
dateTimeStrFormat = new SimpleDateFormat(TIME_STR_FORMAT);
zhcnDateTimeStrFormat = new SimpleDateFormat(ZHCN_TIME_FORMAT);
}
// 日期常量
enum DateConstants {
TODAY(0), NEARLYWEEK(1), MONTH(2), NEARLYMONTH(3), LASTWEEK(4);
private int value;
DateConstants(int value) {
this.value = value;
}
}
/**
*
* convertStringToDateFormat:字符串转换为时间格式，仅支持日期，分钟和秒
* @param source 时间字符串
* @return Date 返回时间类型
*/
@Override
public Date convert(String source) {
if (StringUtils.isEmpty(source)) {
return null;
}
List<String> formarts = new ArrayList<>();
formarts.add(DATE_FORMAT);
formarts.add(DATE_MIN_FORMAT);
formarts.add(TIMEF_FORMAT);
if (StringUtils.isEmpty(source)) {
return null;
}
String date = source.trim();
if (date.matches("^\\d{4}-\\d{1,2}-\\d{1,2}$")) {
return parseDate(date, formarts.get(0));
} else if (date.matches("^\\d{4}-\\d{1,2}-\\d{1,2} {1}\\d{1,2}:\\d{1,2}$")) {
return parseDate(date, formarts.get(1));
} else if (date.matches("^\\d{4}-\\d{1,2}-\\d{1,2} {1}\\d{1,2}:\\d{1,2}:\\d{1,2}$")) {
return parseDate(date, formarts.get(2));
} else {
return null;
}
}
/**
* 获取当前时间在＋－n分钟后的字符串时间
*
* @param nMinute 分钟数值
* @return String
*/
public static String getTimebyMinAfter(int nMinute) {
Calendar now = Calendar.getInstance(TimeZone.getDefault());
now.add(Calendar.MINUTE, nMinute);
return dateTimeFormat.format(now.getTime());
}
/**
* 获取当前时间在＋－n秒后的字符串时间
*
* @param n int
* @return String
*/
public static String getTimebySecAfter(int n) {
Calendar now = Calendar.getInstance(TimeZone.getDefault());
now.add(Calendar.SECOND, n);
return dateTimeFormat.format(now.getTime());
}
/**
* 获取定义的DateFormat格式
*
* @param formatStr 时间格式
* @return
*/
private static DateFormat getDateFormat(String formatStr) {
if (formatStr.equalsIgnoreCase(DATE_FORMAT)) {
return dateFormat;
} else if (formatStr.equalsIgnoreCase(TIMEF_FORMAT)) {
return dateTimeFormat;
} else {
return new SimpleDateFormat(formatStr);
}
}
/**
* 将Date转换成字符串“yyyy-mm-dd hh:mm:ss”的字符串
*
* @param date 日期
* @return String 字符串
*/
public static String dateToDateString(Date date) {
return dateToDateString(date, TIMEF_FORMAT);
}
/**
* 将Date转换成formatStr格式的字符串
*
* @param date 时间值
* @param formatStr 时间格式
* @return 返回时间值
*/
public static String dateToDateString(Date date, String formatStr) {
DateFormat df = getDateFormat(formatStr);
return df.format(date);
}
/**
* 将字符串的Date转换成指定formatStr格式的字符串
*
* @param date
* @param formatStr
* @return
*/
public static String dateToDateString(String date, String formatStr) {
DateFormat df = getDateFormat(formatStr);
return df.format(date);
}
/**
* 将Date转换成yyyy-MM-dd的字符串
*
* @param date 时间值
* @return 返回时间值yyyy-MM-dd的字符串
*/
public static String getDateString(Date date) {
DateFormat df = getDateFormat(DATE_FORMAT);
return df.format(date);
}
/**
* 将小时数换算成返回以毫秒为单位的时间
*
* @param hours
* @return 返回小时数换算成返回以毫秒为单位的时间
*/
public static long getMicroSec(BigDecimal hours) {
BigDecimal bd;
bd = hours.multiply(new BigDecimal(3600 * 1000));
return bd.longValue();
}
/**
* 获取今天的日期，格式自定
*
* @param pattern - 设定显示格式
* @return String - 返回今天的日期
*/
public static String getToday(String pattern) {
Calendar now = Calendar.getInstance(TimeZone.getDefault());
DateFormat sdf = getDateFormat(pattern);
sdf.setTimeZone(TimeZone.getDefault());
return sdf.format(now.getTime());
}
// 得到系统当前的分钟数,如当前时间是上午12:00,系统当前的分钟数就是12*60
public static int getCurrentMinutes() {
Calendar now = Calendar.getInstance(TimeZone.getDefault());
return now.get(Calendar.HOUR_OF_DAY) * 60 + now.get(Calendar.MINUTE);
}
/**
*
* getCurrentMin:获取当前分钟数
*
* @return int
*/
public static int getCurrentMin() {
Calendar calendar = Calendar.getInstance();
return calendar.get(Calendar.MINUTE);
}
/**
* 获取当前日期时间yyyy年MM月dd日HH时mm分ss秒的形式
*
* @return 当前日期时间yyyy年MM月dd日HH时mm分ss秒的形式
*/
public static String getCurZhCNDateTime() {
return dateToDateString(new Date(), ZHCN_TIME_FORMAT);
}
/**
* 获取当前时间
*
* @return
*/
public static Date getCurrentDate() {
return new Date(System.currentTimeMillis());
}
/**
*
* getCurrentDate:按指定格式获取当前时间
*
* @param format 时间格式
* @return String
*/
public static String getCurrentDate(String format) {
String strFormat = TIME_STR_FORMAT;
if (!StringUtil.isEmptyOrNull(format)) {
strFormat = format;
}
// 设置日期格式
SimpleDateFormat df = new SimpleDateFormat(strFormat);
return df.format(new Date());
}
/**
* @return 得到本月月份 如09
*/
public static String getMonth() {
Calendar now = Calendar.getInstance();
int month = now.get(Calendar.MONTH) + 1;
String monStr = String.valueOf(month);
// 对于10月份以下的月份,加"0"在前面
if (month < 10){
monStr = "0" + monStr;
}
return monStr;
}
/**
* @return 得到本月第几天
*/
public static String getDay() {
Calendar now = Calendar.getInstance();
int day = now.get(Calendar.DAY_OF_MONTH);
String dayStr = String.valueOf(day);
// 对于10月份以下的月份,加"0"在前面
if (day < 10){
dayStr = "0" + dayStr;
}
return dayStr;
}
/**
* @return 获取指定日期月份 如09
*/
public static String getMonth(Date date) {
Calendar now = Calendar.getInstance();
now.setTime(date);
int month = now.get(Calendar.MONTH) + 1;
String monStr = String.valueOf(month);
// 对于10月份以下的月份,加"0"在前面
if (month < 10){
monStr = "0" + monStr;
}
return monStr;
}
/**
* @return 获取指定日期天数
*/
public static String getDay(Date date) {
Calendar now = Calendar.getInstance();
now.setTime(date);
int day = now.get(Calendar.DAY_OF_MONTH);
String dayStr = String.valueOf(day);
// 对于10月份以下的月份,加"0"在前面
if (day < 10){
dayStr = "0" + dayStr;
}
return dayStr;
}
/**
* 根据失效时间判断是否依然有效
*
* @param expireTime 失效时间的字符串形式,格式要求:yyMMddHHmmss
* @return true:失效 false:没有失效
* @throws ParseException
*/
public static boolean isTimeExpired(String expireTime) {
boolean ret = false;
try{
// SimpleDateFormat不是线程安全的,所以每次调用new一个新的对象
Date date = new SimpleDateFormat(TIME_STR_FORMAT).parse(expireTime);
Calendar expire = Calendar.getInstance();
expire.setTime(date);
Calendar now = Calendar.getInstance();
// 将毫秒字段设为0,保持精度一致性
now.set(Calendar.MILLISECOND, 0);
if (now.after(expire)) {
ret = true;
}
}catch(Exception e){
LOGGER.error(String.format("DateUtil.isTimeExpired:%s", e));
}
return ret;
}
/**
* 根据开始时间和可用时间计算出失效时间
* @param startTime 开始时间
* @param availableTime 有效时长（单位：秒）
* @return 失效时间
*/
public static String getExpireTimeByCalculate(Date startTime, int availableTime) {
Calendar expire = Calendar.getInstance();
// 设置为开始时间
expire.setTime(startTime);
// 开始时间向后有效时长秒得到失效时间
expire.add(Calendar.SECOND, availableTime);
// 返回失效时间字符串
return new SimpleDateFormat(TIME_STR_FORMAT).format(expire.getTime());
}
/**
* 将Date转换为yyyyMMddHHmmss的形式
* @param date
* @return 日期的字符串形式,格式：yyyyMMddHHmmss
*/
public static String convertDateToString(Date date) {
return new SimpleDateFormat(TIME_STR_FORMAT).format(date);
}
/**
* 将Date转换为yyMMddHHmmss的形式
* @param date
* @return 日期的字符串形式,格式：yyMMddHHmmss
*/
public static String convertDateToString(Date date, String format) {
return new SimpleDateFormat(format).format(date);
}
/**
* 将yyMMddHHmmss形式的字符串转换成Date的形式
* @param date yyMMddHHmmss形式的日期字符串
* @return Date对象
*/
public static Date convertStringToDate(String date) {
try{
return new SimpleDateFormat(TIME_STR_FORMAT).parse(date);
}catch(Exception e){
LOGGER.error(String.format("DateUtil.convertStringToDate:%s", e));
}
return new Date();
}
/**
* 字符串转化为日期
*
* @param date 日期字符串
* @param formatString 格式化字符串
* @return
*/
public static Date convertStringToDate(String date, String formatString) {
try{
return new SimpleDateFormat(formatString).parse(date);
}catch(Exception e){
LOGGER.error(String.format("DateUtil.convertStringToDate:%s", e));
}
return new Date();
}
/**
* 日期转化为格式化日期
*
* @param date 日期
* @param formatString 格式化字符串
* @return
*/
public static Date convertDateToDate(Date date, String formatString) {
try{
return new SimpleDateFormat(formatString).parse(convertDateToString(date, formatString));
}catch(Exception e){
LOGGER.error(String.format("DateUtil.convertDateToDate:%s", e));
}
return new Date();
}
/**
* 字符串转化为格式化字符串格式
*
* @param date 日期
* @param formatString 格式化字符串
* @return
* 修改日期：2017年10月21日08:35:24 用途：使用字符传的日期格式，会有一个隐性的转换异常，转换会报错
*/
public static String convertStringToString(String date, String formatString) {
try {
DateFormat df = new SimpleDateFormat(formatString);
Date dateValue;
dateValue = DateUtil.convertStringToDate(date, DateUtil.TIMEF_FORMAT);
return df.format(dateValue);
} catch (Exception e) {
LOGGER.error(String.format("DateUtil.convertStringToString:%s", e));
}
return StringUtil.empty();
}
/**
* 将yy-MM-dd形式的字符串转换成Date的形式
*
*
*
* @param date
* yy-MM-dd形式的日期字符串
* @return Date对象
* @throws ParseException
*/
public static Date convertSimpleStringToDate(String date) throws ParseException {
return new SimpleDateFormat(DATE_FORMAT).parse(date);
}
/**
* @param date
* yyyyMMddHHmmss格式的日期字符转换为yyyy年MM月dd日HH时mm分ss秒格式的字符串
*
* @return yyyy年MM月dd日HH时mm分ss秒格式的日期字符串
*
* @throws ParseException
*/
public static String convertStringToZhCN(String date) throws ParseException {
return zhcnDateTimeStrFormat.format(dateTimeStrFormat.parse(date));
}
/**
* 时间字符串转换成日期时间的形式
*
* @param date
* yy-MM-dd HH:mm:ss形式的日期字符串
* @return Date对象
* @throws ParseException
*/
public static Date convertSimpleStringToDateTime(String date) throws ParseException {
return new SimpleDateFormat(TIMEF_FORMAT).parse(date);
}
/**
* 获取当天日期
*/
public static Date getTodayDate() {
// 获取昨日的日期
Calendar cal = Calendar.getInstance();
return cal.getTime();
}
/**
* 获取昨日日期 返回格式：yyyy-MM-dd
*/
public static String getYesterdayDateStr() {
// 获取昨日的日期
Calendar cal = Calendar.getInstance();
cal.add(Calendar.DAY_OF_MONTH, -1);
Date yesterday = cal.getTime();
return new SimpleDateFormat(DATE_FORMAT).format(yesterday);
}
/**
* 获取昨日日期 返回格式：yyyy-MM-dd
*/
public static Date getYesterdayDate() {
// 获取昨日的日期
Calendar cal = Calendar.getInstance();
cal.add(Calendar.DAY_OF_MONTH, -1);
return cal.getTime();
}
/**
* 获取明天日期 返回格式：yyyy-MM-dd
*/
public static String getTomorrowDateStr() {
// 获取昨日的日期
Calendar cal = Calendar.getInstance();
cal.add(Calendar.DAY_OF_MONTH, 1);
Date tomorrow = cal.getTime();
return new SimpleDateFormat(DATE_FORMAT).format(tomorrow);
}
/**
* 获取明天日期 返回格式：yyyy-MM-dd
*/
public static Date getTomorrowDate() {
// 获取昨日的日期
Calendar cal = Calendar.getInstance();
cal.add(Calendar.DAY_OF_MONTH, 1);
return cal.getTime();
}
/**
* 根据Calendar对象、字符串日期类型获得字符串日期
*
* @param date
* Calendar对象
* @param strDatetype
* 字符串日期类型（1：XXXX年XX月XX日，2：XX月XX日，3，XXXX年，4：XXXX-XX-XX，5：XX-XX，6：XXXX）
*
* @return
*/
public static String getStrDate(Calendar calendar, int strDateType) {
String year = String.valueOf(calendar.get(Calendar.YEAR));
String month = (calendar.get(Calendar.MONTH) + 1) < 10 ? "0" + (calendar.get(Calendar.MONTH) + 1)
: String.valueOf
(calendar.get(Calendar.MONTH) + 1);
String day = calendar.get(Calendar.DAY_OF_MONTH) < 10 ? "0" + calendar.get(Calendar.DAY_OF_MONTH)
: String.valueOf
(calendar.get(Calendar.DAY_OF_MONTH));
String strDate;
switch (strDateType) {
case 1:
strDate = String.format("%s年%s月%s日", year, month, day);
break;
case 2:
strDate = String.format("%s月%s日", month, day);
break;
case 3:
strDate = String.format("%s年", year);
break;
case 5:
strDate = String.format("%s-%s", month, day);
break;
case 6:
strDate = year;
break;
case 4:
default:
strDate = String.format("%s-%s-%s", year, month, day);
break;
}
return strDate;
}
/**
* 根据原来的时间（Date）获得相对偏移 N 月的时间（Date）
*
* @param protoDate
* 原来的时间（java.util.Date）
*
* @param dateOffset（向前移正数，向后移负数）
*
* @return 时间（java.util.Date）
*
*/
public static Date getOffsetMonthDate(Date protoDate, int monthOffset) {
Calendar cal = Calendar.getInstance();
cal.setTime(protoDate);
cal.add(Calendar.MONTH, -monthOffset);
return cal.getTime();
}
/**
* 根据原来的时间（Date）获得相对偏移 N 天的时间（Date）
*
* @param protoDate
* 原来的时间（java.util.Date）
*
* @param dateOffset（向前移正数，向后移负数）
*
* @return 时间（java.util.Date）
*
*/
public static Date getOffsetDayDate(Date protoDate, int dateOffset) {
Calendar cal = Calendar.getInstance();
cal.setTime(protoDate);
cal.set(Calendar.DAY_OF_MONTH, cal.get(Calendar.DAY_OF_MONTH) - dateOffset);
return cal.getTime();
}
/**
* 根据原来的时间（Date）获得相对偏移 N 小时的时间（Date）
*
* @param protoDate
* 原来的时间（java.util.Date）
*
* @param offsetHour
* （向前移正数，向后移负数）
*
* @return 时间（java.util.Date）
*
*/
public static Date getOffsetHourDate(Date protoDate, int offsetHour) {
Calendar cal = Calendar.getInstance();
cal.setTime(protoDate);
cal.set(Calendar.HOUR_OF_DAY, cal.get(Calendar.HOUR_OF_DAY) - offsetHour);
return cal.getTime();
}
/**
* 获取指定月份和日子的日期(未做日期效验)
*
* @param currentDate
* 当前日期
* @param assignYear
* 指定年份,-1代表年不做修改
* @param assignMonth
* 指定月份,从0开始,超过月最大值自动往后加一个月年,-1代表月不做修改
* @param assignDay
* 指定日,从1开始,超过日最大值往后加一个月,-1代表日不做修改
* @return 修改后的日期
*/
public static Date getAssignDate(Date currentDate, int assignYear, int assignMonth, int assignDay) {
Calendar cal = Calendar.getInstance();
cal.setTime(currentDate);
if (assignYear > -1) {
cal.set(Calendar.YEAR, assignYear);
}
if (assignMonth > -1) {
cal.set(Calendar.MONTH, assignMonth);
}
if (assignDay > -1) {
cal.set(Calendar.DAY_OF_MONTH, assignDay);
}
return cal.getTime();
}
/**
* 获得两个日前之间相差的小时数
*
* @param startDate
* 开始日期
* @param endDate
* 结束日期
* @return 小时数
*/
public static int getHourCountBetweenDate(Date startDate, Date endDate) {
Calendar startCalendar = Calendar.getInstance();
startCalendar.setTime(startDate);
startCalendar.set(Calendar.MINUTE, 0);
startCalendar.set(Calendar.SECOND, 0);
Calendar endCalendar = Calendar.getInstance();
endCalendar.setTime(endDate);
endCalendar.set(Calendar.MINUTE, 0);
endCalendar.set(Calendar.SECOND, 0);
int i = 0;
while (endCalendar.compareTo(startCalendar) >= 0) {
startCalendar.set(Calendar.HOUR_OF_DAY, startCalendar.get(Calendar.HOUR_OF_DAY) + 1);
i++;
}
return i;
}
/**
* 获得两个日前之间相差的天数,有时分秒的影响
*
* @param startDate
* 开始日期
*
* @param endDate
* 结束日期
* @return 天数
*/
public static int getDayCountBetweenDate(Date startDate, Date endDate) {
Calendar startCalendar = Calendar.getInstance();
startCalendar.setTime(startDate);
Calendar endCalendar = Calendar.getInstance();
endCalendar.setTime(endDate);
int i = 0;
while (endCalendar.compareTo(startCalendar) >= 0) {
startCalendar.set(Calendar.DAY_OF_MONTH, startCalendar.get(Calendar.DAY_OF_MONTH) + 1);
i++;
}
return i;
}
/**
* 获得两个日前之间相差的月份
*
* @param startDate
* 开始日期
*
* @param endDate
* 结束日期
* @return 月数
*/
public static int getMonthCountBetweenDate(Date startDate, Date endDate) {
Calendar startCalendar = Calendar.getInstance();
startCalendar.setTime(startDate);
Calendar endCalendar = Calendar.getInstance();
endCalendar.setTime(endDate);
int i = 0;
while (endCalendar.compareTo(startCalendar) >= 0) {
startCalendar.set(Calendar.MONTH, startCalendar.get(Calendar.MONTH) + 1);
i++;
}
return i;
}
/**
* 获得两个日前之间相差的年
*
* @param startDate
* 开始日期
*
* @param endDate
* 结束日期
* @return 年
*/
public static int getYearlyCountBetweenDate(Date startDate, Date endDate) {
Calendar startCalendar = Calendar.getInstance();
startCalendar.setTime(startDate);
Calendar endCalendar = Calendar.getInstance();
endCalendar.setTime(endDate);
int i = 0;
while (endCalendar.compareTo(startCalendar) >= 0) {
startCalendar.set(Calendar.YEAR, startCalendar.get(Calendar.YEAR + 1));
i++;
}
return i;
}
/**
* 根据原来的时间（Date）获得相对偏移 N 天的时间（Date）
* @param protoDate 原来的时间（java.util.Date）
* @param dateOffset（向前移正数，向后移负数）
* @param type 指定不同的格式（1：年月日，2：年月日时，3：年月日时分）
* @return 时间（java.util.Date），没有时分秒
*/
public static Date getOffsetSimpleDate(Date protoDate, int dateOffset, int type) {
Calendar cal = Calendar.getInstance();
cal.setTime(protoDate);
cal.set(Calendar.DAY_OF_MONTH, cal.get(Calendar.DAY_OF_MONTH) - dateOffset);
if (type == 1) {
cal.set(Calendar.HOUR_OF_DAY, 0);
cal.set(Calendar.MINUTE, 0);
}
if (type == 2) {
cal.set(Calendar.MINUTE, 0);
}
cal.set(Calendar.SECOND, 0);
cal.set(Calendar.MILLISECOND, 0);
return cal.getTime();
}
/**
* 时间转为化为字符串
* 格式为：yyyyMMddHHmmssSSS
* @return
*/
public static String getDateToString() {
SimpleDateFormat dateFormat = new SimpleDateFormat(TIMESSS_STR_FORMAT);
Date date = new Date();
return dateFormat.format(date);
}
/**
* 时间转为化为字符串
* 格式为：yyyy-MM-dd HH:mm:ss
* @return
*/
public static String getTodayTimeString() {
SimpleDateFormat dateFormat = new SimpleDateFormat(TIMEF_FORMAT);
Date date = new Date();
return dateFormat.format(date);
}
/**
* 增加秒
* @param dateTime 时间值
* @param nSecond 增加秒数
* @return 返回时间值
*/
public static Date addSecond(Date dateTime, int nSecond) {
Calendar cd = Calendar.getInstance();
cd.setTime(dateTime);
cd.add(Calendar.SECOND, nSecond);// 增加秒
return cd.getTime();
}
/**
* 增加秒
* @param dateTime 时间值
* @param nSecond 增加秒数
* @param formatstring 时间格式
* @return 返回时间值
*/
public static String addSecond(Date m, int n, String formatstring) {
try {
SimpleDateFormat sdf = new SimpleDateFormat(formatstring);
Calendar cd = Calendar.getInstance();
cd.setTime(m);
cd.add(Calendar.SECOND, n);// 增加秒
return sdf.format(cd.getTime());
} catch (Exception e) {
LOGGER.error(String.format("DateUtil.addSecond formatstring:%s", e));
}
return StringUtil.empty();
}
/**
* 增加秒
* @param dateTime 时间值
* @param nSecond 增加秒数
* @return 返回时间值
*/
public static String addSecond(String dateTime, int nSecond) {
try {
SimpleDateFormat sdf = new SimpleDateFormat(DateUtil.TIMEF_FORMAT);
Calendar cd = Calendar.getInstance();
cd.setTime(sdf.parse(dateTime));
cd.add(Calendar.SECOND, nSecond);// 增加秒
return sdf.format(cd.getTime());
} catch (Exception e) {
LOGGER.error(String.format("DateUtil.addSecond:%s", e));
}
return StringUtil.empty();
}
/**
* 增加分钟
* @param dateTime 时间值
* @param nMinute 分钟数
* @return 返回时间值
*/
public static Date addMinute(Date dateTime, int nMinute) {
Calendar cd = Calendar.getInstance();
cd.setTime(dateTime);
cd.add(Calendar.MINUTE, nMinute);// 增加分钟
return cd.getTime();
}
/**
* 增加分钟
* @param dateTime 时间值
* @param nMinute 分钟数
* @param formatstring 时间格式
* @return 返回时间值
*/
public static String addMinute(Date dateTime, int nMinute, String formatstring) {
try {
SimpleDateFormat sdf = new SimpleDateFormat(formatstring);
Calendar cd = Calendar.getInstance();
cd.setTime(dateTime);
cd.add(Calendar.MINUTE, nMinute);// 增加分钟
return sdf.format(cd.getTime());
} catch (Exception e) {
LOGGER.error(String.format("DateUtil.addMinute:%s", e));
}
return StringUtil.empty();
}
/**
* 增加小时
* @param dateTime 时间值
* @param nHour 小时数
* @return 返回时间值
*/
public static Date addHour(Date dateTime, int nHour) {
Calendar cd = Calendar.getInstance();
cd.setTime(dateTime);
cd.add(Calendar.HOUR_OF_DAY, nHour);// 增加小时
return cd.getTime();
}
/**
* 增加小时
* @param dateTime 时间值
* @param nHour 小时数
* @param formatstring 时间格式
* @return 返回时间值
*/
public static String addHour(Date dateTime, int nHour, String formatstring) {
try {
SimpleDateFormat sdf = new SimpleDateFormat(formatstring);
Calendar cd = Calendar.getInstance();
cd.setTime(dateTime);
cd.add(Calendar.HOUR_OF_DAY, nHour);// 增加小时
return sdf.format(cd.getTime());
} catch (Exception e) {
LOGGER.error(String.format("DateUtil.addHour:%s", e));
}
return StringUtil.empty();
}
/**
* 增加一天
* @param dateTime 时间值
* @param nDay 天数
* @return 返回时间值
*/
public static String addDay(String dateTime, int nDay) {
try {
SimpleDateFormat sdf = new SimpleDateFormat(DateUtil.DATE_FORMAT);
Calendar cd = Calendar.getInstance();
cd.setTime(sdf.parse(dateTime));
cd.add(Calendar.DATE, nDay);// 增加一天
return sdf.format(cd.getTime());
} catch (Exception e) {
LOGGER.error(String.format("DateUtil.addDay:%s", e));
}
return StringUtil.empty();
}
/**
* 增加一天
* @param dateTime 时间值
* @param nDay 天数
* @return 返回时间值
*/
public static Date addDay(Date dateTime, int nDay) {
Calendar cd = Calendar.getInstance();
cd.setTime(dateTime);
cd.add(Calendar.DATE, nDay);// 增加一天
return cd.getTime();
}
/**
* 增加一个月
* @param dateTime 时间值
* @param nMonth 增加月份值
* @return String 返回增加月份后的时间
*/
public static Date addMonth(Date dateTime, int nMonth) {
Calendar cd = Calendar.getInstance();
cd.setTime(dateTime);
cd.add(Calendar.MONTH, nMonth);// 增加一个月
return cd.getTime();
}
/**
* 增加一个月
* @param dateTime 时间值
* @param nMonth 增加月份值
* @param formatstring 时间格式
* @return String 返回增加月份后的时间
*/
public static String addMonth(Date dateTime, int nMonth, String formatstring) {
try {
SimpleDateFormat sdf = new SimpleDateFormat(formatstring);
Calendar cd = Calendar.getInstance();
cd.setTime(dateTime);
cd.add(Calendar.MONTH, nMonth);// 增加一个月
return sdf.format(cd.getTime());
} catch (Exception e) {
LOGGER.error(String.format("DateUtil.addMonth formatstring:%s", e));
}
return StringUtil.empty();
}
/**
* 增加N个月
* @param dateTime 时间值
* @param nMonth 增加月份值
* @param formatstring 时间格式
* @return String 返回增加月份后的时间
*/
public static String addMonth(String dateTime, int nMonth, String format) {
try {
SimpleDateFormat sdf = new SimpleDateFormat(format);
Calendar cd = Calendar.getInstance();
cd.setTime(sdf.parse(dateTime));
cd.add(Calendar.MONTH, nMonth);// 增加一个月
return sdf.format(cd.getTime());
} catch (Exception e) {
return null;
}
}
/**
* 增加月份
* @param dateTime 时间值
* @param nMonth 增加月份值
* @return String 返回增加月份后的时间
*/
public static String addMonth(String dateTime, int nMonth) {
try {
SimpleDateFormat sdf = new SimpleDateFormat(DateUtil.DATE_FORMAT);
Calendar cd = Calendar.getInstance();
cd.setTime(sdf.parse(dateTime));
cd.add(Calendar.MONTH, nMonth);// 增加一个月
return sdf.format(cd.getTime());
} catch (Exception e) {
LOGGER.error(String.format("DateUtil.addMonth:%s", e));
}
return StringUtil.empty();
}
/**
* 方法描述:增加年
* @param dateTime 时间值
* @param nYear 增加年数值
* @param formatstring 时间格式
* @return 返回时间字符串
*/
public static String addYear(Date dateTime, int nYear, String formatstring) {
Calendar cd = Calendar.getInstance();
cd.setTime(dateTime);
cd.add(Calendar.YEAR, nYear);
DateFormat sdf = new SimpleDateFormat(formatstring);
return sdf.format(cd.getTime());
}
/**
* 获取需要执行的统计的日期数组
* @return 格式['2011-01-01',2011-01-02']
*/
public static String[] getExecDay(Date lastDate) {
String[] day = null;
// 获取昨天日期
Date yesdate = null;
try {
yesdate = DateUtil.convertDateToDate(DateUtil.getYesterdayDate(), DateUtil.DATE_FORMAT);
} catch (Exception e) {
LOGGER.error(String.format("DateUtil.getExecDay:%s", e));
}
// 获取上次最后执行日期与昨天相隔天数
int dayCount = DateUtil.getDayCountBetweenDate(lastDate, yesdate);
if (dayCount <= 0) {
return day;
}
if (dayCount == 1) {
return new String[] { DateUtil.getYesterdayDateStr() };
} else {
day = new String[dayCount];
for (int i = 0; i < dayCount; i++) {
String date = new SimpleDateFormat(DateUtil.DATE_HOUR_FORMAT).format(DateUtil.addDay(lastDate, i));
day[i] = date;
}
}
return day;
}
/**
* 获取需要执行的统计的年-月数组
* @return 格式['2011-01',2011-01']
*/
public static String[] getExecYearMonth(Date lastYearMonth) {
String[] yearMonth = null;
// 获取上个月日期
Date lastMonth = DateUtil.getOffsetMonthDate(new Date(), 1);
try {
lastMonth = DateUtil.convertDateToDate(lastMonth, DateUtil.DATE_MONTH_FORMAT);
} catch (Exception e) {
LOGGER.error(String.format("DateUtil.getExecYearMonth:%s", e));
}
// 获取上次最后执行日期与昨天相隔天数
int monthCount = DateUtil.getMonthCountBetweenDate(lastYearMonth, lastMonth);
if (monthCount <= 0) {
return yearMonth;
}
if (monthCount == 1) {
return new String[] { DateUtil.convertDateToString(lastMonth, DateUtil.DATE_MONTH_FORMAT) };
} else {
yearMonth = new String[monthCount];
for (int i = 0; i < monthCount; i++) {
String date = DateUtil.addMonth(lastYearMonth, i, DateUtil.DATE_MONTH_FORMAT);
yearMonth[i] = date;
}
}
return yearMonth;
}
/**
* 获取当月第一天
* @return 返回当月第一天
*/
public static Date getFirstDayOfMonth() {
Calendar ca = Calendar.getInstance();
ca.set(Calendar.DAY_OF_MONTH, 1);
Date firstDate = ca.getTime();
ca.add(Calendar.MONTH, 1);
ca.add(Calendar.DAY_OF_MONTH, -1);
return firstDate;
}
/**
* 获当月的最后一天
* @return 返回当月的最后一天
*/
public static Date getLastDayOfMonth() {
Calendar ca = Calendar.getInstance();
ca.set(Calendar.DAY_OF_MONTH, 1);
ca.add(Calendar.MONTH, 1);
ca.add(Calendar.DAY_OF_MONTH, -1);
return ca.getTime();
}
/**
*
* getBeginTime:获取指定月份的开始时间
* @param year 年份
* @param month 月份
* @return String 返回指定月份的开始时间
*/
public static String getBeginTime(int year, int month) {
YearMonth yearMonth = YearMonth.of(year, month);
LocalDate localDate = yearMonth.atDay(1);
LocalDateTime startOfDay = localDate.atStartOfDay();
ZonedDateTime zonedDateTime = startOfDay.atZone(ZoneId.of("Asia/Shanghai"));
return convertDateToString(Date.from(zonedDateTime.toInstant()), DateUtil.DATE_FORMAT) + " 00:00:00";
}
/**
*
* getEndTime:获取指定月份的结束时间
* @param year 年份
* @param month 月份
* @return String 返回指定月份的结束时间
*/
public static String getEndTime(int year, int month) {
YearMonth yearMonth = YearMonth.of(year, month);
LocalDate endOfMonth = yearMonth.atEndOfMonth();
LocalDateTime localDateTime = endOfMonth.atTime(23, 59, 59, 999);
ZonedDateTime zonedDateTime = localDateTime.atZone(ZoneId.of("Asia/Shanghai"));
return convertDateToString(Date.from(zonedDateTime.toInstant()), DateUtil.DATE_FORMAT) + " 23:59:59";
}
/**
* 获取日期所在月份的天数
* @return 返回日期所在月份的天数
*/
public static int getDaysOfMonth(Date date) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
return calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
}
/**
* 获取一天的最后时间，常用于时间段查询的结束时间的处理
* @param dateTime 时间值
* @return 得到的时间为在d的23:59:59
*/
public static Date getLastTimeOfDay(Date dateTime) {
Date date = dateTime;
if (null == date) {
date = DateUtil.getCurrentDate();
}
Calendar ca = Calendar.getInstance();
ca.setTime(date);
ca.add(Calendar.DAY_OF_MONTH, 1);
ca.add(Calendar.MILLISECOND, -1);
date = ca.getTime();
return date;
}
/**
* getWeekDay(); 获查询日期区间 今天(0), 近一周(1), 本月(2),近一月(3),上一周(4) ;
* @return Date[0] 开始时间 Date[1] 结束时间
*/
public static Date[] getDateSection(int dateType) {
Date[] dateSection = new Date[2];
if (DateConstants.TODAY.value == dateType) {
dateSection[0] = getTodayDate();
dateSection[1] = dateSection[0];
} else if (DateConstants.NEARLYWEEK.value == dateType) {
dateSection[0] = getOffsetDayDate(getTodayDate(), 6);
dateSection[1] = getTodayDate();
} else if (DateConstants.NEARLYMONTH.value == dateType) {
dateSection[0] = getOffsetMonthDate(getTodayDate(), 1);
dateSection[1] = getTodayDate();
} else if (DateConstants.MONTH.value == dateType) {
dateSection[0] = getFirstDayOfMonth();
dateSection[1] = getLastDayOfMonth();
} else if (DateConstants.LASTWEEK.value == dateType) {
dateSection[0] = getOffsetDayDate(getTodayDate(), getWeekDay() + 6);
dateSection[1] = getOffsetDayDate(getTodayDate(), getWeekDay());
} else {
dateSection = null;
}
return dateSection;
}
public static boolean isNumberic(String str) {
if (StringUtil.isEmpty(str)) {
return false;
}
int sz = str.length();
for (int i = 0; i < sz; i++) {
if (!Character.isDigit(str.charAt(i))) {
return false;
}
}
return true;
}
/**
* 将日期转化为oracle的函数TO_DATE('" + dateStr + "','YYYY-MM-DD HH24:MI:SS')表达式
* @param date 时间类型时间值
* @param format 时间格式
* @return 返回日期转化为oracle的函数TO_DATE('" + dateStr + "','YYYY-MM-DD HH24:MI:SS')表达式
*/
public static String convertDateToOracleToDateExp(Date date, String format) {
return "TO_DATE('" + new SimpleDateFormat(format).format(date) + "','YYYY-MM-DD HH24:MI:SS')";
}
/**
* 将日期转化为oracle的函数TO_DATE('" + dateStr + "','YYYY-MM-DD HH24:MI:SS')表达式
* @param date 时间类型时间
* @return 返回oracle的函数TO_DATE('" + dateStr + "','YYYY-MM-DD HH24:MI:SS')表达式
*/
public static String convertDateToOracleToDateExp(Date date) {
return convertDateToOracleToDateExp(date, TIMEF_FORMAT);
}
/**
* 将日期转化为oracle的函数TO_DATE('" + dateStr + "','YYYY-MM-DD HH24:MI:SS')表达式
*
* @param date 时间字符串时间
* @return 返回oracle的函数TO_DATE('" + dateStr + "','YYYY-MM-DD HH24:MI:SS')表达式
*/
public static String convertDateToOracleToDateExp(String dateStr) {
return "TO_DATE('" + dateStr + "','YYYY-MM-DD HH24:MI:SS')";
}
/**
* 方法描述:将日期String，按照日期格式转成日期
* @param strDate 时间字符串
* @param formate 时间格式
* @return 返回时间类型的时间值
*/
public static Date parseDate(String strDate, String formate) {
DateFormat df = new SimpleDateFormat(formate);
Date date = null;
try {
date = df.parse(strDate);
} catch (Exception e) {
LOGGER.error(String.format("DateUtil.parseDate:%s", e));
date = null;
}
return date;
}
/**
* 方法描述:获取日期的年份
* @param date 时间
* @return 返回日期的年份
*/
public static int getYearByDate(Date date) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
return calendar.get(Calendar.YEAR);
}
/**
* 方法描述:添加小时
* @param addHour 增加小时数
* @return 返回增加小时数后的时间
*/
public static Date addHour(int addHour) {
Calendar calendar = Calendar.getInstance();
calendar.add(Calendar.HOUR_OF_DAY, addHour);
return calendar.getTime();
}
/**
* 获取当年的第一天
* @return 返回当年的第一天
*/
public static Date getCurrYearFirst() {
Calendar currCal = Calendar.getInstance();
int currentYear = currCal.get(Calendar.YEAR);
return getYearFirst(currentYear);
}
/**
* 获取当年的最后一天
* @return 返回当年的最后一天
*/
public static Date getCurrYearLast() {
Calendar currCal = Calendar.getInstance();
int currentYear = currCal.get(Calendar.YEAR);
return getYearLast(currentYear);
}
/**
* 获取某年第一天日期
* @param year 年份
* @return Date 返回某年第一天日期
*/
public static Date getYearFirst(int year) {
Calendar calendar = Calendar.getInstance();
calendar.clear();
calendar.set(Calendar.YEAR, year);
return calendar.getTime();
}
/**
* 获取某年最后一天日期
* @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);
return calendar.getTime();
}
/**
* 获得某个月最大天数
* @param dateTime 时间
* @return int 某个月最大天数
*/
public static int getMaxDayByYearMonth(String dateTime) {
int days = 0;
SimpleDateFormat sdf = new SimpleDateFormat(DATE_FORMAT);
Date date;
try {
date = sdf.parse(dateTime);
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
days = calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
} catch (ParseException e) {
LOGGER.error(String.format("DateUtil.getMaxDayByYearMonth:%s", e));
}
return days;
}
/**
* 两个时间之间相差距离多少天
* @param startTime 起始时间
* @param endTime 结束时间
* @return long 返回两个时间相差天数
*/
public static long getDistanceDays(String startTime, String endTime) {
DateFormat df = new SimpleDateFormat(DATE_FORMAT);
Date one;
Date two;
long days = 0;
try {
one = df.parse(startTime);
two = df.parse(endTime);
long time1 = one.getTime();
long time2 = two.getTime();
long diff;
if (time1 < time2) {
diff = time2 - time1;
} else {
diff = time1 - time2;
}
days = diff / (1000 * 60 * 60 * 24);
} catch (Exception e) {
LOGGER.error(String.format("DateUtil.getDistanceDays:%s", e));
}
return days;
}
/**
* 判断时间是否在时间段内
* @param date 当前时间 yyyy-MM-dd HH:mm:ss
* @param strDateBegin 开始时间 00:00:00
* @param strDateEnd 结束时间 00:05:00
* @return boolean 返回时间是否在时间段内
*/
public static boolean isInDate(Date date, String strDateBegin, String strDateEnd) {
SimpleDateFormat sdf = new SimpleDateFormat(TIMEF_FORMAT);
String strDate = sdf.format(date);
// 截取当前时间时分秒
int strDateH = Integer.parseInt(strDate.substring(11, 13));
int strDateM = Integer.parseInt(strDate.substring(14, 16));
int strDateS = Integer.parseInt(strDate.substring(17, 19));
// 截取开始时间时分秒
int strDateBeginH = Integer.parseInt(strDateBegin.substring(0, 2));
int strDateBeginM = Integer.parseInt(strDateBegin.substring(3, 5));
int strDateBeginS = Integer.parseInt(strDateBegin.substring(6, 8));
// 截取结束时间时分秒
int strDateEndH = Integer.parseInt(strDateEnd.substring(0, 2));
int strDateEndM = Integer.parseInt(strDateEnd.substring(3, 5));
int strDateEndS = Integer.parseInt(strDateEnd.substring(6, 8));
if ((strDateH >= strDateBeginH && strDateH <= strDateEndH)) {
// 当前时间小时数在开始时间和结束时间小时数之间
if (strDateH > strDateBeginH && strDateH < strDateEndH) {
return true;
// 当前时间小时数等于开始时间小时数，分钟数在开始和结束之间
} else if (strDateH == strDateBeginH && strDateM >= strDateBeginM && strDateM <= strDateEndM) {
return true;
// 当前时间小时数等于开始时间小时数，分钟数等于开始时间分钟数，秒数在开始和结束之间
} else if (strDateH == strDateBeginH && strDateM == strDateBeginM && strDateS >= strDateBeginS
&& strDateS <= strDateEndS) {
return true;
}
// 当前时间小时数大等于开始时间小时数，等于结束时间小时数，分钟数小等于结束时间分钟数
else if (strDateH == strDateEndH && strDateM <= strDateEndM) {
return true;
// 当前时间小时数大等于开始时间小时数，等于结束时间小时数，分钟数等于结束时间分钟数，秒数小等于结束时间秒数
} else if (strDateH == strDateEndH && strDateS <= strDateEndS) {
return true;
} else {
return false;
}
} else {
return false;
}
}
/**
*
* getWeekDay:获取当前时间星期几
* @return int
*/
public static int getWeekDay() {
Calendar now = Calendar.getInstance();
// 一周第一天是否为星期天
boolean isFirstSunday = now.getFirstDayOfWeek() == Calendar.SUNDAY;
// 获取周几
int weekDay = now.get(Calendar.DAY_OF_WEEK);
// 若一周第一天为星期天，则-1
if (isFirstSunday) {
weekDay = weekDay - 1;
if (weekDay == 0) {
weekDay = 7;
}
}
return weekDay;
}
/**
* getWeekDay:计算传入时间星期几
* @param date 传入时间
* @return 返回传入时间星期几
*/
public static int getWeekDay(Date date) {
Calendar now = Calendar.getInstance();
now.setTime(date);
// 一周第一天是否为星期天
boolean isFirstSunday = now.getFirstDayOfWeek() == Calendar.SUNDAY;
// 获取周几
int weekDay = now.get(Calendar.DAY_OF_WEEK);
// 若一周第一天为星期天，则-1
if (isFirstSunday) {
weekDay = weekDay - 1;
if (weekDay == 0) {
weekDay = 7;
}
}
return weekDay;
}
/**
*
* getDistanceHours: 计算两个时间段之间相差的小时数
* @param startTime 开始时间
* @param endTime 结束时间
* @return 返回两个时间段之间相差的小时数
*/
public static double getDistanceHours(String startTime, String endTime) {
DateFormat df = new SimpleDateFormat(TIMEF_FORMAT);
DecimalFormat dec = new DecimalFormat(twoDecimalFormat);
Date one;
Date two;
String hours = "";
try {
one = df.parse(startTime);
two = df.parse(endTime);
long time1 = one.getTime();
long time2 = two.getTime();
double diff;
diff = Math.abs(time1 - time2);
hours = dec.format(diff / (1000 * 60 * 60));
} catch (ParseException e) {
LOGGER.error(String.format("DateUtil.getDistanceHours:%s", e));
}
return Double.valueOf(hours);
}
/**
*
* getDistanceSecond: 计算两个时间段之间相差的秒数
* @param startTime 开始时间
* @param endTime 结束时间
* @return 返回两个时间段之间相差的秒数
*/
public static int getDistanceSecond(String startTime, String endTime) {
DateFormat df = new SimpleDateFormat(TIMEF_FORMAT);
DecimalFormat dec = new DecimalFormat(twoDecimalFormat);
Date one;
Date two;
String seconds = "";
try {
one = df.parse(startTime);
two = df.parse(endTime);
long time1 = one.getTime();
long time2 = two.getTime();
double diff = (double)(time1 - time2);
seconds = dec.format(diff / (1000));
} catch (ParseException e) {
LOGGER.error(String.format("DateUtil.getDistanceSecond:%s", e));
}
return Double.valueOf(seconds).intValue();
}
/**
*
* getDistanceSecond: 计算距离当前时间相差的秒数
* @param startTime 起始时间
* @return 返回距离当前时间相差的秒数
*/
public static int getDistanceSecond(String startTime) {
DateFormat df = new SimpleDateFormat(TIMEF_FORMAT);
DecimalFormat dec = new DecimalFormat("##0.0");
Date one;
Date two = new Date();
String hours = "";
try {
one = df.parse(startTime);
long time1 = one.getTime();
long time2 = two.getTime();
long diff = time1 - time2;
hours = dec.format(diff / (1000));
} catch (ParseException e) {
LOGGER.error(String.format("DateUtil.getDistanceSecond:%s", e));
}
return Double.valueOf(hours).intValue();
}
/**
*
* getDistanceMin:计算日期相差分钟数
* @param startTime 开始时间
* @param endTime 结束时间
* @return 返回两个时间相差分钟数
*/
public static long getDistanceMin(Date startTime, Date endTime) {
return (startTime.getTime() - endTime.getTime())/ (1000 * 60);
}
/**
* 根据传入的时间和state判断是年、季或者月报
* @param dateTime 时间
* @param state 类型 0：年，1：季， 2 月
* @return
*/
public static String getTime(String dateTime, int state) {
Date date = parseDate(dateTime, TIMEF_FORMAT);
String time = StringUtil.empty();
switch(state) {
case DATE_YEAR:{
time = convertDateToOracleToDateExp(date, ZHCN_YEAR_FORMAT);
}
break;
case DATE_SEASON:{
String season = StringUtil.empty();
int month = Integer.parseInt(getMonth(date));
if (month < 3){
season = "一";
}else if (month < 6){
season = "二";
}else if (month < 10){
season = "三";
}else{
season = "四";
}
time = convertDateToOracleToDateExp(date, ZHCN_YEAR_FORMAT) + String.format("第%s季度", season);
}
break;
case DATE_MONTH:{
time = convertDateToOracleToDateExp(date, ZHCN_MONTH_FORMAT);
}
break;
}
return time;
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
