date(前几个月 前几个季度 前几天 前几周 等等 日期段内所有周、所有天、所有季度、所有月等)

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class ReportDateUtils {

    /**
     * （日）计算去年同期和上期的起止时间   （日）
     * beginkey、endkey  返回的map key
     *
     * begin \  end本期起止日期
     */
    public static Map<String,String> getDayDate(int type,String beginkey,String endkey,String begin,String end){
        Map<String,String> map = new HashMap<String, String>();
         DateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
          Date date1 = null; // 开始日期
          Date dEnd = null; // 结束日期
          try {
            date1 = sdf.parse(begin);
            dEnd = sdf.parse(end);
            Calendar calBegin = Calendar.getInstance();
            // 使用给定的 Date 设置此 Calendar 的时间
            calBegin.setTime(date1);
            Calendar calEnd = Calendar.getInstance();
            // 使用给定的 Date 设置此 Calendar 的时间
            calEnd.setTime(dEnd);
            if (type == 1) {// 计算上期
                // 计算查询时间段相隔多少天
                long beginTime = date1.getTime();
                long endTime = dEnd.getTime();
                long inter = endTime - beginTime;
                if (inter < 0) {
                    inter = inter * (-1);
                }
                long dateMillSec = 24 * 60 * 60 * 1000;
                long dateCnt =  inter / dateMillSec;
                long remainder = inter % dateMillSec;
                if (remainder != 0) {
                    dateCnt++;
                }
                int day = Integer.parseInt(String.valueOf(dateCnt))+1;
                calBegin.add(Calendar.DATE, -day);// 像前推day天
                calEnd.add(Calendar.DATE, -day);// 像前推day天
            }else if(type==2){
                calBegin.add(Calendar.YEAR, -1);// 去年同期
                calEnd.add(Calendar.YEAR, -1);// 去年同期
            }
            map.put(beginkey, sdf.format(calBegin.getTime()));
            map.put(endkey, sdf.format(calEnd.getTime()));
          } catch (ParseException e) {
              e.printStackTrace();
          }
        return map;
        
    }
    
    /**
     * （日）返回时间段内的所有的天  type 0本期    1上期   2去年同期(日)
     * @param begin  起始日期
     * @param end    截止日期
     * @return
     */
    public static List<String> getDaysList(String begin,String end){
         DateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
         List<String> lDate = new ArrayList<String>();
          Date date1 = null; // 开始日期
          Date dEnd = null; // 结束日期
          try {
            date1 = sdf.parse(begin);
            dEnd = sdf.parse(end);
            Calendar calBegin = Calendar.getInstance();
            // 使用给定的 Date 设置此 Calendar 的时间
            calBegin.setTime(date1);
            Calendar calEnd = Calendar.getInstance();
            // 使用给定的 Date 设置此 Calendar 的时间
            calEnd.setTime(dEnd);
            // 添加第一个 既开始时间
            lDate.add(sdf.format(calBegin.getTime()));
            while (calBegin.compareTo(calEnd)<0) {
                // 根据日历的规则，为给定的日历字段添加或减去指定的时间量
                calBegin.add(Calendar.DAY_OF_MONTH, 1);
                Date ss = calBegin.getTime();
                String str = sdf.format(ss);
                lDate.add(str);
            }
          } catch (ParseException e) {
              e.printStackTrace();
          }
         return lDate;
    }

    /**
     * （周）计算（周） 上期和去年同期的起止日期和起止周
     * 计算上期的起止时间 和去年同期  type 0本期    1上期   2去年同期
     * 起始日期key  beginkey  endkey
     * 起始日期的起止周key  beginWkey  endWkey
     * 本期：begin    end
     * 本期起止周 beginW、endW
     */
    public static Map<String,String> getWeekDate(int type,String beginkey,String endkey,String beginWkey,String endWkey,String begin,String end,String beginW,String endW){
        Map<String,String> map = new HashMap<String, String>();
         DateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
          Date date1 = null; // 开始日期
          Date dEnd = null; // 结束日期
          try {
            date1 = sdf.parse(begin);
            dEnd = sdf.parse(end);
            Calendar calBegin = Calendar.getInstance();
            // 使用给定的 Date 设置此 Calendar 的时间
            calBegin.setTime(date1);
            Calendar calEnd = Calendar.getInstance();
            // 使用给定的 Date 设置此 Calendar 的时间
            calEnd.setTime(dEnd);
            calBegin.setFirstDayOfWeek(Calendar.MONDAY);
            calEnd.setFirstDayOfWeek(Calendar.MONDAY);
            if (type == 1) {// 计算上期
                // 计算查询时间段相隔多少周
                int week = getWeekCount(date1,dEnd);
                //往前推week周
                calBegin.add(Calendar.WEEK_OF_YEAR, -week);// 像前推week周
                calEnd.add(Calendar.WEEK_OF_YEAR, -week);// 像前推week周
                map.put(beginWkey, String.valueOf(calBegin.get(Calendar.WEEK_OF_YEAR)));//得到其实日期的周);
                map.put(endWkey, String.valueOf(calEnd.get(Calendar.WEEK_OF_YEAR)));//得到其实日期的周);
                //得到起始周的周一   和结束周的周末
                int day_of_week = calBegin.get(Calendar.DAY_OF_WEEK) - 1;
                if (day_of_week == 0)
                    day_of_week = 7;
                calBegin.add(Calendar.DATE, -day_of_week + 1);
                //本周周末
                int day_of_week_end = calEnd.get(Calendar.DAY_OF_WEEK) - 1;
                if (day_of_week_end == 0)
                    day_of_week_end = 7;
                calEnd.add(Calendar.DATE, -day_of_week_end + 7);
            }else if(type==2){
                calBegin.add(Calendar.YEAR, -1);// 去年同期
                calEnd.add(Calendar.YEAR, -1);// 去年同期
                
                //去年的开始的本周
                calBegin.set(Calendar.WEEK_OF_YEAR,Integer.parseInt(beginW));
                calEnd.set(Calendar.WEEK_OF_YEAR,Integer.parseInt(endW));
                //年-1   周不变
                map.put(beginWkey,beginW);
                map.put(endWkey,endW);
                
                //得到起始周的周一   和结束周的周末
                int day_of_week = calBegin.get(Calendar.DAY_OF_WEEK) - 1;
                if (day_of_week == 0)
                    day_of_week = 7;
                calBegin.add(Calendar.DATE, -day_of_week + 1);
                //本周周末
                int day_of_week_end = calEnd.get(Calendar.DAY_OF_WEEK) - 1;
                if (day_of_week_end == 0)
                    day_of_week_end = 7;
                calEnd.add(Calendar.DATE, -day_of_week_end + 7);
            }
            map.put(beginkey, sdf.format(calBegin.getTime()));
            map.put(endkey, sdf.format(calEnd.getTime()));
          } catch (ParseException e) {
              e.printStackTrace();
          }
        return map;
        
    }
    
    
    
    /**
     * （周）返回起止时间内的所有自然周
     * @param begin  时间起
     * @param end   时间止
     * @param startw  周起
     * @param endW    周止
     * @return
     */
    public static List<String> getWeeksList(String begin,String end,String startw,String endW){
         DateFormat sdf = new SimpleDateFormat("yyyy");
         List<String> lDate = new ArrayList<String>();
          Date date1 = null; // 开始日期
          Date dEnd = null; // 结束日期
          try {
            date1 = sdf.parse(begin);
            dEnd = sdf.parse(end);
            Calendar calBegin = Calendar.getInstance();
            // 使用给定的 Date 设置此 Calendar 的时间
            calBegin.setTime(date1);
            Calendar calEnd = Calendar.getInstance();
            // 使用给定的 Date 设置此 Calendar 的时间
            calEnd.setTime(dEnd);
            //开始时间是今年的第几周
            calBegin.setFirstDayOfWeek(Calendar.MONDAY);
            int count = calBegin.get(Calendar.WEEK_OF_YEAR);//得到其实日期的周
            //添加第一个周
            int beginww = Integer.parseInt(startw);
            int endww = Integer.parseInt(endW);
            
            int beginY = calBegin.get(Calendar.YEAR);
            int endY = calEnd.get(Calendar.YEAR);
            
            int weekall = getAllWeeks(beginY+"");
            //如果是同一年
            do{
                lDate.add(beginY+"年第"+beginww+"周");
                if(beginww==weekall){
                    beginww = 0;
                    beginY++;
                    weekall = getAllWeeks(beginY+"");
                }
                if(beginY==endY &&beginww==endww){
                    break;
                }
                beginww++;
            }while(beginY<=endY);
          } catch (ParseException e) {
              e.printStackTrace();
          }
         return lDate;
    }
    
    /**
     * （月）得当时间段内的所有月份
     * @param StartDate
     * @param endDate
     * @return
     */
    public static List<String> getYearMouthBy(String StartDate,String endDate) {
          DateFormat df = new SimpleDateFormat("yyyy-MM");
          Date date1 = null; // 开始日期
          Date date2 = null; // 结束日期
          try {
               date1 = df.parse(StartDate);
               date2 = df.parse(endDate);
          } catch (ParseException e) {
              e.printStackTrace();
          }
          Calendar c1 = Calendar.getInstance();
          Calendar c2 = Calendar.getInstance();
          //定义集合存放月份
          List<String> list = new ArrayList<String>();
          //添加第一个月，即开始时间
          list.add(df.format(date1));
          c1.setTime(date1);
          c2.setTime(date2);
          while (c1.compareTo(c2) < 0) {
               c1.add(Calendar.MONTH, 1);// 开始日期加一个月直到等于结束日期为止
               Date ss = c1.getTime();
               String str = df.format(ss);
               list.add(str);
          }
          return list;
    }
    
    /**
     * （月）计算本期的上期和去年同期   1 上期   2同期  
     * 返回的mapkay  beginkey   endkey
     * 本期起止：begin    end
     * 计算上期的起止时间 和去年同期  type 0本期    1上期   2去年同期
     */
    public static Map<String,String> getMonthDate(int type,String beginkey,String endkey,String begin,String end){
        Map<String,String> map = new HashMap<String, String>();
         DateFormat sdf = new SimpleDateFormat("yyyy-MM");
          Date date1 = null; // 开始日期
          Date dEnd = null; // 结束日期
          try {
            date1 = sdf.parse(begin);
            dEnd = sdf.parse(end);
            Calendar calBegin = Calendar.getInstance();
            // 使用给定的 Date 设置此 Calendar 的时间
            calBegin.setTime(date1);
            Calendar calEnd = Calendar.getInstance();
            // 使用给定的 Date 设置此 Calendar 的时间
            calEnd.setTime(dEnd);
            if (type == 1) {// 计算上期
                int year = calBegin.get(Calendar.YEAR);
                int month = calBegin.get(Calendar.MONTH);
                
                int year1 = calEnd.get(Calendar.YEAR);
                int month1 = calEnd.get(Calendar.MONTH);
                int result;
                if(year==year1){
                  result=month1-month;//两个日期相差几个月，即月份差
                }
                else{
                  result=12*(year1-year)+month1-month;//两个日期相差几个月，即月份差
                }
                result++;
                calBegin.add(Calendar.MONTH, -result);// 像前推day天
                calEnd.add(Calendar.MONTH, -result);// 像前推day天
            }else if(type==2){
                calBegin.add(Calendar.YEAR, -1);// 去年同期
                calEnd.add(Calendar.YEAR, -1);// 去年同期
            }
            map.put(beginkey, sdf.format(calBegin.getTime()));
            map.put(endkey, sdf.format(calEnd.getTime()));
          } catch (ParseException e) {
              e.printStackTrace();
          }
        return map;
        
    }

    /**
     * （年）计算本期（年）的上期
     */
    public static Map<String,String> getYearDate(String beginkey,String endkey,String begin,String end){
        Map<String,String> map = new HashMap<String, String>();
         DateFormat sdf = new SimpleDateFormat("yyyy");
          Date date1 = null; // 开始日期
          Date dEnd = null; // 结束日期
          try {
            date1 = sdf.parse(begin);
            dEnd = sdf.parse(end);
            Calendar calBegin = Calendar.getInstance();
            // 使用给定的 Date 设置此 Calendar 的时间
            calBegin.setTime(date1);
            Calendar calEnd = Calendar.getInstance();
            // 使用给定的 Date 设置此 Calendar 的时间
            calEnd.setTime(dEnd);
            int year = calBegin.get(Calendar.YEAR);
            int year1 = calEnd.get(Calendar.YEAR);
            int result;
            result = year1 - year + 1;// 两个日期的年份差
            calBegin.add(Calendar.YEAR, -result);// 像前推N年
            calEnd.add(Calendar.YEAR, -result);// 像前推N年
            map.put(beginkey, sdf.format(calBegin.getTime()));
            map.put(endkey, sdf.format(calEnd.getTime()));
          } catch (ParseException e) {
              e.printStackTrace();
          }
        return map;
        
    }
    
    /**
     * 获取年份时间段内的所有年
     * @param StartDate
     * @param endDate
     * @return
     */
    public static List<String> getYearBy(String StartDate,String endDate) {
          DateFormat df = new SimpleDateFormat("yyyy");
          Date date1 = null; // 开始日期
          Date date2 = null; // 结束日期
          try {
               date1 = df.parse(StartDate);
               date2 = df.parse(endDate);
          } catch (ParseException e) {
              e.printStackTrace();
          }
          Calendar c1 = Calendar.getInstance();
          Calendar c2 = Calendar.getInstance();
          //定义集合存放月份
          List<String> list = new ArrayList<String>();
          //添加第一个月，即开始时间
          list.add(df.format(date1));
          c1.setTime(date1);
          c2.setTime(date2);
          while (c1.compareTo(c2) < 0) {
               c1.add(Calendar.YEAR, 1);// 开始日期加一个月直到等于结束日期为止
               Date ss = c1.getTime();
               String str = df.format(ss);
               list.add(str);
          }
          return list;
    }

    /**
     * 获取两个日期段相差的周数
     */
    public static int getWeekCount(Date date1,Date dEnd){
        Calendar c_begin = Calendar.getInstance();
        // 使用给定的 Date 设置此 Calendar 的时间
        c_begin.setTime(date1);
        Calendar c_end = Calendar.getInstance();
        // 使用给定的 Date 设置此 Calendar 的时间
        c_end.setTime(dEnd);
        int count = 0;
//        c_end.add(Calendar.DAY_OF_YEAR, 1); // 结束日期下滚一天是为了包含最后一天
        c_begin.setFirstDayOfWeek(Calendar.MONDAY);
        c_end.setFirstDayOfWeek(Calendar.MONDAY);
        while (c_begin.before(c_end)) {
            if (c_begin.get(Calendar.DAY_OF_WEEK) == Calendar.SUNDAY) {
                count++;
            }
            c_begin.add(Calendar.DAY_OF_YEAR, 1);
        }
        return count;
    }
    
    /**
     * 返回该年有多少个自然周
     * @param year   最多53  一般52
     * 如果12月月末今天在本年53周（属于第二年第一周） 那么按照当年52周算
     * @return
     */
    public static int getAllWeeks(String year){
          Calendar calendar = Calendar.getInstance();
          SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
           try {
            calendar.setTime(sdf.parse(year+"-12-31"));
        } catch (ParseException e) {
            e.printStackTrace();
        }
          calendar.setFirstDayOfWeek(Calendar.MONDAY);
          int count = calendar.get(Calendar.WEEK_OF_YEAR);//得到其实日期的周
          int week =  calendar.get(Calendar.WEEK_OF_YEAR);
          if(week != 53){
             week = 52;
          }
          return week;
    }
    
    /**
     *
     * (季度) 计算本期的上期起止时间和同期的起止时间
     * 返回的mao key 时间起止：beginkey   endkey   季度起止： beginWkey  endWkey
     * 本期的时间起止：begin end   季度：beginW  endW
     * type 0本期    1上期   2去年同期  季度
     */
    public static Map<String,String> getQuarterDate(int type,String beginkey,String endkey,String beginWkey,String endWkey,String begin,String end,String beginW,String endW){
        //计算本期的起始日期 和截止日期
        Map<String,String> map = new HashMap<String, String>();
         DateFormat sdf = new SimpleDateFormat("yyyy");
          Date date1 = null; // 开始日期
          Date dEnd = null; // 结束日期
          try {
            date1 = sdf.parse(begin);
            dEnd = sdf.parse(end);
            Calendar calBegin = Calendar.getInstance();
            // 使用给定的 Date 设置此 Calendar 的时间
            calBegin.setTime(date1);
            calBegin.set(Calendar.MONTH, setMonthByQuarter(Integer.parseInt(beginW)));
            Calendar calEnd = Calendar.getInstance();
            // 使用给定的 Date 设置此 Calendar 的时间
            calEnd.setTime(dEnd);
            calEnd.set(Calendar.MONTH, setMonthByQuarter(Integer.parseInt(endW)));
            
            if (type == 1) {// 计算上期
                // 计算查询时间段相隔多少季度(多少个月)
                int quarter =  ((Integer.parseInt(end)-Integer.parseInt(begin))*4+(Integer.parseInt(endW) - Integer.parseInt(beginW))+1)*3;
                //往前推week周
                calBegin.add(Calendar.MONTH, -quarter);// 像前推week月份
                calEnd.add(Calendar.MONTH, -quarter);// 像前推week月份   
                map.put(beginWkey,String.valueOf(getQuarterByMonth(calBegin.get(Calendar.MONTH))));//得到其实日期的月);
                map.put(endWkey,String.valueOf(getQuarterByMonth(calEnd.get(Calendar.MONTH))));//得到其实日期的月);
            }else if(type==2){
                calBegin.add(Calendar.YEAR, -1);// 去年同期
                calEnd.add(Calendar.YEAR, -1);// 去年同期
                //年-1   周不变
                map.put(beginWkey,beginW);
                map.put(endWkey,endW);
            }
            map.put(beginkey,String.valueOf(calBegin.get((Calendar.YEAR)))+"-"+setMonthByQuarterToString(0,Integer.parseInt(map.get(beginWkey))));
            map.put(endkey, String.valueOf(calEnd.get((Calendar.YEAR))+"-"+setMonthByQuarterToString(1,Integer.parseInt(map.get(endWkey)))));
          } catch (ParseException e) {
              e.printStackTrace();
          }
        return map;
        
    }
    /**
     * （季度）获取季度份时间段内的所有季度
     * @param StartDate
     * @param endDate
     * @return
     */
    public static List<String> getQuarterBy(String StartDate,String beginQ,String endDate,String endQ) {
        DateFormat sdf = new SimpleDateFormat("yyyy-MM");
        Date date1 = null; // 开始日期
        Date dEnd = null; // 结束日期

        try {
            date1 = sdf.parse(StartDate);
            dEnd = sdf.parse(endDate);
        } catch (ParseException e) {
            e.printStackTrace();
        }

        Calendar calBegin = Calendar.getInstance();
        // 使用给定的 Date 设置此 Calendar 的时间
        calBegin.setTime(date1);
        Calendar calEnd = Calendar.getInstance();
        // 使用给定的 Date 设置此 Calendar 的时间
        calEnd.setTime(dEnd);
        List<String> list = new ArrayList<String>();
        int beginY = calBegin.get(Calendar.YEAR);
        int beginYQ = Integer.parseInt(beginQ);
        int endY = calEnd.get(Calendar.YEAR);
        int endYQ = Integer.parseInt(endQ);
        do {
            list.add(beginY + "年第" + beginYQ + "季度");
            if (beginY == endY && beginYQ == endYQ) {
                return list;
            }
            beginYQ++;
            if (beginYQ > 4) {
                beginYQ = 1;
                beginY++;
            }
         }while(true);
    }
    
    
    //根据季度给年设置月份
    /**
     * 根据季度返回季度第一月
     */
    public static int setMonthByQuarter(int quarter){
        if(quarter==1){
            return 1;
        }
        if(quarter==2){
            return 4;
        }
        if(quarter==3){
            return 7;
        }
        if(quarter==4){
            return 10;
        }
        
        return 1;
        
    }

    
    /**
     * 根据季度返回季度第一月或最后一月
     * 0 起始月  1截止月
     *
     */
    public static String setMonthByQuarterToString(int type,int quarter){
        if(quarter==1){
            if(type==1){
                return "03";
            }
            return "01";
        }
        if(quarter==2){
            if(type==1){
                return "06";
            }
            return "04";
        }
        if(quarter==3){
            if(type==1){
                return "09";
            }
            return "07";
        }
        if(quarter==4){
            if(type==1){
                return "12";
            }
            return "10";
        }
        return "01";
        
    }
    /**
     * 根据月份获取所在季度
     * @param month
     * @return
     */
    private static int getQuarterByMonth(int month){
        int quarter = 1;
        if(month>=1&&month<=3){
            return 1;
        }
        if(month>=4&&month<=6){
            return 2;
        }
        if(month>=7&&month<=9){
            return 3;
        }
        if(month>=10&&month<=12){
            return 4;
        }
        
        return quarter;
        
    }
    
    public static void main(String[] args) throws Exception{
          String start = "2012-02-28";
          String end = "2012-03-01";
//          SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
//          List<String> lDate = getDaysList(start, end);
//          for (String date : lDate)
//          {
//             System.out.println(date);
//          }
//          System.out.println(getWeeksList("2014-03-30","2014-04-14"));-- aa=2014-03-02, bb=2014-03-17
//          System.out.println(getWeekDate(2,"aa","bb","cc","dd","2014-03-30","2014-04-14","13","16"));
//          System.out.println(getWeeksList("2014-03-30","2014-04-14","13","16"));
//          System.out.println(getAllWeeks("2013"));
//          System.out.println(getQuarterDate(1,"aaa","bbb","ccc","ddd","2014","2014","2","2"));
//          System.out.println(getYearBy("2013","4","2014","2"));
          
     }
    

}