Java中很好用的时间工具类

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;

public class DateTimeHelper {
	
	
	/**
	 * Date类型日期时间转为字符串类型日期时间	
	 * @param fromatString，时间格式字符串，如"yyyy-MM-dd HH:mm:ss"
	 * @param date Date类型的日期时间
	 * @return 字符串类型的时间，如"2016-12-13 08:59:32"
	 */
	public static String dateFormat(String fromatString, Date date) {
		SimpleDateFormat df = new SimpleDateFormat(fromatString);// 设置日期格式
		return df.format(date);// new Date()为获取当前系统时间
	}
			
	/**
	 * 字符串日期时间转为Date类型日期时间	
	 * @param fromatString，时间格式字符串，如"yyyy-MM-dd HH:mm:ss"
	 * @param 字符串类型的时间，如"2016-12-13 08:59:32"
	 * @return date Date类型的日期时间
	 */
	public static Date stringDateFormat(String fromatString, String dateString) {
		
		SimpleDateFormat df = new SimpleDateFormat(fromatString);// 设置日期格式
		Date date=new Date();
		try {
			date= df.parse(dateString);
		} catch (ParseException e) {			
			e.printStackTrace();
		}		
		return date;
	}
	
	/**
	 * 将日期时间字符串转为指定格式
	 * @param formatString 指定的日期时间格式	
	 * 若"yyyy-MM-dd",则获取传入日期时间的年月日
	 * 若"MM-dd",则获取传入日期时间的月日
	 * 若"dd",则获取传入日期时间的日
	 * 若"HH:mm:ss"，则获取传入日期时间的时分秒，若传入的日期时间字符串为"2016-12-13"，但格式化字符串为"HH:mm:ss"，则返回"00:00:00"
	 * @param dateString 日期时间字符串，如"2016-12-13 15:28:00" 或"2016-12-13"
	 * @return 字符串类型的日
	 */
	public static String dateFormat(String formatString, String dateString)
			throws ParseException {
		String formatStr = "yyyy-MM-dd HH:mm:ss";
		if (dateString.length() < 12)
			formatStr = "yyyy-MM-dd";
		DateFormat format = new SimpleDateFormat(formatStr);
		Date date = format.parse(dateString);
		SimpleDateFormat df = new SimpleDateFormat(formatString);// 设置日期格式
		return df.format(date);// new Date()为获取当前系统时间
	}

	/**
	 * 由Date类型日期时间得到当天的起始时间	
	 * @param date Date类型的日期时间，如2016-12-13 08:23:55
	 * @return 字符串类型的时间，如"2016-12-13 00:00:00"
	 */
	public static String dateStartFormat(Date date) {
		SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");// 设置日期格式
		String dateStart = df.format(date)+" 00:00:00";
		return dateStart;
	}

	/**
	 * 得到本月的第一天日期	
	 */
	public static String getMonthFirstDay() {
		Calendar calendar = Calendar.getInstance();
		calendar.set(Calendar.DAY_OF_MONTH,	calendar.getActualMinimum(Calendar.DAY_OF_MONTH));
		return dateFormat("yyyy-MM-dd", calendar.getTime());
	}

	/**
	 * 得到本月的最后一天日期	
	 */
	public static String getMonthLastDay() {
		Calendar calendar = Calendar.getInstance();
		calendar.set(Calendar.DAY_OF_MONTH,	calendar.getActualMaximum(Calendar.DAY_OF_MONTH));
		return dateFormat("yyyy-MM-dd", calendar.getTime());
	}

	/**
	 * 根据年、月获取某年某月最后一天	 
	 * @param year int型
	 * @param month int型
	 * @return 该月最后一天的dd "31"
	 */
	public static String getLastDayOfMonth(int year, int month) {
		Calendar cal = Calendar.getInstance();		
		cal.set(Calendar.YEAR, year);          // 设置年份		
		cal.set(Calendar.MONTH, month - 1);    // 设置月份		
		int lastDay = cal.getActualMaximum(Calendar.DAY_OF_MONTH);	// 获取某月最大天数
		return lastDay + "";
	}
	
	/**
	 * 根据某个日期获取该月最后一天	 
	 * @param dateString "2016-12-13"	 
	 * @return 该月最后一天的 dd "31"
	 * @throws ParseException 
	 */
	public static String getLastDayOfMonth(String dateString) throws ParseException {
		String y=dateFormat("yyyy", dateString);
		String m=dateFormat("MM", dateString);
	
		int year=Integer.parseInt(y);
		int month=Integer.parseInt(m);
		
		Calendar cal = Calendar.getInstance();		
		cal.set(Calendar.YEAR, year);         // 设置年份		
		cal.set(Calendar.MONTH, month - 1);   // 设置月份		
		int lastDay = cal.getActualMaximum(Calendar.DAY_OF_MONTH);	// 获取某月最大天数
		return lastDay + "";
	}
	/**
	 * 根据年、月获取某年某月最后一天	 
	 * @param year int型
	 * @param month int型
	 * @return 该月最后一天的日期 "2016-12-31
	 */
	public static String getLastDayOfMonthDate(int year, int month) {
		Calendar cal = Calendar.getInstance();		
		cal.set(Calendar.YEAR, year);          // 设置年份		
		cal.set(Calendar.MONTH, month - 1);    // 设置月份		
		cal.set(Calendar.DAY_OF_MONTH, cal.getActualMaximum(Calendar.DAY_OF_MONTH));	// 获取某月最大天数
		return dateFormat("yyyy-MM-dd", cal.getTime());
	}
	
	/**
	 * 根据某个日期获取该月最后一天	 
	 * @param dateString "2016-12-13"	 
	 * @return 该月最后一天的日期 "2016-12-31
	 * @throws ParseException 
	 */
	public static String getLastDayOfMonthDate(String dateString) throws ParseException {
		String y=dateFormat("yyyy", dateString);
		String m=dateFormat("MM", dateString);
	
		int year=Integer.parseInt(y);
		int month=Integer.parseInt(m);
		
		Calendar cal = Calendar.getInstance();		
		cal.set(Calendar.YEAR, year);         // 设置年份		
		cal.set(Calendar.MONTH, month - 1);   // 设置月份		
		cal.set(Calendar.DAY_OF_MONTH, cal.getActualMaximum(Calendar.DAY_OF_MONTH));	// 获取某月最大天数
		return dateFormat("yyyy-MM-dd", cal.getTime());
	}
	
	/**
	 * 由日期字符串得到该日期为那个月的第几天
	 * @param dateString
	 * @return int 天数
	 */
	public static int getDay(String dateString) throws ParseException {
		DateFormat format = new SimpleDateFormat("yyyy-MM-dd");
		Date date = format.parse(dateString);
		Calendar calendar = new GregorianCalendar();
		calendar.setTime(date);
		int day = calendar.get(Calendar.DAY_OF_MONTH);
		return day;
	}

	
	/**
	 * 由日期字符串得到该月有几天
	 * @return int 天数
	 * @throws ParseException 
	 */
	public static int getDays(String dateString) throws ParseException {
				
		DateFormat format = new SimpleDateFormat("yyyy-MM");
		Date date = format.parse(dateString);		
		Calendar calendar = new GregorianCalendar();
		calendar.setTime(date);
		return calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
	}
	

	/**
	 * 格式化字符串， 将int型转为可以作为日期的字符串型，如将1转为"01"
	 * @param i
	 */
	public static String getFormatString(int i) {
		if (i < 1)
			return "0";
		if (i > 0 && i < 10)
			return "0" + i;
		else
			return i + "";
	}
	
	
	/**
	 * 获得某个日期+dayAdd天后的日期	
	 * @param dayAdd 可正可负
	 * @param dateString
	 * @return
	 * @throws ParseException
	 */
	public static String dayAdd(int dayAdd, String dateString)
			throws ParseException {
		DateFormat format = new SimpleDateFormat("yyyy-MM-dd");
		Date date = format.parse(dateString);
		Calendar calendar = new GregorianCalendar();
		calendar.setTime(date);
		calendar.add(calendar.DATE, dayAdd);
		return dateFormat("yyyy-MM-dd", calendar.getTime());
	}

	/**
	 * 计算两个日期之间相差的天数	
	 * @param sdate 起始时期
	 * @param edate 结束日期
	 * @return
	 * @throws ParseException
	 */
	public static int daysBetween(String sdate, String edate)
			throws ParseException {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		Calendar cal = Calendar.getInstance();
		cal.setTime(sdf.parse(sdate));
		long time1 = cal.getTimeInMillis();
		cal.setTime(sdf.parse(edate));
		long time2 = cal.getTimeInMillis();
		long between_days = (time2 - time1) / (1000 * 3600 * 24);
		
		return Integer.parseInt(String.valueOf(between_days));
	}

	/**
	 * 获取某个日期的月份+monthAdd后的月份
	 * @param monthAdd
	 * @param dateString
	 * @return
	 * @throws ParseException
	 */
	public static String MonthAdd(int monthAdd, String dateString)
			throws ParseException {
		DateFormat format = new SimpleDateFormat("yyyy-MM-dd");
		Date date = format.parse(dateString);
		Calendar calendar = new GregorianCalendar();
		calendar.setTime(date);
		calendar.add(calendar.MONTH, monthAdd);
		return dateFormat("yyyy-MM", calendar.getTime());
	}

	/**
	 * 计算两个日期时间相差的月份	
	 * @param sdate
	 * @param edate
	 * @return
	 * @throws ParseException
	 */
	public static int monthBetween(String sdate, String edate)
			throws ParseException {
		DateFormat format = new SimpleDateFormat("yyyy-MM-dd");
		Date date1 = format.parse(edate);
		Date date2 = format.parse(sdate);
		Calendar cal1 = new GregorianCalendar();
		cal1.setTime(date1);
		Calendar cal2 = new GregorianCalendar();
		cal2.setTime(date2);
		int c = (cal1.get(Calendar.YEAR) - cal2.get(Calendar.YEAR)) * 12
				+ cal1.get(Calendar.MONTH) - cal2.get(Calendar.MONTH);
		return c;
	}

	/**
	 * 获取某个日期时间秒数+secondAdd后的日期时间	
	 * @param secondAdd
	 * @param dateString
	 * @return
	 * @throws ParseException
	 */
	public static String secondAdd(int secondAdd, String dateString)
			throws ParseException {
		DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		Date date = format.parse(dateString);
		Calendar calendar = new GregorianCalendar();
		calendar.setTime(date);
		calendar.add(calendar.SECOND, secondAdd);
		return dateFormat("yyyy-MM-dd HH:mm:ss", calendar.getTime());
	}

	/**
	 * 计算两个时间相差的秒数	
	 * @param sdate
	 * @param edate
	 * @return
	 * @throws ParseException
	 */
	public static int secondBetween(String sdate, String edate)
			throws ParseException {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

		Date start = sdf.parse(sdate);
		Date end = sdf.parse(edate);
		long a = start.getTime();
		long b = end.getTime();
		int c = (int) (b - a) / 1000;
		return c;
	}

	

	/**
	 * 验证日期字符串是否合法
	 * @param str
	 * @return
	 * 如传入"2017-01-32" 则会报错
	 */
	public static boolean isValidDate(String str) {
		boolean convertSuccess = true;
		SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
		try {
			// 设置lenient为false.
			// 否则SimpleDateFormat会比较宽松地验证日期，比如2007/02/29会被接受，并转换成2007/03/01
			format.setLenient(false);
			format.parse(str);
		} catch (ParseException e) {
			// e.printStackTrace();
			// 如果throw java.text.ParseException或者NullPointerException，就说明格式不对
			convertSuccess = false;
		}
		return convertSuccess;
	}
}