当前位置： 首页 > news >正文

【知识分享】Java获取全年每个月的有几周且每周是几号到几号

news 2025/7/6 2:56:33

加哥本周给大家分享一期怎么用java把全年每个月有几周，本周是几号到几号的工具类。便于大家根据需求获取想要的形式进行改造。话不多说，直接给大家上代码。

package com.techfantasy.common.utils;

import com.techfantasy.common.entity.DateRange;
import org.springframework.util.StringUtils;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.time.temporal.TemporalAdjusters;
import java.time.temporal.WeekFields;
import java.util.*;

/**
 * @Author feng
 * @Date 2023/8/510:21
 * @Version 1.0
 * @Param
 * 时间分割工具类
 */
public class DateSplitUtil {
    private DateSplitUtil() {
        throw new IllegalStateException("请通过静态方法调用！");
    }

    /**
     * 切分时间，并且获取切分后的时间段集合
     *
     * @param type      分割类型：按年、按月、按周、按日
     * @param startTime 开始时间
     * @param endTime   结束时间
     * @return 切分后的时间段集合
     */
    public static List<DateRange> splitAndGetByType(int type, LocalDateTime startTime, LocalDateTime endTime) {
        if (type == 1) {
            // 按年切分
            return splitDateRangeByYear1(startTime, endTime);
        } else if (type == 2) {
            // 按月切分
            return splitDateRangeByMonth(startTime, endTime);
        } else if (type == 3) {
            // 按周切分
            return splitDateRangeByWeek(startTime, endTime);
        } else if (type == 4) {
            //按日切分
            return splitDateRangeByDay(startTime, endTime);
        } else if (type == 5) {
            //一次性
            List<DateRange> dateRangeList = new ArrayList<>();
            DateRange dateRange = new DateRange();
            dateRange.setBegin(startTime);
            dateRange.setEnd(endTime);
            dateRangeList.add(dateRange);
            return dateRangeList;
        } else {
            return new ArrayList<>();
        }
    }

    /**
     * 切分时间，并且获取某一轮的时间对象
     *
     * @param type      分割类型：按年、按月、按周、按日
     * @param turn      时间段（分割后的时间轮数，如将2021-10-01~2022-10-01，按月分割时，就能得到12轮时间段）
     * @param startTime 开始时间
     * @param endTime   结束时间
     * @return 第turn段的时间对象
     */
    public static DateRange splitAndGetByTurn(int type, long turn, LocalDateTime startTime, LocalDateTime endTime) {
        //按年切分
        if (type == 1) {
            List<DateRange> dateRangeList = splitDateRangeByYear(startTime, endTime);
            return getRangeByTurn(dateRangeList, turn);
        } else if (type == 2) {
            // 按月切分
            List<DateRange> dateRangeList = splitDateRangeByMonth(startTime, endTime);
            return getRangeByTurn(dateRangeList, turn);
        } else if (type == 3) {
            // 按周切分
            List<DateRange> dateRangeList = splitDateRangeByWeek(startTime, endTime);
            return getRangeByTurn(dateRangeList, turn);
        } else if (type == 4) {
            //按日切分
            List<DateRange> dateRangeList = splitDateRangeByDay(startTime, endTime);
            return getRangeByTurn(dateRangeList, turn);
        } else if (type == 5) {
            //一次性
            DateRange dateRange = new DateRange();
            dateRange.setBegin(startTime);
            dateRange.setEnd(endTime);
            return dateRange;
        } else {
            return new DateRange();
        }
    }


    /**
     * 按年分割
     *
     * @param startTime 开始时间
     * @param endTime   结束时间
     * @return 分割后的时间段集合
     */
    private static List<DateRange> splitDateRangeByYear(LocalDateTime startTime, LocalDateTime endTime) {
        long seconds = startTime.until(endTime, ChronoUnit.SECONDS);
        if (seconds <= 0) {
            return new ArrayList<>();
        }
        //轮数
        long turnNum = 0;
        //分割的时间段集合，使用累加算法
        List<DateRange> dateList = new ArrayList<>();
        DateRange range = new DateRange();
        range.setBegin(startTime);
        while (true) {
            turnNum++;
            //年份相等，不再累加
            if (startTime.getYear() == endTime.getYear()) {
                range.setEnd(endTime);
                range.setTurnNum(turnNum);
                dateList.add(range);
                break;
            }
            //将时间调整为该年的第一天 0时 0分 0秒
            startTime = LocalDateTime.of(LocalDate.from(startTime.with(TemporalAdjusters.firstDayOfYear()).plusYears(1)), LocalTime.MIN);
            LocalDateTime tmpBegin = startTime;
            //计算出上一天的最后一秒
            LocalDateTime endDate = tmpBegin.minusSeconds(1);
            range.setEnd(endDate);
            range.setTurnNum(turnNum);
            dateList.add(range);
            //创建新的时间段
            range = new DateRange();
            range.setBegin(tmpBegin);
        }
        return dateList;
    }

    /**
     * 按月分割
     *
     * @param startTime 开始时间
     * @param endTime   结束时间
     * @return 分割后的时间段集合
     */
    private static List<DateRange> splitDateRangeByMonth(LocalDateTime startTime, LocalDateTime endTime) {

        long seconds = startTime.until(endTime, ChronoUnit.SECONDS);
        if (seconds <= 0) {
            return new ArrayList<>();
        }
        //轮数
        long turnNum = 0;
        //分割的时间段集合，使用累加算法
        List<DateRange> dateList = new ArrayList<>();
        DateRange range = new DateRange();
        range.setBegin(startTime);
        while (true) {
            turnNum++;
            startTime = startTime.plusMonths(1);
            //大于截止日期时，不再累加
            if (startTime.isAfter(endTime)) {
                range.setEnd(endTime);
                range.setTurnNum(turnNum);
                dateList.add(range);
                break;
            }
            //将时间调整为当前月的第一天的 0时 0分 0秒
            startTime = LocalDateTime.of(LocalDate.from(startTime.with(TemporalAdjusters.firstDayOfMonth())), LocalTime.MIN);
            LocalDateTime tmpBegin = startTime;
            //计算出上一天的最后一秒
            LocalDateTime endDate = tmpBegin.minusSeconds(1);
            range.setEnd(endDate);
            range.setTurnNum(turnNum);
            dateList.add(range);
            //创建新的时间段
            range = new DateRange();
            range.setBegin(tmpBegin);
        }
        return dateList;
    }
    /**
     * 按年分割
     *
     * @param startTime 开始时间
     * @param endTime   结束时间
     * @return 分割后的时间段集合
     */
    private static List<DateRange> splitDateRangeByYear1(LocalDateTime startTime, LocalDateTime endTime) {
        long seconds = startTime.until(endTime, ChronoUnit.SECONDS);
        if (seconds <= 0) {
            return new ArrayList<>();
        }
        //轮数
        long turnNum = 0;
        //分割的时间段集合，使用累加算法
        List<DateRange> dateList = new ArrayList<>();
        DateRange range = new DateRange();
        range.setBegin(startTime);
        while (true) {
            turnNum++;
            //年份相等，不再累加
            if (range.getBegin().getYear() == endTime.getYear()) {
                range.setEnd(endTime);
                range.setTurnNum(turnNum);
                dateList.add(range);
                break;
            }
           LocalDateTime tmpBegin = range.getBegin();
            startTime=tmpBegin;
            //计算出上一天的最后一秒
            LocalDateTime endDate = tmpBegin.plusYears(1).minusDays(1);
            if(endDate.getYear()==endTime.getYear()&&endDate.getMonth()!=endTime.getMonth()&&endDate.getDayOfYear()==endTime.getDayOfYear()){
                range.setEnd(endTime);
                range.setTurnNum(turnNum);
                dateList.add(range);
                break;
            }
            range.setEnd(endDate);
            range.setTurnNum(turnNum);
            dateList.add(range);
            //创建新的时间段
            range = new DateRange();
            range.setBegin(endDate.plusDays(1));
            //如果上一次结束的时间大于当前传入的开始时间跳出
            Date inendTime=Date.from(endTime.atZone(ZoneId.systemDefault()).toInstant());
            Date newstartTime =Date.from(range.getBegin().atZone(ZoneId.systemDefault()).toInstant());
            if(isBeforeDate(newstartTime, inendTime)){
                break;
            }
        }
        return dateList;
    }

    /**
     * 按周分割
     *
     * @param startTime 开始时间
     * @param endTime   结束时间
     * @return 分割后的时间段集合
     */
    private static List<DateRange> splitDateRangeByWeek(LocalDateTime startTime, LocalDateTime endTime) {
        long seconds = startTime.until(endTime, ChronoUnit.SECONDS);
        if (seconds <= 0) {
            return new ArrayList<>();
        }
        //轮数
        long turnNum = 0;
        //分割的时间段集合，使用累加算法
        List<DateRange> dateList = new ArrayList<>();
        DateRange range = new DateRange();
        range.setBegin(startTime);
        while (true) {
            turnNum++;
            startTime = startTime.plusWeeks(1);
            //大于截止日期时，不再累加
            if (startTime.isAfter(endTime)) {
                range.setEnd(endTime);
                range.setTurnNum(turnNum);
                dateList.add(range);
                break;
            }
            //将时间调整为该周第一天的 0时 0分 0秒
            startTime = LocalDateTime.of(LocalDate.from(startTime.with(DayOfWeek.MONDAY)), LocalTime.MIN);
            LocalDateTime tmpBegin = startTime;
            //计算出上一天的最后一秒
            LocalDateTime endDate = tmpBegin.minusSeconds(1);
            range.setEnd(endDate);
            range.setTurnNum(turnNum);
            dateList.add(range);
            //创建新的时间段
            range = new DateRange();
            range.setBegin(tmpBegin);
        }
        return dateList;
    }

    /**
     * 按日分割
     *
     * @param startTime 开始时间
     * @param endTime   结束时间
     * @return 分割后的时间段集合
     */
    private static List<DateRange> splitDateRangeByDay(LocalDateTime startTime, LocalDateTime endTime) {
        long seconds = startTime.until(endTime, ChronoUnit.SECONDS);
        if (seconds < 0) {
            return new ArrayList<>();
        }
        //轮数
        long turnNum = 0;
        //分割的时间段集合，使用累加算法
        List<DateRange> dateList = new ArrayList<>();
        DateRange range = new DateRange();
        range.setBegin(startTime);
        while (true) {
            turnNum++;
            startTime = startTime.plusDays(1);
            //大于截止日期时，不再累加
            if (startTime.isAfter(endTime)) {
                range.setEnd(endTime);
                range.setTurnNum(turnNum);
                dateList.add(range);
                break;
            }
            //将时间调整为该天的 0时 0分 0秒
            startTime = LocalDateTime.of(startTime.getYear(), startTime.getMonth(), startTime.getDayOfMonth(), 0, 0, 0);
            LocalDateTime tmpBegin = startTime;
            //计算出上一天的最后一秒
            LocalDateTime endDate = tmpBegin.minusSeconds(1);
            range.setEnd(endDate);
            range.setTurnNum(turnNum);
            dateList.add(range);
            //创建新的时间段
            range = new DateRange();
            range.setBegin(tmpBegin);
        }
        return dateList;
    }

    /**
     * 根据时间段（分割后的时间轮数，2021-10-01~2022-10-01，按月分隔时就有12轮时间段）获取时间范围
     *
     * @param dateRangeList 分隔后的时间段集合
     * @param turn          轮次，当前时间处于第几段
     * @return 时间对象
     */
    private static DateRange getRangeByTurn(List<DateRange> dateRangeList, long turn) {
        DateRange dateRange = new DateRange();
        for (DateRange d : dateRangeList) {
            if (d.getTurnNum() == turn) {
                dateRange = d;
            }
        }
        return dateRange;
    }
    /**
     *判断当前时间是否在[startTime, endTime]区间，注意三个参数的时间格式要一致
     ** @param nowTime
     *      * @param startTime
     *      * @param endTime
     *      * @return 在时间段内返回true，不在返回false
     * **/

    public static boolean isEffectiveDate(Date nowTime, Date startTime, Date endTime) {
        if (nowTime.getTime() == startTime.getTime()
                || nowTime.getTime() == endTime.getTime()) {
            return true;
        }
        Calendar date = Calendar.getInstance();
        date.setTime(nowTime);

        Calendar begin = Calendar.getInstance();
        begin.setTime(startTime);

        Calendar end = Calendar.getInstance();
        end.setTime(endTime);

        return date.after(begin) && date.before(end);
    }

    public static boolean isBeforeDate(Date nowTime,Date endTime) {
        if (nowTime.getTime() == endTime.getTime()) {
            return true;
        }

        Calendar date = Calendar.getInstance();
        date.setTime(nowTime);

        Calendar end = Calendar.getInstance();
        end.setTime(endTime);

        return date.after(end);
    }

    /**
     * 月底时间处理工具类
     *
     */
    public static String downdate() throws ParseException {
     //1.获取当前时间
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date now = new Date();
        Date nowTime;
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(now);
        calendar.set(Calendar.DATE, (calendar.get(Calendar.DATE) + 1));
        if (calendar.get(Calendar.DAY_OF_MONTH) == 1) {
            //返回本月
            Calendar cale = Calendar.getInstance();
            SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
            String now1 = sdf.format(new Date());
            cale.setTime(formatter.parse(now1));
            cale.add(Calendar.MONTH, 1);
            cale.set(Calendar.DAY_OF_MONTH, 0);
            String lastDayOfMonth = formatter.format(cale.getTime());
            return lastDayOfMonth;
        }else{
            //返回上月末
            Calendar cale = Calendar.getInstance();
            SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
            String now1 = sdf.format(new Date());
            cale.setTime(formatter.parse(now1));
            cale.add(Calendar.MONTH, 0);
            cale.set(Calendar.DAY_OF_MONTH, 0);
            String lastDayOfMonth = formatter.format(cale.getTime());
            return lastDayOfMonth;
        }
     //2.判断当前时间是否本月底 是返回本月底 不是返回上月底
    }
    public static String getChinaDateFromString(String str) {
        try {
            if(str==null ){
                return getChinaCurrentDate();
            }
            str = str.trim();
            int year = 0;
            int month = 0;
            int day = 0;
            //System.out.println("==="+str);
            if(str==null || str.equals("null") || str.equals("")){
                return getChinaCurrentDate();
            }
            else if (str.indexOf("年") > 0||str.indexOf("月") > 0||str.indexOf("日") > 0) {
                return str;
            }
            else {
                if (str.length() == 10 && (str.indexOf("-") > 0)) {
                    // by meconsea  add str.indexOf("-") > 0
                    year = Integer.parseInt(str.substring(0, 4));
                    month = Integer.parseInt(str.substring(5, 7));
                    day = Integer.parseInt(str.substring(8, 10));
                }
                else if (str.length() == 8) {
                    year = Integer.parseInt(str.substring(0, 4));
                    month = Integer.parseInt(str.substring(4, 6));
                    day = Integer.parseInt(str.substring(6, 8));
                }
                else if (str.length() == 6) {
                    year = Integer.parseInt(str.substring(0, 4));
                    month = Integer.parseInt(str.substring(4, 6));
                }
                if (day == 0) {
                    str = year + "年" + month + "月";
                }
                else {
                    str = year + "年" + month + "月" + day + "日";
                }
            }
        }
        catch (Exception e) {
            e.printStackTrace();
        }
        return str;
    }
    public static String getChinaCurrentDate() {
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMdd");
        String str_date = dateFormat.format(Calendar.getInstance().getTime());
        str_date = str_date.substring(0, 4) + "年" + str_date.substring(4, 6) + "月" +
                str_date.substring(6, 8) + "日 ";
        return str_date;
    }
    /***
     * 获取系统当前时间
     */
    public static String getNowTime(int type) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd");
        String now = sdf.format(new Date());
        Date nowTime = sdf.parse(now);
        String now1 = sdf1.format(new Date());
        Date nowTime1 = sdf1.parse(now);
        if (type == 1) {
            // yyyy-MM-dd HH:mm:ss
            return String.valueOf(now);
        } else{
            // yyyy-MM-dd
            return String.valueOf(now1);
        }
    }

    /***
     * 字符串形式日期 补月初神操作 yyyy-MM  转yyyy-MM-dd
     * @param dateTime
     */
    public static String addDayTime(String dateTime){
        String newDateTime =null;
        if(dateTime.length()==7){
            newDateTime=dateTime+"-01";
        }
        return newDateTime;
    }
    /***
     * 统一时间格式处理工具类
     * 均统一为yyyy-MM-dd形式
     * 目前数据中存在的形式有 yyyy-MM-dd yyyy.MM.dd  yyyy/MM/dd  yyyy.MM (yyyy年MM月)暂时不处理
     */
    public static  String strToDate(String date) throws ParseException {
        String newTime =null;
        if (!StringUtils.isEmpty(date)){
            SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat("yyyy-MM-dd");
            if (date.contains("-")) {
                if(date.length()<=7){
                     newTime=DateSplitUtil.addDayTime(date);
                }else {
                    newTime=simpleDateFormat1.format(simpleDateFormat1.parse(date));;
                }
            }
            else if (date.contains(".")) {
                int count = (date.length()-date.replace(".", "").length());
                SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy.MM");
                SimpleDateFormat simpleDateFormat2 = new SimpleDateFormat("yyyy.MM.dd");
                if(date.length()<=7 && count == 1){
                     newTime=simpleDateFormat1.format(simpleDateFormat.parse(date));
                }else {
                    newTime=simpleDateFormat1.format(simpleDateFormat2.parse(date));
                }
            }
            else if (date.contains("/")) {
                int count = (date.length()-date.replace("/", "").length());
                SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy/MM");
                SimpleDateFormat simpleDateFormat3 = new SimpleDateFormat("yyyy/MM/dd");
                if(date.length()<=7 && count == 1){
                    newTime=simpleDateFormat1.format(simpleDateFormat.parse(date));
                }else {
                    newTime=simpleDateFormat1.format(simpleDateFormat3.parse(date));
                }
            }
        }
            return newTime;
    }


//        public static void main(String[] args) {
//            int year = 2023; // 指定年份
//            List<List<LocalDate>> workWeeks = partitionCalendar(year);
//
//            // 输出每个工作周的起始和结束日期
//            for (int i = 0; i < workWeeks.size(); i++) {
//                List<LocalDate> week = workWeeks.get(i);
//                LocalDate start = week.get(0);
//                LocalDate end = week.get(week.size() - 1);
//                System.out.println("Work Week " + (i + 1) + ": " + start + " - " + end);
//            }
//        }

        public static List<List<LocalDate>> partitionCalendar(int year) {
            List<List<LocalDate>> workWeeks = new ArrayList<>();
            int dayOfYear = Year.of(year).length(); // 获取指定年份的总天数

            LocalDate startDate = LocalDate.of(year, Month.JANUARY, 1);
            LocalDate endDate = LocalDate.of(year, Month.DECEMBER, 31);

            // 划分工作周
            List<LocalDate> week = new ArrayList<>();
            for (LocalDate date = startDate; date.isBefore(endDate.plusDays(1)); date = date.plusDays(1)) {
                week.add(date);

                // 判断是否为工作周的最后一天
                if (date.getDayOfWeek() == DayOfWeek.SATURDAY || date.getDayOfYear() == dayOfYear) {
                    workWeeks.add(week);
                    week = new ArrayList<>();
                }
            }

            return workWeeks;
        }

//    public static void main(String[] args) {
//        int year = 2023; // 指定年份
//        int month = 9; // 指定月份
//        List<WorkDay> workDays = partitionCalendar(year, month);
//
//        // 输出每个工作日是本月的第几周
//        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd");
//        for (WorkDay workDay : workDays) {
//            LocalDate date = workDay.getDate();
//            String week = workDay.getWeek();
//            System.out.println(formatter.format(date) + " is in Week " + week);
//        }
//    }

    public static List<WorkDay> partitionCalendar(int year, int month) {
        List<WorkDay> workDays = new ArrayList<>();
        YearMonth yearMonth = YearMonth.of(year, month);

        LocalDate startDate = yearMonth.atDay(1);
        LocalDate endDate = yearMonth.atEndOfMonth();

        // 划分工作日
        for (LocalDate date = startDate; date.isBefore(endDate.plusDays(1)); date = date.plusDays(1)) {
            DayOfWeek dayOfWeek = date.getDayOfWeek();

            // 判断是否为工作日（周一到周五）
            if (dayOfWeek != DayOfWeek.SATURDAY && dayOfWeek != DayOfWeek.SUNDAY) {
                int week = date.get(WeekFields.of(DayOfWeek.MONDAY, 1).weekOfMonth()); // 获取是本月的第几周
                workDays.add(new WorkDay(date, String.valueOf(week)));
            }
        }

        return workDays;
    }

    static class WorkDay {
        private LocalDate date;
        private String week;

        public WorkDay(LocalDate date, String week) {
            this.date = date;
            this.week = week;
        }

        public LocalDate getDate() {
            return date;
        }

        public String getWeek() {
            return week;
        }
    }

//    public static void main(String[] args) {
//        int year = 2022; // 指定年份
//        int month = 3; // 指定月份
//        List<Week> weeklyCalendar = generateWeeklyCalendar(year, month);
//
//        // 输出周日历
//        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd");
//        for (Week week : weeklyCalendar) {
//            System.out.println("Week " + week.getWeekNumber() + ":");
//            for (LocalDate date : week.getDates()) {
//                System.out.print(formatter.format(date) + " ");
//            }
//            System.out.println();
//        }
//    }

    public static List<Week> generateWeeklyCalendar(int year, int month) {
        List<Week> weeklyCalendar = new ArrayList<>();
        YearMonth yearMonth = YearMonth.of(year, month);

        LocalDate startDate = yearMonth.atDay(1);
        LocalDate endDate = yearMonth.atEndOfMonth();

        int weekNumber = 1;
        List<LocalDate> dates = new ArrayList<>();
        for (LocalDate date = startDate; date.isBefore(endDate.plusDays(1)); date = date.plusDays(1)) {
            dates.add(date);

            // 如果是周日，则表示一个完整的周结束，创建一个新的周
            if (date.getDayOfWeek() == DayOfWeek.SUNDAY) {
                weeklyCalendar.add(new Week(weekNumber, new ArrayList<>(dates)));
                dates.clear();
                weekNumber++;
            }
        }

        // 处理最后一周不满一周的情况
        if (!dates.isEmpty()) {
            weeklyCalendar.add(new Week(weekNumber, dates));
        }

        return weeklyCalendar;
    }

//    static class Week {
//        private int weekNumber;
//        private List<LocalDate> dates;
//
//        public Week(int weekNumber, List<LocalDate> dates) {
//            this.weekNumber = weekNumber;
//            this.dates = dates;
//        }
//
//        public int getWeekNumber() {
//            return weekNumber;
//        }
//
//        public List<LocalDate> getDates() {
//            return dates;
//        }
//    }

    public static void main(String[] args) {
        int year = 2023; // 指定年份
        Map<Integer, List<Week>> yearlyCalendar = generateYearlyCalendar(year);

        // 输出每个月的周日历
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
        for (int month : yearlyCalendar.keySet()) {
            System.out.println("Month " + month + ":");
            List<Week> weeklyCalendar = yearlyCalendar.get(month);
            for (Week week : weeklyCalendar) {
                System.out.println("  Week " + week.getWeekNumber() + ":");
                //判断weeklyCalendar.get(0).size是否等于7  不等于的话从上一期上不全
                // 1.不是1月的话拿上一个月的最后一月的最后一星期的数据顺序追加到最前面
                // 2.1月份的话需要拿上一年最后一月最后一星期的数据来补全

                //判断weeklyCalendar.get(（weeklyCalendar.size））不足七天的话舍弃
                int last = weeklyCalendar.size()-1;
//                if(weeklyCalendar.get(last).dates.size() < 7){
//                    weeklyCalendar.remove(last);
//                }
                for (LocalDate date : week.getDates()) {
                    System.out.print("    " + formatter.format(date) + " ");
                }
                System.out.println();
            }
        }
    }

    public static Map<Integer, List<Week>> generateYearlyCalendar(int year) {
        Map<Integer, List<Week>> yearlyCalendar = new TreeMap<>();

        for (int month = 1; month <= 12; month++) {
            YearMonth yearMonth = YearMonth.of(year, month);

            LocalDate startDate = yearMonth.atDay(1);
            LocalDate endDate = yearMonth.atEndOfMonth();

            int weekNumber = 1;
            List<Week> weeklyCalendar = new ArrayList<>();
            List<LocalDate> dates = new ArrayList<>();
            for (LocalDate date = startDate; date.isBefore(endDate.plusDays(1)); date = date.plusDays(1)) {
                dates.add(date);

                // 如果是周日，则表示一个完整的周结束，创建一个新的周
                if (date.getDayOfWeek() == DayOfWeek.SUNDAY) {
                    weeklyCalendar.add(new Week(weekNumber, new ArrayList<>(dates)));
                    dates.clear();
                    weekNumber++;
                }
            }

            // 处理最后一周不满一周的情况
            if (!dates.isEmpty()) {
                weeklyCalendar.add(new Week(weekNumber, dates));
            }

            yearlyCalendar.put(month, weeklyCalendar);
        }

        return yearlyCalendar;
    }

    static class Week {
        private int weekNumber;
        private List<LocalDate> dates;

        public Week(int weekNumber, List<LocalDate> dates) {
            this.weekNumber = weekNumber;
            this.dates = dates;
        }

        public int getWeekNumber() {
            return weekNumber;
        }

        public List<LocalDate> getDates() {
            return dates;
        }
    }
//    public static void main(String[] args) throws ParseException {
//        String a="2022-6-1";
//        String b="2017.3";
//        String c="2021.11.1";
//        String d="2021.1.1";
//        String e="2020/11/1";
//        String f="2020/7";
//        String newtime=DateSplitUtil.strToDate(a);
//        System.out.println("时间:"+newtime);
//         newtime=DateSplitUtil.strToDate(b);
//        System.out.println("时间:"+newtime);
//         newtime=DateSplitUtil.strToDate(c);
//        System.out.println("时间:"+newtime);
//         newtime=DateSplitUtil.strToDate(d);
//        System.out.println("时间:"+newtime);
//         newtime=DateSplitUtil.strToDate(e);
//        System.out.println("时间:"+newtime);
//         newtime=DateSplitUtil.strToDate(f);
//        System.out.println("时间:"+newtime);
//
//    }
//    public static void main(String[] args) {
//        String s ="2023-01-11";
//        String newtime=DateSplitUtil.addDayTime(s);
//        System.out.println("字符串的长度为:"+s.length());
//        System.out.println("新时间:"+newtime);
//    }
//    public static void main(String[] args) throws ParseException {
//       String s =DateSplitUtil.getNowTime(1);
//       System.out.println(s);
//    }
//    public static void main(String[] args) {
//        /**
//         * 判断当前时间是否在一个时间段内 HH:mm 格式
//         */
//        String strStartTime1 = "2024-1-1";
//        String strEndTime1 = "2025-12-31";
//
//        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
//        String now = sdf.format(new Date());
//        Date nowTime;
//        try {
//            nowTime = sdf.parse(now);
//            Date startTime1 = sdf.parse(strStartTime1);
//            Date endTime1 = sdf.parse(strEndTime1);
//            // 注：也可以通过此方式判断当前时间是否具体时间段内 yyyy-MM-dd HH:mm:ss格式 [2022-03-09 12:00:00,2022-03-10 15:00:00]
//            //   当前时间和时间段的格式保持一致即可判断
//            if (isBeforeDate(nowTime, startTime1)) {
//                System.out.println("当前时间在时间段内[" + isBeforeDate(nowTime, startTime1) + ",");
//            } else {
//                System.out.println("当前时间不再时间段内[" + isBeforeDate(nowTime, startTime1) + "]");
//            }
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//    }
//       public static void main(String[] args) throws ParseException {
//           String s=DateSplitUtil.downdate();
//           String s1=DateSplitUtil.getChinaDateFromString(DateSplitUtil.downdate());
//           System.out.println("结果输出"+DateSplitUtil.getChinaDateFromString(DateSplitUtil.downdate()));
//        //2019-10-25 13:25:55
//        DateFormat dateFormat1 = new SimpleDateFormat("yyyy-MM-dd");
//        Date start = dateFormat1.parse("2020-08-01");
//        Date end = dateFormat1.parse("2025-08-05");
//        LocalDateTime startTime = start.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime();
//        LocalDateTime endTime = end.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime();
//        //LocalDateTime startTime = LocalDateTime.of(2019, 10, 25, 13, 25, 55);
//        //2020-01-25 12:30:32
//        //LocalDateTime endTime = LocalDateTime.of(2020, 1, 25, 12, 30, 32);
//        List<DateRange> dateMonthRanges = DateSplitUtil.splitDateRangeByYear1(startTime, endTime);
//        System.out.println("按月切分后的结果：\n{}"+dateMonthRanges);
//        System.out.println("按月切分后的结果：\n{}"+dateMonthRanges.size());
//    }
}
 

下面是运行的效果截图：

相关文章：

【知识分享】Java获取全年每个月的有几周且每周是几号到几号

加哥本周给大家分享一期怎么用java把全年每个月有几周&#xff0c;本周是几号到几号的工具类。便于大家根据需求获取想要的形式进行改造。话不多说&#xff0c;直接给大家上代码。 package com.techfantasy.common.utils; import com.techfantasy.common.entity.DateRange; i…...

编程日记 2023/9/25 8:08:27

学信息系统项目管理师第4版系列11_信息安全管理

1. 信息安全基础 1.1. 保密性(Confidentiality&#xff09; 1.1.1. 信息不被未授权者知晓的属性 1.1.2. 确保信息不暴露给未授权的实体或进程 1.2. 完整性(Integrity) 1.2.1. 信息是正确的、真实的、未被篡改的、完整无缺的属性 1.2.2. 只有得到允许的人才能修改数据&…...

编程日记 2023/9/25 8:05:25

sql注入原理分析

...

编程日记 2023/9/25 8:03:23

Mac磁盘空间满了怎么办？Mac如何清理磁盘空间

你是不是发现你的Mac电脑存储越来越满&#xff0c;甚至操作系统本身就占了100多G的空间&#xff1f;这不仅影响了电脑的性能&#xff0c;而且也让你无法存储更多的重要文件和软件。别担心&#xff0c;今天这篇文章将告诉你如何清除多余的文件&#xff0c;让你的Mac重获新生。 一…...

编程日记 2023/9/25 8:02:22

能ping通但无法上网的问题

大家好&#xff0c;今天我要和大家分享一下当你的IP地址能够成功 ping 通&#xff0c;却无法上网时该如何解决这个问题。这是一个相当常见的情况&#xff0c;在网络故障排查中经常遇到。别担心&#xff0c;我将为你揭开这个谜题&#xff0c;提供一些解决方案和技巧。 首先&…...

编程日记 2023/9/25 8:01:21

仿制 Google Chrome 的恐龙小游戏

通过仿制 Google Chrome 的恐龙小游戏&#xff0c;我们可以掌握如下知识点&#xff1a; 灵活使用视口单位掌握绝对定位JavaScript 来操作 CSS 变量requestAnimationFrame 函数的使用无缝动画实现 页面结构 实现页面结构 通过上述的页面结构我们可以知道&#xff0c;此游戏中…...

编程日记 2023/9/25 8:00:21

Redis面试题(五)

文章目录 前言一、使用过 Redis 做异步队列么&#xff0c;你是怎么用的&#xff1f;有什么缺点&#xff1f;二、 什么是缓存穿透&#xff1f;如何避免&#xff1f;什么是缓存雪崩&#xff1f;何如避免&#xff1f;总结 前言 使用过 Redis 做异步队列么&#xff0c;你是怎么用的…...

编程日记 2023/9/25 7:58:19

组队竞赛（int溢出问题）

目录 一、题目 二、代码 &#xff08;一&#xff09;没有注意int溢出 &#xff08;二&#xff09;正确代码 1. long long sum0 2. #define int long long 3. 使用现成的sort函数 一、题目 二、代码 &#xff08;一&#xff09;没有注意int溢出 #include <iostream&g…...

编程日记 2023/9/25 7:57:18

Swift SwiftUI 隐藏键盘

如果仅支持 iOS 15 及更高版本&#xff0c;则可以通过聚焦和取消聚焦来激活和关闭文本字段的键盘。 在最简单的形式中&#xff0c;这是使用 FocusState 属性包装器和 focusable() 修饰符完成的-第一个存储一个布尔值&#xff0c;用于跟踪第二个当前是否被聚焦。 Code struct C…...

编程日记 2023/9/25 7:56:17

Python与数据分析--Pandas-1

目录 1.Pandas简介 2.Series的创建 1.通过数组列表来创建 2.通过传入标量创建 3.通过字典类型来创建 4.通过numpy来创建 3.Series的索引和应用 1. 通过index和values信息 2. 通过切片方法获取信息 4.DataFrame的创建 1.直接创建 2.矩阵方式创建 3.字典类型创建 5.…...

编程日记 2023/9/25 7:53:14

如何完美通过token获取用户信息（springboot）

1. 什么是Token&#xff1f; 身份验证令牌&#xff08;Authentication Token&#xff09;&#xff1a;在身份验证过程中&#xff0c;“token” 可以表示一个包含用户身份信息的令牌。 例如 Token&#xff08;JWT&#xff09;是一种常见的身份验证令牌&#xff0c;它包含用户的…...

编程日记 2023/9/25 7:52:13

2023 “华为杯” 中国研究生数学建模竞赛（B题）深度剖析|数学建模完整代码+建模过程全解全析

华为杯数学建模B题 当大家面临着复杂的数学建模问题时&#xff0c;你是否曾经感到茫然无措&#xff1f;作为2021年美国大学生数学建模比赛的O奖得主&#xff0c;我为大家提供了一套优秀的解题思路&#xff0c;让你轻松应对各种难题。 让我们来看看研赛的B题呀~&#xff01; 问…...

编程日记 2023/9/25 7:51:11

文件相关工具类

文章目录 1.MultipartFile文件转File2.读取文件(txt、json)3.下载网络文件4.压缩文件 1.MultipartFile文件转File public File transferToFile(MultipartFile multipartFile) { // 选择用缓冲区来实现这个转换即使用java 创建的临时文件 使用 MultipartFile.transferto()…...

编程日记 2023/9/25 7:49:10

18795-2012 茶叶标准样品制备技术条件

声明 本文是学习GB-T 18795-2012 茶叶标准样品制备技术条件. 而整理的学习笔记,分享出来希望更多人受益,如果存在侵权请及时联系我们 1 范围 本标准规定了各类茶叶(除再加工茶)标准样品的制备、包装、标签、标识、证书和有效期。 本标准适用于各类茶叶(除再加工茶)感官品质…...

编程日记 2023/9/25 7:48:09

C++11互斥锁的使用

是C11标准库中用于多线程同步的库&#xff0c;提供互斥锁(mutex)及其相关函数。 以下是一些基本的使用示例&#xff1a; 1.创建和销毁互斥锁 #include <mutex>std::mutex mtx;2.加锁 std::lock_guard<std::mutex> lock(mtx); // 加锁 // 或者 mtx.lock(); //…...

编程日记 2023/9/25 7:46:06

unity 桌面程序

using System; using System.Collections; using System.Collections.Generic; using System.Runtime.InteropServices; using UnityEngine; public class chuantou : MonoBehaviour { [DllImport(“user32.dll”)] public static extern int MessageBox(IntPtr hwnd,string t…...

编程日记 2023/9/25 7:45:05

echarts统一纵坐标y轴的刻度线，刻度线对齐。

要求&#xff1a; 纵坐标刻度线对齐&#xff1b;刻度间隔为5&#xff1b;去掉千位默认的逗号&#xff1b;刻度最小是0. 效果图&#xff1a; 代码&#xff1a; yAxis: [{type: "value",position: "left",name: "kW",offset: 100,nameTextStyle:…...

编程日记 2023/9/25 7:44:04

一个数据库版本兼容问题

mysql旧的版本号是&#xff1a;5.3.10 本机版本号是&#xff1a;8.0.22 报错&#xff1a;“com.mysql.jdbc.exceptions.jdbc4.MySQLNonTransientConnectionException: Could not create” 1.程序里做兼容&#xff1a; <dependency><groupId>mysql</groupId>…...

编程日记 2023/9/25 7:40:00

学习Nano编辑器：入门指南、安装步骤、基本操作和高级功能

文章目录 使用Nano编辑器入门指南引言1.1 关于Nano编辑器1.2 Nano的起源和特点 安装Nano2.1 在Debian/Ubuntu系统上安装Nano2.2 在CentOS/RHEL系统上安装Nano2.3 在其他Linux发行版上安装Nano 启动Nano3.1 命令行启动Nano3.2 打开文件 Nano的基本操作4.1 光标移动和选择文本4.2…...

编程日记 2023/9/25 7:37:58

在北京多有钱能称为富

背景 首先声明&#xff0c;此讨论仅限个人的观点&#xff0c;因为我本身不富嘛&#xff0c;所以想法应该非常局限。 举个栗子 富二代问我朋友&#xff0c;100~1000w之间&#xff0c;推荐一款车&#xff1f; 一开始听到这个问题的时候&#xff0c;有被唬住&#xff0c;觉得预…...

编程日记 2023/9/25 7:35:56

转转集团旗下首家二手多品类循环仓店“超级转转”开业

6月9日&#xff0c;国内领先的循环经济企业转转集团旗下首家二手多品类循环仓店“超级转转”正式开业。 转转集团创始人兼CEO黄炜、转转循环时尚发起人朱珠、转转集团COO兼红布林CEO胡伟琨、王府井集团副总裁祝捷等出席了开业剪彩仪式。 据「TMT星球」了解&#xff0c;“超级…...

编程新知 2025/7/6 1:15:25

深入解析C++中的extern关键字：跨文件共享变量与函数的终极指南

&#x1f680; C extern 关键字深度解析&#xff1a;跨文件编程的终极指南 &#x1f4c5; 更新时间&#xff1a;2025年6月5日 &#x1f3f7;️ 标签&#xff1a;C | extern关键字 | 多文件编程 | 链接与声明 | 现代C 文章目录 前言&#x1f525;一、extern 是什么&#xff1f;&…...

编程新知 2025/6/22 1:04:56

Java 二维码

Java 二维码 **技术&#xff1a;**谷歌 ZXing 实现 首先添加依赖 <!-- 二维码依赖 --><dependency><groupId>com.google.zxing</groupId><artifactId>core</artifactId><version>3.5.1</version></dependency><de…...

编程新知 2025/6/21 12:56:10

重启Eureka集群中的节点，对已经注册的服务有什么影响

先看答案&#xff0c;如果正确地操作&#xff0c;重启Eureka集群中的节点&#xff0c;对已经注册的服务影响非常小&#xff0c;甚至可以做到无感知。 但如果操作不当&#xff0c;可能会引发短暂的服务发现问题。 下面我们从Eureka的核心工作原理来详细分析这个问题。 Eureka的…...

编程新知 2025/6/25 4:08:42

JVM虚拟机：内存结构、垃圾回收、性能优化

1、JVM虚拟机的简介 Java 虚拟机（Java Virtual Machine 简称：JVM）是运行所有 Java 程序的抽象计算机，是 Java 语言的运行环境，实现了 Java 程序的跨平台特性。JVM 屏蔽了与具体操作系统平台相关的信息，使得 Java 程序只需生成在 JVM 上运行的目标代码（字节码），就可以…...

编程新知 2025/6/27 10:36:03

嵌入式学习笔记DAY33（网络编程——TCP）

一、网络架构 C/S &#xff08;client/server 客户端/服务器&#xff09;&#xff1a;由客户端和服务器端两个部分组成。客户端通常是用户使用的应用程序&#xff0c;负责提供用户界面和交互逻辑 &#xff0c;接收用户输入&#xff0c;向服务器发送请求&#xff0c;并展示服务…...

编程新知 2025/7/4 15:02:59

Linux 中如何提取压缩文件 ？

Linux 是一种流行的开源操作系统&#xff0c;它提供了许多工具来管理、压缩和解压缩文件。压缩文件有助于节省存储空间&#xff0c;使数据传输更快。本指南将向您展示如何在 Linux 中提取不同类型的压缩文件。 1. Unpacking ZIP Files ZIP 文件是非常常见的&#xff0c;要在 …...

编程新知 2025/7/2 15:09:00

【 java 虚拟机知识 第一篇 】

目录 1.内存模型 1.1.JVM内存模型的介绍 1.2.堆和栈的区别 1.3.栈的存储细节 1.4.堆的部分 1.5.程序计数器的作用 1.6.方法区的内容 1.7.字符串池 1.8.引用类型 1.9.内存泄漏与内存溢出 1.10.会出现内存溢出的结构 1.内存模型 1.1.JVM内存模型的介绍 内存模型主要分…...

编程新知 2025/7/5 23:21:51

提升移动端网页调试效率：WebDebugX 与常见工具组合实践

在日常移动端开发中&#xff0c;网页调试始终是一个高频但又极具挑战的环节。尤其在面对 iOS 与 Android 的混合技术栈、各种设备差异化行为时&#xff0c;开发者迫切需要一套高效、可靠且跨平台的调试方案。过去&#xff0c;我们或多或少使用过 Chrome DevTools、Remote Debug…...

编程新知 2025/6/10 21:08:23

面试高频问题

文章目录 &#x1f680; 消息队列核心技术揭秘&#xff1a;从入门到秒杀面试官1️⃣ Kafka为何能"吞云吐雾"&#xff1f;性能背后的秘密1.1 顺序写入与零拷贝&#xff1a;性能的双引擎1.2 分区并行&#xff1a;数据的"八车道高速公路"1.3 页缓存与批量处理…...

编程新知 2025/6/21 4:22:18