`

java常用的日期工具类

    博客分类:
  • Java
阅读更多
package com.fengzhiyin.util;

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

/**
 * @classname: 日期处理类
 * @author: Fengzhiyin
 * @time: 2009-07-23
 */
@SuppressWarnings("static-access")
public final class DateUtil {

	/**
	 * 得到当前日期的月首 格式为:2009-08-01
	 */
	public static String monthFist() {
		Calendar localTime = Calendar.getInstance();
		String strY = null;// 日期属性:日
		int x = localTime.get(Calendar.YEAR); // 日期属性:年
		int y = localTime.get(Calendar.MONTH) + 1; // 日期属性:月
		strY = y >= 10 ? String.valueOf(y) : ("0" + y); // 组合月份
		return x + "-" + strY + "-01"; // 最后组合成yyyy-mm-dd形式字符串
	}

	/**
	 * 得到上个月月首 格式为:2009-08-01
	 */
	public static String beforeMonth() {
		Calendar localTime = Calendar.getInstance();
		localTime.add(Calendar.MONTH, -1); // 通过提取这个月计算上个月号
		String strz = null;
		int x = localTime.get(Calendar.YEAR); // 得到年
		int y = localTime.get(Calendar.MONTH) + 1; // 得到月
		strz = y >= 10 ? String.valueOf(y) : ("0" + y);
		return x + "-" + strz + "-01";
	}

	/**
	 * 得到当前日期 格式为:2009-08-01
	 */
	public static String curDate() {
		// 分别根据日历时间提取当前年月日组合成字符串
		Calendar localTime = Calendar.getInstance();
		int x = localTime.get(Calendar.YEAR);
		int y = localTime.get(Calendar.MONTH) + 1;
		int z = localTime.get(Calendar.DAY_OF_MONTH);
		return x + "-" + y + "-" + z;
	}

	/**
	 * 给定的日期加一个月 格式为:2009-08-01
	 */
	public static String addMonth(String strdate) {
		Date date = new Date(); // 构造一个日期型中间变量
		String dateresult = null; // 返回的日期字符串
		// 创建格式化格式
		SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
		// 加减日期所用
		GregorianCalendar gc = new GregorianCalendar();
		try {
			date = df.parse(strdate); // 将字符串格式化为日期型
		} catch (ParseException e) {
			e.printStackTrace();
		}
		gc.setTime(date); // 得到gc格式的时间
		gc.add(2, 1); // 2表示月的加减,年代表1依次类推(周,天。。)
		// 把运算完的时间从新赋进对象
		gc.set(gc.get(gc.YEAR), gc.get(gc.MONTH), gc.get(gc.DATE));
		// 在格式化回字符串时间
		dateresult = df.format(gc.getTime());
		return dateresult;
	}

	/**
	 * 判端date1是否在date2之前;当date1的时间早于date2是返回true date1,date2的格式为:2009-08-01
	 */
	public static boolean isDate10Before(String date1, String date2) {
		try {
			DateFormat df = DateFormat.getDateInstance();
			return df.parse(date1).before(df.parse(date2));
		} catch (ParseException e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 给定的日期减一个月 格式为:2009-08-01
	 */
	public static String subMonth(String strdate) {

		Date date = new Date(); // 构造一个日期型中间变量

		String dateresult = null; // 返回的日期字符串
		// 创建格式化格式
		SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
		// 加减日期所用
		GregorianCalendar gc = new GregorianCalendar();
		try {
			date = df.parse(strdate); // 将字符串格式化为日期型
		} catch (ParseException e) {
			e.printStackTrace();
		}
		gc.setTime(date); // 得到gc格式的时间
		gc.add(2, -1); // 2表示月的加减,年代表1依次类推(周,天。。)
		// 把运算完的时间从新赋进对象
		gc.set(gc.get(gc.YEAR), gc.get(gc.MONTH), gc.get(gc.DATE));
		// 在格式化回字符串时间
		dateresult = df.format(gc.getTime());
		return dateresult;
	}

	/**
	 * 给定的日期减一天 格式为:2009-08-01
	 */
	public static String subDay(String strdate) {
		Date date = new Date(); // 构造一个日期型中间变量
		String dateresult = null; // 返回的日期字符串
		// 创建格式化格式
		SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
		// 加减日期所用
		GregorianCalendar gc = new GregorianCalendar();
		try {
			date = df.parse(strdate); // 将字符串格式化为日期型
		} catch (ParseException e) {
			e.printStackTrace();
		}
		gc.setTime(date); // 得到gc格式的时间
		gc.add(5, -1); // 2表示月的加减,年代表1依次类推(3周....5天。。)
		// 把运算完的时间从新赋进对象
		gc.set(gc.get(gc.YEAR), gc.get(gc.MONTH), gc.get(gc.DATE));
		// 在格式化回字符串时间
		dateresult = df.format(gc.getTime());
		return dateresult;
	}

	/**
	 * 给定的日期加一天 格式为:2009-08-01
	 */
	public static String addDay(String strdate) {
		Date date = new Date(); // 构造一个日期型中间变量
		String dateresult = null; // 返回的日期字符串
		// 创建格式化格式
		SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
		// 加减日期所用
		GregorianCalendar gc = new GregorianCalendar();
		try {
			date = df.parse(strdate); // 将字符串格式化为日期型
		} catch (ParseException e) {
			e.printStackTrace();
		}
		gc.setTime(date); // 得到gc格式的时间
		gc.add(5, 1); // 2表示月的加减,年代表1依次类推(3周....5天。。)
		// 把运算完的时间从新赋进对象
		gc.set(gc.get(gc.YEAR), gc.get(gc.MONTH), gc.get(gc.DATE));
		// 在格式化回字符串时间
		dateresult = df.format(gc.getTime());
		return dateresult;
	}

	/**
	 * 拆分给定字符串构造本月月初 格式为:2009-08-01
	 */
	public static String giveMonthFist(String strdate) {
		// 以“-”为分隔符拆分字符串
		String strArray[] = strdate.split("-");

		String tempyear = strArray[0]; // 得到字符串中的年

		String tempmonth = strArray[1]; // 得到字符串中的月
		// 拼接成月首字符串
		return tempyear + "-" + tempmonth + "-01";
	}

	/**
	 * 拆分给定字符串构造本月月末 格式为:2009-08-01
	 */
	public static String giveMonthLast(String strdate) {
		// 先得到下个月的同一天
		String addmonth = DateUtil.addMonth(strdate);
		// 得到下个月的月初
		String monthfirst = DateUtil.giveMonthFist(addmonth);
		// 下个月月初减一天为本月月末
		String subday = DateUtil.subDay(monthfirst);
		return subday;
	}

	/**
	 * 拆分给定字符串构造上个月月初 格式为:2009-08-01
	 */
	public static String giveBeforeMonthFirst(String strdate) {
		// 调用得到上个月的函数
		String beforemonth = DateUtil.subMonth(strdate);
		// 调用构造月初的函数
		return DateUtil.giveMonthFist(beforemonth);
	}

	/**
	 * 拆分给定字符串构造上个月月末 格式为:2009-08-01
	 */
	public static String giveBeforeMonthLast(String strdate) {
		// 先调用函数得到本月月初
		String monthfirst = DateUtil.giveMonthFist(strdate);
		// 调用当前日期减一天方法得到上个月月末
		return DateUtil.subDay(monthfirst);
	}

	/**
	 * 给定的日期得到年月 格式为:2009-08-01
	 */
	public static String giveyrmo(String yrmoday) {
		// 以“-”为分隔符拆分字符串
		String strArray[] = yrmoday.split("-");
		String tempyear = strArray[0]; // 得到字符串中的年
		String tempmonth = strArray[1]; // 得到字符串中的月
		// 拼接成月首字符串
		return tempyear + "-" + tempmonth; // 最后组合成yyyy-mm形式字符串
	}

	/**
	 * 两个日期做减法,返回相差天数
	 * @throws ParseException
	 * @throws ParseException
	 */
	public static long datesub(Date date1, Date date2) throws ParseException {
		@SuppressWarnings("unused")
		long l = date1.getTime() - date2.getTime() > 0 ? date1.getTime() - date2.getTime() : date2.getTime() - date1.getTime();
		// 日期相减得到相差的日期
		long day = (date1.getTime() - date2.getTime()) / (24 * 60 * 60 * 1000) > 0 ? (date1.getTime() - date2.getTime()) / (24 * 60 * 60 * 1000) : (date2
				.getTime() - date1.getTime())
				/ (24 * 60 * 60 * 1000);
		return day + 1;
	}

	/**
	 * 根据给定的年月构造日期月首字符串
	 */
	public static String giveMonthFist(Integer yr, Integer mo) {
		// 拼接成月首字符串
		if (mo >= 10) {
			return yr + "-" + mo + "-01";
		} else {
			return yr + "-" + "0" + mo + "-01";
		}
	}

	/**
	 * 根据给定的年月构造年月字符串
	 */
	public static String giveYrMo(Integer yr, Integer mo) {
		// 拼接成月首字符串
		if (mo >= 10) {
			return yr + "-" + mo;
		} else {
			return yr + "-" + "0" + mo;
		}
	}

	/**
	 * 给定年月字串返回一个整型月份 格式为:2009-08-01
	 */
	public static Integer retrunmo(String yrmoday) {
		// 以“-”为分隔符拆分字符串
		String strArray[] = yrmoday.split("-");
		String tempmonth = strArray[1]; // 得到字符串中的月
		return new Integer(tempmonth);
	}

	/**
	 * 给定年月字串返回一个整型年份 格式为:2009-08-01
	 */
	public static Integer retrunyr(String yrmoday) {
		// 以“-”为分隔符拆分字符串
		String strArray[] = yrmoday.split("-");
		String tempmonth = strArray[0]; // 得到字符串中的月
		return new Integer(tempmonth);
	}

	/**
	 * 给定的两个日期作比较,返回bool的类型 格式为:2009-08-01
	 * 
	 * @throws ParseException
	 */
	public static boolean boolcompara(String startdate, String enddate) throws ParseException {
		if (DateFormat.getDateInstance().parse(startdate).compareTo(DateFormat.getDateInstance().parse(startdate)) >= 0) {
			return true;
		} else {
			return false;
		}
	}

	/**
	 * 
	 * @todo:判断时间date1是否在时间date2之前 时间格式 2008-08-08 16:16:34
	 * @param date1
	 * @param date2
	 * @return
	 */
	public static boolean isDateBefore(String date1, String date2) {
		try {
			DateFormat df = DateFormat.getDateTimeInstance();
			return df.parse(date1).before(df.parse(date2));
		} catch (ParseException e) {
			System.out.print("[SYS] " + e.getMessage());
			return false;
		}
	}

	// 判断当前时间是否在时间date2之前
	// 时间格式 2005-4-21 16:16:34
	public static boolean isDateBefore(String date2) {
		try {
			Date date1 = new Date();
			DateFormat df = DateFormat.getDateTimeInstance();
			return date1.before(df.parse(date2));
		} catch (ParseException e) {
			System.out.print("[SYS] " + e.getMessage());
			return false;
		}
	}

	/**
	 * 
	 * 当前时间增加间隔小时后的时间 时间格式 2008-08-08 16:16:34
	 */
	public static String addHours(String startDate, int intHour) {
		try {
			DateFormat df = DateFormat.getDateTimeInstance();
			Date date = df.parse(startDate);
			Calendar cal = Calendar.getInstance();
			cal.setTime(date);
			long longMills = cal.getTimeInMillis() + intHour * 60 * 60 * 1000;
			cal.setTimeInMillis(longMills);

			// 返回日期
			return df.format(cal.getTime());
		} catch (Exception Exp) {
			return null;
		}
	}

	/**
	 * 
	 * 当前时间减去间隔小时后的时间 时间格式 2008-08-08 16:16:34
	 */
	public static String delHours(String startDate, int intHour) {
		try {
			DateFormat df = DateFormat.getDateTimeInstance();
			Date date = df.parse(startDate);
			Calendar cal = Calendar.getInstance();
			cal.setTime(date);
			long longMills = cal.getTimeInMillis() - intHour * 60 * 60 * 1000;
			cal.setTimeInMillis(longMills);

			// 返回日期
			return df.format(cal.getTime());
		} catch (Exception Exp) {
			return null;
		}
	}

	/**
	 * 得到当前日期 日期格式 2008-08-08
	 */
	public static String getCurrentDate() {
		try {
			long longCalendar = 0;
			// 获得当前日期
			Calendar cldCurrent = Calendar.getInstance();
			// 获得年月日
			String strYear = String.valueOf(cldCurrent.get(Calendar.YEAR));
			String strMonth = String.valueOf(cldCurrent.get(Calendar.MONTH) + 1);
			String strDate = String.valueOf(cldCurrent.get(Calendar.DATE));
			// 整理格式
			if (strMonth.length() < 2) {
				strMonth = "0" + strMonth;
			}
			if (strDate.length() < 2) {
				strDate = "0" + strDate;
			}
			// 组合结果
			longCalendar = Long.parseLong(strYear + strMonth + strDate);
			// 系统默认月份加一
			longCalendar += 100L;
			// 创建上初始化上下文环境并返回
			return String.valueOf(strYear + "-" + strMonth + "-" + strDate);
		} catch (Exception Exp) {
			return "2008-08-08";
		}
	}

	/**
	 * @TODO:将给定的日期加一个月 参数类型“2009-03”
	 */
	public static String getThisMonthLast(String strdate) {
		String thisStrDate = strdate + "-01";
		// 先得到下个月的同一天
		String addmonth = DateUtil.addMonth(thisStrDate);
		// 得到下个月的月初
		String monthfirst = DateUtil.giveMonthFist(addmonth);
		// 下个月月初减一天为本月月末
		String subday = DateUtil.subDay(monthfirst);
		return subday;
	}

	/**
	 * 	获得系统中使用长整形表示的日期 
	 * 返回参数:long:表示的日期的8位长整形值 如:20090723
	 */
	public static long getLongCalendar() {
		try {
			long longCalendar = 0;

			// 获得当前日期
			Calendar cldCurrent = Calendar.getInstance();

			// 获得年月日
			String strYear = String.valueOf(cldCurrent.get(Calendar.YEAR));
			String strMonth = String.valueOf(cldCurrent.get(Calendar.MONTH));
			String strDate = String.valueOf(cldCurrent.get(Calendar.DATE));

			// 整理格式
			if (strMonth.length() < 2) {
				strMonth = "0" + strMonth;
			}
			if (strDate.length() < 2) {
				strDate = "0" + strDate;
			}
			// 组合结果
			longCalendar = Long.parseLong(strYear + strMonth + strDate);
			// 系统默认月份加一
			longCalendar += 100L;
			// 创建上初始化上下文环境并返回
			return longCalendar;
		} catch (Exception Exp) {
			return 0;
		}
	}

	/**
	 * 返回字符串行日期
	 * @param canlendar 20090801或20090802080808
	 * @return 2009/08/01或2009/08/01 08:08:08
	 */
	public static String toString(long canlendar) {
		try {
			StringBuffer sbCalendar = new StringBuffer();
			sbCalendar.insert(0, canlendar);
			// 整理格式
			if (sbCalendar.length() == 8) {
				sbCalendar.insert(6, "/");
				sbCalendar.insert(4, "/");
			} else if (sbCalendar.length() == 14) {
				sbCalendar.insert(12, ":");
				sbCalendar.insert(10, ":");
				sbCalendar.insert(8, " ");
				sbCalendar.insert(6, "/");
				sbCalendar.insert(4, "/");
			} else {
				// 错误处理
				return null;
			}
			// 返回格式化好的整形日期的字符串格式
			return sbCalendar.toString();
		} catch (Exception Exp) {
			// 错误处理
			return null;
		}
	}

	/**
	 * 	长整形时间类组合Calender,封装Calender的数字接口和方法
	 *  返回 20090802080808 包含日期和时间
	 * 
	 */
	public static long getLongTime() {
		try {
			long longCalendar = 0;
			// 获得当前日期
			Calendar cldCurrent = Calendar.getInstance();
			// 获得年月日
			String strYear = String.valueOf(cldCurrent.get(Calendar.YEAR));
			String strMonth = String.valueOf(cldCurrent.get(Calendar.MONTH) + 1);
			String strDate = String.valueOf(cldCurrent.get(Calendar.DATE));
			String strHour = String.valueOf(cldCurrent.get(Calendar.HOUR));
			String strAM_PM = String.valueOf(cldCurrent.get(Calendar.AM_PM));
			String strMinute = String.valueOf(cldCurrent.get(Calendar.MINUTE));
			String strSecond = String.valueOf(cldCurrent.get(Calendar.SECOND));

			// 把时间转换为24小时制
			// strAM_PM=="1",表示当前时间是下午,所以strHour需要加12
			if (strAM_PM.equals("1")) {
				strHour = String.valueOf(Long.parseLong(strHour) + 12);
			}
			// 整理格式
			if (strMonth.length() < 2) {
				strMonth = "0" + strMonth;
			}
			if (strDate.length() < 2) {
				strDate = "0" + strDate;
			}
			if (strHour.length() < 2) {
				strHour = "0" + strHour;
			}
			if (strMinute.length() < 2) {
				strMinute = "0" + strMinute;
			}
			if (strSecond.length() < 2) {
				strSecond = "0" + strSecond;
			}
			// 组合结果
			longCalendar = Long.parseLong(strYear + strMonth + strDate + strHour + strMinute + strSecond);

			// 创建上初始化上下文环境并返回
			return longCalendar;
		} catch (Exception Exp) {
			return 0;
		}
	}

	/**
	 *	由长整型时间变为字符 
	 *	通过长整数变为时间格式,可以自动适应8位或16位
	 *	输入:"20090808"或"20090808080808"
	 *	返回:"2009年08月08日"或"2009年08月08日 08:08:08"
	 */
	public static String getDateStringByLongDatetime(long longCalendar) {
		try {
			String StrCalendar = String.valueOf(longCalendar);
			String StrCalendarResult = "";
			// 判断为日期型
			if (StrCalendar.length() == 8) {
				StrCalendarResult = StrCalendar.substring(0, 4) + "年" + StrCalendar.substring(4, 6) + "月" + StrCalendar.substring(6, 8) + "日";
				return StrCalendarResult;
			}
			// 判断为日期及时间型
			if (StrCalendar.length() == 14) {
				StrCalendarResult = StrCalendar.substring(0, 4) + "年" + StrCalendar.substring(4, 6) + "月" + StrCalendar.substring(6, 8) + "日";
				StrCalendarResult = StrCalendarResult + " " + StrCalendar.substring(8, 10) + ":" + StrCalendar.substring(10, 12) + ":"
						+ StrCalendar.substring(12, 14);
				return StrCalendarResult;
			}
			// 否则返回空字符
			return "";
		} catch (Exception e) {
			// 错误处理
			e.printStackTrace();
			return "";
		}
	}

	/**
	 *	由长整型时间变为字符 
	 *	通过长整数变为时间格式,可以自动适应8位或16位
	 *	输入:"20090808"或"20090808080808"
	 *	返回:"2009/08/08"或"2009/08/08 08:08:08"
	 */
	public static String getDateStringByLongDatetimeForPage(long longCalendar) {
		try {
			String StrCalendar = String.valueOf(longCalendar);
			String StrCalendarResult = "";
			// 判断为日期型
			if (StrCalendar.length() == 8) {
				StrCalendarResult = StrCalendar.substring(0, 4) + "/" + StrCalendar.substring(4, 6) + "/" + StrCalendar.substring(6, 8);
				return StrCalendarResult;
			}
			// 判断为日期及时间型
			if (StrCalendar.length() == 14) {
				StrCalendarResult = StrCalendar.substring(0, 4) + "/" + StrCalendar.substring(4, 6) + "/" + StrCalendar.substring(6, 8);
				StrCalendarResult = StrCalendarResult + " " + StrCalendar.substring(8, 10) + ":" + StrCalendar.substring(10, 12);
				return StrCalendarResult;
			}
			// 否则返回空字符
			return "";
		} catch (Exception e) {
			// 错误处理
			e.printStackTrace();
			return "";
		}
	}

	/**
	 * 得到系统当前时间 
	 * 返回参数:String:系统当前时间 格式:yyyy/mm/dd
	 */
	public static String getCurrentDateTime() {
		return getDateStringByLongDatetimeForPage(getLongCalendar());
	}

	/**
	 *	得到系统当前日期显示,
	 *	返回格式:yyyy/mm/dd
	 */
	public static String getCurrentDateView() {
		// 获得当前日期
		Calendar cldCurrent = Calendar.getInstance();
		// 获得年月日
		String strYear = String.valueOf(cldCurrent.get(Calendar.YEAR));
		String strMonth = String.valueOf(cldCurrent.get(Calendar.MONTH) + 1);
		String strDate = String.valueOf(cldCurrent.get(Calendar.DATE));
		// 整理格式
		if (strMonth.length() < 2) {
			strMonth = "0" + strMonth;
		}
		if (strDate.length() < 2) {
			strDate = "0" + strDate;
		}
		// 得出当天日期的字符串
		String StrCurrentCalendar = strYear + "/" + strMonth + "/" + strDate;
		return StrCurrentCalendar;
	}

	/**
	 * 得到给定时间显示,格式:yyyy/mm/dd 
	 * 参数格式:"20090808"或"20090808080808"
	 */
	public static String getCurrentDateView(long longCalendar) {
		if (longCalendar == 0) {
			return "";
		}
		String strDateView = String.valueOf(longCalendar);
		// 获得年月日
		String strYear = strDateView.substring(0, 4);
		String strMonth = strDateView.substring(4, 6);
		String strDate = strDateView.substring(6, 8);
		// 整理格式
		if (strMonth.length() < 2) {
			strMonth = "0" + strMonth;
		}
		if (strDate.length() < 2) {
			strDate = "0" + strDate;
		}
		// 得出当天日期的字符串
		String StrCurrentCalendar = strYear + "/" + strMonth + "/" + strDate;
		return StrCurrentCalendar;
	}

	/**
	 * 由长整型时间变为字符 
	 * 通过长整数变为时间格式,输入参数为6位的时间 如"123143"
	 * 返回格式:12点31分43秒
	 */
	public static String getTimeStringByLongTime(long longCalendar) {
		try {
			String StrCalendar = String.valueOf(longCalendar);
			String StrCalendarResult = "";
			// 判断为时间型
			if (StrCalendar.length() == 6) {
				StrCalendarResult = StrCalendar.substring(0, 2) + "点" + StrCalendar.substring(2, 4) + "分" + StrCalendar.substring(4, 6) + "秒";
				return StrCalendarResult;
			}
			// 否则返回空字符
			return "";
		} catch (Exception e) {
			// 错误处理
			e.printStackTrace();
			return "";
		}
	}

	/**
	 * 由长整型时间变为字符 
	 * 通过长整数变为时间格式,输入参数为6位的时间 如"123143"
	 * 返回格式:12:31:43
	 */
	public static String getTimeStringByLongTimeForPage(long longCalendar) {
		try {
			String StrCalendar = String.valueOf(longCalendar);
			String StrCalendarResult = "";

			// 判断为时间型
			if (StrCalendar.length() == 6) {
				StrCalendarResult = StrCalendar.substring(0, 2) + ":" + StrCalendar.substring(2, 4) + ":" + StrCalendar.substring(4, 6);
				return StrCalendarResult;
			}
			// 否则返回空字符
			return "";
		} catch (Exception e) {
			// 错误处理
			e.printStackTrace();
			return "";
		}
	}

	/**
	 * 给指定的Calendar,返回常用的8位时间
	 */
	public static long getLongCalendar(Calendar yourCalendar) {
		try {
			long longCalendar = 0;
			// 获得年月日
			String strYear = String.valueOf(yourCalendar.get(Calendar.YEAR));
			String strMonth = String.valueOf(yourCalendar.get(Calendar.MONTH));
			String strDate = String.valueOf(yourCalendar.get(Calendar.DATE));
			// 整理格式
			if (strMonth.length() < 2) {
				strMonth = "0" + strMonth;
			}
			if (strDate.length() < 2) {
				strDate = "0" + strDate;
			}
			// 组合结果
			longCalendar = Long.parseLong(strYear + strMonth + strDate);
			// 系统默认月份加一
			longCalendar += 100L;
			// 创建上初始化上下文环境并返回
			return longCalendar;
		} catch (Exception Exp) {
			return 0;
		}
	}

	/**
	 * 给指定的Calendar,返回常用的14位时间
	 */
	public static long getLongTime(Calendar yourCalendar) {
		try {
			long longCalendar = 0;
			// 获得年月日
			String strYear = String.valueOf(yourCalendar.get(Calendar.YEAR));
			String strMonth = String.valueOf(yourCalendar.get(Calendar.MONTH) + 1);
			String strDate = String.valueOf(yourCalendar.get(Calendar.DATE));
			String strHour = String.valueOf(yourCalendar.get(Calendar.HOUR));
			String strAM_PM = String.valueOf(yourCalendar.get(Calendar.AM_PM));
			String strMinute = String.valueOf(yourCalendar.get(Calendar.MINUTE));
			String strSecond = String.valueOf(yourCalendar.get(Calendar.SECOND));

			// 把时间转换为24小时制
			// strAM_PM=="1",表示当前时间是下午,所以strHour需要加12
			if (strAM_PM.equals("1")) {
				strHour = String.valueOf(Long.parseLong(strHour) + 12);
			}
			// 整理格式
			if (strMonth.length() < 2) {
				strMonth = "0" + strMonth;
			}
			if (strDate.length() < 2) {
				strDate = "0" + strDate;
			}
			if (strHour.length() < 2) {
				strHour = "0" + strHour;
			}
			if (strMinute.length() < 2) {
				strMinute = "0" + strMinute;
			}
			if (strSecond.length() < 2) {
				strSecond = "0" + strSecond;
			}
			// 组合结果
			longCalendar = Long.parseLong(strYear + strMonth + strDate + strHour + strMinute + strSecond);
			// 创建上初始化上下文环境并返回
			return longCalendar;
		} catch (Exception Exp) {
			return 0;
		}
	}

	/**
	 * 将长整型日期转换为日历,自适应8位或14位 
	 */
	public static Calendar getCalendar(long longCalendar) {
		long longNF = 0;
		long longYF = 0;
		long longRZ = 0;
		long longXS = 0;
		long longFZ = 0;
		long longM = 0;
		GregorianCalendar gc = null;
		// 判断是8位还是14位
		if (String.valueOf(longCalendar).length() < 14) {
			longNF = Long.parseLong(String.valueOf(longCalendar).substring(0, 4));
			longYF = Long.parseLong(String.valueOf(longCalendar).substring(4, 6)) - 1;
			longRZ = Long.parseLong(String.valueOf(longCalendar).substring(6));
			gc = new GregorianCalendar((int) longNF, (int) longYF, (int) longRZ);
		} else {
			longNF = Long.parseLong(String.valueOf(longCalendar).substring(0, 4));
			longYF = Long.parseLong(String.valueOf(longCalendar).substring(4, 6)) - 1;
			longRZ = Long.parseLong(String.valueOf(longCalendar).substring(6, 8));
			longXS = Long.parseLong(String.valueOf(longCalendar).substring(8, 10));
			longFZ = Long.parseLong(String.valueOf(longCalendar).substring(10, 12));
			longM = Long.parseLong(String.valueOf(longCalendar).substring(12));

			gc = new GregorianCalendar((int) longNF, (int) longYF, (int) longRZ, (int) longXS, (int) longFZ, (int) longM);
		}
		return gc;
	}

	/**
	 * 当前时间增加间隔分钟后的时间
	 */
	public static long addMinutes(long longCalendar, int intMin) {
		try {
			//
			long longDate = 0;
			Calendar cal = getCalendar(longCalendar);
			long longMills = cal.getTimeInMillis() + intMin * 60 * 1000;
			cal.setTimeInMillis(longMills);
			if (String.valueOf(longCalendar).length() < 14){
				longDate = getLongCalendar(cal);
			}else{
				longDate = getLongTime(cal);
			}
			// 返回日期
			return longDate;
		} catch (Exception Exp) {
			return -1;
		}
	}

	/**
	 * 当前时间增加间隔小时后的时间
	 */
	public static long addHours(long longCalendar, int intHour) {
		try {
			//
			long longDate = 0;
			Calendar cal = getCalendar(longCalendar);
			long longMills = cal.getTimeInMillis() + intHour * 60 * 60 * 1000;
			cal.setTimeInMillis(longMills);

			if (String.valueOf(longCalendar).length() < 14){
				longDate = getLongCalendar(cal);
			}else{
				longDate = getLongTime(cal);
			}
			// 返回日期
			return longDate;
		} catch (Exception Exp) {
			return -1;
		}
	}

	/**
	 * 当前时间增加间隔天后的时间
	 */
	public static long addDays(long longCalendar, int intDay) {
		try {
			//
			long longDate = 0;
			Calendar cal = getCalendar(longCalendar);
			long longMills = cal.getTimeInMillis() + intDay * 24 * 60 * 60 * 1000;
			cal.setTimeInMillis(longMills);
			if (String.valueOf(longCalendar).length() < 14)
				longDate = getLongCalendar(cal);
			else
				longDate = getLongTime(cal);

			// 返回日期
			return longDate;
		} catch (Exception Exp) {
			return -1;
		}
	}

	/**
	 *当前时间增加间隔星期后的时间
	 */
	public static long addWeeks(long longCalendar, int intWeek) {
		try {
			long longDate = 0;
			Calendar cal = getCalendar(longCalendar);
			long longMills = cal.getTimeInMillis() + intWeek * 7 * 24 * 60 * 60 * 1000;
			cal.setTimeInMillis(longMills);
			if (String.valueOf(longCalendar).length() < 14)
				longDate = getLongCalendar(cal);
			else
				longDate = getLongTime(cal);
			// 返回日期
			return longDate;
		} catch (Exception Exp) {
			return -1;
		}
	}

	/**
	 * 当前日期增加间隔月份后的时间 
	 */
	public static long addMonths(long longCalendar, int intMonth) {
		try {
			long longNF = 0;
			long longYF = 0;
			long longRZ = 0;
			long longDate = 0;
			long longNIAN = 0;
			String strYF = "";
			String strRZ = "";
			longNF = Long.parseLong(String.valueOf(longCalendar).substring(0, 4));
			longYF = Long.parseLong(String.valueOf(longCalendar).substring(4, 6));
			longRZ = Long.parseLong(String.valueOf(longCalendar).substring(6, 8));
			longYF = longYF + intMonth;

			if (longYF > 12) {
				longNIAN = (long) Math.floor(longYF / 12);
				longYF = longYF % 12;
				if (longYF == 0) {
					longYF = 12;
				}
				longNF = longNF + longNIAN;
			}
			// 处理特殊日
			if (longRZ >= 28)
				longRZ = getNormalDay(longNF, longYF, longRZ);
			if (longYF < 10)
				strYF = "0" + String.valueOf(longYF);
			else
				strYF = String.valueOf(longYF);
			if (longRZ < 10)
				strRZ = "0" + String.valueOf(longRZ);
			else
				strRZ = String.valueOf(longRZ);

			// 判断是8位还是14位
			if (String.valueOf(longCalendar).length() < 14) {
				longDate = Long.parseLong(String.valueOf(longNF) + strYF + strRZ);
			} else {
				longDate = Long.parseLong(String.valueOf(longNF) + strYF + strRZ + String.valueOf(longCalendar).substring(8, 14));
			}
			// 返回日期
			return longDate;
		} catch (Exception Exp) {
			return -1;
		}
	}

	/**
	 * 返回正常日-处理30/31/28 输入参数:long calendar 当前时间, int
	 * intWeek 间隔星期 返回值: long:处理后的时间
	 */
	public static long getNormalDay(long longNF, long longYF, long longRZ) {
		try {
			// 只有日为28/29/30/31才运行此函数
			// 处理2月份
			if (longYF == 2) {
				if ((longNF % 4) == 0) {
					if (longRZ > 28)
						longRZ = 29;
				} else
					longRZ = 28;
			}
			if (longRZ == 31) {
				if (longYF == 4 || longYF == 6 || longYF == 9 || longYF == 11)
					longRZ = 30;
			}
			return longRZ;

		} catch (Exception Exp) {
			return -1;
		}
	}

	/**
	 * 获得系统中使用长整形表示的日期加星期 
	 */
	public static String getStringCalendarAndWeek() {
		try {
			String strCalendar = "";

			// 获得当前日期
			Calendar cldCurrent = Calendar.getInstance();

			// 获得年月日
			String strYear = String.valueOf(cldCurrent.get(Calendar.YEAR));
			String strMonth = String.valueOf(cldCurrent.get(Calendar.MONTH) + 1);
			String strDate = String.valueOf(cldCurrent.get(Calendar.DATE));
			// 整理格式
			if (strMonth.length() < 2) {
				strMonth = "0" + strMonth;
			}
			if (strDate.length() < 2) {
				strDate = "0" + strDate;
			}
			// 组合结果
			strCalendar = strYear + "年" + strMonth + "月" + strDate + "日";
			int intWeek = cldCurrent.get(Calendar.DAY_OF_WEEK);
			String strWeek = "";
			switch (intWeek) {
			case 1:
				strWeek = "星期日";
				break;
			case 2:
				strWeek = "星期一";
				break;
			case 3:
				strWeek = "星期二";
				break;
			case 4:
				strWeek = "星期三";
				break;
			case 5:
				strWeek = "星期四";
				break;
			case 6:
				strWeek = "星期五";
				break;
			case 7:
				strWeek = "星期六";
				break;
			}
			strCalendar = strCalendar + " " + strWeek + " ";
			// 创建上初始化上下文环境并返回
			return strCalendar;
		} catch (Exception Exp) {
			return "";
		}
	}

	public static String Text2HtmlToPageContent(String text) {
		// 若原字符串为空,则返回空对象
		if (text == null) {
			return "";
		}
		// 保存原字符串,方法结束时此字符串被转换成HTML格式的字符串
		String strSource = text;
		// 转换字符串的临时空间
		StringBuffer sbTarget = new StringBuffer();
		// 纯文本中要转换的字符或字符串
		char[] charArraySource = { '<', '>', '&', '"', '\n' };
		// 纯文本中要转换的字符或字符串对应的HTML表达方式
		String[] strArrayTarget = { "&lt;", "&gt;", "&amp;", "&quot;", "<br>" };

		// 记录处理过特殊字符的位置
		int intStart = 0;

		// 依次检查每一个源字符串的字符或字符串
		for (int i = 0; i < strSource.length(); i++) {
			// 字符串中包含要转换的字符或字符串,则进行相应转换
			for (int j = 0; j < charArraySource.length; j++) {
				// 当前检查的字符是要转换的特殊字符,则进行处理
				if (strSource.charAt(i) == charArraySource[j]) {
					sbTarget.append(strSource.substring(intStart, i));
					sbTarget.append(strArrayTarget[j]);
					intStart = i + 1;
					continue;
				}
			}
		}
		// 将所有处理位置之后的字符串放入目标字符串中
		sbTarget.append(strSource.substring(intStart));

		// 转换完成,返回转换结果
		return sbTarget.toString();
	}

	public static String getDateStringByLongDate(long longCalendar) {
		try {
			String StrCalendar = String.valueOf(longCalendar);
			String StrCalendarResult = "";
			StrCalendarResult = StrCalendar.substring(0, 4) + "年" + StrCalendar.substring(4, 6) + "月" + StrCalendar.substring(6, 8) + "日";
			return StrCalendarResult;
		} catch (Exception e) {
			// 错误处理
			e.printStackTrace();
			return "";
		}
	}

	public static String getJi(String strYue) {
		int intYue = Integer.decode(strYue).intValue();
		if (intYue >= 1 && intYue <= 3) {
			return "1";
		} else if (intYue >= 4 && intYue <= 6) {
			return "2";
		} else if (intYue >= 7 && intYue <= 9) {
			return "3";
		} else {
			return "4";
		}
	}
}

 

分享到:
评论

相关推荐

    java常用日期工具类方法

    java常用日期工具类方法. 包含格式化日期,字符串转日期格式,日期格式转字符串,获取当天是本月第几天、是当年多少天等

    java常用日期工具类

    该工具类包含了日常开发中常用的日期转换,类型转换的方法 解决String转Date类型,Date转String类型所引发的问题

    一些java常用的工具类

    JUnit是Java中广泛使用的单元测试框架,它提供了断言、测试套件等功能,帮助开发者编写可测试的代码。 总之,Java工具类是提高开发效率的关键,它们封装了常见的操作,减少了代码重复,提高了代码可读性和维护性。...

    java常用的工具类整理28个

    下面我们将详细探讨Java中28个常用的工具类,主要涉及`IO`相关的开发工具。 1. **java.lang.Math**:这个类提供了许多基础数学函数,如求平方根、最大值、最小值、随机数生成等。 2. **java.util.Arrays**:用于...

    Java 日期比较工具类

    Java 日期比较工具类 各种日期操作及计算( 获取两个日期 间隔天数 间隔月数 格式化日期 )

    java日期工具类

    java日期工具类,java日期工具类,java日期工具类,java日期工具类

    常用的java工具类

    2.[工具类] Java中计算任意两个日期之间的工作天数 .java 3.[工具类] MD5 .java 4.[工具类] 时间工具TimeUtil.java 5.[工具类] 通信服务端simpleServer 6.[工具类] 使用Java程序来实现HTTP文件的队列下载 .java 7....

    Java日期工具类

    Java日期工具类 1、日期的各种格式化 2、获取当前年度 3、获取当前月份 4、获取当前天号数 5、获取当前时间往前推一个月的时间 6、获取上个月("MMM yyyy") 7、获取上个月("yyyymm") 8、获取上个月("yyyy-mm") 9、...

    Java常用工具类

    在Java中,最著名的工具类库是`java.util`包,它包含了大量实用类,如集合、日期时间、数学计算、线程管理等。此外,还有一些第三方库,如Apache Commons Lang、Guava等,提供了更丰富的功能。 1. **java.util包**...

    java常用工具类

    在Java中,`java.util`包就是这样一个包含大量工具类的包,提供了很多实用的功能。 1. **集合框架**:Java集合框架是Java中处理对象集合的核心部分,包括List、Set、Queue和Map等接口,以及ArrayList、LinkedList、...

    Java开发常用Util工具类

    字符串工具类/数据类型转换类/集合工具类/数组工具类/Properties文件操作类/常用流操作工具类/编码工具类/Json工具类/日期工具类/下载文件工具类/解压ZIP工具类/文件编码转码

    java开发常用工具类

    Java中`java.util.Calendar`和`java.time`包提供了处理日期和时间的功能。`Calendar`是旧版API,而`java.time`(JSR 310)是Java 8引入的新API,它更易用且功能强大。例如,`LocalDate`、`LocalTime`和`...

    java常用开发工具类大全

    "java常用开发工具类大全"可能包含了一系列这样的工具类,旨在帮助开发者高效地解决各种常见问题。下面我们将深入探讨几个常见的Java工具类库以及它们在实际开发中的应用。 1. **Java标准库中的工具类** - `java....

    Java常用工具类大全

    提供了很丰富的java工具类,包括字符串、数字、日期、文件、图像、编码解码、校验工具、文档操作等。 主要分为以下几种: - 1.通用操作类,例如String、数字、日期、各种校验等 - 2.文档操作,excel、pdf等 - 3.加密...

    java常用的工具类

    以下是一些在Java中常用的工具类及其功能详解: 1. **Base64**: Base64是网络上最常见的用于传输8Bit字节代码的编码方式之一。Java中的`java.util.Base64`类提供了Base64编码和解码的功能,包括对字节数组、字符串...

    Java常用工具类大全,工作5年精心整理.zip

    "Java常用工具类大全,工作5年精心整理.zip"这个压缩包文件很可能包含了一位有经验的Java开发者在五年工作中积累的各种实用工具类,这些工具类能够极大地提高开发效率,简化代码编写。以下是对可能包含的知识点进行...

Global site tag (gtag.js) - Google Analytics