日期处理工具类

package com.jh.util;

import java.sql.Timestamp;
import java.text.NumberFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

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

/**
 * @author duhongming
 * 
 */

public class DateUtil {

	public static final String PATTERN_DATE = "yyyy-MM-dd";
	public static final String PATTERN_STANDARD = "yyyy-MM-dd HH:mm:ss";
	public static final String PATTERN_SN_DATE = "yyyyMMdd";

	public static String getTimestampStr() {
		Date date = new Date();
		Long longTime = date.getTime();
		return longTime.toString();
	}

	public static String date2String(Date date, String pattern) {
		if (date == null) {
			throw new java.lang.IllegalArgumentException(
					"timestamp null illegal");
		}
		if (pattern == null || pattern.equals("")) {
			pattern = PATTERN_STANDARD;
			;
		}
		SimpleDateFormat sdf = new SimpleDateFormat(pattern);
		return sdf.format(date);
	}

	public static Date string2Date(String strDate, String pattern) {
		if (strDate == null || strDate.equals("")) {
			throw new RuntimeException("str date null");
		}
		if (pattern == null || pattern.equals("")) {
			pattern = DateUtil.PATTERN_DATE;
		}
		SimpleDateFormat sdf = new SimpleDateFormat(pattern);
		Date date = null;

		try {
			date = sdf.parse(strDate);
		} catch (ParseException e) {
			throw new RuntimeException(e);
		}
		return date;
	}

	public static Date getSomeDate(int i) {
		Calendar c = Calendar.getInstance();
		c.add(Calendar.DATE, i);
		return c.getTime();
	}

	public static String timestamp2String(Timestamp timestamp, String pattern) {
		if (timestamp == null) {
			throw new java.lang.IllegalArgumentException(
					"timestamp null illegal");
		}
		if (pattern == null || pattern.equals("")) {
			pattern = PATTERN_STANDARD;
		}
		SimpleDateFormat sdf = new SimpleDateFormat(pattern);
		return sdf.format(new Date(timestamp.getTime()));
	}

	public static Timestamp currentTimestamp() {
		return new Timestamp(new Date().getTime());
	}

	public static String currentTimestamp2String(String pattern) {
		return timestamp2String(currentTimestamp(), pattern);
	}

	public static Timestamp string2Timestamp(String strDateTime, String pattern) {
		if (strDateTime == null || strDateTime.equals("")) {
			throw new java.lang.IllegalArgumentException(
					"Date Time Null Illegal");
		}
		if (pattern == null || pattern.equals("")) {
			pattern = PATTERN_STANDARD;
		}

		SimpleDateFormat sdf = new SimpleDateFormat(pattern);
		Date date = null;
		try {
			date = sdf.parse(strDateTime);
		} catch (ParseException e) {
			throw new RuntimeException(e);
		}
		return new Timestamp(date.getTime());
	}

	public static String stringToYear(String strDest) {
		if (strDest == null || strDest.equals("")) {
			throw new java.lang.IllegalArgumentException("str dest null");
		}

		Date date = string2Date(strDest, DateUtil.PATTERN_DATE);
		Calendar c = Calendar.getInstance();
		c.setTime(date);
		return String.valueOf(c.get(Calendar.YEAR));
	}

	public static String stringToMonth(String strDest) {
		if (strDest == null || strDest.equals("")) {
			throw new java.lang.IllegalArgumentException("str dest null");
		}

		Date date = string2Date(strDest, DateUtil.PATTERN_DATE);
		Calendar c = Calendar.getInstance();
		c.setTime(date);
		// return String.valueOf(c.get(Calendar.MONTH));
		int month = c.get(Calendar.MONTH);
		month = month + 1;
		if (month < 10) {
			return "0" + month;
		}
		return String.valueOf(month);
	}

	public static String stringToDay(String strDest) {
		if (strDest == null || strDest.equals("")) {
			throw new java.lang.IllegalArgumentException("str dest null");
		}

		Date date = string2Date(strDest, DateUtil.PATTERN_DATE);
		Calendar c = Calendar.getInstance();
		c.setTime(date);
		// return String.valueOf(c.get(Calendar.DAY_OF_MONTH));
		int day = c.get(Calendar.DAY_OF_MONTH);
		if (day < 10) {
			return "0" + day;
		}
		return "" + day;
	}

	public static Date getFirstDayOfMonth(Calendar c) {
		int year = c.get(Calendar.YEAR);
		int month = c.get(Calendar.MONTH);
		int day = 1;
		c.set(year, month, day, 0, 0, 0);
		return c.getTime();
	}

	public static Date getLastDayOfMonth(Calendar c) {
		int year = c.get(Calendar.YEAR);
		int month = c.get(Calendar.MONTH) + 1;
		int day = 1;
		if (month > 11) {
			month = 0;
			year = year + 1;
		}
		c.set(year, month, day - 1, 0, 0, 0);
		return c.getTime();
	}

	public static String date2GregorianCalendarString(Date date) {
		if (date == null) {
			throw new java.lang.IllegalArgumentException("Date is null");
		}
		long tmp = date.getTime();
		GregorianCalendar ca = new GregorianCalendar();
		ca.setTimeInMillis(tmp);
		try {
			XMLGregorianCalendar t_XMLGregorianCalendar = DatatypeFactory
					.newInstance().newXMLGregorianCalendar(ca);
			return t_XMLGregorianCalendar.normalize().toString();
		} catch (DatatypeConfigurationException e) {
			e.printStackTrace();
			throw new java.lang.IllegalArgumentException("Date is null");
		}

	}

	public static boolean compareDate(Date firstDate, Date secondDate) {
		if (firstDate == null || secondDate == null) {
			throw new java.lang.RuntimeException();
		}

		String strFirstDate = date2String(firstDate, "yyyy-MM-dd");
		String strSecondDate = date2String(secondDate, "yyyy-MM-dd");
		if (strFirstDate.equals(strSecondDate)) {
			return true;
		}
		return false;
	}

	public static Date firstOfQuarter(Date date) {
		if (date == null) {
			throw new java.lang.RuntimeException();
		}
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		switch (calendar.get(Calendar.MONTH)) {
		case 0:
		case 1:
		case 2:
			calendar.set(Calendar.MONTH, 0);
			break;
		case 3:
		case 4:
		case 5:
			calendar.set(Calendar.MONTH, 3);
			break;
		case 6:
		case 7:
		case 8:
			calendar.set(Calendar.MONTH, 6);
			break;
		case 9:
		case 10:
		case 11:
			calendar.set(Calendar.MONTH, 9);
			break;
		}

		calendar.set(Calendar.DATE, 1);
		SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
		try {
			return df.parse(df.format(calendar.getTime()));
		} catch (ParseException e) {
			throw new java.lang.RuntimeException();
		}
	}

	public static Date lastOfQuarter(Date date) {
		Date firstDate = firstOfQuarter(date);

		Calendar calendar = Calendar.getInstance();
		calendar.setTime(firstDate);
		calendar.set(Calendar.MONTH, calendar.get(Calendar.MONTH) + 3);

		return calendar.getTime();
	}

	public static Date getLastDayOfMonth(Date date) {
		if (date == null) {
			throw new java.lang.RuntimeException();
		}
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		calendar.set(Calendar.DATE, 1);
		calendar.roll(Calendar.DATE, -1);
		return calendar.getTime();
	}

	public static Date getDateAfterMonth(Date date, int amount) {
		if (date == null) {
			throw new java.lang.RuntimeException();
		}
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		calendar.add(Calendar.MONTH, amount);
		return calendar.getTime();
	}

	/**
	 * 用默认的格式字符串获得当前日期的字符串
	 * 
	 * @param date
	 *            要格式化的Date.
	 * @param formatString
	 *            格式字符串.
	 * @return 格式化好的日期字符串.
	 */
	public static String getToday() {
		return getDateStringByFormat(new Date(), PATTERN_DATE);
	}

	/**
	 * 根据默认的格式字符串格式化Date
	 * 
	 * @param date
	 *            要格式化的Date.
	 * @param formatString
	 *            格式字符串.
	 * @return 格式化好的日期字符串.
	 */
	public static String getDateStringByFormat(Date date) {
		return getDateStringByFormat(date, PATTERN_DATE);
	}

	/**
	 * 根据指定的格式字符串格式化Date
	 * 
	 * @param date
	 *            要格式化的Date.
	 * @param formatString
	 *            格式字符串.
	 * @return 格式化好的日期字符串.
	 */
	public static String getDateStringByFormat(Date date, String formatString) {
		SimpleDateFormat dateFormat = new SimpleDateFormat(formatString);
		return dateFormat.format(date);
	}

	/**
	 * 用默认的格式字符串和指定的Date字符串来取得Date
	 * 
	 * @param dateString
	 *            Date字符串.
	 * @return 格式化好的Date.
	 */
	public static Date getDateByFormat(String dateString) throws ParseException {
		return getDateByFormat(dateString, PATTERN_DATE);
	}

	/**
	 * 根据指定的格式字符串和Date字符串来取得Date
	 * 
	 * @param dateString
	 *            Date字符串.
	 * @param formatString
	 *            格式字符串.
	 * @return 格式化好的Date.
	 */
	public static Date getDateByFormat(String dateString, String formatString)
			throws ParseException {
		SimpleDateFormat dateFormat = new SimpleDateFormat(formatString);
		return dateFormat.parse(dateString);
	}

	/**
	 * 将数字格式化为符合流水号格式的字符串
	 * 
	 * @param num
	 *            要格式化的数字.
	 * @return 格式化好的字符串.
	 */
	public static String getSNFormat(int num) {
		NumberFormat nf = NumberFormat.getInstance();
		// 设置是否使用分组
		nf.setGroupingUsed(false);
		// 设置最大整数位数
		nf.setMaximumIntegerDigits(3);
		// 设置最小整数位数
		nf.setMinimumIntegerDigits(3);
		// 输出测试语句
		return nf.format(num);
	}

	/**
	 * 生一个32为的UUID，作为数据库的主键.
	 * 
	 * @return UUID字符串.
	 */
	public static String getUUID() {
		UUID uuid = UUID.randomUUID();
		return uuid.toString().replace("-", "");
	}

	/**
	 * 把日期字符串转换为符合数据库存储格式的Date
	 * 
	 * @param dateString
	 *            日期字符串.
	 * @return Date.
	 */
	public static java.sql.Date getSQLDate(String dateString) {
		return java.sql.Date.valueOf(dateString);
	}

	/**
	 * 将数据库中得到的timestamp格式化为YYYY-MM-DD hh:mm:ss形式
	 * 
	 * @param timestamp
	 *            Timestamp值
	 * @return 格式化好的timestamp.
	 * @throws ParseException
	 */
	public static String getFormatTimestamp(Timestamp ts) throws ParseException {
		return getDateStringByFormat(ts, PATTERN_STANDARD);
	}

	public static void main(String[] args) {
		// System.out.println(stringToYear("2007-12-10"));
		// System.out.println(stringToMonth("2007-1-10"));
		// System.out.println(stringToDay("2007-12-10"));
		// System.out.println(string2Date("2007-09-11",TangCEDateUtil.PATTERN_DATE));
		// Calendar c = Calendar.getInstance();
		// System.out.println(c.(Calendar.DAY_OF_MONTH));
		// System.out.println(c.getMaximum(Calendar.DAY_OF_MONTH));
		// System.out.println(getFirstDayOfMonth(c));
		// System.out.println(getLastDayOfMonth(c));
		// String pattern =
		// String tmp = System.getProperty("file.separator");
		// String pattern = "yyyy" + tmp + "MM" + tmp + "dd";
		// System.out.println(DateUtil.date2String(new java.util.Date(),
		// pattern));
		// System.out.println(date2GregorianCalendarString(new Date()));;

		// System.out.println(DateUtil.date2String(new java.util.Date(), "hh"));
		// System.out.println(DateUtil.date2String(new Date(), "ss"));
		System.out.println(date2String(new Date(), "yyyy/MM/dd/"));
		System.out.println(date2GregorianCalendarString(new Date()));
	}

	/**
	 * 英文简写（默认）如：2010-12-01
	 */
	public static String FORMAT_SHORT = "yyyy-MM-dd";

	/**
	 * 英文全称 如：2010-12-01 23:15:06
	 */
	public static String FORMAT_LONG = "yyyy-MM-dd HH:mm:ss";

	/**
	 * 精确到毫秒的完整时间 如：yyyy-MM-dd HH:mm:ss.S
	 */
	public static String FORMAT_FULL = "yyyy-MM-dd HH:mm:ss.S";

	/**
	 * 英文全称 如：20130728111506
	 */
	public static String FORMAT_EASY = "yyyyMMddHHmmss";
	public static String FORMAT_EASY_E = "yyMMdd";
	/**
	 * 汉字加年月
	 */
	public static String FORMAT_CHINA = "yyyy年MM月dd日";

	/**
	 * 获得默认的 date pattern
	 */
	public static String getDatePattern() {
		return FORMAT_LONG;
	}

	/**
	 * 根据预设格式返回当前日期
	 * 
	 * @return
	 */
	public static String getNow() {
		return format(new Date());
	}

	/**
	 * 根据用户格式返回当前日期
	 * 
	 * @param format
	 * @return
	 */
	public static String getNow(String format) {
		return format(new Date(), format);
	}

	/**
	 * 使用预设格式格式化日期
	 * 
	 * @param date
	 * @return
	 */
	public static String format(Date date) {
		return format(date, getDatePattern());
	}

	/**
	 * 使用用户格式格式化日期
	 * 
	 * @param date
	 *            日期
	 * @param pattern
	 *            日期格式
	 * @return
	 */
	public static String format(Date date, String pattern) {
		String returnValue = "";
		if (date != null) {
			SimpleDateFormat df = new SimpleDateFormat(pattern);
			returnValue = df.format(date);
		}
		return (returnValue);
	}

	/**
	 * 使用预设格式提取字符串日期
	 * 
	 * @param strDate
	 *            日期字符串
	 * @return
	 */
	public static Date parse(String strDate) {
		return parse(strDate, getDatePattern());
	}

	/**
	 * 使用用户格式提取字符串日期
	 * 
	 * @param strDate
	 *            日期字符串
	 * @param pattern
	 *            日期格式
	 * @return
	 */
	public static Date parse(String strDate, String pattern) {
		SimpleDateFormat df = new SimpleDateFormat(pattern);
		try {
			return df.parse(strDate);
		} catch (ParseException e) {
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 计算当月的天数
	 * 
	 * @return
	 */
	public static int getCurrentMonthLastDay(Date date) {
		Calendar a = Calendar.getInstance();
		a.setTime(date);
		a.set(Calendar.DATE, 1);// 把日期设置为当月第一天
		a.roll(Calendar.DATE, -1);// 日期回滚一天，也就是最后一天
		int maxDate = a.get(Calendar.DATE);
		return maxDate;
	}

	/**
	 * 在日期上增加数个整月
	 * 
	 * @param date
	 *            日期
	 * @param n
	 *            要增加的月数
	 * @return
	 */
	public static Date addMonth(Date date, int n) {
		Calendar cal = Calendar.getInstance();
		cal.setTime(date);
		cal.add(Calendar.MONTH, n);
		return cal.getTime();
	}

	/**
	 * 在日期上增加天数
	 * 
	 * @param date
	 *            日期
	 * @param n
	 *            要增加的天数
	 * @return
	 */
	public static Date addDay(Date date, int n) {
		Calendar cal = Calendar.getInstance();
		cal.setTime(date);
		cal.add(Calendar.DATE, n);
		return cal.getTime();
	}

	/**
	 * 获取时间戳
	 */
	public static String getTimeString() {
		SimpleDateFormat df = new SimpleDateFormat(FORMAT_FULL);
		Calendar calendar = Calendar.getInstance();
		return df.format(calendar.getTime());
	}

	/**
	 * 获取日期年份
	 * 
	 * @param date
	 *            日期
	 * @return
	 */
	public static String getYear(Date date) {
		return format(date).substring(0, 4);
	}

	/**
	 * 按默认格式的字符串距离今天的天数
	 * 
	 * @param date
	 *            日期字符串
	 * @return
	 */
	public static int countDays(String date) {
		long t = Calendar.getInstance().getTime().getTime();
		Calendar c = Calendar.getInstance();
		c.setTime(parse(date));
		long t1 = c.getTime().getTime();
		return (int) (t / 1000 - t1 / 1000) / 3600 / 24;
	}

	/**
	 * 按默认格式的字符串距离今天的差几个月
	 * 
	 * @param date
	 * @return
	 */
	public static int countMonth(String date) {
		// 把当前日期换成当月的一号
		Calendar t = Calendar.getInstance();
		t.set(Calendar.DATE, 1);
		t.set(Calendar.HOUR_OF_DAY, 0);
		t.set(Calendar.MINUTE, 0);
		t.set(Calendar.SECOND, 0);
		long t2 = t.getTime().getTime();

		Calendar c = Calendar.getInstance();
		c.setTime(parse(date));
		c.set(Calendar.DATE, 1);
		c.set(Calendar.HOUR_OF_DAY, 0);
		c.set(Calendar.MINUTE, 0);
		c.set(Calendar.SECOND, 0);
		long t1 = c.getTime().getTime();
		return (int) (t2 / 1000 - t1 / 1000) / 3600 / 24 / 30;
	}

	/**
	 * 按用户格式字符串距离今天的天数
	 * 
	 * @param date
	 *            日期字符串
	 * @param format
	 *            日期格式
	 * @return
	 */
	public static int countDays(String date, String format) {
		long t = Calendar.getInstance().getTime().getTime();
		Calendar c = Calendar.getInstance();
		c.setTime(parse(date, format));
		long t1 = c.getTime().getTime();
		return (int) (t / 1000 - t1 / 1000) / 3600 / 24;
	}

	/**
	 * 计算小时差
	 * 
	 * @param date1
	 * @param date2
	 * @return
	 * @throws Exception
	 */
	public static double jisuan(String date1, String date2) throws Exception {
		java.text.SimpleDateFormat sdf = new java.text.SimpleDateFormat(
				"yyyy-MM-dd HH:mm");
		java.util.Date start = sdf.parse(date1);
		java.util.Date end = sdf.parse(date2);
		long cha = end.getTime() - start.getTime();
		double result = cha * 1.0 / (1000 * 60 * 60);

		return result;
	}

	/**
	 * 日期向后，前推n年，n月，n天,n时，n分，n秒
	 * 
	 * @param date
	 *            : 需要处理的日期
	 * @param num
	 *            : 处理的数量,+为向后退，-为向前推
	 * @param type
	 *            ： 类型：年-Y,月-M,日-D,时-H,分-MIN,秒-S
	 * @return
	 */
	public static Date addDate(Date date, int num, String type) {
		try {
			Calendar calendar = new GregorianCalendar();
			calendar.setTime(date);
			if (type.equals("Y")) {
				calendar.add(Calendar.YEAR, num);// 把日期往后增加n年.整数往后推,负数往前移动
			} else if (type.equals("M")) {
				calendar.add(Calendar.MONTH, num);// 把日期往后增加n月.整数往后推,负数往前移动
			} else if (type.equals("D")) {
				calendar.add(Calendar.DATE, num);// 把日期往后增加n天.整数往后推,负数往前移动
			} else if (type.equals("H")) {
				calendar.add(Calendar.HOUR, num);// 把日期往后增加n小时.整数往后推,负数往前移动
			} else if (type.equals("MIN")) {
				calendar.add(Calendar.MINUTE, num);// 把日期往后增加n分.整数往后推,负数往前移动
			} else if (type.equals("S")) {
				calendar.add(Calendar.SECOND, num);// 把日期往后增加n秒.整数往后推,负数往前移动
			}

			date = calendar.getTime(); // 这个时间就是日期往后推一天的结果
		} catch (Exception e) {
			e.printStackTrace();
		}
		return date;
	}

	public static Date toDate(String d) throws ParseException {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		if (d != null) {
			Date date = sdf.parse(d);
			return date;
		}
		return null;
	}

	public static Date toDateTime(String d) throws ParseException {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		if (d != null) {
			Date date = sdf.parse(d);
			return date;
		}
		return null;
	}

	public static Date toDateHour(String d) throws ParseException {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH");
		if (d != null) {
			Date date = sdf.parse(d);
			return date;
		}
		return null;
	}

	public static Date toDateMin(String d) throws ParseException {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm");
		if (d != null) {
			Date date = sdf.parse(d);
			return date;
		}
		return null;
	}

	/**
	 * 获取月份
	 * 
	 * @author 孙东泉 2014-2-10 上午10:28:46
	 */
	public static Date getMonth(String yearMonth) {
		String year = yearMonth.substring(0, 3);
		String month = yearMonth.substring(5, 6);
		Calendar calendar = Calendar.getInstance();
		calendar.set(Integer.parseInt(year), Calendar.YEAR);
		calendar.set(Integer.parseInt(month), Calendar.MONTH);
		return calendar.getTime();
	}

	/**
	 * 获取本周的周一和周日
	 */
	public static Map<String,String> getWeekDay() {
		Map<String, String> map = new HashMap<String, String>();
		Calendar cal = Calendar.getInstance();
		SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
		cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY); // 获取本周一的日期
		map.put("mon", df.format(cal.getTime()));
		// System.out.println("********得到本周一的日期*******" +
		// df.format(cal.getTime()));
		// 这种输出的是上个星期周日的日期，因为老外那边把周日当成第一天
		cal.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY);
		// 增加一个星期，才是我们中国人理解的本周日的日期
		cal.add(Calendar.WEEK_OF_YEAR, 1);
		map.put("sun", df.format(cal.getTime()));
		// System.out.println("********得到本周天的日期*******" +
		// df.format(cal.getTime()));
		return map;
	}

}

版权声明：本文为博主原创文章，未经博主允许不得转载。