JAVA 时间工具类
2015-08-21 08:01
666 查看
package com.XXXXX.XXXXXXX.XXXXXXXX;
import java.sql.Timestamp;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.StringTokenizer;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* 日期时间管理类.
* <p>
* Title: CicroDate
* </p>
* <p>
* Description: 日期时间管理
* </p>
* <p>
* Copyright: Copyright (c) 2002
* </p>
* <p>
* Company: Cicro
* </p>
*
* @author kongxx
* @author Sunyi
* @version 1.3 *
*/
public class DateUtil {
private static final String DATE_PATTERN = "yyyy-MM-dd";
private static final String DATETIME_PATTERN = "yyyy-MM-dd HH:mm:ss";
/**
* 获取当前系统时间. 默认模板格式yyyy-MM-dd hh:mm:ss.
*
* @return 当前系统时间
*/
public static String getCurrentDateTime() {
return getCurrentDateTime(DATETIME_PATTERN);
}
/**
* 获取当前系统同期。
*
* @return 当前系统日期
* @author zhenggz 2003-11-09
*/
public static String getCurrentDate() {
return getCurrentDateTime(DATE_PATTERN);
}
/**
* 获取当前系统时间.
*
* @param strPattern
* 时间模板
* @return 当前系统时间
*/
public static String getCurrentDateTime(String pattern) {
Calendar cal = Calendar.getInstance();
SimpleDateFormat sdf = new SimpleDateFormat(pattern);
return sdf.format(cal.getTime());
}
/**
* 把字串转化成为Date对象，时间字串格式为2000-01-01 00:00:00
*
* @param dateString
* 被转化的时间字串，以 yyyy-MM-dd HH:mm:ss 的格式
* @throws ParseException
* */
public static Date getDate(String dateStr) throws ParseException {
return getDate(dateStr, DATETIME_PATTERN);
}
/**
* 把字串转化成为Date对象，时间字串格式需要设定
*
* @param dateString
* 被转化的时间字串
* @param pattern
* 时间字串的日期格式，如yyyy-MM-dd
* @throws ParseException
* */
public static Date getDate(String dateStr, String pattern)
throws ParseException {
Date date = null;
SimpleDateFormat dateFormat = new SimpleDateFormat(pattern);
date = dateFormat.parse(dateStr);
return date;
}
/**
* 取得日期字串
*
* @param date
* Date对象
* @return 日期字串，格式如：2003-12-02
* */
public static String getDateString(Date date) {
return getString(date, DATE_PATTERN);
}
/**
* 取得日期时间字串
*
* @param date
* Date对象
* @return 日期时间字串，格式如：2003-12-02 13:10:00
* */
public static String getDateTimeString(Date date) {
return getString(date, DATETIME_PATTERN);
}
/**
* 按照指定格式取得时间字串
*
* @param date
* Date对象
* @param pattern
* 时间字串的日期格式，如yyyy-MM-dd
* @return 日期时间字串，格式如：2003-12-02 13:10:00
* */
public static String getString(Date date, String pattern) {
SimpleDateFormat dateFormat = new SimpleDateFormat(pattern);
return dateFormat.format(date);
}
/**
* 格式化日期字串
*
* @param dateStr
* @return 格式化后的字串，格式如：2003-12-02
* */
public static String formatToDateString(String dateStr)
throws ParseException {
return formatToString(dateStr, DATE_PATTERN);
}
/**
* 格式化日期时间字串
*
* @param dateTimeStr
* @return String 格式化后的字串，格式如：2003-12-02 12:12:10
* */
public static String formatToDateTimeString(String dateTimeStr)
throws ParseException {
return formatToString(dateTimeStr, DATETIME_PATTERN);
}
/**
* 格式化日期时间字串为指定的格式字串
*
* @param String
* 时间字串
* @param String
* 时间字串的日期格式，如yyyy-MM-dd
* @return String 格式化后的字串，格式如：2003-12-02 12:12:10
* */
public static String formatToString(String dateStr, String pattern)
throws ParseException {
dateStr = format(dateStr);
Date date = null;
if (checkDateString(dateStr)) {
date = getDate(dateStr, DATE_PATTERN);
return getString(date, pattern);
} else if (checkDateTimeString(dateStr)) {
date = getDate(dateStr);
return getString(date, pattern);
} else {
throw new ParseException("日期格式不正确", 1);
}
}
/**
* 检查日期字串的格式
*
* @param String
* 时间字串 YYYY-MM-DD
* @return boolean true or false
* */
public static boolean checkDateString(String dateStr) {
Pattern pattern = Pattern.compile("\\d{2,4}-\\d{1,2}-\\d{1,2}");
Matcher matcher = pattern.matcher(dateStr);
return matcher.matches();
}
/**
* 检查日期时间字串的格式
*
* @param String
* 时间字串 YYYY-MM-DD hh:mm:ss
* @return boolean true or false
* */
public static boolean checkDateTimeString(String dateTimeStr) {
Pattern pattern = Pattern
.compile("\\d{2,4}-\\d{1,2}-\\d{1,2}\\s\\d{1,2}:\\d{1,2}:\\d{1,2}");
Matcher matcher = pattern.matcher(dateTimeStr);
return matcher.matches();
}
/**
* 规范化时间字串
*
* @param String
* 时间字串
* @return String 格式化后的字串，格式如：2003-12-02 12:12:10
* */
public static String format(String dateStr) {
Pattern pattern = Pattern
.compile("\\d{4}-\\d{2}-\\d{2}\\s\\d{2}:\\d{2}:\\d{2}.*");
Matcher matcher = pattern.matcher(dateStr);
if (matcher.matches()) {
dateStr = dateStr.substring(0, 19);
} else {
pattern = Pattern.compile("\\d{4}-\\d{2}-\\d{2}.*");
matcher = pattern.matcher(dateStr);
if (matcher.matches()) {
dateStr = dateStr.substring(0, 10);
}
}
return dateStr;
}
/**
* History 2004-08-09 Added by xiecs 增加了根据Date对象获得年，月，日等信息的方法
* 获得某天的开始时间和结束时间，获得一周的开始时间和结束时间的方法
*
* @param Date
* date 时间对象
* @return int 返回这日期的年份 格式如：2010
*/
public static int getYear(Date date) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
int year = calendar.get(Calendar.YEAR);
return year;
}
/**
* History 2004-08-09 Added by xiecs 增加了根据Date对象获得年，月，日等信息的方法
* 获得某天的开始时间和结束时间，获得一周的开始时间和结束时间的方法
*
* @param Date
* date 时间对象
* @return int 返回这日期的月份 格式如：11
*/
public static int getMonth(Date date) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
int month = calendar.get(Calendar.MONTH);
return month;
}
/**
* History 2004-08-09 Added by xiecs 增加了根据Date对象获得年，月，日等信息的方法
* 获得某天的开始时间和结束时间，获得一周的开始时间和结束时间的方法
*
* @param Date
* date 时间对象
* @return int 返回这日期在当月的第几天 格式如：15
*/
public static int getDayOfMonth(Date date) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
int day = calendar.get(Calendar.DAY_OF_MONTH);
return day;
}
/**
* History 2004-08-09 Added by xiecs 增加了根据Date对象获得年，月，日等信息的方法
* 获得某天的开始时间和结束时间，获得一周的开始时间和结束时间的方法
*
* @param Date
* date 时间对象
* @return int 返回这日期在第几周 格式如：52
*/
public static int getDayOfWek(Date date) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
int day = calendar.get(Calendar.DAY_OF_WEEK);
return day;
}
/**
* History 2004-08-09 Added by xiecs 增加了根据Date对象获得年，月，日等信息的方法
* 获得某天的开始时间和结束时间，获得一周的开始时间和结束时间的方法
*
* @param Date
* date 时间对象
* @return int 返回这日期的小时 格式如：23
*/
public static int getHour(Date date) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
int hour = calendar.get(Calendar.HOUR_OF_DAY);
return hour;
}
/**
* History 2004-08-09 Added by xiecs 增加了根据Date对象获得年，月，日等信息的方法
* 获得某天的开始时间和结束时间，获得一周的开始时间和结束时间的方法
*
* @param Date
* date 时间对象
* @return int 返回这日期的分钟 格式如：59
*/
public static int getMinute(Date date) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
int minute = calendar.get(Calendar.MINUTE);
return minute;
}
/**
* History 2004-08-09 Added by xiecs 增加了根据Date对象获得年，月，日等信息的方法
* 获得某天的开始时间和结束时间，获得一周的开始时间和结束时间的方法
*
* @param Date
* date 时间对象
* @return int 返回这日期的秒钟 格式如：40
*/
public static int getSecond(Date date) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
int second = calendar.get(Calendar.SECOND);
return second;
}
/**
* 获得某天的开始时间的Date对象，一般用来作比较用
*
* @param Date
* date 时间对象
* @return Date
*/
public static Date getStartOfDay(Date date) {
Date startDate = null;
try {
startDate = DateUtil.getDate(
DateUtil.getString(date, "yyyy-MM-dd"), "yyyy-MM-dd");
} catch (Exception e) {
return null;
}
return startDate;
}
/**
* 获得某天的结束时间的Date对象，一般用来作比较用
*
* @param Date
* date 时间对象
* @return Date
*/
public static Date getEndOfDay(Date date) {
Calendar calendar = Calendar.getInstance();
Date endDate = null;
try {
calendar.set(DateUtil.getYear(date), DateUtil.getMonth(date),
DateUtil.getDayOfMonth(date), 23, 59, 59);
endDate = calendar.getTime();
} catch (Exception e) {
return null;
}
return endDate;
}
/**
* 获得某天所在的星期的第一天（星期一）的开始时间（0时0分0秒）Date对象，一般用来作比较用
*
* @param Date
* date 时间对象
* @return Date
*/
public static Date getStartOfWeek(Date date) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
int n = 0;
int day = calendar.get(Calendar.DAY_OF_WEEK);
switch (day) {
case Calendar.MONDAY: {
n = 0;
break;
}
case Calendar.TUESDAY: {
n = 1;
break;
}
case Calendar.WEDNESDAY: {
n = 2;
break;
}
case Calendar.THURSDAY: {
n = 3;
break;
}
case Calendar.FRIDAY: {
n = 4;
break;
}
case Calendar.SATURDAY: {
n = 5;
break;
}
case Calendar.SUNDAY: {
n = 6;
break;
}
}
Date monday = new Date(date.getTime() - 24 * 60 * 60 * 1000 * n);
Date startDate = getStartOfDay(monday);
return startDate;
}
/**
* 获得某天所在的星期的最后一天（星期天）的结束时间（23时59分59秒）Date对象，一般用来作比较用
*
* @param Date
* date 时间对象
* @return Date
*/
public static Date getEndOfWeek(Date date) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
int n = 0;
int day = calendar.get(Calendar.DAY_OF_WEEK);
switch (day) {
case Calendar.MONDAY: {
n = 6;
break;
}
case Calendar.TUESDAY: {
n = 5;
break;
}
case Calendar.WEDNESDAY: {
n = 4;
break;
}
case Calendar.THURSDAY: {
n = 3;
break;
}
case Calendar.FRIDAY: {
n = 2;
break;
}
case Calendar.SATURDAY: {
n = 1;
break;
}
case Calendar.SUNDAY: {
n = 0;
break;
}
}
Date sunday = new Date(date.getTime() + 24 * 60 * 60 * 1000 * n);
Date startDate = getEndOfDay(sunday);
return startDate;
}
/**
* 判断两个日期之间相差的天数
*
* @param String
* day1 时间1 2010-01-03
* @param String
* day1 时间2 2010-01-05
* @return long 相差天数
*/
public static long daysOf2Day(String day1, String day2) {
try {
day1 += " 00:00:00";
day2 += " 00:00:00";
long secs = secsOf2Day(day1, day2);
return secs / (24 * 60 * 60);
} catch (Exception e) {
return -1;
}
}
/**
* 判断两个时间之间相差的天数
*
* @param String
* day1 时间1 2010-01-03 00:00:00
* @param String
* day1 时间2 2010-01-05 10:25:44
* @return long 相差天数
*/
public static long secsOf2Day(String day1, String day2) {
try {
Date date1 = getDate(day1);
Date date2 = getDate(day2);
long secs = Math.abs(date1.getTime() - date2.getTime()) / 1000;
return secs;
} catch (Exception e) {
return -1;
}
}
/**
* 获得到当前时间为止的天数,不足一天按一天计.
*
* @param strDateTime
* 'yyyy-mm-dd hh:mm:ss'
* @return 天数
*/
public static String getDaysToNow(String strDateTime) {
try {
StringTokenizer strToken = new StringTokenizer(strDateTime, " ");
StringTokenizer strTokenDate = new StringTokenizer(
strToken.nextToken(), "-");
StringTokenizer strTokenTime = new StringTokenizer(
strToken.nextToken(), ":");
int intYear = Integer.parseInt(strTokenDate.nextToken());
int intMonth = Integer.parseInt(strTokenDate.nextToken()) - 1;
int intDay = Integer.parseInt(strTokenDate.nextToken());
int intHour = Integer.parseInt(strTokenTime.nextToken());
int intMin = Integer.parseInt(strTokenTime.nextToken());
int intSec = Integer.parseInt(strTokenTime.nextToken());
Calendar cal = Calendar.getInstance();
cal.set(intYear, intMonth, intDay, intHour, intMin, intSec);
long longDays = (new Date().getTime() - cal.getTimeInMillis()) / 24
/ 60 / 60 / 1000;
longDays = longDays == 0 ? 1 : longDays;
return "" + longDays;
} catch (Exception e) {
return "0";
}
}
/**
* 比较两个时间的差值
*
* @param date1
* yyyy-MM-dd HH:mm:ss
* @param date2
* yyyy-MM-dd HH:mm:ss
* @return int 小时
*/
public static long compareDatetime(String date1, String date2) {
DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
long timestamp1 = -1;
long timestamp2 = -1;
// 先将时间格式转换成Timestamp
try {
timestamp1 = df.parse(date1).getTime() / 1000;
timestamp2 = df.parse(date2).getTime() / 1000;
} catch (ParseException e) {
System.out.println("时间格式 [ " + date1 + " ] 或 [ " + date2
+ " ] 无法被解析");
return -1;
}
if (timestamp1 > timestamp2)
return (timestamp1 - timestamp2) / 3600;
else
return (timestamp2 - timestamp1) / 3600;
}
/**
* 得到某个数值之后的时间
*
* @param String
* yyyy-MM-dd HH:mm:ss
* @param int 整数
* @return String yyyy-MM-dd HH:mm:ss
*/
public static Date getDateTimesAfter(String datetimes, int day) {
Calendar now = Calendar.getInstance();
try {
now.setTime(getDate(datetimes, DATETIME_PATTERN));
} catch (ParseException e) {
System.out.println("时间格式 [ " + datetimes + " ] 无法被解析");
return null;
}
now.set(Calendar.DATE, now.get(Calendar.DATE) + day);
return now.getTime();
}
/**
* 得到某个数值之后的时间
*
* @param String
* yyyy-MM-dd HH:mm:ss or yyyy-MM-dd
* @param int 整数
* @return String yyyy-MM-dd
*/
public static Date getDateAfter(String datetimes, int day) {
Calendar now = Calendar.getInstance();
try {
now.setTime(getDate(datetimes, DATE_PATTERN));
} catch (ParseException e) {
System.out.println("时间格式 [ " + datetimes + " ] 无法被解析");
return null;
}
now.set(Calendar.DATE, now.get(Calendar.DATE) + day);
return now.getTime();
}
/**
* 得到某个数值之前的日期
*
* @param String
* yyyy-MM-dd HH:mm:ss or yyyy-MM-dd
* @param int 整数
* @return String yyyy-MM-dd
*/
public static String getDateBefore(String datetimes, int day) {
Calendar now = Calendar.getInstance();
try {
now.setTime(getDate(datetimes, DATE_PATTERN));
} catch (ParseException e) {
System.out.println("时间格式 [ " + datetimes + " ] 无法被解析");
return null;
}
now.set(Calendar.DATE, now.get(Calendar.DATE) - day);
return getString(now.getTime(), "yyyy-MM-dd");
}
/**
* 将某个时间的Timestamp转换成Datetime
*
* @param long 时间数值
* @param String
* 时间格式 yyyy-MM-dd hh:mm:ss
* @return String yyyy-MM-dd hh:mm:ss
*/
public static String timestampToDate(long timestamp, String format) {
Date date = new Timestamp(timestamp);
DateFormat df = new SimpleDateFormat(format);
return df.format(date);
}
/**
* 得到当前时间的数值
*
* @return String yyyy-MM-dd hh:mm:ss
*/
public static long dateToTimestamp() {
long ts = System.currentTimeMillis();
return ts;
}
/**
* 得到指定时间之后的时间
*
* @param String
* time
* @param int num
* @return String yyyy-MM-dd hh:mm:ss
*/
public static String getDateTimeAfter(String times, int num) {
if (times == null || "".equals(times))
times = getCurrentDateTime();
long tl = dateToTimestamp(times) + num * 1000;
return timestampToDate(tl, "yyyy-MM-dd HH:mm:ss");
}
/**
* 将某个时间的Datetime转换成Timestamp
*
* @param dateFormat
* yyyy-MM-dd HH:mm:ss
* @return long
*/
public static long dateToTimestamp(String dateFormat) {
long timestamp = -1;
try {
DateFormat df = new SimpleDateFormat(DATETIME_PATTERN);
Date date = df.parse(dateFormat);
timestamp = date.getTime();
} catch (Exception e) {
System.out.println("时间格式 [ " + dateFormat + " ] 无法被解析");
}
return timestamp;
}
public static long compareDatetime2(String date1, String date2) {
DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS");
long timestamp1 = -1;
long timestamp2 = -1;
// 先将时间格式转换成Timestamp
try {
timestamp1 = df.parse(date1).getTime();
timestamp2 = df.parse(date2).getTime();
} catch (ParseException e) {
System.out.println("时间格式 [ " + date1 + " ] 或 [ " + date2
+ " ] 无法被解析");
return -1;
}
if (timestamp1 > timestamp2)
return (timestamp1 - timestamp2);
else
return (timestamp2 - timestamp1);
}
// 对比两个日期大小
public static boolean compare_date(String DATE1, String DATE2) {
DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
try {
Date dt1 = df.parse(DATE1);
Date dt2 = df.parse(DATE2);
if (dt1.getTime() > dt2.getTime()) {
// System.out.println("dt1 在dt2前");
return false;
} else if (dt1.getTime() < dt2.getTime()) {
// System.out.println("dt1在dt2后");
return true;
} else {
return true;
}
} catch (Exception exception) {
exception.printStackTrace();
}
return true;
}
public static void main(String[] args) throws Exception {
// System.out.println(getDaysToNow("2010-01-10 00:00:00"));
// System.out.println(compare_date("2011-05-16 17:50:50","2011-05-16 17:50:55"));
// System.out.println(getDateTimesAfter("2010-01-10 12:00:00",-5));
// System.out.println(getDateAfter("2010-01-10",-5));
// System.out.println(timestampToDate(1262575579707L,"yyyy-MM-dd HH:mm:ss"));
System.out.println(compareDatetime("2012-02-02 17:36:46:673",
"2012-02-03 18:47:37:392"));
// "2010-01-20 17:58:37:319","2010-01-20 18:44:32:592" ibatis + bonecp
// 27ss
// "2010-01-21 14:51:49:307","2010-01-21 15:47:45:794" hib + c3p0 33ss
// "2010-01-21 17:36:46:673","2010-01-21 18:47:37:392" ibatis + c3p0
// 42ss
// System.out.println(dateToTimestamp());
// System.out.println(timestampToDate(1268231397000L-120000,"yyyy-MM-dd HH:mm:ss"));
System.out.println(DateUtil.getDateString(getDateAfter(
"2012-02-02 17:36:46", 30)));
}
}
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- Java中类型的长度
- Java中关于原子操作和volatile关键字
- Eclipse使用Maven构建web项目二
- eclipse Maven 插件添加第三方远程仓库
- eclipse中将Maven Dependencies Libraries移除后的恢复办法
- Java实现多线程的两种方式
- 【8-20】java学习笔记02
- 使用spring-boot 中遇到的一个小坑
- 粗略。。。java设计模式总结。。。studying
- 转：如何从普通Java类中获取WEB-INF目录绝对路径
- 粗略。。Java项目设计模式之笔记----studying
- Java设计模式之适配器模式
- Java设计模式之单例模式
- Java设计模式之原型模式
- 快速排序java
- java反射机制详解 及 Method.invoke解释
- Java动态代理
- spring boot
- java连接数据库时出现如下错误:
- Struts2入门示例教程