java 日期操作工具类：包括计算两个时间相差距离多少天多少小时多少分多少秒

package com.csidc.as.util;

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.List;
import java.util.Vector;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import com.csidc.as.pojo.Days;
import com.sun.org.apache.xerces.internal.impl.xpath.regex.ParseException;

/**
*
* 功能作用: 对外提供日期操作的相关方法
*
* @version: 1.0
* @create date: 2012-11-29
* @author: lili
* @remark:
*/
public class DateOperate {

private static final Log LOG = LogFactory.getLog(DateOperate.class);

private static Calendar now;

// public static void main(String[] args) throws Exception{
// String start = "2012-12-19 09:00:00";
// String end = "2012-12-20 17:00:10";
// //String date = getStartEndDate(start,end);
//
// long[] difday = DateOperate.getDistanceTimes(start,end);//返回值为：{天, 时, 分,
// 秒}
// String str = difday[0]+"天"+difday[1]+"时"+difday[2]+"分"+difday[3]+"秒";
// System.out.println(str);
// }

public static String getStartEndDate(String start, String end) {
String date = "0";

return date;
}

// 获得当前年
public static String getCurYear() {
now = Calendar.getInstance();
return now.get(Calendar.YEAR) + "";
}

// 获得当前月
public static String getCurMoth() {
now = Calendar.getInstance();
return (now.get(Calendar.MONTH) + 1) + "";
}

// 获得当前日期
public static String getCurDay() {
now = Calendar.getInstance();
return now.get(Calendar.DAY_OF_MONTH) + "";
}

// 获得当前日期
public static String getCurDate() {
Date d = new Date();
return dateToStr(d);
// SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
// String dateNowStr = sdf.format(d);
// return dateNowStr;
}

/**
* 根据日期字符串获得时分秒字符串"2013-10-31 09:10:00";
* @param str
* @return
*/
public static String getHMS(String str){
try{
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date d = sdf1.parse(str);
SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");//时:分:秒:毫秒
String s = sdf.format(d);
System.out.println();
return s;
}catch (Exception e) {
return "";
}
}

/**
* 将Date对象转换为yyyy-MM-dd HH:mm:ss字符串
*
* @param d
* @return
*/
public static String dateToStr(Date d) {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String dateNowStr = sdf.format(d);
return dateNowStr;
}

/**
* 将yyyy-MM-dd HH:mm:ss字符串转换为Date对象
*
* @param d
* @return
*/
public static Date strToDate(String dstr) {
Date today = null;
try {
// String str = "2012-1-13 17:26:33"; //要跟上面sdf定义的格式一样
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
today = sdf.parse(dstr);
} catch (Exception e) {
today = new Date();
}
return today;
}

/**
* 获得当前时间毫秒数
*
* @return
*/
public static String getMillis() {
now = Calendar.getInstance();
return now.getTimeInMillis() + "";
}

/**
* 获得主键
*
* @return
*/
public static synchronized String getPk() {
String pk = getMillis() + generateCheckCode();
return pk;
}

/**
* 随机产生4个字符串
*
* @return
*/
public static String generateCheckCode() {
String chars = "0123456789";
char[] rands = new char[4];
for (int i = 0; i < 4; i++) {
int rand = (int) (Math.random() * 10);
rands[i] = chars.charAt(rand);
}
String tmp = new String(rands);
return tmp;
}

/**
* 两个时间相差距离多少天多少小时多少分多少秒
*
* @param str1
*            时间参数 1 格式：1990-01-01 12:00:00
* @param str2
*            时间参数 2 格式：2009-01-01 12:00:00
* @return long[] 返回值为：{天, 时, 分, 秒}
* @throws java.text.ParseException
*/
public static long[] getDistanceTimes(String str1, String str2)
throws java.text.ParseException {
DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date one;
Date two;
long day = 0;
long hour = 0;
long min = 0;
long sec = 0;
try {
one = df.parse(str1);
two = df.parse(str2);
long time1 = one.getTime();
long time2 = two.getTime();
long diff;
if (time1 < time2) {
diff = time2 - time1;
} else {
diff = time1 - time2;
}
day = diff / (24 * 60 * 60 * 1000);
hour = (diff / (60 * 60 * 1000) - day * 24);
min = ((diff / (60 * 1000)) - day * 24 * 60 - hour * 60);
sec = (diff / 1000 - day * 24 * 60 * 60 - hour * 60 * 60 - min * 60);
} catch (ParseException e) {
e.printStackTrace();
}
long[] times = { day, hour, min, sec };
return times;
}

/************************* 验证超过5个工作日 *****************************/
public static void main(String[] args) {
// String ckdate = "2013-03-15 16:33:44";
// System.out.println(isgt5(ckdate));

try {
// String strDateStart = "2013-5-8";
// SimpleDateFormat sdf = new
// SimpleDateFormat("yyyy-MM-dd");//yyyy/MM/dd HH:mm:ss
//
// Date date_start = sdf.parse(strDateStart);
// Calendar cal_start = Calendar.getInstance();
// Calendar cal_end = Calendar.getInstance();
// cal_start.setTime(date_start);
// System.out.println(getChineseWeek(cal_start));

// System.out.println(">>>>>>>>");
// String date = "2013-5-8";
// DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
// Date d = df.parse(date);
// date = df.format(d);
// System.out.println(date);

/*
* //判断上周周数 Calendar now = Calendar.getInstance(); int nowweek =
* now.get(Calendar.WEEK_OF_YEAR); String years =
* now.get(Calendar.YEAR
* )+"-"+(now.get(Calendar.MONTH)+1)+"-"+now.get
* (Calendar.DAY_OF_MONTH); System.out.println(years+"周："+nowweek);
* int lastWeek = nowweek -1; System.out.println("上周："+lastWeek);
* String date = "2013-6-2"; DateFormat df = new
* SimpleDateFormat("yyyy-MM-dd"); Date d = df.parse(date); Calendar
* cal = Calendar.getInstance(); cal.setTime(d); int week =
* cal.get(Calendar.WEEK_OF_YEAR);
* System.out.println(date+"周："+week);
*/

// String str = "08:20 08:21 17:12 17:33";
// String str = "08:55";
// String str = "09:10 16:59";

/*String str = "08:56 17:10";
if (null == str || "".equals(str)) {

} else {
String[] strs = str.split(" ");
String tmp = "";
boolean islate = true;// 默认迟到
boolean isearlyLeft = true;// 默认早退
// System.out.println("大小:"+strs.length);
for (int i = 0; i < strs.length; i++) {
tmp = strs[i];
// System.out.println(tmp+":"+compTime(tmp,"09:10"));//如果大于9:10就是迟到'
if (islate) {
if (compTime(tmp, "09:10", "lt")) {// 如果小于9:10,就不迟到
islate = false;
}
}
if (isearlyLeft) {
if (compTime(tmp, "17:00", "gt")) {// 如果大于17:00,就不早退
isearlyLeft = false;
}
}
}
System.out.println("上班：" + islate);
System.out.println("下班：" + isearlyLeft);
}

*/


List<String> dayStrL = getBetweenDaysStr("2013-09-22","2013-09-26");
String ckStr = "2013-09-26";
if(dayStrL.contains(ckStr)){
System.out.println("存在");
}else{
System.out.println("不存在");
}
} catch (Exception e) {
e.printStackTrace();
}
}

public static boolean compTime(String s1, String s2, String gtlt) {
if (s1.indexOf(":") < 0 || s1.indexOf(":") < 0) {
System.out.println("格式不正确");
} else {
String[] array1 = s1.split(":");
int total1 = Integer.valueOf(array1[0]) * 3600
+ Integer.valueOf(array1[1]) * 60
// + Integer.valueOf(array1[2]);
;
// System.out.println(total1);
String[] array2 = s2.split(":");
int total2 = Integer.valueOf(array2[0]) * 3600
+ Integer.valueOf(array2[1]) * 60;
// + Integer.valueOf(array2[2]);
// System.out.println(total2);
if ("gt".equalsIgnoreCase(gtlt)) {// 大于等于
return total1 - total2 >= 0 ? true : false;
} else if ("lt".equalsIgnoreCase(gtlt)) {
return total1 - total2 <= 0 ? true : false;
}
}
return false;
}

public static boolean isgt5(String ckdate){
try {
boolean isgt = false;
//String strDateStart = "2013-3-1";
// String strDateEnd = "2006-10-14";

// SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");//yyyy/MM/dd HH:mm:ss
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");//
// Date date_start = sdf.parse(strDateStart);
// Date date_end = sdf.parse(strDateEnd);
// Date date_end = new Date();

//新建一个日历对象。注意：类Calendar是抽象的要使用getInstance()实例化，或者实例化其子类
Calendar calen = Calendar.getInstance();
//日历对象默认的日期为当前日期，调用setTime设置该日历对象的日期为程序中指定的日期
// calen.setTime(date_end);
Date date_end = calen.getTime();
//将日历的"天"增加5

int num = 8;//默认5
try{
//获得配置文件里的天数
String filePath = Thread.currentThread().getContextClassLoader().getResource("")+"prop.properties";
LOG.info("获得当前线程路径:"+filePath);
filePath = filePath.substring(6);
LOG.info("获得路径:"+filePath);

String attTimeNum = PropertyEditor.readValue(filePath,"attTimeNum");
LOG.info("读取到考勤限制天数:"+attTimeNum);
num = Integer.parseInt(attTimeNum);
num += 3;//向前3天进行计算
}catch (Exception e) {
LOG.info("读取到考勤限制天数出错");
num = 8;//默认5
}


LOG.info("应减去天数:"+num);
calen.add(Calendar.DAY_OF_YEAR,-num);
//获取日历对象的时间，并赋给日期对象c
Date date_start = calen.getTime();
LOG.info(num+"天前："+sdf.format(date_start));
LOG.info("结束时间："+sdf.format(date_end));

// DateCal app = new DateCal();
Calendar cal_start = Calendar.getInstance();
Calendar cal_end = Calendar.getInstance();
cal_start.setTime(date_start);
cal_end.setTime(date_end);

// System.out.println("5天前："+getChineseWeek(cal_start)
// + " 日期-->" + cal_start.get(Calendar.YEAR) + "-"
// + (cal_start.get(Calendar.MONTH) + 1) + "-"
// + cal_start.get(Calendar.DAY_OF_MONTH));
// System.out.println("当前："+getChineseWeek(cal_end) + " 日期-->"
// + cal_end.get(Calendar.YEAR) + "-"
// + (cal_end.get(Calendar.MONTH) + 1) + "-"
// + cal_end.get(Calendar.DAY_OF_MONTH));

// System.out.println("工作日为-->"
// + app.getWorkingDay(cal_start, cal_end));
int freeday = getHolidays(cal_start, cal_end);
LOG.info(sdf.format(date_start)+"到"+sdf.format(date_end)+"假日天数-->" + freeday);

if(0<freeday){//表示有休息日
calen = Calendar.getInstance();
//日历对象默认的日期为当前日期，调用setTime设置该日历对象的日期为程序中指定的日期
calen.setTime(date_start);
//将日历的"天"增加5
calen.add(Calendar.DAY_OF_YEAR,-freeday);
//获取日历对象的时间，并赋给日期对象c
date_start = calen.getTime();
LOG.info("减去假日天数"+freeday+"后日期为：-->" + sdf.format(date_start));
}

// System.out.println("5个工作日前："+sdf.format(date_start));
// System.out.println("填写日期："+ckdate);

//去除这个时间段里的法定结假日

List<Days> daysList = InitDate.curDaysList;//获得今年的法定假日数据
List<String> getHolidayStr = new ArrayList<String>();
for (Days days : daysList) {
getHolidayStr.add(days.getHoliday());
}
String holidaystr = Arrays.toString(getHolidayStr.toArray()).replace("[",
"").replace("]", "");//获得节假日字符串

List<String> strL = getBetweenDaysStr(sdf.format(date_start), sdf.format(date_end));//获得两个日期字符串里的日期
int count = 0;
for (String str : strL) {
if(holidaystr.indexOf(str) != -1){//表示找到
count ++;
}
}
if(0 < count){
calen = Calendar.getInstance();
//日历对象默认的日期为当前日期，调用setTime设置该日历对象的日期为程序中指定的日期
calen.setTime(date_start);
//将日历的"天"增加5
calen.add(Calendar.DAY_OF_YEAR,-count);
//获取日历对象的时间，并赋给日期对象c
date_start = calen.getTime();
LOG.info("减去法定假日天数"+count+"后日期为：-->" + sdf.format(date_start));
}

//判断日期
Date dt1 = sdf.parse(ckdate);//要验证的日期
Date dt2 = sdf.parse(sdf.format(date_start));

LOG.info(dt1.toLocaleString()+"<"+dt2.toLocaleString());
            if (dt1.getTime() < dt2.getTime()) {
            isgt = true;
//                System.out.println("超过5天");
            } /*else{
                System.out.println("未超过5天");
            }*/

return isgt;
} catch (Exception e) {
// TODO: handle exception
return false;
}

}

public static int getDaysBetween(java.util.Calendar d1,
java.util.Calendar d2) {
if (d1.after(d2)) { // swap dates so that d1 is start and d2 is end
java.util.Calendar swap = d1;
d1 = d2;
d2 = swap;
}
int days = d2.get(java.util.Calendar.DAY_OF_YEAR)
- d1.get(java.util.Calendar.DAY_OF_YEAR);
int y2 = d2.get(java.util.Calendar.YEAR);
if (d1.get(java.util.Calendar.YEAR) != y2) {
d1 = (java.util.Calendar) d1.clone();
do {
days += d1.getActualMaximum(java.util.Calendar.DAY_OF_YEAR);
d1.add(java.util.Calendar.YEAR, 1);
} while (d1.get(java.util.Calendar.YEAR) != y2);
}
return days;
}

/**
* 计算2个日期之间的相隔天数
*
* @param d1
* @param d2
* @return
*/
public static int getWorkingDay(java.util.Calendar d1, java.util.Calendar d2) {
int result = -1;
if (d1.after(d2)) { // swap dates so that d1 is start and d2 is end
java.util.Calendar swap = d1;
d1 = d2;
d2 = swap;
}

int betweendays = getDaysBetween(d1, d2);

int charge_date = 0;
int charge_start_date = 0;// 开始日期的日期偏移量
int charge_end_date = 0;// 结束日期的日期偏移量
// 日期不在同一个日期内
int stmp;
int etmp;
stmp = 7 - d1.get(Calendar.DAY_OF_WEEK);
etmp = 7 - d2.get(Calendar.DAY_OF_WEEK);
if (stmp != 0 && stmp != 6) {// 开始日期为星期六和星期日时偏移量为0
charge_start_date = stmp - 1;
}
if (etmp != 0 && etmp != 6) {// 结束日期为星期六和星期日时偏移量为0
charge_end_date = etmp - 1;
}
// }
result = (getDaysBetween(getNextMonday(d1), getNextMonday(d2)) / 7) * 5
+ charge_start_date - charge_end_date;
// System.out.println("charge_start_date>" + charge_start_date);
// System.out.println("charge_end_date>" + charge_end_date);
// System.out.println("between day is-->" + betweendays);
return result;
}

public static String getChineseWeek(Calendar date) {
final String dayNames[] = { "星期日", "星期一", "星期二", "星期三", "星期四", "星期五",
"星期六" };

int dayOfWeek = date.get(Calendar.DAY_OF_WEEK);

// System.out.println(dayNames[dayOfWeek - 1]);
return dayNames[dayOfWeek - 1];

}

/**
* 获得日期的下一个星期一的日期
*
* @param date
* @return
*/
public static Calendar getNextMonday(Calendar date) {
Calendar result = null;
result = date;
do {
result = (Calendar) result.clone();
result.add(Calendar.DATE, 1);
} while (result.get(Calendar.DAY_OF_WEEK) != 2);
return result;
}

/**
*
* @param d1
* @param d2
* @return
*/
public static int getHolidays(Calendar d1, Calendar d2) {
return getDaysBetween(d1, d2) - getWorkingDay(d1, d2);

}

/************************* 验证超过5个工作日 *****************************/

/**
* 添加天数
*
* @param d
* @param day
* @return
* @throws ParseException
*/
public static Date addDate(Date d, long day) throws ParseException {
long time = d.getTime();
day = day * 24 * 60 * 60 * 1000;
time += day;
return new Date(time);

}

/**
* 获得周几
*
* @param s
* @return
*/
public static String getWeekName(String s) {
final String dayNames[] = { "星期日", "星期一", "星期二", "星期三", "星期四", "星期五",
"星期六" };

// String s = "2013-03-04 9:00:44";
SimpleDateFormat sdfInput = new SimpleDateFormat("yyyy-MM-dd");

Calendar calendar = Calendar.getInstance();
Date date = new Date();

try {
date = sdfInput.parse(s);
} catch (Exception e) {
e.printStackTrace();
}

calendar.setTime(date);
int dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK) - 1;
if (dayOfWeek < 0)
dayOfWeek = 0;
// System.out.println(dayNames[dayOfWeek]);
return dayNames[dayOfWeek];
}

public static String getChineseWeek(String strDateStart) {
try {
// String strDateStart = "2013-5-8";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");// yyyy/MM/dd
// HH:mm:ss
Date date_start = sdf.parse(strDateStart);
Calendar cal_start = Calendar.getInstance();
cal_start.setTime(date_start);

String str = getChineseWeek(cal_start);
// System.out.println(str);
return str;
} catch (Exception e) {
return "";
}
}

/**
* 判断a是否大于b
*
* @param a
* @param b
* @return
*/
public static boolean pkdategt(String a, String b) {
boolean gt = false;
try {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");// yyyy/MM/dd
// HH:mm:ss
Date ad = sdf.parse(a);
Date bd = sdf.parse(b);
if (ad.after(bd)) {
gt = true;
}
} catch (Exception e) {

}
return gt;
}

/**
* 判断a是否大于b
*
* @param a
* @param b
* @return
*/
public static boolean pkdatelt(String a, String b) {
boolean gt = false;
try {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");// yyyy/MM/dd
// HH:mm:ss
Date ad = sdf.parse(a);
Date bd = sdf.parse(b);
if (ad.before(bd)) {
gt = true;
}
} catch (Exception e) {

}
return gt;
}

/*******获得两个日期字符串里的日期******/
public static GregorianCalendar[] getBetweenDate(String d1, String d2)
throws Exception {
Vector<GregorianCalendar> v = new Vector<GregorianCalendar>();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
GregorianCalendar gc1 = new GregorianCalendar(), gc2 = new GregorianCalendar();
gc1.setTime(sdf.parse(d1));
gc2.setTime(sdf.parse(d2));
do {
GregorianCalendar gc3 = (GregorianCalendar) gc1.clone();
v.add(gc3);
gc1.add(Calendar.DAY_OF_MONTH, 1);
} while (!gc1.after(gc2));
return v.toArray(new GregorianCalendar[v.size()]);
}

public static List<String> getBetweenDaysStr(String d1, String d2) {
List<String> strL = new ArrayList<String>();
try {
GregorianCalendar[] ga = getBetweenDate(d1, d2);
String str = "";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

for (GregorianCalendar e : ga) {
str = e.get(Calendar.YEAR) + "-" + (e.get(Calendar.MONTH) + 1)
+ "-" + e.get(Calendar.DAY_OF_MONTH);
str = sdf.format(sdf.parse(str));
// System.out.println(str);
strL.add(str);
}
} catch (Exception e) {
}
return strL;
}

}