abc

最新推荐文章于 2024-02-07 15:37:13 发布

落叶的追求

最新推荐文章于 2024-02-07 15:37:13 发布

阅读量153

点赞数

分类专栏： Flex开发

本文链接：https://blog.csdn.net/u010679383/article/details/86462995

版权

Flex开发专栏收录该内容

6 篇文章 0 订阅

订阅专栏

/**

@(#) DateTimeUtil.java 1.0 2015年11月17日 {author name}
Copyright © 2015 fcuh.com. All Rights Reserved.
*/

package platform.common.utils;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.TimeZone;

import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.time.DateFormatUtils;
import org.apache.commons.lang3.time.DateUtils;

/**

日期时间工具类，进行各种日期时间格式的转化以及格式化
@version v1.0.0
*/
public class DateTimeUtil {
public final static int TIME_DAY_MILLISECOND = 86400000;
// /
// 定义时间日期显示格式
// /
private final static String DATE_FORMAT = “yyyy-MM-dd”;

private final static String DATE_FORMAT_CN = “yyyy年MM月dd日”;

private final static String TIME_FORMAT = “yyyy-MM-dd HH:mm:ss”;

private final static String TIME_FORMAT_2 = “yyyyMMddHHmmss”;

private final static String TIME_FORMAT_CN = “yyyy年MM月dd日 HH:mm:ss”;

private final static String MONTH_FORMAT = “yyyy-MM”;

private final static String DAY_FORMAT = “yyyyMMdd”;

public final static SimpleDateFormat sft = new SimpleDateFormat(DateTimeUtil.TIME_FORMAT_2);

// private final static String TIME_FORMAT_MILLI = “yyyy-MM-dd
// HH:mm:ss.SSS”;

/**
- 取得当前系统时间，返回java.util.Date类型
- @return java.util.Date
  */
  public static Date getUTCTime(){
  // 取得本地时间：
  Calendar cal = Calendar.getInstance();
  // 取得时间偏移量：
  int zoneOffset = cal.get(java.util.Calendar.ZONE_OFFSET);
  // 取得夏令时差：
  int dstOffset = cal.get(java.util.Calendar.DST_OFFSET);
  // 从本地时间里扣除这些差量，即可以取得UTC时间：
  cal.add(java.util.Calendar.MILLISECOND, -(zoneOffset + dstOffset));
  Date utcDate = cal.getTime();
  return utcDate;
  }
/**
- 当日0点utc时间
- @return
  /
  public static Date getToDayZeroTime(){
  // 取得本地时间：
  Calendar cal = Calendar.getInstance();
  cal.set(Calendar.HOUR_OF_DAY, 0);
  cal.set(Calendar.MINUTE, 0);
  cal.set(Calendar.SECOND, 0);
  // 取得时间偏移量：
  int zoneOffset = cal.get(java.util.Calendar.ZONE_OFFSET);
  // 取得夏令时差：
  int dstOffset = cal.get(java.util.Calendar.DST_OFFSET);
  // 从本地时间里扣除这些差量，即可以取得UTC时间：
  cal.add(java.util.Calendar.MILLISECOND, -(zoneOffset + dstOffset));
  Date utcDate = cal.getTime();
  return utcDate;
  }
  /*
- 接收一个date，返回java.util.Date类型
- @return java.util.Date
  */
  public static Date local2UtcTime(Date date){
  Calendar nowCal = Calendar.getInstance();
  nowCal.setTime(date);
  int zoneOffset = nowCal.get(java.util.Calendar.ZONE_OFFSET);
  int dstOffset = nowCal.get(java.util.Calendar.DST_OFFSET);
  nowCal.add(java.util.Calendar.MILLISECOND, -(zoneOffset + dstOffset));
  Date utcDate = nowCal.getTime();
  return utcDate;
  }
/** UTC时间类型的date 转为本地时间类型返回java.util.Date类型
*
- @param utcDate
- @return java.util.Date
  */
  public static Date utc2LcalTime(Date utcDate){
  // 取得本地时间：
  Calendar cal = Calendar.getInstance();
  // 取得时间偏移量：
  int zoneOffset = cal.get(java.util.Calendar.ZONE_OFFSET);
  // 取得夏令时差：
  int dstOffset = cal.get(java.util.Calendar.DST_OFFSET);
  cal.setTimeInMillis(utcDate.getTime());
  SimpleDateFormat foo = new SimpleDateFormat(“yyyy-MM-dd HH:mm:ss”);
  String time = foo.format(cal.getTime());
  // 从本地时间里扣除这些差量，即可以取得UTC时间：
  cal.add(java.util.Calendar.MILLISECOND, (zoneOffset + dstOffset));
  return cal.getTime();
  }
/**
- 取得当前系统时间，返回java.util.Date类型
- @see java.util.Date
- @return java.util.Date 返回服务器当前系统时间
  */
  public static java.util.Date getCurrDate() {
  return new java.util.Date();
  }
/**
- 取得当前系统时间戳
- @see java.sql.Timestamp
- @return java.sql.Timestamp 系统时间戳
  */
  public static java.sql.Timestamp getCurrTimestamp() {
  return new java.sql.Timestamp(System.currentTimeMillis());
  }
/**
- 将2007-12-1变成2007-12-01。将2007-9-1变为2007-09-01。
- @param date
- @return
  */
  public static String getFormatDateV2(String date) {
  if (date == null) {
  return null;
  }
  String[] datearr = StringUtils.split(date, “-”);
  if (datearr == null || datearr.length != 3) {
  return date;
  }
  
  StringBuffer ret = new StringBuffer();
  ret.append(datearr[0]);
  ret.append("-");
  ret.append(Integer.parseInt(datearr[1]) < 10 ? “0” + Integer.parseInt(datearr[1]) : datearr[1]);
  ret.append("-");
  ret.append(Integer.parseInt(datearr[2]) < 10 ? “0” + Integer.parseInt(datearr[2]) : datearr[2]);
  return ret.toString();
  }
/**
- 从时间串中获取小时数。
- @param timestr
- ```
       "2007-10-12 13:25:00"
```
- @return
  */
  public static int getHourFromTimeString(String timestr) {
  if (StringUtils.isBlank(timestr)) {
  return 0;
  }
  
  return Integer.parseInt(timestr.substring(timestr.length() - 8, timestr.length() - 6));
  }
/**
- 返回当前时间是上午还是下午
- @see Calendar.AM 0
- @see Calendar.PM 1
- @author lenghao
- @createTime 2008-8-2 下午04:22:07
- @return
  */
  public static Integer getCurrDateAMorPM() {
  Calendar calendar = Calendar.getInstance();
  return calendar.get(Calendar.AM_PM);
  }
/**
- 得到格式化后的日期，格式为yyyy-MM-dd，如2006-02-15
- @param currDate
- ```
       要格式化的日期
```
- @see #getFormatDate(java.util.Date, String)
- @return String 返回格式化后的日期，默认格式为为yyyy-MM-dd，如2006-02-15
  */
  public static String getFormatDate(java.util.Date currDate) {
  return getFormatDate(currDate, DATE_FORMAT);
  }
/**
- 得到格式化后的日期，格式为yyyy-MM-dd，如2006-02-15
- @param currDate
- ```
       要格式化的日期
```
- @see #getFormatDate(java.util.Date)
- @return Date 返回格式化后的日期，默认格式为为yyyy-MM-dd，如2006-02-15
  */
  public static Date getFormatDateToDate(java.util.Date currDate) {
  return getFormatDate(getFormatDate(currDate));
  }
/**
- 得到格式化后的日期，格式为yyyy年MM月dd日，如2006年02月15日
- @param currDate
- ```
       要格式化的日期
```
- @see #getFormatDate(java.util.Date, String)
- @return String 返回格式化后的日期，默认格式为yyyy年MM月dd日，如2006年02月15日
  */
  public static String getFormatDate_CN(java.util.Date currDate) {
  return getFormatDate(currDate, DATE_FORMAT_CN);
  }
/**
- 得到格式化后的日期，格式为yyyy年MM月dd日，如2006年02月15日
- @param currDate
- ```
       要格式化的日期
```
- @see #getFormatDate_CN(String)
- @return Date 返回格式化后的日期，默认格式为yyyy年MM月dd日，如2006年02月15日
  */
  public static Date getFormatDateToDate_CN(java.util.Date currDate) {
  return getFormatDate_CN(getFormatDate_CN(currDate));
  }
/**
- 得到格式化后的日期，格式为yyyy-MM-dd，如2006-02-15
- @param currDate
- ```
       要格式化的日期
```
- @see #getFormatDate(String, String)
- @return Date 返回格式化后的日期，默认格式为yyyy-MM-dd，如2006-02-15
  */
  public static Date getFormatDate(String currDate) {
  return getFormatDate(currDate, DATE_FORMAT);
  }
/**
- 得到格式化后的日期，格式为yyyy年MM月dd日，如2006年02月15日
- @param currDate
- ```
       要格式化的日期
```
- @see #getFormatDate(String, String)
- @return 返回格式化后的日期，默认格式为yyyy年MM月dd日，如2006年02月15日
  */
  public static Date getFormatDate_CN(String currDate) {
  return getFormatDate(currDate, DATE_FORMAT_CN);
  }
/**
- 根据格式得到格式化后的日期
- @param currDate
- ```
       要格式化的日期
```
- @param format
- ```
       日期格式，如yyyy-MM-dd
```
- @see java.text.SimpleDateFormat#format(java.util.Date)
- @return String 返回格式化后的日期，格式由参数format
- ```
    定义，如yyyy-MM-dd，如2006-02-15
```
*/
public static String getFormatDate(java.util.Date currDate, String format) {
if (currDate == null) {
return “”;
}
SimpleDateFormat dtFormatdB = null;
try {
dtFormatdB = new SimpleDateFormat(format);
return dtFormatdB.format(currDate);
} catch (Exception e) {
dtFormatdB = new SimpleDateFormat(DATE_FORMAT);
try {
return dtFormatdB.format(currDate);
} catch (Exception ex) {
}
}
return null;
}

/**
- 得到格式化后的时间，格式为yyyy-MM-dd HH:mm:ss，如2006-02-15 15:23:45
- @param currDate
- ```
       要格式化的时间
```
- @see #getFormatDateTime(java.util.Date, String)
- @return String 返回格式化后的时间，默认格式为yyyy-MM-dd HH:mm:ss，如2006-02-15 15:23:45
  */
  public static String getFormatDateTime(java.util.Date currDate) {
  return getFormatDateTime(currDate, TIME_FORMAT);
  }
/**
- 得到格式化后的时间，格式为yyyy-MM-dd HH:mm:ss，如2006-02-15 15:23:45
- @param currDate
- ```
       要格式环的时间
```
- @see #getFormatDateTime(String)
- @return Date 返回格式化后的时间，默认格式为yyyy-MM-dd HH:mm:ss，如2006-02-15 15:23:45
  */
  public static Date getFormatDateTimeToTime(java.util.Date currDate) {
  return getFormatDateTime(getFormatDateTime(currDate));
  }
/**
- 得到格式化后的时间，格式为yyyy-MM-dd HH:mm:ss，如2006-02-15 15:23:45
- @param currDate
- ```
       要格式化的时间
```
- @see #getFormatDateTime(String, String)
- @return Date 返回格式化后的时间，默认格式为yyyy-MM-dd HH:mm:ss，如2006-02-15 15:23:45
  */
  public static Date getFormatDateTime(String currDate) {
  return getFormatDateTime(currDate, TIME_FORMAT);
  }
/**
- 得到格式化后的时间，格式为yyyy年MM月dd日 HH:mm:ss，如2006年02月15日 15:23:45
- @param currDate
- ```
       要格式化的时间
```
- @see #getFormatDateTime(java.util.Date, String)
- @return String 返回格式化后的时间，默认格式为yyyy年MM月dd日 HH:mm:ss，如2006年02月15日 15:23:45
  */
  public static String getFormatDateTime_CN(java.util.Date currDate) {
  return getFormatDateTime(currDate, TIME_FORMAT_CN);
  }
/**
- 得到格式化后的时间，格式为yyyy年MM月dd日 HH:mm:ss，如2006年02月15日 15:23:45
- @param currDate
- ```
       要格式化的时间
```
- @see #getFormatDateTime_CN(String)
- @return Date 返回格式化后的时间，默认格式为yyyy年MM月dd日 HH:mm:ss，如2006年02月15日 15:23:45
  */
  public static Date getFormatDateTimeToTime_CN(java.util.Date currDate) {
  return getFormatDateTime_CN(getFormatDateTime_CN(currDate));
  }
/**
- 得到格式化后的时间，格式为yyyy年MM月dd日 HH:mm:ss，如2006年02月15日 15:23:45
- @param currDate
- ```
       要格式化的时间
```
- @see #getFormatDateTime(String, String)
- @return Date 返回格式化后的时间，默认格式为yyyy年MM月dd日 HH:mm:ss，如2006年02月15日 15:23:45
  */
  public static Date getFormatDateTime_CN(String currDate) {
  return getFormatDateTime(currDate, TIME_FORMAT_CN);
  }
/**
- 根据格式得到格式化后的时间
- @param currDate
- ```
       要格式化的时间
```
- @param format
- ```
       时间格式，如yyyy-MM-dd HH:mm:ss
```
- @see java.text.SimpleDateFormat#format(java.util.Date)
- @return String 返回格式化后的时间，格式由参数format定义，如yyyy-MM-dd HH:mm:ss
  */
  public static String getFormatDateTime(java.util.Date currDate, String format) {
  if (currDate == null) {
  return “”;
  }
  SimpleDateFormat dtFormatdB = null;
  try {
  dtFormatdB = new SimpleDateFormat(format);
  return dtFormatdB.format(currDate);
  } catch (Exception e) {
  dtFormatdB = new SimpleDateFormat(TIME_FORMAT);
  try {
  return dtFormatdB.format(currDate);
  } catch (Exception ex) {
  }
  }
  return “”;
  }
/**
- 根据格式得到格式化后的日期
- @param currDate
- ```
       要格式化的日期
```
- @param format
- ```
       日期格式，如yyyy-MM-dd
```
- @see java.text.SimpleDateFormat#parse(java.lang.String)
- @return Date 返回格式化后的日期，格式由参数format
- ```
    定义，如yyyy-MM-dd，如2006-02-15
```
*/
public static Date getFormatDate(String currDate, String format) {
if (currDate == null) {
return null;
}
SimpleDateFormat dtFormatdB = null;
try {
dtFormatdB = new SimpleDateFormat(format);
return dtFormatdB.parse(currDate);
} catch (Exception e) {
dtFormatdB = new SimpleDateFormat(DATE_FORMAT);
try {
return dtFormatdB.parse(currDate);
} catch (Exception ex) {
}
}
return null;
}

/**
- 根据格式得到格式化后的时间
- @param currDate
- ```
       要格式化的时间
```
- @param format
- ```
       时间格式，如yyyy-MM-dd HH:mm:ss
```
- @see java.text.SimpleDateFormat#parse(java.lang.String)
- @return Date 返回格式化后的时间，格式由参数format定义，如yyyy-MM-dd HH:mm:ss
  */
  public static Date getFormatDateTime(String currDate, String format) {
  if (currDate == null) {
  return null;
  }
  SimpleDateFormat dtFormatdB = null;
  try {
  dtFormatdB = new SimpleDateFormat(format);
  return dtFormatdB.parse(currDate);
  } catch (Exception e) {
  dtFormatdB = new SimpleDateFormat(TIME_FORMAT);
  try {
  return dtFormatdB.parse(currDate);
  } catch (Exception ex) {
  }
  }
  return null;
  }
/**
- 得到本日的上月时间如果当日为2007-9-1,那么获得2007-8-1
  */
  public static String getDateBeforeMonth() {
  Calendar cal = Calendar.getInstance();
  cal.add(Calendar.MONTH, -1);
  return getFormatDate(cal.getTime(), DATE_FORMAT);
  }
/**
- 得到本日的前几个月时间如果number=2当日为2007-9-1,那么获得2007-7-1
  */
  public static String getDateBeforeMonth(int number) {
  Calendar cal = Calendar.getInstance();
  cal.add(Calendar.MONTH, -number);
  return getFormatDate(cal.getTime(), DATE_FORMAT);
  }
public static long getDaysOfDates(Date first, Date second) {
Date d1 = getFormatDateTime(getFormatDate(first), DATE_FORMAT);
Date d2 = getFormatDateTime(getFormatDate(second), DATE_FORMAT);
```
 long mils = d1.getTime() - d2.getTime();

 return mils / (TIME_DAY_MILLISECOND);
```
}

/**
- 获得两个Date型日期之间相差的天数（第2个减第1个）
- @param Date
- ```
       first, Date second
```
- @return int 相差的天数
  */
  public static int getDaysBetweenDates(Date first, Date second) {
  Date d1 = getFormatDateTime(getFormatDate(first), DATE_FORMAT);
  Date d2 = getFormatDateTime(getFormatDate(second), DATE_FORMAT);
  
  Long mils = (d2.getTime() - d1.getTime()) / (TIME_DAY_MILLISECOND);
  
  return mils.intValue();
  }
/**
- 获得两个String型日期之间相差的天数（第2个减第1个）
- @param String
- ```
       first, String second
```
- @return int 相差的天数
  */
  public static int getDaysBetweenDates(String first, String second) {
  Date d1 = getFormatDateTime(first, DATE_FORMAT);
  Date d2 = getFormatDateTime(second, DATE_FORMAT);
  
  Long mils = (d2.getTime() - d1.getTime()) / (TIME_DAY_MILLISECOND);
  
  return mils.intValue();
  }
/**
- @author lenghao
- @createTime 2008-8-5 下午01:57:09
- @param first
- @param second
- @return 获取两个Date之间的天数的列表
  */
  public static List getDaysListBetweenDates(Date first, Date second) {
  List dateList = new ArrayList();
  Date d1 = getFormatDateTime(getFormatDate(first), DATE_FORMAT);
  Date d2 = getFormatDateTime(getFormatDate(second), DATE_FORMAT);
  if (d1.compareTo(d2) > 0) {
  return dateList;
  }
  do {
  dateList.add(d1);
  d1 = getDateBeforeOrAfter(d1, 1);
  } while (d1.compareTo(d2) <= 0);
  return dateList;
  }
/**
*/
public static String getDateBeforeDay() {
Calendar cal = Calendar.getInstance();
cal.add(Calendar.DAY_OF_YEAR, -1);
return getFormatDate(cal.getTime(), DATE_FORMAT);
}

/**
- 得到格式化后的当前系统日期，格式为yyyy-MM-dd，如2006-02-15
- @see #getFormatDate(java.util.Date)
- @return String 返回格式化后的当前服务器系统日期，格式为yyyy-MM-dd，如2006-02-15
  */
  public static String getCurrDateStr() {
  return getFormatDate(getCurrDate());
  }
/**
- 得到格式化后的当前系统时间，格式为yyyy-MM-dd HH:mm:ss，如2006-02-15 15:23:45
- @see #getFormatDateTime(java.util.Date)
- @return String 返回格式化后的当前服务器系统时间，格式为yyyy-MM-dd HH:mm:ss，如2006-02-15
- ```
    15:23:45
```
*/
public static String getCurrDateTimeStr() {
return getFormatDateTime(getCurrDate());
}

/**
- 得到格式化后的当前系统日期，格式为yyyy年MM月dd日，如2006年02月15日
- @see #getFormatDate(java.util.Date, String)
- @return String 返回当前服务器系统日期，格式为yyyy年MM月dd日，如2006年02月15日
  */
  public static String getCurrDateStr_CN() {
  return getFormatDate(getCurrDate(), DATE_FORMAT_CN);
  }
/**
- 得到格式化后的当前系统时间，格式为yyyy年MM月dd日 HH:mm:ss，如2006年02月15日 15:23:45
- @see #getFormatDateTime(java.util.Date, String)
- @return String 返回格式化后的当前服务器系统时间，格式为yyyy年MM月dd日 HH:mm:ss，如2006年02月15日
- ```
    15:23:45
```
*/
public static String getCurrDateTimeStr_CN() {
return getFormatDateTime(getCurrDate(), TIME_FORMAT_CN);
}

/**
- 得到系统当前日期的前或者后几天
- @param iDate
- ```
       如果要获得前几天日期，该参数为负数； 如果要获得后几天日期，该参数为正数
```
- @see java.util.Calendar#add(int, int)
- @return Date 返回系统当前日期的前或者后几天
  */
  public static Date getDateBeforeOrAfter(int iDate) {
  Calendar cal = Calendar.getInstance();
  cal.add(Calendar.DAY_OF_MONTH, iDate);
  return cal.getTime();
  }
/**
- 得到日期的前或者后几天
- @param iDate
- ```
       如果要获得前几天日期，该参数为负数； 如果要获得后几天日期，该参数为正数
```
- @see java.util.Calendar#add(int, int)
- @return Date 返回参数curDate定义日期的前或者后几天
  */
  public static Date getDateBeforeOrAfter(Date curDate, int iDate) {
  Calendar cal = Calendar.getInstance();
  cal.setTime(curDate);
  cal.add(Calendar.DAY_OF_MONTH, iDate);
  return cal.getTime();
  }
/**
- 得到格式化后的月份，格式为yyyy-MM，如2006-02
- @param currDate
- ```
       要格式化的日期
```
- @see #getFormatDate(java.util.Date, String)
- @return String 返回格式化后的月份，格式为yyyy-MM，如2006-02
  */
  public static String getFormatMonth(java.util.Date currDate) {
  return getFormatDate(currDate, MONTH_FORMAT);
  }
/**
- 得到格式化后的日，格式为yyyyMMdd，如20060210
- @param currDate
- ```
       要格式化的日期
```
- @see #getFormatDate(java.util.Date, String)
- @return String 返回格式化后的日，格式为yyyyMMdd，如20060210
  */
  public static String getFormatDay(java.util.Date currDate) {
  return getFormatDate(currDate, DAY_FORMAT);
  }
/**
- 得到格式化后的当月第一天，格式为yyyy-MM-dd，如2006-02-01
- @param currDate
- ```
       要格式化的日期
```
- @see java.util.Calendar#getMinimum(int)
- @see #getFormatDate(java.util.Date, String)
- @return String 返回格式化后的当月第一天，格式为yyyy-MM-dd，如2006-02-01
  */
  public static String getFirstDayOfMonth() {
  Calendar cal = Calendar.getInstance();
  int firstDay = cal.getMinimum(Calendar.DAY_OF_MONTH);
  cal.set(Calendar.DAY_OF_MONTH, firstDay);
  return getFormatDate(cal.getTime(), DATE_FORMAT);
  }
/**
- 得到格式化后的下月第一天，格式为yyyy-MM-dd，如2006-02-01
- @param currDate
- ```
       要格式化的日期
```
- @see java.util.Calendar#getMinimum(int)
- @see #getFormatDate(java.util.Date, String)
- @return String 返回格式化后的下月第一天，格式为yyyy-MM-dd，如2006-02-01
- ```
    public static String getFirstDayOfNextMonth() { Calendar cal =
```
- ```
    Calendar.getInstance(); cal.add(Calendar.MONTH, +1); int firstDay
```
- ```
    = cal.getMinimum(Calendar.DAY_OF_MONTH);
```
- ```
    cal.set(Calendar.DAY_OF_MONTH, firstDay); return
```
- ```
    getFormatDate(cal.getTime(), DATE_FORMAT); }
```
- ```
    /** 得到格式化后的当月第一天，格式为yyyy-MM-dd，如2006-02-01
```
- @param currDate
- ```
       要格式化的日期
```
- @see java.util.Calendar#getMinimum(int)
- @see #getFormatDate(java.util.Date, String)
- @return String 返回格式化后的当月第一天，格式为yyyy-MM-dd，如2006-02-01
  */
  public static String getFirstDayOfMonth(Date currDate) {
  Calendar cal = Calendar.getInstance();
  cal.setTime(currDate);
  int firstDay = cal.getMinimum(Calendar.DAY_OF_MONTH);
  cal.set(Calendar.DAY_OF_MONTH, firstDay);
  return getFormatDate(cal.getTime(), DATE_FORMAT);
  }
/**
- 得到格式化后的当月最后一天，格式为yyyy-MM-dd，如2006-02-28
- @param currDate
- ```
       要格式化的日期
```
- @see java.util.Calendar#getMinimum(int)
- @see #getFormatDate(java.util.Date, String)
- @return String 返回格式化后的当月最后一天，格式为yyyy-MM-dd，如2006-02-28
  */
  public static String getLastDayOfMonth(Date currDate) {
  Calendar cal = Calendar.getInstance();
  cal.setTime(currDate);
  int lastDay = cal.getActualMaximum(Calendar.DAY_OF_MONTH);
  cal.set(Calendar.DAY_OF_MONTH, lastDay);
  return getFormatDate(cal.getTime(), DATE_FORMAT);
  }
/**
- 得到格式化后的当月最后一天，格式为yyyy-MM-dd，如2006-02-28
- @param currDate
- ```
       要格式化的日期
```
- @see java.util.Calendar#getMinimum(int)
- @see #getFormatDate(java.util.Date, String)
- @return String 返回格式化后的当月最后一天，格式为yyyy-MM-dd，如2006-02-28
  */
  public static String getLastDayOfMonth() {
  Calendar cal = Calendar.getInstance();
  int lastDay = cal.getActualMaximum(Calendar.DAY_OF_MONTH);
  cal.set(Calendar.DAY_OF_MONTH, lastDay);
  return getFormatDate(cal.getTime(), DATE_FORMAT);
  }
/**
- 得到日期的前或者后几小时
- @param iHour
- ```
       如果要获得前几小时日期，该参数为负数； 如果要获得后几小时日期，该参数为正数
```
- @see java.util.Calendar#add(int, int)
- @return Date 返回参数curDate定义日期的前或者后几小时
  */
  public static Date getDateBeforeOrAfterHours(Date curDate, int iHour) {
  Calendar cal = Calendar.getInstance();
  cal.setTime(curDate);
  cal.add(Calendar.HOUR_OF_DAY, iHour);
  return cal.getTime();
  }
/**
- 判断日期是否在当前周内
- @param curDate
- @param compareDate
- @return
  */
  public static boolean isSameWeek(Date curDate, Date compareDate) {
  if (curDate == null || compareDate == null) {
  return false;
  }
  
  Calendar calSun = Calendar.getInstance();
  calSun.setTime(getFormatDateToDate(curDate));
  calSun.set(Calendar.DAY_OF_WEEK, 1);
  
  Calendar calNext = Calendar.getInstance();
  calNext.setTime(calSun.getTime());
  calNext.add(Calendar.DATE, 7);
  
  Calendar calComp = Calendar.getInstance();
  calComp.setTime(compareDate);
  if (calComp.after(calSun) && calComp.before(calNext)) {
  return true;
  } else {
  return false;
  }
  }
/**
- 时间查询时,结束时间的 23:59:59
  */
  public static String addDateEndfix(String datestring) {
  if ((datestring == null) || datestring.equals("")) {
  return null;
  }
  return datestring + " 23:59:59";
  }
/**
- 返回格式化的日期
- @param datePre
- ```
       格式"yyyy-MM-dd 23:59:59";
```
- @return
  */
  public static Date getFormatDateEndfix(String dateStr) {
  dateStr = addDateEndfix(dateStr);
  return getFormatDateTime(dateStr);
  }
/**
- 返回格式化的日期
- @param datePre
- ```
       格式"yyyy-MM-dd HH:mm:ss";
```
- @return
  */
  public static Date formatEndTime(String datePre) {
  if (datePre == null)
  return null;
  String dateStr = addDateEndfix(datePre);
  return getFormatDateTime(dateStr);
  }
// date1加上compday天数以后的日期与当前时间比较，如果大于当前时间返回true，否则false
public static Boolean compareDay(Date date1, int compday) {
if (date1 == null)
return false;
Date dateComp = getDateBeforeOrAfter(date1, compday);
Date nowdate = new Date();
if (dateComp.after(nowdate))
return true;
else
return false;
}

/**
- 进行时段格式转换，对于输入的48位的01串，将进行如下操作：
- 1.先将输入中每个0变成两个0，每个1变成2个1，形成一个96位的二进制串。
2.将上述的96位的二进制串分成3组，每组32位。
3.将每个32位的二进制串转换成一个8位的16进制串。
4.将3个8位的16进制串合并成一个串，中间以","分割。
@param timespan

       一个48位的二进制串，如：

       "011111111011111111111111111111111111111111111110"

@return 一个16进制串，每位间以",“分割。如：“3fffcfff,ffffffff,fffffffc”
*/
public static String convertBinaryTime2Hex(String timespan) {
if (timespan == null || timespan.equals(”")) {
return “”;
}

String ret = “”;
String tmp = “”;
for (int i = 0; i < timespan.length(); i++) {
tmp += timespan.charAt(i);
tmp += timespan.charAt(i);
// tmp += i;
if ((i + 1) % 16 == 0) {
if (!ret.equals("")) {
ret += “,”;
}
Long t = Long.parseLong(tmp, 2);
String hexStr = Long.toHexString(t);
if (hexStr.length() < 8) {
int length = hexStr.length();
for (int n = 0; n < 8 - length; n++) {
hexStr = “0” + hexStr;
}
}
```
 	ret += hexStr;
 	tmp = "";
 }
```
}

return ret;
}

/**

进行时段格式转换，将输入的26位的2进制串转换成48位的二进制串。
@param timespan

       一个16进制串，每位间以","分割。如："3fffcfff,ffffffff,fffffffc"

@return 一个48位的二进制串，如：“011111111011111111111111111111111111111111111110”
*/
public static String convertHexTime2Binary(String timespan) {
if (timespan == null || timespan.equals("")) {
return “”;
}

String tmp = “”;
String ret = “”;
String[] strArr = timespan.split(",");
for (int i = 0; i < strArr.length; i++) {
String binStr = Long.toBinaryString(Long.parseLong(strArr[i], 16));
if (binStr.length() < 32) {
int length = binStr.length();
for (int n = 0; n < 32 - length; n++) {
binStr = “0” + binStr;
}
}
tmp += binStr;
}

for (int i = 0; i < 48; i++) {
ret += tmp.charAt(i * 2);
}

return ret;
}

/**

进行时段格式转换，将输入的32位的10进制串转换成48位的二进制串。
@param timespan

       一个16进制串，每位间以","分割。如："1234567890,1234567890,1234567890c"

@return 一个48位的二进制串，如：“011111111011111111111111111111111111111111111110”
*/
public static String convertDecTime2Binary(String timespan) {
if (timespan == null || timespan.equals("")) {
return “”;
}

String tmp = “”;
String ret = “”;
String[] strArr = timespan.split(",");
for (int i = 0; i < strArr.length; i++) {
String binStr = Long.toBinaryString(Long.parseLong(strArr[i], 10));
if (binStr.length() < 32) {
int length = binStr.length();
for (int n = 0; n < 32 - length; n++) {
binStr = “0” + binStr;
}
}
tmp += binStr;
}

for (int i = 0; i < 48; i++) {
ret += tmp.charAt(i * 2);
}

return ret;
}

/**

进行时段格式转换，对于输入的48位的01串，将进行如下操作：
1.先将输入中每个0变成两个0，每个1变成2个1，形成一个96位的二进制串。
2.将上述的96位的二进制串分成3组，每组32位。
3.将每个32位的二进制串转换成一个10位的10进制串。
4.将3个8位的16进制串合并成一个串，中间以","分割。
@param timespan

       一个48位的二进制串，如：

       "011111111011111111111111111111111111111111111110"

@return 一个16进制串，每位间以",“分割。如：“1234567890,1234567890,1234567890”
*/
public static String convertBinaryTime2Dec(String timespan) {
if (timespan == null || timespan.equals(”")) {
return “”;
}

String ret = “”;
String tmp = “”;
for (int i = 0; i < timespan.length(); i++) {
tmp += timespan.charAt(i);
tmp += timespan.charAt(i);
// tmp += i;
if ((i + 1) % 16 == 0) {
if (!ret.equals("")) {
ret += “,”;
}
Long t = Long.parseLong(tmp, 2);
String decStr = Long.toString(t);
if (decStr.length() < 10) {
int length = decStr.length();
for (int n = 0; n < 10 - length; n++) {
decStr = “0” + decStr;
}
}
```
 	ret += decStr;
 	tmp = "";
 }
```
}

return ret;
}

/**

计算指定日期+addMonth月+15号返回格式"2008-02-15"
@param date
@param addMonth
@param monthDay
@return
*/
public static String genericSpecdate(Date date, int addMonth, int monthDay) {
Calendar cal = Calendar.getInstance();
cal.setTime(date);
cal.add(Calendar.MONTH, addMonth);
cal.set(Calendar.DAY_OF_MONTH, monthDay);
return getFormatDate(cal.getTime(), DATE_FORMAT);
}

/**

获得以今天为单位若干天以前或以后的日期的标准格式"Wed Feb 20 00:00:00 CST 2008"，是0点0分0秒。
@param idx
@return
*/
public static Date getDateBeforeOrAfterV2(int idx) {
return getDateBeforeOrAfter(getFormatDateToDate(getCurrDate()), idx);
}

/**

获得给定时间若干秒以前或以后的日期的标准格式。
@param curDate
@param seconds
@return curDate
*/
public static Date getSpecifiedDateTimeBySeconds(Date curDate, int seconds) {
long time = (curDate.getTime() / 1000) + seconds;
curDate.setTime(time * 1000);
return curDate;
}

/**

获得给定日期当天23点59分59秒的标准格式。
@param curDate
@return curDate
*/
public static Date getSpecifiedDateTime_235959(Date curDate) {
return getSpecifiedDateTimeBySeconds(getFormatDateToDate(curDate), 24 * 60 * 60 - 1);
}

public static String getSpecifiedDateTime_month(Date curDate) {
return getFormatDateTime(curDate, “MM.dd”);
}

// change by bbq
public static final String dtSimple = “yyyy-MM-dd”;

private static final Object[] Date = null;

/**

alahan add 20050825 获取传入时间相差的日期
@param dt
```
       传入日期，可以为空
```
@param diff

       需要获取相隔diff天的日期 如果为正则取以后的日期，否则时间往前推

@return
*/
public static String getDiffStringDate(Date dt, int diff) {
Calendar ca = Calendar.getInstance();

if (dt == null) {
ca.setTime(new Date());
} else {
ca.setTime(dt);
}

ca.add(Calendar.DATE, diff);
return dtSimpleFormat(ca.getTime());
}

/**

yyyy-MM-dd
@param date
@return
*/
public static final String dtSimpleFormat(Date date) {
if (date == null) {
return “”;
}

return getFormat(dtSimple).format(date);
}

// SimpleDateFormat(“yyyy-MM-dd HH:mm”);
private static final DateFormat getFormat(String format) {
return new SimpleDateFormat(format);
}

/**

取得多个日期中间隔的最大天数
@author Alvise
@param startDateAndEndDate
@return
*/
public static int maxContinuousDays(Date[][] startDateAndEndDate) {
// 冒泡排序
for (int i = 0; i < startDateAndEndDate.length - 1; i++) {
for (int j = 0; j < startDateAndEndDate.length - i - 1; j++) {
if (DateTimeUtil.getDaysBetweenDates(startDateAndEndDate[j + 1][0], startDateAndEndDate[j][0]) > 0) {
Date[] tempDate = startDateAndEndDate[j];
startDateAndEndDate[j] = startDateAndEndDate[j + 1];
startDateAndEndDate[j + 1] = tempDate;
}
}
}

// for (int i = 0; i < startDateAndEndDate.length; i++) {
// if (startDateAndEndDate[i][0] == null)
// break;
// System.out.println(DateTimeUtil.getFormatDate(
// startDateAndEndDate[i][0]) + “,”
// + DateTimeUtil.getFormatDate(startDateAndEndDate[i][1]));
// }
//
// System.out.println(
// “===========================================”);

// 合并连续的时间段
int j = 0;
Date[][] startDateAndEndDateNew = new Date[startDateAndEndDate.length][2];
for (int i = 0; i < startDateAndEndDateNew.length; i++) {
if (j >= startDateAndEndDate.length)
break;
```
 startDateAndEndDateNew[i] = startDateAndEndDate[j];
 j++;
 while (j < startDateAndEndDate.length) {
 	if (DateTimeUtil.getDaysBetweenDates(startDateAndEndDateNew[i][1], startDateAndEndDate[j][0]) > 0) {
 		break;
 	} else if (DateTimeUtil.getDaysBetweenDates(startDateAndEndDateNew[i][1],
 			startDateAndEndDate[j][1]) > 0) {
 		startDateAndEndDateNew[i][1] = startDateAndEndDate[j][1];
 		j++;
 	} else if (DateTimeUtil.getDaysBetweenDates(startDateAndEndDateNew[i][1],
 			startDateAndEndDate[j][1]) <= 0) {
 		j++;
 	}

 }
```
}

// for (int i = 0; i < startDateAndEndDateNew.length; i++) {
// if (startDateAndEndDateNew[i][0] == null)
// break;
// System.out.println(DateTimeUtil.getFormatDate(startDateAndEndDateNew[i][0])
// + “,”
// + DateTimeUtil.getFormatDate(startDateAndEndDateNew[i][1]));
// }

// 选择法排序
int maxDays = 0;
for (int i = 0; i < startDateAndEndDateNew.length - 1; i++) {
Date curEndDate = startDateAndEndDateNew[i][1];
Date nextStartDate = startDateAndEndDateNew[i + 1][0];
if (curEndDate == null || nextStartDate == null) {
break;
}
```
 int temDays = DateTimeUtil.getDaysBetweenDates(curEndDate, nextStartDate);
 if (temDays > maxDays) {
 	maxDays = temDays;
 }
```
}
return maxDays;
}

/**

取得多个日期中间隔的最大天数,这里的参数是用 ",“和”;"分割的字符字符串例如 “2008-08-03,2008-08-04;”
@author Alvise
@param startDateAndEndDate
@return
*/
public static int maxContinuousDays(String dateStr) {
String[] seDate = dateStr.split(";");
Date[][] startDateAndEndDate = new Date[seDate.length][2];

for (int i = 0; i < seDate.length; i++) {
String[] tempDate = seDate[i].split(",");
startDateAndEndDate[i][0] = DateTimeUtil.getFormatDate(tempDate[0]);
startDateAndEndDate[i][1] = DateTimeUtil.getFormatDate(tempDate[1]);
}

return maxContinuousDays(startDateAndEndDate);

}

/**

判断时间段1和时间段2是否有交集
@param begintimeOne
@param endtimeOne
@param begintimeTwo
@param endtimeTwo
@return true:有交集,false:没有交集
*/
public static boolean isConfilct(String begintimeOne, String endtimeOne, String begintimeTwo, String endtimeTwo) {
Date beginOne = getFormatDate(begintimeOne);
Date endOne = getFormatDate(endtimeOne);
Date beginTwo = getFormatDate(begintimeTwo);
Date endTwo = getFormatDate(endtimeTwo);
if ((beginOne.compareTo(beginTwo) <= 0 && endOne.compareTo(beginTwo) >= 0)
|| (beginOne.compareTo(endTwo) <= 0 && endOne.compareTo(endTwo) >= 0)
|| (beginTwo.compareTo(beginOne) <= 0 && endTwo.compareTo(beginOne) >= 0)
|| (beginTwo.compareTo(endOne) <= 0 && endTwo.compareTo(endOne) >= 0)) {
return true;
}
return false;
}

/**

取得最早可购买时间
@param busytimes

       被购买时间,格式为2008-08-06,2008-08-06;2008-08-9,2008-08-12;2008-08-14

       ,2008-08-22;2008-09-04,2008-09-04

@param days
```
       购买时长
```
@return 最高可购买时间
*/
public static String getCansellTime(String busytimes, int days) {
Map<String, Integer> dayMap = new HashMap<String, Integer>();
String[] busytimeArr = StringUtils.split(busytimes, “;”);
for (int i = 0; i < busytimeArr.length; i++) {
String[] time = StringUtils.split(busytimeArr[i], “,”);
Date d1 = getFormatDateTime(time[0], DATE_FORMAT);
Date d2 = getFormatDateTime(time[1], DATE_FORMAT);
while (d1.compareTo(d2) <= 0) {
dayMap.put(getFormatDate(d1), null);
d1 = getDateBeforeOrAfter(d1, 1);
}
}

Date lastDate = getFormatDateTime(getFormatDate(getDateBeforeOrAfter(29)), DATE_FORMAT);
Date beginDate = getFormatDateTime(getFormatDate(getDateBeforeOrAfter(2)), DATE_FORMAT);
Date endDate = getDateBeforeOrAfter(beginDate, days - 1);

while (beginDate.compareTo(lastDate) <= 0) {
boolean conflict = false;
List daysList = getDaysListBetweenDates(beginDate, endDate);
for (Date d : daysList) {
if (dayMap.containsKey(getFormatDate(d))) {
conflict = true;
break;
}
}
if (!conflict) {
break;
}
beginDate = getDateBeforeOrAfter(beginDate, 1);
endDate = getDateBeforeOrAfter(beginDate, days - 1);
}
return getFormatDate(beginDate);
}

/**

如果当前时间是UTC时间，则返回GMT+8时间，否则返回当前时区时间
@return
*/
public static Calendar getCalendarForChina() {
Calendar cal = Calendar.getInstance();
// 取得时间偏移量：
int zoneOffset = cal.get(java.util.Calendar.ZONE_OFFSET);
// 取得夏令时差：
int dstOffset = cal.get(java.util.Calendar.DST_OFFSET);
long s = zoneOffset + dstOffset;
long zone = (((s/1000)/60)/60);
if(zone == 0){
cal.add(Calendar.HOUR_OF_DAY, 8);
}
return cal;
}