对两个日期之间的操作

package com.iscc.servicesupport.analysis.util;

import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;

 

public class AccountDateUtil {
 private static transient int gregorianCutoverYear = 1582;

 /** 闰年中每月天数 */
 private static final int[] DAYS_P_MONTH_LY = { 31, 29, 31, 30, 31, 30, 31,
   31, 30, 31, 30, 31 };

 /** 非闰年中每月天数 */
 private static final int[] DAYS_P_MONTH_CY = { 31, 28, 31, 30, 31, 30, 31,
   31, 30, 31, 30, 31 };

 /** 代表数组里的年、月、日 */
 private static final int Y = 0, M = 1, D = 2, H = 3;

 /** 过滤掉17点到08点的数据 */
 private static final String[] DELETE_NO_NEED_HOUR = { "17", "18", "19",
   "20", "21", "22", "23", "24", "00", "01", "02", "03", "04", "05",
   "06", "07" };

 /**
  * 将代表日期的字符串分割为代表年月日的整形数组
  *
  * @param date
  * @return ymd
  */
 public static int[] splitYMD(String date) {
  date = date.replace("-", "");
  int[] ymd = { 0, 0, 0 };
  ymd[Y] = Integer.parseInt(date.substring(0, 4));
  ymd[M] = Integer.parseInt(date.substring(4, 6));
  ymd[D] = Integer.parseInt(date.substring(6, 8));
  return ymd;
 }

 /**
  * 将代表日期的字符串分割为代表年月日小时的整形数组
  *
  * @param date
  * @return ymdh
  */
 public static int[] splitYMDH(String date) {
  date = date.replace("-", "");
  date = date.replace(" ", "");
  date = date.replace(":", "");
  int[] ymdh = { 0, 0, 0, 0 };
  ymdh[Y] = Integer.parseInt(date.substring(0, 4));
  ymdh[M] = Integer.parseInt(date.substring(4, 6));
  ymdh[D] = Integer.parseInt(date.substring(6, 8));
  ymdh[H] = Integer.parseInt(date.substring(8, 10));
  return ymdh;
 }

 /**
  * 将代表日期的字符串分割为代表年月的整形数组
  *
  * @param date
  * @return ym
  */
 public static int[] splitYM(String date) {
  date = date.replace("-", "");
  int[] ym = { 0, 0 };
  ym[Y] = Integer.parseInt(date.substring(0, 4));
  ym[M] = Integer.parseInt(date.substring(4, 6));
  return ym;
 }

 /**
  * 检查传入的参数代表的年份是否为闰年
  *
  * @param year
  * @return boolean
  */
 public static boolean isLeapYear(int year) {
  return year >= gregorianCutoverYear ? ((year % 4 == 0) && ((year % 100 != 0) || (year % 400 == 0)))
    : (year % 4 == 0);
 }

 /**
  * 日期加1天
  *
  * @param year
  * @param month
  * @param day
  * @return ymd
  */
 private static int[] addOneDay(int year, int month, int day) {
  if (isLeapYear(year)) {
   day++;
   if (day > DAYS_P_MONTH_LY[month - 1]) {
    month++;
    if (month > 12) {
     year++;
     month = 1;
    }
    day = 1;
   }
  } else {
   day++;
   if (day > DAYS_P_MONTH_CY[month - 1]) {
    month++;
    if (month > 12) {
     year++;
     month = 1;
    }
    day = 1;
   }
  }
  int[] ymd = { year, month, day };
  return ymd;
 }

 /**
  * 时间加1小时
  *
  * @param year
  * @param month
  * @param day
  * @param hour
  * @return ymdh
  */
 private static int[] addOneHour(int year, int month, int day, int hour) {
  if (isLeapYear(year)) {
   hour++;
   if (hour > 24) {
    day++;
    if (day > DAYS_P_MONTH_LY[month - 1]) {
     month++;
     if (month > 12) {
      year++;
      month = 1;
     }
     day = 1;
    }
    hour = 1;
   }
  } else {
   hour++;
   if (hour > 24) {
    day++;
    if (day > DAYS_P_MONTH_CY[month - 1]) {
     month++;
     if (month > 12) {
      year++;
      month = 1;
     }
     day = 1;
    }
    hour = 1;
   }
  }
  int[] ymdh = { year, month, day, hour };
  return ymdh;
 }

 /**
  * 月数加1月
  *
  * @param year
  * @param month
  * @return ym
  */
 private static int[] addOneMonth(int year, int month) {
  month++;
  if (month > 12) {
   year++;
   month = 1;
  }
  int[] ym = { year, month };
  return ym;
 }

 /**
  * 将不足两位的月份或日期补足为两位
  *
  * @param decimal
  * @return String
  */
 public static String formatMonthDayHour(int decimal) {
  DecimalFormat df = new DecimalFormat("00");
  return df.format(decimal);
 }

 /**
  * 将不足四位的年份补足为四位
  *
  * @param decimal
  * @return String
  */
 public static String formatYear(int decimal) {
  DecimalFormat df = new DecimalFormat("0000");
  return df.format(decimal);
 }

 /**
  * 计算两个日期之间相隔的天数
  *
  * @param begin
  * @param end
  * @return day
  */
 public static long countDay(String begin, String end) {
  SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
  Date beginDate, endDate;
  long day = 0;

  try {
   beginDate = format.parse(begin);
   endDate = format.parse(end);
   day = (endDate.getTime() - beginDate.getTime())
     / (24 * 60 * 60 * 1000);
  } catch (ParseException e) {
   e.printStackTrace();
  }

  return day;
 }

 /**
  * 计算两个日期之间相隔的小时数
  *
  * @param begin
  * @param end
  * @return hour
  */
 public static long countDayAndHour(String begin, String end) {
  SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  Date beginDate, endDate;
  long hour = 0;

  try {
   beginDate = format.parse(begin);
   endDate = format.parse(end);
   hour = (endDate.getTime() - beginDate.getTime()) / (60 * 60 * 1000);
  } catch (ParseException e) {
   e.printStackTrace();
  }

  return hour;
 }

 /**
  * 计算两个日期之间相隔的月数
  *
  * @param begin
  * @param end
  * @return iMonth
  */
 public static long countMonth(String begin, String end) {
  SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
  long iMonth = 0;
  int flag = 0;
  try {
   Calendar objCalendarDate1 = Calendar.getInstance();
   objCalendarDate1.setTime(format.parse(begin));

   Calendar objCalendarDate2 = Calendar.getInstance();
   objCalendarDate2.setTime(format.parse(end));

   if (objCalendarDate2.equals(objCalendarDate1))
    return 0;
   if (objCalendarDate1.after(objCalendarDate2)) {
    Calendar temp = objCalendarDate1;
    objCalendarDate1 = objCalendarDate2;
    objCalendarDate2 = temp;
   }
   if (objCalendarDate2.get(Calendar.DAY_OF_MONTH) < objCalendarDate1
     .get(Calendar.DAY_OF_MONTH))
    flag = 1;

   if (objCalendarDate2.get(Calendar.YEAR) > objCalendarDate1
     .get(Calendar.YEAR))
    iMonth = ((objCalendarDate2.get(Calendar.YEAR) - objCalendarDate1
      .get(Calendar.YEAR))
      * 12
      + objCalendarDate2.get(Calendar.MONTH) - flag)
      - objCalendarDate1.get(Calendar.MONTH);
   else
    iMonth = objCalendarDate2.get(Calendar.MONTH)
      - objCalendarDate1.get(Calendar.MONTH) - flag;

  } catch (Exception e) {
   e.printStackTrace();
  }
  return iMonth;

 }

 /**
  * 以循环的方式计算日期
  *
  * @param beginDate
  * @param endDate
  * @return everyDays
  */
 public static List<String> getEveryday(String beginDate, String endDate) {
  long days = countDay(beginDate, endDate);
  int[] ymd = splitYMD(beginDate);
  List<String> everyDays = new ArrayList<String>();
  everyDays.add(beginDate.split(" ")[0]);
  if (days != 1) {
   for (int i = 0; i < days; i++) {
    ymd = addOneDay(ymd[Y], ymd[M], ymd[D]);
    everyDays.add(formatYear(ymd[Y]) + "-"
      + formatMonthDayHour(ymd[M]) + "-"
      + formatMonthDayHour(ymd[D]));
   }
  }
  return everyDays;
 }

 /**
  * 以循环的方式计算小时
  *
  * @param beginDate
  * @param endDate
  * @return everyHours
  */
 public static List<String> getEverydayAndEveryhour(String beginDate,
   String endDate) {
  long dayHours = countDayAndHour(beginDate, endDate);
  int[] ymdh = splitYMDH(beginDate);
  List<String> everyHours = new ArrayList<String>();
  everyHours.add(beginDate.split(" ")[0] + " "
    + beginDate.split(" ")[1].split(":")[0]);
  if (dayHours != 1) {
   for (int i = 0; i < dayHours; i++) {
    ymdh = addOneHour(ymdh[Y], ymdh[M], ymdh[D], ymdh[H]);
    everyHours.add(formatYear(ymdh[Y]) + "-"
      + formatMonthDayHour(ymdh[M]) + "-"
      + formatMonthDayHour(ymdh[D]) + " "
      + formatMonthDayHour(ymdh[H]));
   }
  }
  return everyHours;
 }

 /**
  * 以循环的方式计算月
  *
  * @param beginDate
  * @param endDate
  * @return everyMonths
  */
 public static List<String> getEveryMonth(String beginDate, String endDate) {
  long months = countMonth(beginDate, endDate);
  int[] ym = splitYM(beginDate);
  List<String> everyMonths = new ArrayList<String>();
  everyMonths.add(beginDate.split(" ")[0].split("-")[0] + "-"
    + beginDate.split(" ")[0].split("-")[1]);
  if (months != 1) {
   for (int i = 0; i < months; i++) {
    ym = addOneMonth(ym[Y], ym[M]);
    everyMonths.add(formatYear(ym[Y]) + "-"
      + formatMonthDayHour(ym[M]));
   }
  }
  return everyMonths;
 }

 /**
  * 过滤掉不需要的时间
  *
  * @param dateList
  * @return dateList
  */
 public static List<String> deleteNoNeedHour(List<String> dateList) {
  List<String> temp = new ArrayList<String>();
  for (String date : dateList) {
   for (int i = 0; i < DELETE_NO_NEED_HOUR.length; i++) {
    if (date.split(" ")[1].equals(DELETE_NO_NEED_HOUR[i])) {
     temp.add(date);
    }
   }
  }
  dateList.removeAll(temp);
  return dateList;
 }

 /**
  * 按天转换日期格式
  *
  * @param beginDate
  * @param endDate
  * @return times
  */
 public static String[] modifyDateByDay(String beginTime, String endTime) {
  String[] times = { "", "" };
  String[] beginTimeTemp = beginTime.split(" ");
  String[] endTimeTemp = endTime.split(" ");
  times[0] = beginTimeTemp[0] + " 08:00:00";
  times[1] = endTimeTemp[0] + " 17:00:00";
  return times;
 }

 /**
  * 按月转换日期格式
  *
  * @param beginDate
  * @param endDate
  * @return times
  */
 public static String[] modifyDateByMonth(String beginTime, String endTime) {
  String[] times = { "", "" };
  int[] beginTimeTemp = splitYMD(beginTime);
  int[] endTimeTemp = splitYMD(endTime);
  times[0] = formatYear(beginTimeTemp[Y]) + "-"
    + formatMonthDayHour(beginTimeTemp[M]) + "-" + "-01"
    + " 08:00:00";
  if (isLeapYear(beginTimeTemp[0])) {
   times[1] = formatYear(beginTimeTemp[Y]) + "-"
     + formatMonthDayHour(beginTimeTemp[M]) + "-"
     + formatMonthDayHour(DAYS_P_MONTH_LY[beginTimeTemp[M] - 1])
     + " 17:00:00";
  } else {
   times[1] = formatYear(beginTimeTemp[Y]) + "-"
     + formatMonthDayHour(beginTimeTemp[M]) + "-"
     + formatMonthDayHour(DAYS_P_MONTH_CY[beginTimeTemp[M] - 1])
     + " 17:00:00";
  }

  return times;
 }

}