记录一个经常用到的日期处理的工具类

最新推荐文章于 2023-02-12 22:28:21 发布
置顶 最新推荐文章于 2023-02-12 22:28:21 发布
阅读量468 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 工具栏 文章标签： DateUtil 日期格式转化 获取前后日期
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Mr_ChinaCheng/article/details/98204040 
package com.ifeng.icrawlms.utils.common;

import org.apache.commons.lang3.StringUtils;
import org.apache.log4j.LogManager;
import org.apache.log4j.Logger;

import javax.xml.datatype.DatatypeFactory;
import javax.xml.datatype.XMLGregorianCalendar;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.ParsePosition;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.TimeZone;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class DateUtil {
	private final static Logger log = LogManager.getLogger(DateUtil.class);
	private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat();
	public static final String DEFAULT_DATE_FORMATE = "yyyyMMddHHmmss";
	public static final String DATE_FORMAT_1 = "yyyy-MM-dd HH:mm:ss";
	public static final String DATE_FORMAT_Day = "yyyyMMdd";
	public static final String DATE_FORMAT_2 = "yyyy-MM-dd";
	public static final String DATE_FORMAT_3 = "yyyy年MM月dd日";

	/**
	 * 取得某日期时间的特定表示格式的字符串
	 *
	 * @param format
	 *            时间格式
	 * @param date
	 *            某日期（Date）
	 * @return 某日期的字符串
	 */
	public static synchronized String getDate2Str(String format, Date date) {
		simpleDateFormat.applyPattern(format);
		return simpleDateFormat.format(date);
	}

	/**
	 * 取得某日期时间的特定表示格式的字符串
	 *
	 * @param format
	 *            时间格式
	 * @return 某日期的字符串
	 */
	public static synchronized String getCurrentDateStr(String format) {
		if (StringUtils.isBlank(format)) {
			simpleDateFormat.applyPattern(DATE_FORMAT_2);
		} else {
			simpleDateFormat.applyPattern(format);
		}
		return simpleDateFormat.format(new Date());
	}

	/**
	 * 取得某日期时间的特定表示格式的字符串
	 *
	 * @param format
	 *            时间格式
	 * @return 某日期的字符串
	 */
	public static synchronized String getCurrentDateTimeStr(String format) {
		if (StringUtils.isBlank(format)) {
			simpleDateFormat.applyPattern(DATE_FORMAT_1);
		} else {
			simpleDateFormat.applyPattern(format);
		}
		return simpleDateFormat.format(new Date());
	}

	public static String getDay() {
		Date date = new Date();
		SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
		return sdf.format(date);
	}

	public static String getNowTime() {
		Date date = new Date();
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		return sdf.format(date);
	}

	public static Date getTimeMin(Date date) {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		String da = sdf.format(date);
		da = da + " 00:00:00";
		Date d = getStrToDate(DATE_FORMAT_1, da);
		return d;
	}

	public static Date getTimeMax(Date date) {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		String da = sdf.format(date);
		da = da + " 23:59:59";
		Date d = getStrToDate(DATE_FORMAT_1, da);
		return d;
	}

	public static Date getTimeMin() {
		Date date = new Date();
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		String da = sdf.format(date);
		da = da + " 00:00:00";
		Date d = getStrToDate(DATE_FORMAT_1, da);
		return d;
	}

	public static Date getTimeMax() {
		Date date = new Date();
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		String da = sdf.format(date);
		da = da + " 23:59:59";
		Date d = getStrToDate(DATE_FORMAT_1, da);
		return d;
	}

	/**
	 * 将特定格式的时间字符串转化为Date类型
	 *
	 * @param format
	 *            时间格式
	 * @param str
	 *            某日期的字符串
	 * @return 某日期（Date）
	 */
	public static synchronized Date getStrToDate(String format, String str) {
		simpleDateFormat.applyPattern(format);
		ParsePosition parseposition = new ParsePosition(0);
		return simpleDateFormat.parse(str, parseposition);
	}

	public static String date2String(Date date) {
		return getDate2Str(DEFAULT_DATE_FORMATE, date);
	}

	public static String dateFormatString(Date date) {
		return getDate2Str(DATE_FORMAT_1, date);
	}

	public static String date2String(Date date, String format) {
		return getDate2Str(format, date);
	}

	/**
	 * 检测字符串是否为日期
	 *
	 * @param dateTime
	 *            时间字符串
	 * @param pattern
	 *            Eg "yyyy-MM-dd"
	 * @return 返回结果
	 */
	public static boolean isDateTime(String dateTime, String pattern) {
		DateFormat df = new SimpleDateFormat(pattern);
		ParsePosition pos = new ParsePosition(0);
		Date dt = df.parse(dateTime, pos);
		return !(dt == null);
	}

	public static XMLGregorianCalendar getXMLGregorianCalendar(Date date) {
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		XMLGregorianCalendar xmlCalendar = null;
		try {
			DatatypeFactory dtf = DatatypeFactory.newInstance();
			xmlCalendar = dtf.newXMLGregorianCalendar(
					calendar.get(Calendar.YEAR),
					calendar.get(Calendar.MONTH) + 1,
					calendar.get(Calendar.DAY_OF_MONTH),
					calendar.get(Calendar.HOUR_OF_DAY),
					calendar.get(Calendar.MINUTE),
					calendar.get(Calendar.SECOND),
					calendar.get(Calendar.MILLISECOND),
					calendar.get(Calendar.ZONE_OFFSET) / (1000 * 60));
		} catch (Exception e) {
			log.error("getXMLGregorianCalendar error!", e);
		}
		return xmlCalendar;
	}

	public static Date getDateFromXmlGregorianCalendar(XMLGregorianCalendar da) {
		if (da != null) {
			int year = da.getYear();
			int month = da.getMonth();
			int day = da.getDay();
			int hour = da.getHour();
			int minute = da.getMinute();
			int second = da.getSecond();
			Calendar calendar = Calendar.getInstance();
			calendar.set(year, month - 1, day, hour, minute, second);
			Date date = calendar.getTime();
			return date;
		} else {
			return null;
		}

	}

	public static boolean passTime(Date tempDate, int hour) {
		return !(tempDate == null || hour <= 0)
				&& tempDate.before(getLimitDate(hour));
	}

	/**
	 * 得到n小时前时间
	 *
	 * @param hour
	 *            小时数
	 * @return Date
	 */
	public static Date getLimitDate(int hour) {
		Calendar cl = Calendar.getInstance();
		Long clTemp = cl.getTimeInMillis() - hour * 60 * 60 * 1000;
		cl.setTimeInMillis(clTemp);
		return cl.getTime();
	}

	/**
	 * 得到指定时间n分钟后时间
	 *
	 * @param minute
	 *            时间
	 * @return Date
	 * @throws Exception
	 */
	public static Date getTimeAfterMinute(int minute, Date date)
			throws Exception {
		long dateTemp = date.getTime() + minute * 60 * 1000L;
		Date newTime = new Date();
		newTime.setTime(dateTemp);
		return getFormatDate(newTime, "yyyy-MM-dd HH:mm:ss");
	}
	
	/**
	 * 得到指定时间n小时前时间
	 *
	 * @param minute
	 *            时间
	 * @return Date
	 * @throws Exception
	 */
	public static Date getTimeBeforeHour(int hour, Date date)
			throws Exception {
		long dateTemp = date.getTime() - hour * 60 * 60 * 1000L;
		Date newTime = new Date();
		newTime.setTime(dateTemp);
		return getFormatDate(newTime, "yyyy-MM-dd HH:mm:ss");
	}
	
	
	/**
	 * 得到指定时间n小时后时间
	 *
	 * @param minute
	 *            时间
	 * @return Date
	 * @throws Exception
	 */
	public static Date getTimeAfterHour(int hour, Date date)
			throws Exception {
		long dateTemp = date.getTime() + hour * 60 * 60 * 1000L;
		Date newTime = new Date();
		newTime.setTime(dateTemp);
		return getFormatDate(newTime, "yyyy-MM-dd HH:mm:ss");
	}
	
	/**
	 * 得到指定时间n天后日期
	 *
	 * @param day
	 *            日期
	 * @return Date
	 * @throws Exception
	 */
	public static Date getDateAfterDate(int day, Date date) throws Exception {
		long dateTemp = date.getTime() + day * 24 * 60 * 60 * 1000L;
		Date newDate = new Date();
		newDate.setTime(dateTemp);
		return getFormatDate(newDate, "yyyy-MM-dd");
	}

	/**
	 * 得到n天后日期
	 *
	 * @param day
	 *            日期
	 * @return Date
	 */
	public static Date getAfterDate(int day) throws Exception {
		Calendar cl = Calendar.getInstance();
		Long clTemp = cl.getTimeInMillis() + day * 24 * 60 * 60 * 1000;
		cl.setTimeInMillis(clTemp);
		return getFormatDate(cl.getTime(), "yyyy-MM-dd");
	}

	/**
	 * 得到当前时间n分钟前时间
	 *
	 * @param day
	 *            日期
	 * @return Date
	 * @throws Exception
	 */
	public static Date getBeforeMinute(int minute)
			throws Exception {
		Date nowtime = new Date();
		long dateTemp = nowtime.getTime() - minute * 60 * 1000L;
		nowtime.setTime(dateTemp);
		return getFormatDate(nowtime, "yyyy-MM-dd HH:mm:ss");
	}
	
	/**
	 * 得到当前时间n分钟前时间
	 *
	 * @param day
	 *            日期
	 * @return Date
	 * @throws Exception
	 */
	public static Date getBeforeHour(int hour)
			throws Exception {
		Date nowtime = new Date();
		long dateTemp = nowtime.getTime() - hour * 60 * 60 * 1000L;
		nowtime.setTime(dateTemp);
		return getFormatDate(nowtime, "yyyy-MM-dd HH:mm:ss");
	}
	
	/**
	 * 得到指定时间n分钟前时间
	 *
	 * @param day
	 *            日期
	 * @return Date
	 * @throws Exception
	 */
	public static Date getTimeBeforeMinute(int minute, Date date)
			throws Exception {
		long dateTemp = date.getTime() - minute * 60 * 1000L;
		Date newTime = new Date();
		newTime.setTime(dateTemp);
		return getFormatDate(newTime, "yyyy-MM-dd HH:mm:ss");
	}

	/**
	 * 得到指定时间n天前日期
	 *
	 * @param day
	 *            日期
	 * @return Date
	 * @throws Exception
	 */
	public static Date getDateBeforeDate(int day, Date date) throws Exception {
		long dateTemp = date.getTime() - day * 24 * 60 * 60 * 1000L;
		date.setTime(dateTemp);
		return getFormatDate(date, "yyyy-MM-dd");
	}

	/**
	 * 得到n天前日期
	 *
	 * @param day
	 *            日期
	 * @return Date
	 */
	public static Date getBeforeDate(int day) throws Exception {
		Calendar cl = Calendar.getInstance();
		Long clTemp = cl.getTimeInMillis() - day * 24 * 60 * 60 * 1000;
		cl.setTimeInMillis(clTemp);
		return getFormatDate(cl.getTime(), "yyyy-MM-dd");
	}

	/**
	 * 得到n天前日期
	 *
	 * @param day
	 *            日期
	 * @return Date
	 */
	public static Date getBeforeDateTime(int day) throws Exception {
		Calendar cl = Calendar.getInstance();
		Long clTemp = cl.getTimeInMillis() - day * 24 * 60 * 60 * 1000;
		cl.setTimeInMillis(clTemp);
		return getFormatDate(cl.getTime(), "yyyy-MM-dd HH:mm:ss");
	}

	/**
	 * 得到n天前日期
	 *
	 * @param day
	 *            日期
	 * @return String
	 */
	public static String getBeforeDateStr(int day) throws Exception {
		Calendar cl = Calendar.getInstance();
		Long clTemp = cl.getTimeInMillis() - day * 24 * 60 * 60 * 1000;
		cl.setTimeInMillis(clTemp);
		return getDate2Str("yyyy-MM-dd", cl.getTime());
	}
	public static String getBeforeDateStr(int day, String format) throws Exception {
		Calendar cl = Calendar.getInstance();
		cl.setTimeInMillis(cl.getTimeInMillis());
		cl.add(Calendar.DAY_OF_YEAR, -1 * day);
		return getDate2Str(format, cl.getTime());
	}

	/**
	 * 得到n天前日期
	 *
	 * @param day
	 *            日期
	 * @return String
	 */
	public static String getBeforeDateTimeStr(int day) throws Exception {
		Calendar cl = Calendar.getInstance();
		cl.setTimeInMillis(cl.getTimeInMillis());
		cl.add(Calendar.DAY_OF_YEAR, -1 * day);
		return getDate2Str("yyyy-MM-dd HH:mm:ss", cl.getTime());
	}

	/**
	 * 得到n分钟前时间
	 * 
	 * @param minute
	 *            小时数
	 * @return Date
	 */
	public static Date getLimitDateByMinute(int minute) {
		Calendar cl = Calendar.getInstance();
		Long clTemp = cl.getTimeInMillis() - minute * 60 * 1000;
		cl.setTimeInMillis(clTemp);
		return cl.getTime();
	}

	// 判断是不是日期型 true代表是日期型，false代表失败
	public static boolean isValidDate(String sDate) {
		String datePattern1 = "\\d{4}-\\d{2}-\\d{2}";
		String datePattern2 = "^((\\d{2}(([02468][048])|([13579][26]))"
				+ "[\\-\\/\\s]?((((0?[13578])|(1[02]))[\\-\\/\\s]?((0?[1-9])|([1-2][0-9])|"
				+ "(3[01])))|(((0?[469])|(11))[\\-\\/\\s]?((0?[1-9])|([1-2][0-9])|(30)))|(0?2[\\-\\/\\s]?"
				+ "((0?[1-9])|([1-2][0-9])))))|(\\d{2}(([02468][1235679])|([13579][01345789]))[\\-\\/\\s]?("
				+ "(((0?[13578])|(1[02]))[\\-\\/\\s]?((0?[1-9])|([1-2][0-9])|(3[01])))|(((0?[469])|(11))[\\-\\/\\s]?"
				+ "((0?[1-9])|([1-2][0-9])|(30)))|(0?2[\\-\\/\\s]?((0?[1-9])|(1[0-9])|(2[0-8]))))))";
		if ((sDate != null)) {
			Pattern pattern = Pattern.compile(datePattern1);
			Matcher match = pattern.matcher(sDate);
			if (match.matches()) {
				pattern = Pattern.compile(datePattern2);
				match = pattern.matcher(sDate);
				return match.matches();
			} else {
				return false;
			}
		}
		return false;
	}

	/**
	 * 计算时间差 传入的是date类型
	 * 
	 * @param date1
	 * @param date2
	 * @param type
	 *            返回类型
	 * @return
	 */
	public static String dateIntervalForDate(Date date1, Date date2, String type) {
		try {
			if (date1 != null && !"".equals(date1) && !"null".equals(date1)
					&& date2 != null && !"".equals(date2)
					&& !"null".equals(date2)) {
				// 转换后调用时间差算法
				return coreDateInterval(date1, date2, type);
			}
		} catch (Exception e) {
			log.error("计算时间差 error", e);
		}
		return "";
	}

	/**
	 * 计算时间差 传入的类型如果是字符串，则用此方法转换成date类型，再调用时间差算法
	 * 
	 * @param date1
	 * @param date2
	 * @param type
	 *            返回类型
	 * @return
	 */
	public static String dateIntervalForString(String date1, String date2,
											   String type) {
		try {
			if (date1 != null && !"".equals(date1) && !"null".equals(date1)
					&& date2 != null && !"".equals(date2)
					&& !"null".equals(date2)) {
				SimpleDateFormat sdf = new SimpleDateFormat(
						"yyyy-MM-dd HH:mm:ss");
				Date date3 = sdf.parse(date1);
				Date date4 = sdf.parse(date2);
				// 转换后调用时间差算法
				return coreDateInterval(date3, date4, type);
			}
		} catch (Exception e) {
			log.error("计算时间差 error", e);
		}
		return "";
	}

	/**
	 * 计算时间差核心方法
	 * 
	 * @param args
	 */
	public static String coreDateInterval(Date date1, Date date2, String type) {
		long l = date2.getTime() - date1.getTime();
		long day = l / (24 * 60 * 60 * 1000);
		long hour = (l / (60 * 60 * 1000) - day * 24);
		long min = ((l / (60 * 1000)) - day * 24 * 60 - hour * 60);
		long s = (l / 1000 - day * 24 * 60 * 60 - hour * 60 * 60 - min * 60);
		if ("1".equals(type)) {
			return day + "天" + hour + "小时" + min + "分" + s + "秒";
		} else if ("2".equals(type)) {
			return day * 24 + hour + ":" + min + ":" + s;
		} else {
			return "";
		}
	}

	/**
	 * 计算当前时间到凌晨时间差
	 * 
	 * @param args
	 */
	public static int getBetweenDayMs() {
		Calendar c = Calendar.getInstance();
		Date date = new Date();
		c.setTime(date);
		c.set(Calendar.DAY_OF_MONTH, c.get(Calendar.DAY_OF_MONTH) + 1);
		c.set(Calendar.HOUR_OF_DAY, 0);
		c.set(Calendar.MINUTE, 0);
		c.set(Calendar.SECOND, 0);
		int ms = (int) (c.getTime().getTime() - date.getTime()) / 1000;
		return ms;
	}

	public static Date getPreMonth() {
		Calendar cal = Calendar.getInstance();
		cal.add(Calendar.DATE, -1); // 得到前一天
		cal.add(Calendar.MONTH, -1); // 得到前一个月
		return cal.getTime();
	}

	public static String default_format = "yyyy-MM-dd HH:mm:ss";

	public static String getDate2String(Date date, String format) {
		SimpleDateFormat sformat = new SimpleDateFormat(format);
		return sformat.format(date);
	}

	public static Date getDateFromString(String date) throws Exception {
		SimpleDateFormat sformat = new SimpleDateFormat(default_format);
		return sformat.parse(date);
	}

	public static Date getDateFromStr(String date, String format)
			throws Exception {
		SimpleDateFormat sformat = new SimpleDateFormat(format);
		return sformat.parse(date);
	}

	public static Date getString2Date(String date, String format)
			throws Exception {
		SimpleDateFormat sformat = new SimpleDateFormat(format);
		return sformat.parse(date);
	}

	public static Date getFormatDate(Date date, String format) throws Exception {
		String dateStr = getDate2String(date, format);
		return getString2Date(dateStr, format);
	}

	// 用于开关模块请求参数,例:pwd=091416
	public static String getSwitchPassword() {
		String pwd = "";
		Date date = new Date();
		SimpleDateFormat nowtime = new SimpleDateFormat("yyyy-MM-dd");
		String timeStr = nowtime.format(date);
		String[] timeArray = timeStr.split("-");

		pwd = timeArray[1] + timeArray[0].substring(2) + timeArray[2];

		return pwd;
	}

	// 用于开关模块请求参数,例:pwd=091416
	public static String getSwitchPasswordUrlParam(String uri) {
		if (uri.indexOf("?") == -1) {
			return uri + "?pwd=" + getSwitchPassword();
		} else {
			return uri + "&pwd=" + getSwitchPassword();
		}
	}

	public static String getLastDateStr(Date createTime, String format) {
		Calendar c = Calendar.getInstance();
		c.setTime(createTime);
		Long clTemp = c.getTimeInMillis() - 1 * 24 * 60 * 60 * 1000;
		c.setTimeInMillis(clTemp);
		return getDate2Str(format, c.getTime());
	}

	public static String getDateStrByLong(long time, String format)
			throws Exception {
		Date date = new Date();
		date.setTime(time);
		return getDate2Str(format, date);
	}

	public static int getDayDiff(Date date1, Date date2) {
		long difference = Math.abs(date2.getTime() - date1.getTime());
		return (int) (difference / 1000 / 60 / 60 / 24 + 1);
	}
	
	public static int get5MinuteDiff(Date date1, Date date2) {
		long difference = Math.abs(date2.getTime() - date1.getTime());
		return (int) (difference / 1000 / 60 / 5 + 1);
	}
	
	public static int getHourDiff(Date date1, Date date2) {
		long difference = Math.abs(date2.getTime() - date1.getTime());
		return (int) (difference / 1000 / 60 / 60 + 1);
	}

	public static Date getDayStart(Date date) throws Exception {
		Calendar c = Calendar.getInstance();
		c.setTime(date);
		c.set(Calendar.HOUR, 0);
		c.set(Calendar.MINUTE, 0);
		c.set(Calendar.SECOND, 0);
		
		return getFormatDate(c.getTime(), "yyyy-MM-dd HH:mm:ss");
	}
	
	public static Date getDayEnd(Date date) throws Exception {
		Calendar c = Calendar.getInstance();
		c.setTime(date);
		c.set(Calendar.HOUR, 23);
		c.set(Calendar.MINUTE, 59);
		c.set(Calendar.SECOND, 59);
		
		return getFormatDate(c.getTime(), "yyyy-MM-dd HH:mm:ss");
	}
	
	public static Date get5MStart(Date date) throws Exception {
		Calendar c = Calendar.getInstance();
		c.setTime(date);
		int minute = c.get(Calendar.MINUTE);
		minute = (minute / 5) * 5;
		c.set(Calendar.MINUTE, minute);
		c.set(Calendar.SECOND, 0);
		
		return c.getTime();
	}
	
	public static Date get5MEnd(Date date) throws Exception {
		Calendar c = Calendar.getInstance();
		c.setTime(date);
		int minute = c.get(Calendar.MINUTE);
		minute = (minute / 5 + 1) * 5;
		c.set(Calendar.MINUTE, minute);
		c.set(Calendar.SECOND, 0);
		
		return c.getTime();
	}
	
	public static Date getHourStart(Date date) throws Exception {
		Calendar c = Calendar.getInstance();
		c.setTime(date);
		c.set(Calendar.MINUTE, 0);
		c.set(Calendar.SECOND, 0);
		
		return c.getTime();
	}
	
	public static Date getHourEnd(Date date) throws Exception {
		Calendar c = Calendar.getInstance();
		c.setTime(date);
		int second = c.get(Calendar.SECOND);
		int minute = c.get(Calendar.MINUTE);
		int hour = c.get(Calendar.HOUR);
		
		if (second == 0 && minute == 0)
			return c.getTime();
		else {
			c.set(Calendar.HOUR, hour + 1);
			c.set(Calendar.MINUTE, 0);
			c.set(Calendar.SECOND, 0);
		}
		
		return c.getTime();
	}
	
	public static Date getBeforeDateInfo(int day) throws Exception {
		Calendar cl = Calendar.getInstance();
		cl.setTimeInMillis(cl.getTimeInMillis());
		cl.add(Calendar.DAY_OF_YEAR, -1 * day);
		return cl.getTime();
	}

	/**
	 *
	 * @param date
	 * @param format
	 * @return
	 */
	public static Date formatDate(Date date,String format) {
		SimpleDateFormat inDf = new SimpleDateFormat(format);
		SimpleDateFormat outDf = new SimpleDateFormat(format);
		String reDate = "";
		try {
			reDate = inDf.format(date);
			return outDf.parse(reDate);
		} catch (Exception e) {

		}
		return date;
	}

	public static Date formatDateUTC(String dateStr) throws ParseException {
		SimpleDateFormat df2 = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS Z");
		df2.setTimeZone(TimeZone.getTimeZone("UTC"));
		Date date = df2.parse(dateStr);
		return date;
	}

	/**
	 * 计算时间延迟多久后的时间
	 * @param date  原始时间
	 * @param unit  延迟单位：Calendar.*    eg: Calendar.MONTH
	 * @param k     延迟量
     * @return
     */
	public static Date getDateAfterDate(Date date,Integer unit,Integer k){
		Calendar calendar=Calendar.getInstance();
		calendar.setTime(date);
		calendar.add(unit,k);
		return calendar.getTime();
	}
	
	public static void main(String[] args) throws Exception {
		System.out.println(getCurrentDateStr("yyyy-MM-dd HH:mm:ss"));
		System.out.println(date2String(getBeforeHour(2), "yyyy-MM-dd HH:mm:ss"));
		System.out.println(getBeforeDateInfo(15));
		System.out.println(getBeforeDate(1));
	}




	
}
zk扩展工具--spring集成--字符串处理--日期处理
03-21
NULL 博文链接：https://sun4love.iteye.com/blog/989584
android 开发常用到的工具类集锦
11-21
"android 开发常用到的工具类集锦"是一个集合了多种实用功能的开源项目，它包括了网络访问、文件操作、图像处理等多个关键领域的工具类。下面我们将详细探讨这些工具类以及它们在实际开发中的应用。 1. **网络访问...
一篇彻底搞定 Java8 日期工具类，包括 LocalDate，LocalDateTime
良月柒
02-12 1130
程序员的成长之路互联网/程序员/技术/资料共享关注阅读本文大概需要 15分钟。来自：blog.youkuaiyun.com/zhouzhiwengang/article/details/1284330111、java 支持日期格式化importjava.text.SimpleDateFormat; importjava.time.format.DateTimeFormatter; publics...
java分享一个日期时间处理工具
weixin_39704957的博客
02-21 655
package com.sento.game.app.common.util; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.*; import java....
java 处理时间的各种方式——获取时间——时间格式化
weixin_33950035的博客
06-16 190
  TimeUtil.java package com.snow; import java.text.DateFormat; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date; public class TimeUtil { ...
java 日期处理工具类
Li_Mao2的博客
01-12 585
package com.conb.util; import java.text.ParseException; import java.text.SimpleDateFormat; import java.time.LocalDate; import java.time.format.DateTimeFormatter; import java.util.ArrayList; import ja
android各种工具类
11-14
在Android开发中，工具类是开发者经常会用到的辅助代码集合，它们可以帮助我们高效地处理各种常见任务。本文将深入探讨“android各种工具类”这一主题，包括文件操作、日期处理、图片处理、系统服务利用、网络通信...
日期处理类
06-09
在编程领域，日期处理是一个非常重要的部分，尤其是在数据分析、日志记录、报表生成以及各种需要时间戳操作的应用中。在Java、Python、JavaScript等常见编程语言中，都有专门的库或者内置类来处理日期和时间。本文将...
SSH框架常用到的一些工具类整理
07-16
在这个“SSH框架常用到的一些工具类整理”中，我们将探讨SSH框架下的一些关键工具类及其应用，这些工具类对于进行SSH开发至关重要。 首先，让我们关注Spring框架。Spring框架提供了一系列工具类，如`BeanUtils`，...
常用工具类常用工具类.zip
05-10
7. **Guava**: Google提供的一个强大的Java库，包含了大量的工具类，如`Preconditions`用于参数检查，`Immutable`类用于创建不可变对象，`Cache`类用于缓存管理等。 8. **SLF4J (Simple Logging Facade for Java)**...
如何计算指定时间的下一次执行时间
红豆和绿豆的博客
07-17 488
<dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz</artifactId> <version>2.3.0</version> </dependency> <dependency> ...
Google Guava常用工具类入门使用介绍及样例说明
进修的CODER
03-04 2865
目录概述基础工具1.Optional2.Objects.equals3.Objects.hash4.MoreObjects.toStringHelper5.ComparisonChain6.Preconditions集合工具1.ImmutableSet2.ImmutableList3.4.5.6.字符串工具1.2.3.4.5.6.附录1.Person.java 概述 工具类将经常用的一些方法进行了封装，遇到相同的场景时不需要重复造轮子，从而大量节省开发人员时间和提高工作效率，Guava就是谷歌发布的高效率的
自用JS逆计时，友好历史时间
成长日记
04-11 146
从数字库中读一个timestamp的值，结果用json输出到前台变成了13位的毫秒。索性就以这个参数来算一下逆计时了。   效果：几秒前，几分钟前，几小时前     /** 参数为13位毫秒时间，也就是new Date().getTime()的格式。 **/ function getTimeBefore(time) {     var ret = "";     var now...
Guava之Stopwatch计时器-Guava
抽象的螺旋
10-26 1169
概述 Stopwatch用来计算经过的时间（精确到纳秒）。 这个类比调用System.nanoTime()优势在于： 性能 表现形式更丰富
验证日期格式，如果是就返回字符串，如果不是就返回空字符
择善师的专栏
07-18 654
import java.text.SimpleDateFormat; public class Test{ public static String isValidDate(String str) { boolean convertSuccess=true;// 指定日期格式为四位年/两位月份/两位日期，注意yyyy/MM/dd区分大小写； String alert=s...
使用Google guava记录时间
不将就不念旧的博客
11-12 2586
导入guava依赖 <dependency> <groupId>com.google.guava</groupId> <artifactId>guava</artifactId> <version>20.0</version> ...
使用Joda-Time优雅的处理日期时间
chq88888的博客
07-22 928
简介 在Java中处理日期和时间是很常见的需求，基础的工具类就是我们熟悉的Date和Calendar，然而这些工具类的api使用并不是很方便和强大，于是就诞生了Joda-Time这个专门处理日期时间的库。 下面是joda-time的官网和API(貌似需要翻墙) Home：http://j...
JAVA 公共方法 之 date时间处理
桃欢李笑
04-23 1414
/** * 字符串转换成Date类型 * @param strDate * @return */ public static Date getDateFromString(String strDate) { if (StringUtils.isBlank(strDate)) { return new Date(); } SimpleDateFormat simple = new Simp
处理时间的工具类
一个不合格的小码农
12-14 268
时间处理的工具类,long string date三者相互转换. 其中 date转long 比较简单,不列入其中. new Date().getTime().就可以得到毫秒,格式为long类型. System.currentTimeMillis() 得到毫秒,格式为long类型.
Java日期处理工具类：格式化与日期运算详解
日期处理工具类是编程中经常会用到的一个工具类，它主要是为了帮助开发者更高效地处理日期数据。在Java中，这个类通常包含了一系列的静态方法，用于实现日期的格式化、字符串转换为日期对象、日期的加减运算等功能。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值