提报周期计算

public class TestSubmitDate {

    private static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

    enum TYPE{
        DAY, WEEKLY, FORTNIGHTLY, MONTHLY,MONTHDOUBLE,QUARTER
    }

    public static void main(String[] args) throws ParseException {
        //第几天
        final int day = 2;
        //计算类型
        final TYPE type = TYPE.QUARTER;
        //持续时长(月)
        final int duration = 12;

        Calendar startDate = Calendar.getInstance();
        //开始日期
        startDate.set(2020, 1, 15);
        StringBuilder log = new StringBuilder();
        Map<String, Date> dateMap = getDateMap(type, startDate, duration, day,log);
        System.out.println(log.toString());
        Set set = dateMap.keySet();
        Iterator iterator = set.iterator();
        System.out.println("提报日期为:");
        while (iterator.hasNext()) {
            String key = iterator.next().toString();
            Date value = dateMap.get(key);
            System.out.println(sdf.format(value));
        }
    }

    /**
     * 每天
     *
     * @param startDate
     * @param duration
     * @param day
     * @return
     */
    public static Map<String, Date> getByDays(Calendar startDate, int duration, int day) {
        //记录开始日期
        final Date firstDate = startDate.getTime();

        int dayOfMonth = DateUtils.getDayOfMonth(startDate.getTime());
        int circle = duration * dayOfMonth;
        LinkedHashMap<String, Date> linkedHashMap = new LinkedHashMap<>();
        //首次提报日期
        linkedHashMap.put("key00",firstDate);

        //计算一共要提报多少天
        for (int i = 0; i < circle; i++) {
            startDate.add(Calendar.DAY_OF_MONTH, 1);
            linkedHashMap.put("key" + i, startDate.getTime());
        }
        return linkedHashMap;
    }

    /**
     * 每周
     *
     * @param startDate
     * @param duration
     * @param day
     * @throws ParseException
     */
    public static Map getByWeek(Calendar startDate, int duration, int day) throws ParseException {
        //记录开始日期
        final Date firstDate = startDate.getTime();

        Calendar endDate = Calendar.getInstance();
        endDate.setTime(startDate.getTime());
        endDate.add(Calendar.MONTH, duration);

        //计算天
        Long d = ((endDate.getTime().getTime() - startDate.getTime().getTime()) / (1000 * 60 * 60 * 24));
        LinkedHashMap<String, Date> weekMap = new LinkedHashMap();
        for (int i = 0; i < d.intValue(); i++) {
            startDate.add(Calendar.DAY_OF_MONTH, 1);

            //计算这一天这一年中是第几周
            int weekNum = DateUtils.getWeekOfYear(startDate.getTime());
            String datekey = "week" + weekNum;
            //本周第一天
            Date mondayOfWeek = DateUtils.getMondayOfWeek(startDate.getTime());
            if (!weekMap.containsKey(datekey) && !weekMap.containsValue(mondayOfWeek)) {
                weekMap.put(datekey, mondayOfWeek);  //所在周的周一
            }
        }

        //System.out.println("---------------------------提报日期---------------------------------");
        Set<String> strings = weekMap.keySet();
        Iterator<String> iterator = strings.iterator();
        LinkedHashMap linkedHashMap = new LinkedHashMap();
        //首次提报日期
        linkedHashMap.put("key00",firstDate);

        while (iterator.hasNext()) {
            String key = iterator.next();
            Date value = weekMap.get(key);
            Calendar c = Calendar.getInstance();
            c.setTime(value);
            if (day > 1) {
                c.add(Calendar.DAY_OF_MONTH, day - 1);
            }
            //结束日期边界
            if (c.getTimeInMillis() > endDate.getTimeInMillis()) {

            } else {
                //开始日期边界
                if (c.getTimeInMillis() > firstDate.getTime()) {
                    linkedHashMap.put(key, c.getTime());
                }
            }
        }
        return linkedHashMap;
    }

    /**
     * 每两周
     *
     * @param startDate
     * @param duration
     * @param day
     * @return
     */
    public static Map getByWeekDouble(Calendar startDate, int duration, int day) {
        //记录开始日期
        final Date firstDate = startDate.getTime();

        Calendar endDate = Calendar.getInstance();
        endDate.setTime(startDate.getTime());
        endDate.add(Calendar.MONTH, duration);

        //计算天
        Long d = ((endDate.getTime().getTime() - startDate.getTime().getTime()) / (1000 * 60 * 60 * 24));
        LinkedHashMap<String, Date> weekMap = new LinkedHashMap();
        for (int i = 0; i < d.intValue(); i++) {
            startDate.add(Calendar.DAY_OF_MONTH, 1);
            int weekNum = DateUtils.getWeekOfYear(startDate.getTime());
            String datekey = "week" + weekNum;
            Date mondayOfWeek = DateUtils.getMondayOfWeek(startDate.getTime());
            if (!weekMap.containsKey(datekey) && !weekMap.containsValue(mondayOfWeek)) {
                weekMap.put(datekey, mondayOfWeek);  //所在周的周一
            }
        }

        //System.out.println("---------------------------提报日期---------------------------------");
        Set<String> strings = weekMap.keySet();
        Iterator<String> iterator = strings.iterator();
        LinkedHashMap linkedHashMap = new LinkedHashMap();

        //首次提报日期
        linkedHashMap.put("key00",firstDate);

        int i = 0;
        while (iterator.hasNext()) {
            String key = iterator.next();
            Date value = weekMap.get(key);
            Calendar c = Calendar.getInstance();
            c.setTime(value);
            if (day > 1) {
                c.add(Calendar.DAY_OF_MONTH, day - 1);
            }
            //System.out.println(sdf.format(c.getTime()));
            if (i % 2 == 1) {

                //结束日期边界
                if (c.getTimeInMillis() > endDate.getTimeInMillis()) {

                } else {
                    //开始日期边界
                    if (c.getTimeInMillis() > firstDate.getTime()) {
                        linkedHashMap.put(key, c.getTime());
                    }
                }
            }
            i++;
        }
        return linkedHashMap;
    }

    /**
     * 每月
     *
     * @param startDate
     * @param duration
     * @param day
     * @return
     */
    public static Map getByMonth(Calendar startDate, int duration, int day) {

        //记录开始日期
        final Date firstDate = startDate.getTime();

        LinkedHashMap<String, Date> linkedHashMap = new LinkedHashMap();
        for (Integer i = 0; i < duration; i++) {
            startDate.add(Calendar.MONTH, 1);
            linkedHashMap.put("key" + i, startDate.getTime());
        }

        LinkedHashMap<String, Date> resultLinkedHashMap = new LinkedHashMap<>();

        //首次提报日期
        resultLinkedHashMap.put("key00",firstDate);

        Iterator iterator = linkedHashMap.keySet().iterator();
        while (iterator.hasNext()) {

            String key = iterator.next().toString();
            Date value = linkedHashMap.get(key);

            //从每个月的第一天开始算, 如传过来2020-3-15, 就从3-1往后推算
            Date firstDateOfMonth = DateUtils.getFirstDateOfMonth(value);

            //从开始日期开始算, 如传过来2020-3-15, 就从3-15往后推算
            Calendar calendar = Calendar.getInstance();
            //calendar.setTime(value);     //如果从开始日期开始算, 把这个注释打开, 下面一行注释
            calendar.setTime(firstDateOfMonth);
            calendar.add(Calendar.DAY_OF_MONTH, day - 1);
            resultLinkedHashMap.put(key, calendar.getTime());
        }

        return resultLinkedHashMap;
    }

    /**
     * 每两月
     * @param startDate
     * @param duration
     * @param day
     * @return
     */
    public static Map getByMonthDouble(Calendar startDate, int duration, int day) {

        //记录开始日期
        final Date firstDate = startDate.getTime();

        LinkedHashMap<String, Date> linkedHashMap = new LinkedHashMap();

        Calendar endDate = Calendar.getInstance();
        endDate.setTime(startDate.getTime());
        endDate.add(Calendar.MONTH, duration);

        //计算相差月份
        Integer diffMonth = getDiffMonth(startDate.getTime(), endDate.getTime());

        for (Integer i = 0; i < diffMonth; i++) {
            startDate.add(Calendar.MONTH, 1);
            if (i % 2 == 0) {
                linkedHashMap.put("key" + i, DateUtils.getFirstDateOfMonth(startDate.getTime()));
            }
        }

        LinkedHashMap<String, Date> resultLinkedHashMap = new LinkedHashMap();

        //第一次提报时间
        resultLinkedHashMap.put("key00", firstDate);

        Iterator<String> iterator = linkedHashMap.keySet().iterator();
        while (iterator.hasNext()) {
            String key = iterator.next();
            Date value = linkedHashMap.get(key);
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(value);
            calendar.add(Calendar.DAY_OF_MONTH, day - 1);
            //System.out.println(sdf.format(calendar.getTime()));
            resultLinkedHashMap.put(key, calendar.getTime());
        }


        return resultLinkedHashMap;
    }

    public static Integer getDiffMonth(Date startDate, Date endDate) {
        Calendar start = Calendar.getInstance();
        Calendar end = Calendar.getInstance();
        start.setTime(startDate);
        end.setTime(endDate);
        int result = end.get(Calendar.MONTH) - start.get(Calendar.MONTH);
        int month = (end.get(Calendar.YEAR) - start.get(Calendar.YEAR)) * 12;
        return Math.abs(month + result);
    }

    /**
     * 每季度
     *
     * @param startDate
     * @param duration
     * @param day
     * @return
     * @throws ParseException
     */
    public static Map<String, Date> getByQuarter(Calendar startDate, int duration, int day) throws ParseException {

        //记录开始日期
        final Date firstDate = startDate.getTime();

        Calendar endDate = Calendar.getInstance();
        endDate.setTime(startDate.getTime());
        endDate.add(Calendar.MONTH, duration);

        //首次提报
        ArrayDeque monthQueue = new ArrayDeque();
        //计算每个月份所属的季度
        for (int i = 0; i < duration; i++) {
            //获取到每个季度的第一天
            String firstDateOfSeason = sdf.format(DateUtils.getFirstDateOfSeason(startDate.getTime()));
            //如果重复就不要加入
            if (!monthQueue.contains(firstDateOfSeason)) {
                monthQueue.offer(firstDateOfSeason);
            }
            startDate.add(Calendar.MONTH, 1);
        }

        //移除第一个提报日
        monthQueue.removeFirst();

        int keyIndex = 0;
        LinkedHashMap<String, Date> resultLinkedHashMap = new LinkedHashMap();
        resultLinkedHashMap.put("key00", firstDate);
        Iterator iterator = monthQueue.iterator();
        while (iterator.hasNext()) {
            Date parse = sdf.parse(iterator.next().toString());
            Calendar c = Calendar.getInstance();
            c.setTime(parse);
            //第几天
            c.add(Calendar.DATE, day-1);

            resultLinkedHashMap.put("key" + keyIndex, c.getTime());

            keyIndex++;
        }
        return resultLinkedHashMap;
    }

    /**
     * 获取提报日期列表
     *
     * @param type      类型
     * @param startDate 开始日期
     * @param duration  持续时长(月)
     * @param day       第几天
     * @return
     * @throws ParseException
     */
    public static Map getDateMap(TYPE type, Calendar startDate, int duration, int day,StringBuilder log) throws ParseException {
        log.append("起始日:"+sdf.format(startDate.getTime()));
        log.append(",持续时长（月）："+duration);
        log.append("，第"+day+"天提报");
        switch (type) {
            //每日
            case DAY:
                log.append(",提报频率:每日");
                return getByDays(startDate, duration, day);
            //每周
            case WEEKLY:
                log.append(",提报频率:每周");
                return getByWeek(startDate, duration, day);
            //每两周
            case FORTNIGHTLY:
                log.append(",提报频率:每两周");
                return getByWeekDouble(startDate, duration, day);
            //每月
            case MONTHLY:
                log.append(",提报频率:每月");
                return getByMonth(startDate, duration, day);
            //每两月
            case MONTHDOUBLE:
                log.append(",提报频率:每两月");
                return getByMonthDouble(startDate, duration, day);
            //季度
            case QUARTER:
                log.append(",提报频率:每季度");
                return getByQuarter(startDate, duration, day);
        }
        return null;
    }