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;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class DateUtils {
public static final String DATETIME_FORMAT = "yyyy-MM-dd HH:mm:ss";
public static final String DATETIME_FORMAT1 = "yyyy-MM-dd HH:mm";
public static final String DATE_FORMAT = "yyyy-MM-dd";
public static final String DATE_FORMAT2 = "MM/dd/yyyy";
public static final String TIME_FORMAT = "HH:mm:ss";
public static final String TIME_NO_FORMAT="HHmmss";
public static final String TIME_FORMAT2 = "HH:mm";
public static final String TIMESTAMP_FORMAT = "yyyyMMddHHmmss";
public static final String MILLI_TIMESTAMP_FORMAT = "yyMMddHHmmssSSS";//精确到毫秒时间戳
public static final String ZEROTIME_FORMAT = "yyyy-MM-dd 00:00:00";	//当天零点
public static final String ENDTIME_FORMAT = "yyyy-MM-dd 23:59:59";	//当天的最后一秒
public static final String M2_D2_H2_M2_FORMAT = "MM-dd HH:mm";

public static final String dateFormatSimpleReg = "[0-9]{4}-[0-9]{2}-[0-9]{2}";//匹配yyyy-MM-dd格式
public static final String dateFormatReg = "[0-9]{4}-[0-9]{2}-[0-9]{2}\\s[0-9]{2}\\:[0-9]{2}\\:[0-9]{2}";//匹配yyyy-MM-dd HH:mm:ss格式

/**
*
* 功能描述：获取当前系统时间
*
* @author bingzhong.qin
*         <p>
*         创建日期 ：2014-1-2 下午2:35:54
*         </p>
*
* @param parse
*            时间格式
* @return
* @throws ParseException
*
*             <p>
*             修改历史 ：(修改人，修改时间，修改原因/内容)
*             </p>
*/
public static Date getCurrentDate(String parse) throws ParseException {

if (StringUtils.isBlank(parse)) {
parse = DATETIME_FORMAT;
}
SimpleDateFormat df = new SimpleDateFormat(parse);
return parse(df.format(new Date()), parse);
}

/**
*
* 功能描述：string 转换成date，默认模式
*
* @author bingzhong.qin
*         <p>
*         创建日期 ：2013-12-31 下午2:15:31
*         </p>
*
* @param source
* @return
*
*         <p>
*         修改历史 ：(修改人，修改时间，修改原因/内容)
*         </p>
*/
public static Date parse(String source) {
try {
SimpleDateFormat format = new SimpleDateFormat();
if (source.indexOf(":") > 0)
format.applyPattern(DATETIME_FORMAT);
else {
format.applyPattern(DATE_FORMAT);
}
return format.parse(source.trim());
} catch (ParseException e) {
}
return null;
}

/**
*
* 功能描述：string 转换成date,自定义格式
*
* @author bingzhong.qin
*         <p>
*         创建日期 ：2013-12-31 下午2:14:30
*         </p>
*
* @param source
* @param formatString
* @return
*
*         <p>
*         修改历史 ：(修改人，修改时间，修改原因/内容)
*         </p>
*/
public static Date parse(String source, String formatString) {
try {
SimpleDateFormat format = new SimpleDateFormat();
format.applyPattern(formatString.trim());
return format.parse(source.trim());
} catch (ParseException e) {
e.printStackTrace();
}
return null;
}

/**
*
* 功能描述：date转换成string
*
* @author bingzhong.qin
*         <p>
*         创建日期 ：2013-12-31 下午2:11:42
*         </p>
*
* @param date
* @param FormatString
* @return
*
*         <p>
*         修改历史 ：(修改人，修改时间，修改原因/内容)
*         </p>
*/
public static String format(Date date, String FormatString) {
SimpleDateFormat format = null;
if(date == null)
return null;
if (StringUtils.isBlank(FormatString)) {
FormatString = DATETIME_FORMAT;
}
format = new SimpleDateFormat(FormatString);
return format.format(date);
}

public static String format(long date, String FormatString) {
SimpleDateFormat format;
if (StringUtils.isBlank(FormatString)) {
FormatString = DATETIME_FORMAT;
}
format = new SimpleDateFormat(FormatString);
return format.format(date);
}

/***************************************************************************
* dateStrToLong
*
* @see 2005-11-15
* @param dateStr
*            日期字符串yyyy-mm-dd
* @return long theDay
**************************************************************************/
public static long dateStrToLong(String dateStr) {
long theDate = System.currentTimeMillis();
Date thisDate = stringToDate(dateStr);
if (thisDate != null) {
theDate = thisDate.getTime();
}
return theDate;
}

/***************************************************************************
* stringToDate 把字符型"yyyy-MM-dd"转换成日期型
*
* @param s
*            String 需要转换的日期时间字符串
* @return theDate Date
**************************************************************************/
public static Date stringToDate(String s) {
Date theDate = null;
try {
if (s != null) {
SimpleDateFormat dateFormatter = new SimpleDateFormat(DATE_FORMAT);
theDate = dateFormatter.parse(s);
} else {
theDate = null;
}
} catch (ParseException pe) {
// plogger.error(e); e.printStackTrace();
theDate = null;
}
return theDate;
}

public static Long stringToLong(String time, String format){
if (null == format){
format = DateUtils.DATETIME_FORMAT;
}
try {
SimpleDateFormat dateFormatter = new SimpleDateFormat(format);
return dateFormatter.parse(time).getTime();
}catch (Exception e){
e.printStackTrace();
}
return 0L;
}

public static Long stringToLong(String time){
if (StringUtils.isEmpty(time)){
return 0L;
}
String format = null;
Pattern pattern = Pattern.compile(dateFormatReg);
Matcher matcher = pattern.matcher(time);
if (matcher.find()){
format = DATETIME_FORMAT;
}
if (StringUtils.isEmpty(format)){
pattern = Pattern.compile(dateFormatSimpleReg);
matcher = pattern.matcher(time);
if (matcher.find()){
format = DATE_FORMAT;
}
}
if (StringUtils.isEmpty(format)){
LogUtil.e("stringToLong","日期字符串格式错误");
return 0L;
}
try {
SimpleDateFormat dateFormatter = new SimpleDateFormat(format);
return dateFormatter.parse(time).getTime();
}catch (Exception e){
e.printStackTrace();
}
return 0L;
}

/**
* 把时间戳类型转换为Date
* @param time
* @return
*/
public static String longToString(long time, String format){
try {
Date date = new Date();
date.setTime(time);
if (StringUtils.isEmpty(format)){
format = DATETIME_FORMAT;
}
SimpleDateFormat dateFormatter = new SimpleDateFormat(format);
return dateFormatter.format(date);
}catch (Exception e){

}
return "";
}

/**
* 获取指定日期是周几
*
* @param date
* @return
*/
public static String getWeekStrByDate(Date date){
4000

String[] weeks = {"星期日","星期一","星期二","星期三","星期四","星期五","星期六"};
Calendar cal = Calendar.getInstance();
cal.setTime(date);
int week_index = cal.get(Calendar.DAY_OF_WEEK) - 1;
if(week_index<0){
week_index = 0;
}
return weeks[week_index];
}

public static int getWeekByDate(Date date){
Calendar cal = Calendar.getInstance();
cal.setTime(date);
int week_index = cal.get(Calendar.DAY_OF_WEEK) - 1;
if(week_index<=0){
week_index = 7;
}
return week_index;
}

public static String currPK() {
Date d = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmssSSS");
String d1 = sdf.format(d);

try {
Thread.sleep(50);/* 沉睡50毫秒 */
} catch (InterruptedException e) {
e.printStackTrace();
}

return d1;

}

/**
* 获取系统当前秒级时间戳
*
* @return
*/
public static long getSecondStamp() {
return System.currentTimeMillis() / 1000;
}

/**
* 传入时间跟当前时间比较
*
* @param dateStr
* @return
*/
public static int compareDate(String dateStr) {
DateFormat df = new SimpleDateFormat(DATETIME_FORMAT);
Date newDate = new Date();
Date paramDate;
try {
paramDate = df.parse(dateStr);
return newDate.compareTo(paramDate);
} catch (ParseException e) {
return -2;
}
}
/**
* 验证时间格式是否合格
* @param timeStr 时间字符串
* @param timeFormart 需要验证的时间格式
* @return
*/
public static boolean isValidDate(String timeStr, String timeFormart) {
boolean dateFlag = false;
try {
// 指定日期格式为四位年/两位月份/两位日期，注意yyyy/MM/dd区分大小写；
DateFormat dateFormat = new SimpleDateFormat(timeFormart);
// 设置lenient为false.
// 否则SimpleDateFormat会比较宽松地验证日期，比如2007/02/29会被接受，并转换成2007/03/01
dateFormat.setLenient(false);
dateFormat.parse(timeStr);
dateFlag = true;
} catch (Exception e) {
dateFlag = false;
// 如果throw java.text.ParseException或者NullPointerException，就说明格式不对
}
return dateFlag;
}

/**
* 获取当天零点
*
* @return
* @throws Exception
*/
public static Date getZeroTimeOfCurDate() throws Exception {
SimpleDateFormat sdf = new SimpleDateFormat(ZEROTIME_FORMAT);
String s =sdf.format(new Date());
return sdf.parse(s);
}

public static Date getZeroTimeOfYesterDay() throws Exception {
// 获取昨天这时候的日期时间
Date nowOfYesterday = addSeconds(new Date(), -24*60*60);
SimpleDateFormat sdf = new SimpleDateFormat(ZEROTIME_FORMAT);
String s =sdf.format(nowOfYesterday);
return sdf.parse(s);
}

/**
* 获取当前时间
*
* @return
* @throws Exception
*/
public static Date getCurTimeOfCurDate() throws Exception {
SimpleDateFormat sdf = new SimpleDateFormat(TIME_FORMAT);
String s =sdf.format(new Date());
return sdf.parse(s);
}
public static Date getTime(String timeStr) throws Exception {
SimpleDateFormat sdf = new SimpleDateFormat(TIME_FORMAT);
return sdf.parse(timeStr);
}

public static String getTimeStrByPattern(Date time ,String dateFormat) throws Exception {
SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);
return sdf.format(time);
}

public static Date getTimeByPattern(String time,String dateFormat) throws Exception {
SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);
return sdf.parse(time);
}

public static Date getDateByPattern(Date time,String cutFormat) throws Exception {
SimpleDateFormat sdf = new SimpleDateFormat(cutFormat);
String newDateStr = sdf.format(time);
sdf = new SimpleDateFormat(DATETIME_FORMAT);
return sdf.parse(newDateStr);
}

public static String getCurDate() throws Exception {
SimpleDateFormat sdf = new SimpleDateFormat(DATETIME_FORMAT);
String s =sdf.format(new Date());
return s;
}

public static Date getEndTimeOfCurDate() throws Exception {
SimpleDateFormat sdf = new SimpleDateFormat(ENDTIME_FORMAT);
String s =sdf.format(new Date());
sdf = new SimpleDateFormat(DATETIME_FORMAT);
return sdf.parse(s);
}

/**
* 获取当前日期为周几
*
* @return
* @throws Exception
*/
public static int getDayOfWeek() throws Exception {
Calendar now = Calendar.getInstance();
//一周第一天是否为星期天
boolean isFirstSunday = (now.getFirstDayOfWeek() == Calendar.SUNDAY);
//获取周几
int weekDay = now.get(Calendar.DAY_OF_WEEK);
//若一周第一天为星期天，则-1
if(isFirstSunday){
weekDay = weekDay - 1;
if(weekDay == 0){
weekDay = 7;
}
}
return weekDay;
}

/**
* 判断当前日期是星期几<br>
* <br>
*
* @param pTime
*            修要判断的时间<br>
* @return dayForWeek 判断结果<br>
* @Exception 发生异常<br>
*/
public static int getDayOfWeek(String pTime) throws Exception {
SimpleDateFormat format = new SimpleDateFormat(DATE_FORMAT);
Calendar c = Calendar.getInstance();
c.setTime(format.parse(pTime));
int dayForWeek = 0;
if (c.get(Calendar.DAY_OF_WEEK) == 1) {
dayForWeek = 7;
} else {
dayForWeek = c.get(Calendar.DAY_OF_WEEK) - 1;
}
return dayForWeek;
}

/**
* Adds a number of years to a date returning a new object.
* The original date object is unchanged.
*
* @param date  the date, not null
* @param amount  the amount to add, may be negative
* @return the new date object with the amount added
* @throws IllegalArgumentException if the date is null
*/
public static Date addYears(Date date, int amount) {
return add(date, Calendar.YEAR, amount);
}

//-----------------------------------------------------------------------
/**
* Adds a number of months to a date returning a new object.
* The original date object is unchanged.
*
* @param date  the date, not null
* @param amount  the amount to add, may be negative
* @return the new date object with the amount added
* @throws IllegalArgumentException if the date is null
*/
public static Date addMonths(Date date, int amount) {
return add(date, Calendar.MONTH, amount);
}

//-----------------------------------------------------------------------
/**
* Adds a number of weeks to a date returning a new object.
* The original date object is unchanged.
*
* @param date  the date, not null
* @param amount  the amount to add, may be negative
* @return the new date object with the amount added
* @throws IllegalArgumentException if the date is null
*/
public static Date addWeeks(Date date, int amount) {
return add(date, Calendar.WEEK_OF_YEAR, amount);
}

//-----------------------------------------------------------------------
/**
* Adds a number of days to a date returning a new object.
* The original date object is unchanged.
*
* @param date  the date, not null
* @param amount  the amount to add, may be negative
* @return the new date object with the amount added
* @throws IllegalArgumentException if the date is null
*/
public static Date addDays(Date date, int amount) {
return add(date, Calendar.DAY_OF_MONTH, amount);
}

//-----------------------------------------------------------------------
/**
* Adds a number of hours to a date returning a new object.
* The original date object is unchanged.
*
* @param date  the date, not null
* @param amount  the amount to add, may be negative
* @return the new date object with the amount added
* @throws IllegalArgumentException if the date is null
*/
public static Date addHours(Date date, int amount) {
return add(date, Calendar.HOUR_OF_DAY, amount);
}

//-----------------------------------------------------------------------
/**
* Adds a number of minutes to a date returning a new object.
* The original date object is unchanged.
*
* @param date  the date, not null
* @param amount  the amount to add, may be negative
* @return the new date object with the amount added
* @throws IllegalArgumentException if the date is null
*/
public static Date addMinutes(Date date, int amount) {
return add(date, Calendar.MINUTE, amount);
}

//-----------------------------------------------------------------------
/**
* Adds a number of seconds to a date returning a new object.
* The original date object is unchanged.
*
* @param date  the date, not null
* @param amount  the amount to add, may be negative
* @return the new date object with the amount added
* @throws IllegalArgumentException if the date is null
*/
public static Date addSeconds(Date date, int amount) {
return add(date, Calendar.SECOND, amount);
}

//-----------------------------------------------------------------------
/**
* Adds a number of milliseconds to a date returning a new object.
* The original date object is unchanged.
*
* @param date  the date, not null
* @param amount  the amount to add, may be negative
* @return the new date object with the amount added
* @throws IllegalArgumentException if the date is null
*/
public static Date addMilliseconds(Date date, int amount) {
return add(date, Calendar.MILLISECOND, amount);
}

/**
* Adds to a date returning a new object.
* The original date object is unchanged.
*
* @param date  the date, not null
* @param calendarField  the calendar field to add to
* @param amount  the amount to add, may be negative
* @return the new date object with the amount added
* @throws IllegalArgumentException if the date is null
* @deprecated Will become privately scoped in 3.0
*/
public static Date add(Date date, int calendarField, int amount) {
if (date == null) {
throw new IllegalArgumentException("The date must not be null");
}
Calendar c = Calendar.getInstance();
c.setTime(date);
c.add(calendarField, amount);
return c.getTime();
}
/**
* 获取当前时间延后day天后的时间
* @param datetime
* @param day
* @return
*/
public static String getDateAfterDay(String datetime,int day){
DateFormat df = new SimpleDateFormat(DATETIME_FORMAT);
try {
Calendar c = Calendar.getInstance();
c.setTime(df.parse(datetime));
c.add(Calendar.DATE, day);
Date d = c.getTime();
return df.format(d);
} catch (ParseException e) {
} catch (Exception e){
}
return null;
}

/**
* 获取当前时间延后day天后的时间
* @param datetime
* @param day
* @param fmt
* @return
*/
public static String getDateAfterDay(String datetime,int day,String fmt){
if (StringUtils.isEmpty(fmt)) {
fmt = DATETIME_FORMAT;
}
DateFormat df = new SimpleDateFormat(fmt);
try {
Calendar c = Calendar.getInstance();
c.setTime(df.parse(datetime));
c.add(Calendar.DATE, day);
Date d = c.getTime();
return df.format(d);
} catch (ParseException e) {
} catch (Exception e){
}
return null;
}

/**
* 获取当前时间延后day天后的时间
* @param datetime
* @param day
* @return
*/
public static String getDateAfterDay(Date datetime,int day){
DateFormat df = new SimpleDateFormat(DATETIME_FORMAT);
try {
Calendar c = Calendar.getInstance();
c.setTime(datetime);
c.add(Calendar.DATE, day);
Date d = c.getTime();
return df.format(d);
} catch (Exception e){
}
return null;
}

/**
* 获取当前时间延后day天后的时间
* @param datetime
* @param day
* @return
*/
public static Long getDateAfterDayReLong(Date datetime,int day) {
DateFormat df = new SimpleDateFormat(DATETIME_FORMAT);
try {
Calendar c = Calendar.getInstance();
c.setTime(datetime);
c.add(Calendar.DATE, day);
Date d = c.getTime();
return d.getTime();
} catch (Exception e) {
}
return null;
}
/**
* 获取当前时间延后hour小时后的时间
* @param datetime
* @return
*/
public static String getDateAfterHour(String datetime,int hour){
DateFormat df = new SimpleDateFormat(TIME_FORMAT);
try {
Calendar c = Calendar.getInstance();
c.setTime(df.parse(datetime));
c.add(Calendar.HOUR, hour);
Date d = c.getTime();
return df.format(d);
} catch (ParseException e) {
} catch (Exception e){
}
return null;
}
/**
* 将日期字符串替换成新的格式
* @param dateTime
* @param oldFmtStr
* @return
*/
public static String convertFmtDateTimeStr(String dateTime,String oldFmtStr,String newFmtStr){
if (StringUtils.isEmpty(oldFmtStr)) {
oldFmtStr = DATETIME_FORMAT;
}
if (StringUtils.isEmpty(newFmtStr)) {
newFmtStr = DATETIME_FORMAT1;
}
try {
DateFormat df = new SimpleDateFormat(oldFmtStr);
dateTime = new SimpleDateFormat(newFmtStr).format(df.parse(dateTime));
} catch (ParseException e) {
} catch (Exception e) {
}
return dateTime;
}

/**
* 获取日期
* @param date
* @return
*/
public static String getDate(Date date){
SimpleDateFormat format = new SimpleDateFormat(DATE_FORMAT);
return format.format(date);
}

public static Date getDateOfDateTime(Date date) throws Exception {
SimpleDateFormat format = new SimpleDateFormat(DATE_FORMAT);
String dateStr =  format.format(date);
return format.parse(dateStr);
}

public static Date getTimeOfDateTime(Date date) throws Exception {
SimpleDateFormat format = new SimpleDateFormat(TIME_FORMAT2);
String dateStr =  format.format(date);
return format.parse(dateStr);
}

public static String getTime(Date date){
SimpleDateFormat format = new SimpleDateFormat(TIME_FORMAT);
return format.format(date);
}

/**
* 计算传入日期时间跟当前日期时间比较
* 如果传入日期>当前日期=false
* @param dtStr
* @return
*/
public static boolean validDateTime(String dtStr){
SimpleDateFormat format = new SimpleDateFormat(DATETIME_FORMAT);
try {
if(!StringUtils.isBlank(dtStr)){
long reqDateTime = format.parse(dtStr).getTime();
long nowDateTime = new Date().getTime();
if((reqDateTime - nowDateTime) <= 0){
return false;
}
}
} catch (Exception e) {
return false;
}
return true;
}

//	public static void main(String[] args) {
//		Calendar now = Calendar.getInstance();
//		//一周第一天是否为星期天
//		boolean isFirstSunday = (now.getFirstDayOfWeek() == Calendar.SUNDAY);
//		//获取周几
//		int weekDay = now.get(Calendar.DAY_OF_WEEK);
//		System.out.println(weekDay);
//		//若一周第一天为星期天，则-1
//		if(isFirstSunday){
//		  weekDay = weekDay - 1;
//		  if(weekDay == 0){
//		    weekDay = 7;
//		  }
//		}
//		System.out.println(weekDay);
//		System.out.println(Calendar.THURSDAY);
//		System.out.println(Calendar.SATURDAY);
//	}
/**
* 验证时间格式是否合格
* @param timeStr 时间字符串
* @param timeFormart 需要验证的时间格式
* @return
*/
public static Date validDateStr(String timeStr, String timeFormart) {
Date date = new Date();
try {
// 指定日期格式为四位年/两位月份/两位日期，注意yyyy/MM/dd区分大小写；
DateFormat dateFormat = new SimpleDateFormat(timeFormart);
// 设置lenient为false.
// 否则SimpleDateFormat会比较宽松地验证日期，比如2007/02/29会被接受，并转换成2007/03/01
dateFormat.setLenient(false);
date = dateFormat.parse(timeStr);
} catch (Exception e) {
// 如果throw java.text.ParseException或者NullPointerException，就说明格式不对
}
return date;
}

/**
*
* 计算开始时间与结束时间的时间间隔的绝对值，单位为分
* @Function: com.idcq.idianmgr.quartz.HandleOrderStatusJob.computeIntervalTime
* @Description:
*
* @return
*
* @version:v1.0
* @author:shengzhipeng
* @date:2015年8月1日 下午2:29:00
*
* Modification History:
* Date            Author       Version     Description
* -----------------------------------------------------------------
* 2015年8月1日    shengzhipeng       v1.0.0         create
*/
public static int computeIntervalTime(Date startTime, Date endTime) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(startTime);
long start = calendar.getTimeInMillis();
calendar.setTime(endTime);
long end = calendar.getTimeInMillis();
return (int)  Math.abs((end - start) / 60000);
}

/**
* 某月第一天
* @return
*/
public static String getFirstDayInMonth(Date date) {
SimpleDateFormat
b49b
df = new SimpleDateFormat("yyyy-MM-dd");
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
Date theDate = calendar.getTime();

GregorianCalendar gcLast = (GregorianCalendar) Calendar.getInstance();
gcLast.setTime(theDate);
gcLast.set(Calendar.DAY_OF_MONTH, 1);
String day_first = df.format(gcLast.getTime());
StringBuffer str = new StringBuffer().append(day_first).append(" 00:00:00");
return str.toString();

}

/**
* 某月最后一天
* @return
*/
public static String getLastDayInMonth(Date date) {
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
calendar.set(Calendar.DAY_OF_MONTH, calendar.getActualMaximum(Calendar.DAY_OF_MONTH));
Date theDate = calendar.getTime();
String s = df.format(theDate);
StringBuffer str = new StringBuffer().append(s).append(" 23:59:59");
return str.toString();

}

public static String diyConvert(String format,long time) {
SimpleDateFormat sd = new SimpleDateFormat(format);
return sd.format(new Date(time));
}

/**
* 将日期时间字符串转换为Long
* @param format
* @param time
* @return
*/
public static Long formatToLong(String format,String time){
try {
SimpleDateFormat sd = new SimpleDateFormat(format);
return sd.parse(time).getTime();
}catch (Exception e){
LogUtil.e("时间转换成long异常： " + e.getMessage());
}
return null;
}

/**
* 获得指定日期的前N天
*
* @param  beforeDay  前N天
* @return
* @throws Exception
* @auhor dengjh
*/
public static String getSpecifiedDayBefore(Integer beforeDay){
Calendar calendar = Calendar.getInstance();//此时打印它获取的是系统当前时间
calendar.add(Calendar.DATE, -beforeDay);    //得到前一天
return new SimpleDateFormat("yyyy-MM-dd").format(calendar.getTime());
}

public static void main(String[] args) {
long d1 = getDateAfterDayReLong(new Date(), 7);
long d2 = getDateAfterDayReLong(new Date(), -7);
System.out.println(d1);
System.out.println(d2);
System.out.println(longToString(d1,DATETIME_FORMAT));
System.out.println(longToString(d2,DATETIME_FORMAT));
}

}