java时间工具类（上周、本周、本月、上月、本季度、上季度、本年、去年开始时间和结束时间）

最新推荐文章于 2024-07-13 03:14:49 发布
最新推荐文章于 2024-07-13 03:14:49 发布
阅读量3.9k 收藏 15
点赞数 2
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39187822/article/details/124375773
版权

1. 获取本周的第一天或最后一天

	/**
     * @Description TODO 获取本周的第一天或最后一天
     * @Param: [today, isFirst: true 表示开始时间，false表示结束时间]
     * @return: java.lang.String
     */
    public static String getStartOrEndDayOfWeek(LocalDate today, Boolean isFirst) {
        Date time;
        Calendar cal = Calendar.getInstance();
        if (isFirst) {
            cal.add(Calendar.WEEK_OF_MONTH, 0);
            cal.set(Calendar.DAY_OF_WEEK, 2);
        } else {
            cal.set(Calendar.DAY_OF_WEEK, cal.getActualMaximum(Calendar.DAY_OF_WEEK));
            cal.add(Calendar.DAY_OF_WEEK, 1);
        }
        time = cal.getTime();
        return new SimpleDateFormat("yyyy-MM-dd").format(time);
    }

2. 获取上一周的开始时间和结束时间（周五为每周第一天）

	/**
     * 功能描述: TODO 获取上一周的开始时间和结束时间（周五为每周第一天）
     */
    public static Map<String, String> getLastWeekStartOrEndDayOfWeek() {
        Map<String, String> dayMap = new HashMap<>(16);
        String beginTime;
        String endTime;
        Calendar date = Calendar.getInstance(Locale.CHINA);
        date.setFirstDayOfWeek(Calendar.FRIDAY);
        //周数减一，即上周
        date.add(Calendar.WEEK_OF_MONTH, -1);
        //日子设为周几开始
        date.set(Calendar.DAY_OF_WEEK, Calendar.FRIDAY);
        beginTime = sdf.format(date.getTime());
        date.set(Calendar.DAY_OF_WEEK, Calendar.THURSDAY);
        endTime = sdf.format(date.getTime());
        dayMap.put("beginTime", beginTime);
        dayMap.put("endTime", endTime);
        return dayMap;
    }

3. 获取本月的第一天或最后一天

	/**
     * 功能描述: 获取本月的第一天或最后一天
     * @Param: [today, isFirst: true 表示开始时间，false表示结束时间]
     * @return: java.lang.String
     */
    public static String getStartOrEndDayOfMonth(LocalDate today, Boolean isFirst) {
        LocalDate resDate = LocalDate.now();
        if (today == null) {
            today = resDate;
        }
        Month month = today.getMonth();
        int length = month.length(today.isLeapYear());
        if (isFirst) {
            resDate = LocalDate.of(today.getYear(), month, 1);
        } else {
            resDate = LocalDate.of(today.getYear(), month, length);
        }
        return resDate.toString();
    }

4. 获取上月开始日期和结束日期

	/**
     * 功能描述: 获取上月开始日期和结束日期
     */
    public static Map<String, String> getLastStartOrEndDayOfMonth() {
        Map<String, String> dayMap = new HashMap<>(16);
        //获取当前日期
        Calendar cal = Calendar.getInstance();
        cal.add(Calendar.MONTH, -1);
        //设置为1号,当前日期既为本月第一天
        cal.set(Calendar.DAY_OF_MONTH, 1);
        String firstDay = sdf.format(cal.getTime());
        //获取前月的最后一天
        Calendar cale = Calendar.getInstance();
        //设置为1号,当前日期既为本月第一天
        cale.set(Calendar.DAY_OF_MONTH, 0);
        String lastDay = sdf.format(cale.getTime());
        dayMap.put("beginTime", firstDay);
        dayMap.put("endTime", lastDay);
        return dayMap;
    }

5. 获取本季度的第一天或最后一天

	/**
     * @Description TODO 获取本季度的第一天或最后一天
     * @Param: [today, isFirst: true 表示开始时间，false表示结束时间]
     * @return: java.lang.String
     */
    public static String getStartOrEndDayOfQuarter(LocalDate today, Boolean isFirst) {
        LocalDate resDate = LocalDate.now();
        if (today == null) {
            today = resDate;
        }
        Month month = today.getMonth();
        Month firstMonthOfQuarter = month.firstMonthOfQuarter();
        Month endMonthOfQuarter = Month.of(firstMonthOfQuarter.getValue() + 2);
        if (isFirst) {
            resDate = LocalDate.of(today.getYear(), firstMonthOfQuarter, 1);
        } else {
            resDate = LocalDate.of(today.getYear(), endMonthOfQuarter, endMonthOfQuarter.length(today.isLeapYear()));
        }
        return resDate.toString();
    }

6. 获取上个季度开始和结束时间

	/**
     * 功能描述: TODO 获取上个季度开始和结束时间
     */
    public static Map<String, String> getLastStartOrEndDayOfQuarter(){
        Map<String, String> dayMap = new HashMap<>(16);
        String beginTime = "";
        String endTime = "";
        LocalDate today = LocalDate.now();
        Month month = today.getMonth();
        // 当前季度的第一个月
        Month firstMonthOfQuarter = month.firstMonthOfQuarter();
        // 如果是当前年的第一个季度
        if(firstMonthOfQuarter.getValue() == 1){
            // 则获取去年的最后一个季度
            LocalDate lastQuarterToday = LocalDate.of(today.getYear()-1, today.getMonth().getValue()+9, today.getDayOfMonth());
            Month lastFirstMonthOfQuarter = lastQuarterToday.getMonth().firstMonthOfQuarter();
            Month endMonthOfQuarter = Month.of(lastFirstMonthOfQuarter.getValue() + 2);
            beginTime = LocalDate.of(today.getYear()-1, lastFirstMonthOfQuarter,1).toString();
            endTime = LocalDate.of(today.getYear()-1, endMonthOfQuarter, endMonthOfQuarter.length(today.isLeapYear())).toString();
        }else{
            // 则获取去年的最后一个季度
            LocalDate lastQuarterToday = LocalDate.of(today.getYear(), today.getMonth().getValue()-3, today.getDayOfMonth());
            Month lastFirstMonthOfQuarter = lastQuarterToday.getMonth().firstMonthOfQuarter();
            Month endMonthOfQuarter = Month.of(lastFirstMonthOfQuarter.getValue() + 2);
            beginTime = LocalDate.of(today.getYear(), lastFirstMonthOfQuarter,1).toString();
            endTime = LocalDate.of(today.getYear(), endMonthOfQuarter, endMonthOfQuarter.length(today.isLeapYear())).toString();
        }
        dayMap.put("beginTime", beginTime);
        dayMap.put("endTime", endTime);
        return dayMap;
    }

7. 获取本年的第一天或最后一天

	/**
     * @Description TODO 获取本年的第一天或最后一天
     * @Param: [today, isFirst: true 表示开始时间，false表示结束时间]
     * @return: java.lang.String
     */
    public static String getStartOrEndDayOfYear(LocalDate today, Boolean isFirst) {
        LocalDate resDate = LocalDate.now();
        if (today == null) {
            today = resDate;
        }
        if (isFirst) {
            resDate = LocalDate.of(today.getYear(), Month.JANUARY, 1);
        } else {
            resDate = LocalDate.of(today.getYear(), Month.DECEMBER, Month.DECEMBER.length(today.isLeapYear()));
        }
        return resDate.toString();
    }

8. 获取去年的第一天或最后一天

	/**
     * @Description TODO 获取去年的第一天或最后一天
     * @Param: [today, isFirst: true 表示开始时间，false表示结束时间]
     * @return: java.lang.String
     */
    public static Map<String, String> getLastStartOrEndDayOfYear() {
        Map<String, String> map = new HashMap<>(16);
        LocalDate today = LocalDate.now();
        LocalDate beginTime = LocalDate.of(today.getYear()-1, Month.JANUARY, 1);
        LocalDate endTime = LocalDate.of(today.getYear()-1, Month.DECEMBER, Month.DECEMBER.length(today.isLeapYear()));
        map.put("beginTime", beginTime.toString());
        map.put("endTime", endTime.toString());
        return map;
    }

整体代码

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.Month;
import java.util.*;

/**
 * @name 时间工具类
 * @Version 1.0
 */
public class DateUtils {

    /**
     * 获取昨天
     * @return String
     */
    public static String getYestoday() {
        Calendar cal = Calendar.getInstance();
        cal.add(Calendar.DATE, -1);
        Date time = cal.getTime();
        return new SimpleDateFormat("yyyy-MM-dd").format(time);
    }

    /**
     * @Description TODO 获取本周的第一天或最后一天
     * @Param: [today, isFirst: true 表示开始时间，false表示结束时间]
     * @return: java.lang.String
     */
    public static String getStartOrEndDayOfWeek(LocalDate today, Boolean isFirst) {
        Date time;
        Calendar cal = Calendar.getInstance();
        if (isFirst) {
            cal.add(Calendar.WEEK_OF_MONTH, 0);
            cal.set(Calendar.DAY_OF_WEEK, 2);
        } else {
            cal.set(Calendar.DAY_OF_WEEK, cal.getActualMaximum(Calendar.DAY_OF_WEEK));
            cal.add(Calendar.DAY_OF_WEEK, 1);
        }
        time = cal.getTime();
        return new SimpleDateFormat("yyyy-MM-dd").format(time);
    }

    /**
     * 功能描述: TODO 获取上一周的开始时间和结束时间（周五为每周第一天）
     */
    public static Map<String, String> getLastWeekStartOrEndDayOfWeek() {
        Map<String, String> dayMap = new HashMap<>(16);
        String beginTime;
        String endTime;
        Calendar date = Calendar.getInstance(Locale.CHINA);
        date.setFirstDayOfWeek(Calendar.FRIDAY);
        //周数减一，即上周
        date.add(Calendar.WEEK_OF_MONTH, -1);
        //日子设为周几
        date.set(Calendar.DAY_OF_WEEK, Calendar.FRIDAY);
        beginTime = sdf.format(date.getTime());
        date.set(Calendar.DAY_OF_WEEK, Calendar.THURSDAY);
        endTime = sdf.format(date.getTime());
        dayMap.put("beginTime", beginTime);
        dayMap.put("endTime", endTime);
        return dayMap;
    }

    /**
     * 功能描述: 获取本月的第一天或最后一天
     * @Param: [today, isFirst: true 表示开始时间，false表示结束时间]
     * @return: java.lang.String
     */
    public static String getStartOrEndDayOfMonth(LocalDate today, Boolean isFirst) {
        LocalDate resDate = LocalDate.now();
        if (today == null) {
            today = resDate;
        }
        Month month = today.getMonth();
        int length = month.length(today.isLeapYear());
        if (isFirst) {
            resDate = LocalDate.of(today.getYear(), month, 1);
        } else {
            resDate = LocalDate.of(today.getYear(), month, length);
        }
        return resDate.toString();
    }

    /**
     * 功能描述: 获取上月开始日期和结束日期
     */
    public static Map<String, String> getLastStartOrEndDayOfMonth() {
        Map<String, String> dayMap = new HashMap<>(16);
        //获取当前日期
        Calendar cal = Calendar.getInstance();
        cal.add(Calendar.MONTH, -1);
        //设置为1号,当前日期既为本月第一天
        cal.set(Calendar.DAY_OF_MONTH, 1);
        String firstDay = sdf.format(cal.getTime());
        //获取前月的最后一天
        Calendar cale = Calendar.getInstance();
        //设置为1号,当前日期既为本月第一天
        cale.set(Calendar.DAY_OF_MONTH, 0);
        String lastDay = sdf.format(cale.getTime());
        dayMap.put("beginTime", firstDay);
        dayMap.put("endTime", lastDay);
        return dayMap;
    }

    /**
     * @Description TODO 获取本季度的第一天或最后一天
     * @Param: [today, isFirst: true 表示开始时间，false表示结束时间]
     * @return: java.lang.String
     */
    public static String getStartOrEndDayOfQuarter(LocalDate today, Boolean isFirst) {
        LocalDate resDate = LocalDate.now();
        if (today == null) {
            today = resDate;
        }
        Month month = today.getMonth();
        Month firstMonthOfQuarter = month.firstMonthOfQuarter();
        Month endMonthOfQuarter = Month.of(firstMonthOfQuarter.getValue() + 2);
        if (isFirst) {
            resDate = LocalDate.of(today.getYear(), firstMonthOfQuarter, 1);
        } else {
            resDate = LocalDate.of(today.getYear(), endMonthOfQuarter, endMonthOfQuarter.length(today.isLeapYear()));
        }
        return resDate.toString();
    }

    /**
     * 功能描述: TODO 获取上个季度开始和结束时间
     */
    public static Map<String, String> getLastStartOrEndDayOfQuarter(){
        Map<String, String> dayMap = new HashMap<>(16);
        String beginTime = "";
        String endTime = "";
        LocalDate today = LocalDate.now();
        Month month = today.getMonth();
        // 当前季度的第一个月
        Month firstMonthOfQuarter = month.firstMonthOfQuarter();
        // 如果是当前年的第一个季度
        if(firstMonthOfQuarter.getValue() == 1){
            // 则获取去年的最后一个季度
            LocalDate lastQuarterToday = LocalDate.of(today.getYear()-1, today.getMonth().getValue()+9, today.getDayOfMonth());
            Month lastFirstMonthOfQuarter = lastQuarterToday.getMonth().firstMonthOfQuarter();
            Month endMonthOfQuarter = Month.of(lastFirstMonthOfQuarter.getValue() + 2);
            beginTime = LocalDate.of(today.getYear()-1, lastFirstMonthOfQuarter,1).toString();
            endTime = LocalDate.of(today.getYear()-1, endMonthOfQuarter, endMonthOfQuarter.length(today.isLeapYear())).toString();
        }else{
            // 则获取去年的最后一个季度
            LocalDate lastQuarterToday = LocalDate.of(today.getYear(), today.getMonth().getValue()-3, today.getDayOfMonth());
            Month lastFirstMonthOfQuarter = lastQuarterToday.getMonth().firstMonthOfQuarter();
            Month endMonthOfQuarter = Month.of(lastFirstMonthOfQuarter.getValue() + 2);
            beginTime = LocalDate.of(today.getYear(), lastFirstMonthOfQuarter,1).toString();
            endTime = LocalDate.of(today.getYear(), endMonthOfQuarter, endMonthOfQuarter.length(today.isLeapYear())).toString();
        }
        dayMap.put("beginTime", beginTime);
        dayMap.put("endTime", endTime);
        return dayMap;
    }

    /**
     * @Description TODO 获取本年的第一天或最后一天
     * @Param: [today, isFirst: true 表示开始时间，false表示结束时间]
     * @return: java.lang.String
     */
    public static String getStartOrEndDayOfYear(LocalDate today, Boolean isFirst) {
        LocalDate resDate = LocalDate.now();
        if (today == null) {
            today = resDate;
        }
        if (isFirst) {
            resDate = LocalDate.of(today.getYear(), Month.JANUARY, 1);
        } else {
            resDate = LocalDate.of(today.getYear(), Month.DECEMBER, Month.DECEMBER.length(today.isLeapYear()));
        }
        return resDate.toString();
    }

    /**
     * @Description TODO 获取去年的第一天或最后一天
     * @Param: [today, isFirst: true 表示开始时间，false表示结束时间]
     * @return: java.lang.String
     */
    public static Map<String, String> getLastStartOrEndDayOfYear() {
        Map<String, String> map = new HashMap<>(16);
        LocalDate today = LocalDate.now();
        LocalDate beginTime = LocalDate.of(today.getYear()-1, Month.JANUARY, 1);
        LocalDate endTime = LocalDate.of(today.getYear()-1, Month.DECEMBER, Month.DECEMBER.length(today.isLeapYear()));
        map.put("beginTime", beginTime.toString());
        map.put("endTime", endTime.toString());
        return map;
    }

    private static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    public static final int DAY = 1;       //日
    public static final int WEEK = 2;      //周
    public static final int MONTH = 3;     //月
    public static final int QUARTER = 4; //季度


    public static String getWeekOfYear(String dateStr, int mode){
        Calendar calendar = Calendar.getInstance();
        //将两个日期加载到Calendar中
        if (calendar != null ) {
            try {
                Date date = sdf.parse(dateStr);
                calendar.setTime(date);
                calendar.setFirstDayOfWeek(mode);//设置周五为每周第一天Calendar.FRIDAY
                if (calendar.get(Calendar.WEEK_OF_YEAR) > 1)
                    calendar.setMinimalDaysInFirstWeek(1);//设置跨年的周超5天算本年的。
                return calendar.get(Calendar.WEEK_OF_YEAR)+"";
            } catch (ParseException e) {
                e.printStackTrace();
            }
        }
        return null;
    }
    /**
     * 遍历两个日期之间的日、周、月
     * @param startDateStr 开始日期字符串
     * @param endDateStr   结束字符串
     * @param Flag         遍历的标志，按日还是按周遍历    DAY:日  WEEK：周  MONTH：月
     */
    public static String[] dateForEach(String startDateStr, String endDateStr, Integer Flag) {
        List<String> result = new ArrayList<>(12);
        //将字符串类型的日期转换为Date类型并加载到Calendar中(有异常直接抛)
        Date startDate = null;
        try {
            System.out.println("startDateStr==>" + startDateStr);
            startDate = sdf.parse(startDateStr);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        Date endDate = null;
        try {
            System.out.println("endDateStr==>" + endDateStr);
            endDate = sdf.parse(endDateStr);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        //实例化Calendar
        Calendar startCalendar = Calendar.getInstance();
        Calendar endCalendar = Calendar.getInstance();
        //将两个日期加载到Calendar中
        if (startDate != null && endDate != null) {
            startCalendar.setTime(startDate);
            endCalendar.setTime(endDate);
        }
        //开始遍历
        switch (Flag) {
            case WEEK:
                //按周输出
                do {

                    System.out.println(startCalendar.get(Calendar.WEEK_OF_YEAR) + "周");
                    System.out.println(startCalendar.getTime());
                    startCalendar.setFirstDayOfWeek(Calendar.FRIDAY);//设置周五为每周第一天
                    if (startCalendar.get(Calendar.WEEK_OF_YEAR) > 1)
                        startCalendar.setMinimalDaysInFirstWeek(1);//设置跨年的周超5天算本年的。
                    result.add(startCalendar.get(Calendar.WEEK_OF_YEAR) + "周");
                    startCalendar.add(Calendar.WEEK_OF_YEAR, 1);
                } while (!startCalendar.equals(endCalendar) && !startCalendar.after(endCalendar));
                break;
            case MONTH:
                do {
                    System.out.println(startCalendar.get(Calendar.MONTH) + 1 + "月");
                    result.add(startCalendar.get(Calendar.MONTH) + 1 + "月");
                    //日期加1
                    startCalendar.add(Calendar.MONTH, 1);
                    //当前日期和结束日历日期比较，超过结束日期则终止
                } while (!startCalendar.after(endCalendar));
                break;
            case QUARTER:
                do {
                    int q = 0;
                    //和按日输出差不多
                    if (startCalendar.get(Calendar.MONTH) <= 2) {
                        q = 1;
                    } else if (startCalendar.get(Calendar.MONTH) >= 3 && startCalendar.get(Calendar.MONTH) <= 5) {
                        q = 2;
                    } else if (startCalendar.get(Calendar.MONTH) >= 6 && startCalendar.get(Calendar.MONTH) <= 8) {
                        q = 3;
                    } else if (startCalendar.get(Calendar.MONTH) >= 9 && startCalendar.get(Calendar.MONTH) <= 11) {
                        q = 4;
                    }
                    System.out.println(q);
                    result.add(q + "季度");
                    //日期加1
                    startCalendar.add(Calendar.MONTH, 3);
                    //当前日期和结束日历日期比较，超过结束日期则终止
                } while (!startCalendar.after(endCalendar));
        }
        return result.toArray(new String[0]);
    }

    //测试
    public static void main(String[] args) {
//        String startDateStr = "2018-05-01";
//        String endDateStr = "2018-12-31";
//        System.out.println(Arrays.toString(DateUtils.dateForEach(startDateStr, endDateStr, WEEK)));
        System.out.println(getLastStartOrEndDayOfQuarter());
    }
}
昵称长度需在 2 到 20 个字符
关注
  • 2
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
Java8 LocalDateTime 获取当前日周月年的起止时间
Athena072213的博客
08-22 5828
Java8 获取当天、本周、本月、本季度、本年度起止时间一、返回 LocalDateTime 格式的起止时间二、返回 String 格式的起止时间 一、返回 LocalDateTime 格式的起止时间 /** * @Description:返回 LocalDateTime 格式的日、周、月、季度、年起止时间 * @Author: lsiyan * @Date: 2020/8/21 22:47 */ import java.time.*; import java.time.temporal.Temp
java根据时间生成唯一ID
06-12
java根据时间生成唯一ID,普通的根据时间生成的ID放在循环内很容易重复。
Java获取上周，本周，本月，本年，开始结束时间 。日期工具类
热门推荐
cjw1231的博客
08-10 2万+
由于获取日期经常会使用到,所有我自己写了一个工具类 1、基本上能用上的都写出来了,包括: 1)获取当天的开始时间  2)获取当天的结束时间  3)获取昨天的开始时间  4)获取昨天的结束时间  5)获取明天的开始时间  6)获取明天的结束时间  7)获取本周的开始时间  8)获取本周的结束时间  9)获取上周的开始时间  10)获取上周的结束时间  11)获取本月的开始时间  12)获取本月的结束...
java获取开始时间和结束时间
最新发布
weixin_42014811的博客
07-13 133
如何在Java中获取开始时间和结束时间 一、整体流程 首先让我们来看一下获取开始时间和结束时间的整体流程： 步骤 操作 1 声明开始时间变量 2 获取当前时间作为开始时间 3 声明结束时间变量 4 获取当前时间作为结束时间 5 计算时间差 二、具体步骤 第一步：声明开始时间变量 在Jav...
Java：获取当前日期当前季度、上一季度开始结束日期时间
枯萎花一朵
02-18 1万+
获取当前时间的所在季度开始结束日期。
Java获取今天、本周、本月、本季度、上月、上一年的时间范围
weixin_51933432的博客
01-15 882
Java获取今天、本周、本月、本季度、上月、上一年的时间范围
Java获取某天、某月或某年的开始结束日期或开始结束时间戳
Just_do_it_HZF的博客
11-21 1322
【代码】Java获取某天、某月或某年的开始结束日期或开始结束时间戳。
Java获取前N个季度的开始时间和结束时间
qq_43700885的博客
05-24 515
Java获取前N个季度的开始时间和结束时间
日期工具Java类
10-23
通过正确使用java.util.Calendar、java.text.SimpleDateFormat等类，可以轻松获取如当前日期、上月日期、上周日期等特殊日期，对于日志记录、数据统计和时间追踪等功能的实现至关重要。在实际开发中，应当仔细处理...
15.时间序列预测（LSTM模型）python代码实现
05-08
时间序列预测是数据分析领域中的一个重要话题，特别是在诸如股票市场预测、销售趋势分析、天气预报等应用场景中。...通过实践这一过程，可以提升对LSTM和时间序列预测的理解，为实际项目提供有力的工具。
java中ping命令ping工具类(循环ping)
05-09
java ping ip ping命令 ping工具类 支持linux和windows等所有平台 Ping是Windows下的一个命令 在Unix和Linux下也有这个命令。 ping也属于一个通信协议，是TCP/IP协议的一部分 利用“ping”命令可以检查网络是否连通...
Java获取本周一、上周一、下周一时间
09-10
Java获取本周一、上周一、下周一时间，Java获取本周一、上周一、下周一时间，Java获取本周一、上周一、下周一时间，Java获取本周一、上周一、下周一时间
时间序列预测讲义（ARIMA&LSTM;）及python代码
06-13
本讲义主要探讨了两种常用的时间序列预测模型：ARIMA（自回归积分滑动平均模型）和LSTM（长短期记忆网络），并结合Python编程实践进行了深入讲解。 ARIMA模型是基于线性统计模型的时间序列预测方法，它结合了自回归...
java 获取当前时间的上下几月、上下几周、前后几天等各种日期转换
jiafeng_lee的博客
11-09 579
【代码】java 获取当前时间的上下几月、上下几周、前后几天等各种日期转换。
Java日期查询：日、周、旬、月、季度、年等时间操作
u010486495的专栏
12-21 6339
在进行频次、周期业务处理的时候，需要查询日、周、旬、月、季度、年等周期时间，为此而写的一个时间工具类。 import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.ArrayList; import java.util.Calendar; import java.util.Date;...
java时间操作工具类(判断时间是周几、多少号、几月、几年，计算时间差、计算时间相差几天，获取今天、昨天、近7天、本周、本月、本季、本年、去年开始时间和结束时间，获取本周、本月、本季、本年集合)
weixin_45826772的博客
12-21 1807
1.获取本周开始和结束时间 /** * 获得本周开始时间 * @return 结果 */ public static Date getTimesWeekmorning() { Calendar cal = Calendar.getInstance(); cal.set(cal.get(Calendar.YEAR), cal.get(Calendar.MONDAY), cal.get(Calendar.DAY_OF_MONTH), 0,
Java集合中，isEmpty()与size()==0的区别(时间复杂度)。
徒手千行代码无bug
09-19 4441
在进行集合判空时，能用Collection.isEmpty(testList)的就不要用testList.size()，isEmpty不仅可以判断集合是否为null，在时间复杂度上也更优秀。 sonar规范这样描述： Collection.isEmpty() should be used to test for emptiness Using Collection.size() to test for emptiness works, but using Collection.isEmpty() makes
JAVA 之日期通用工具类（日期格式，获取当天开始结束时间，当前年月日，本年第几周等等等）
ABC_wangershao的博客
04-12 2870
代码可以借鉴，转发请标明出处，不可直接盗用发表。 很多新手可能会遇到开发中需要去各种方式的调用时间，为了方便大家，我直接把写好的时间Util提供大家参考，有不当之处不吝赐教。 ​ import org.apache.commons.lang.time.DateFormatUtils; import java.sql.Timestamp; import java.text.ParseException; import java.text.SimpleDateFormat; import java.t
Java获取开始时间和结束时间的季度区间
weixin_35756690的博客
02-15 654
获取开始时间和结束时间所在的季度区间可以按照以下步骤进行： 首先，使用Java中的LocalDate类创建开始时间和结束时间的LocalDate对象，例如： LocalDate startDate= LocalDate.parse("2023-01-01"); LocalDate endDate = LocalDate.parse("2023-02-15"); ...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值