calendar 订阅
Calendar 常数 音标 [英]'kælɪndə(r) [美]ˈkæləndə 中文 日历可在代码中的任何地方用下列常数代替实际值,使用方便 展开全文
Calendar 常数 音标 [英]'kælɪndə(r) [美]ˈkæləndə 中文 日历可在代码中的任何地方用下列常数代替实际值,使用方便
信息
作    用
在代码中任何地方代替实际值
名    称
Calendar
vbCalGreg 0
使用的是阳历
实    质
函数,用于计算机命令
vbCalHijri 1
使用的是伊斯兰历法
Calendar控件
是一个传统的单月份日历
Calendar函数
Calendar 常数可在代码中的任何地方用下列常数代替实际值:常数 值 描述vbCalGreg 0 指出使用的是阳历。vbCalHijri 1 指出使用的是伊斯兰历法。-------------------------------------------------------------
收起全文
精华内容
下载资源
问答
  • calendar
    千次阅读
    2021-08-02 22:57:48

    常量字段

    Calendar类的常量字段是非常重要的参数,在set()、add()、get()方法中都会用到。

    Calendar类中常用的常量字段如下:

    常量字段说明
    Calendar.ERAERA表示纪元,只能为0或1。0表示BC(“before Christ”,即公元前);1表示AD(拉丁语“Anno Domini”,即公元)。
    Calendar.YEAR表示年份
    Calendar.MONTH表示月份,需要加1,因为0表示1月,1表示2月,以此类推
    Calendar.HOUR小时(12小时制)
    Calendar.HOUR_OF_DAY一天中第几个小时(24小时制)
    Calendar.MINUTE分钟
    Calendar.SECOND
    Calendar.MILLISECOND毫秒
    Calendar.DAY_OF_YEAR一年中第几天
    DAY_OF_MONTH一月中第几天
    DAY_OF_WEEK一周中第几天,注意,周日是1,周一是2,...
    Calendar.DATE一月中第几天,同DAY_OF_MONTH的值是一样的
    Calendar.DAY_OF_WEEK_IN_MONTH当月内一周中的某天的序号
    Calendar.WEEK_OF_YEAR一年中的星期数,即本年中第几个星期
    Calendar.WEEK_OF_MONTH当前月中的星期数,即本月中第几个星期
    Calendar.DAY_OF_WEEK_IN_MONTH当前月中的第几个星期
    Calendar.AM_PMAM_PM是在中午之前还是在中午之后,在中午12点之前返回0,在中午12点(包括12点)之后返回1
    Calendar.JANUARY1月
    Calendar.FEBRUARY2月
    Calendar.MARCH3月
    Calendar.APRIL4月
    Calendar.MAY5月
    Calendar.JUNE6月
    Calendar.JULY7月
    Calendar.AUGUST8月
    Calendar.SEPTEMBER9月
    Calendar.OCTOBER10月
    Calendar.NOVEMBER11月
    Calendar.DECEMBER12月

    获取Calendar对象

    不需要通过new来创建Calendar对象,而是通过Calendar类的getInstance()静态方法。代码如下:

    // 获取日历对象
    Calendar calendar = Calendar.getInstance();
    calendar.setTime(new Date());// 将Date对象设置到Calendar对象中

    常用方法

    常用方法就是get、set和add方法,它们的API说明如下:

    方法说明
    int get(int field)用于获取日历字段的值,返回值是int类型,其中field参数的值可以是Calendar.YEARCalendar.MONTH等常量字段。
    void set(int field, int value)将给定的日历字段设置为指定的值。
    void set(int year, int month, int date)设置Calendar中的年、月、日字段
    void set(int year, int month, int date, int hourOfDay, int minute)设置Calendar中的年、月、日、时、分字段
    void set(int year, int month, int date, int hourOfDay, int minute, int second)设置Calendar中的年、月、日、时、分、秒字段
    void add(int field, int amount)可以对指定的一个日历字段进行整数的偏移,比如在今年的日期基础上加上一年,就是明年这个时候的日期。其中amount可以为负数,可以表示如去年、上个月等。

    其他方法

    方法说明
    boolean after(Object when)使用例如:c4.after(c3),判断c4的日期是否在c3的日期之后。传入的参数必须是Calendar对象。
    boolean before(Object when)使用例如:c3.before(c4),判断c3的日期是否在c4的日期之前。传入的参数必须是Calendar对象。
    boolean equals(Object obj)使用例如:c3.equals(c4),判断c3的日期是否等于c4所表示的日期。传入的参数必须是Calendar对象。
    int compareTo(Calendar anotherCalendar)使用例如:c3.compareTo(c4),如果比较c3和c4,如果c3<c4则返回-1,如果c3==c4则返回0,c3>c4则返回1。
    int getActualMaximum(int field)返回指定日历字段可能具有的最大值,例如:c5.getActualMaximum(Calendar.DAY_OF_MONTH),获取本月最后一天的号数。
    int getActualMinimum(int field)返回指定日历字段可能具有的最小值,例如:c5.getActualMinimum(Calendar.DAY_OF_MONTH),获取本月第一天的号数。
    long getTimeInMillis()返回此日历对象所表示的毫秒值。
    int getFirstDayOfWeek()获取一周的第一天是什么。
    TimeZone getTimeZone()获取时区。

    Calendar对象与Date对象的相互转换

    • Date对象转换成Calendar对象
    // Date对象转换成Calendar对象
    Calendar c2 = Calendar.getInstance();
    c2.setTime(new Date());
    • Calendar对象转换成Date对象
    Calendar c2 = Calendar.getInstance();
    // Calendar对象转换成Date对象
    Date c2Date = c2.getTime();// 类似于new Date()

    实例

    Calendar类的实例代码如下:

    public class CalendarTest {
        public static void main(String[] args) {
            // 获取日历对象
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(new Date());
    
            // 获取日期字段值
            System.out.println(calendar.get(Calendar.ERA));// 纪元,公元前还是公元
            System.out.println(calendar.get(Calendar.YEAR));// 年份
            System.out.println(calendar.get(Calendar.MONTH));// 月份,需要加1,因为0表示1月,1表示2月,以此类推
            System.out.println(calendar.get(Calendar.HOUR));// 小时(12小时制)
            System.out.println(calendar.get(Calendar.HOUR_OF_DAY));// 一天中第几个小时(24小时制)
            System.out.println(calendar.get(Calendar.MINUTE));// 分钟
            System.out.println(calendar.get(Calendar.SECOND));// 秒
            System.out.println(calendar.get(Calendar.MILLISECOND));// 毫秒
            System.out.println(calendar.get(Calendar.DAY_OF_YEAR));// 一年中第几天
            System.out.println(calendar.get(Calendar.DAY_OF_MONTH));// 一月中第几天
            System.out.println(calendar.get(Calendar.DAY_OF_WEEK));// 一周中第几天,注意,周日是1,周一是2,...
            System.out.println(calendar.get(Calendar.DATE));// 一月中第几天,同DAY_OF_MONTH的值是一样的
            System.out.println(calendar.get(Calendar.DAY_OF_WEEK_IN_MONTH));// 当月内一周中的某天的序号
            System.out.println("Calendar.WEEK_OF_YEAR=" + calendar.get(Calendar.WEEK_OF_YEAR));// 一年中的星期数,即本年中第几个星期
            System.out.println("Calendar.WEEK_OF_MONTH=" + calendar.get(Calendar.WEEK_OF_MONTH));// 当前月中的星期数,即本月中第几个星期
            System.out.println(calendar.get(Calendar.DAY_OF_WEEK_IN_MONTH));// 当前月中的第几个星期
            System.out.println("Calendar.AM_PM=" + calendar.get(Calendar.AM_PM));// AM_PM是在中午之前还是在中午之后,在中午12点之前返回0,在中午12点(包括12点)之后返回1
            System.out.println(Calendar.JANUARY);// 1月
            System.out.println(Calendar.FEBRUARY);// 2月
            System.out.println(Calendar.MARCH);// 3月
            System.out.println(Calendar.APRIL);// 4月
            System.out.println(Calendar.MAY);// 5月
            System.out.println(Calendar.JUNE);// 6月
            System.out.println(Calendar.JULY);// 7月
            System.out.println(Calendar.AUGUST);// 8月
            System.out.println(Calendar.SEPTEMBER);// 9月
            System.out.println(Calendar.OCTOBER);// 10月
            System.out.println(Calendar.NOVEMBER);// 11月
            System.out.println(Calendar.DECEMBER);// 12月
    
            // 设置日期字段值
            calendar.set(2021, Calendar.JUNE, 3);// 设定指定年月日,其中Calendar.JUNE为5实际上是六月,所以0表示1月,1表示2月,以此类推
            System.out.println(new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(calendar.getTime()));
            calendar.set(2021, Calendar.FEBRUARY, 3, 23, 55);// 设置年月日时分
            System.out.println(new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(calendar.getTime()));
            calendar.set(2021, Calendar.MARCH, 3, 23, 55, 30);// 设置年月日时分秒
            calendar.set(Calendar.YEAR, 2005);// 单独设置日历字段,设置年份
            calendar.set(Calendar.MONTH, 7);// 单独设置日历字段,设置月份,注意0代表1月
            calendar.set(Calendar.DATE, 11);// 单独设置日历字段,设置天数
            calendar.set(Calendar.HOUR_OF_DAY, 22);// 单独设置日历字段,设置小时
            calendar.set(Calendar.MINUTE, 45);// 单独设置日历字段,设置分钟
            calendar.set(Calendar.SECOND, 30);// 单独设置日历字段,设置秒
            calendar.set(Calendar.MILLISECOND, 235);// 单独设置日历字段,设置毫秒
            System.out.println(new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(calendar.getTime()));
    
            // 计算日期字段值,既可以为正数,又可以为负数
            calendar.add(Calendar.YEAR, 2);// 在当前日期的基础上添加年份,后年
            System.out.println(new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(calendar.getTime()));
            calendar.add(Calendar.YEAR, -1);// 在当前日期的基础上减去年份,昨年
            System.out.println(new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(calendar.getTime()));
            calendar.add(Calendar.MONTH, 1);// 添加月份,下个月
            calendar.add(Calendar.MONTH, -1);// 添加月份,上个月
            calendar.add(Calendar.DATE, 2);// 添加天数,后天
            calendar.add(Calendar.DATE, -1);// 添加天数,昨天
            calendar.add(Calendar.HOUR_OF_DAY, 1);// 添加小时,下一个小时
            calendar.add(Calendar.HOUR_OF_DAY, -1);// 添加小时,上一个小时
            calendar.add(Calendar.MINUTE, 20);// 添加分钟,下20分钟
            calendar.add(Calendar.MINUTE, -20);// 添加分钟,上20分钟
            calendar.add(Calendar.SECOND, 30);// 添加秒数,下30秒
            calendar.add(Calendar.SECOND, -30);// 添加秒数,上30秒
            calendar.add(Calendar.DATE, 7);// 添加周数,即添加7天,下一周
            calendar.add(Calendar.DATE, -7);// 添加周数,上一周
            System.out.println(new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(calendar.getTime()));
    
            // Calendar对象与Date对象的相互转换
            // Date对象转换成Calendar对象
            Calendar c2 = Calendar.getInstance();
            c2.setTime(new Date());
            // Calendar对象转换成Date对象
            Date c2Date = c2.getTime();// 类似于new Date()
    
            // 其他方法,如after、before
            Calendar c3 = Calendar.getInstance();
            c3.set(Calendar.YEAR, 2005);
            Calendar c4 = Calendar.getInstance();
            boolean after = c4.after(c3);// 判断c4的日期是否在c3之后
            System.out.println(after);
            boolean before = c3.before(c4);
            System.out.println(before);// 判断c3的日期是否在c4之前
            boolean equals = c3.equals(c4);// 判断c3的日期是否等于c4
            System.out.println(equals);
            int result = c3.compareTo(c4);// 如果比较c3和c4,如果c3<c4则返回-1,如果c3==c4则返回0,c3>c4则返回1
            System.out.println(result);
    
            Calendar c5 = Calendar.getInstance();
            c5.clear();
            c5.set(Calendar.YEAR, 2017);
            c5.set(Calendar.MONTH, 1);
            c5.set(Calendar.DAY_OF_MONTH, 30);
            System.out.println(c5.getTime());
            int lastDay = c5.getActualMaximum(Calendar.DAY_OF_MONTH);// 获取本月最后一天的号数
            int firstDay = c5.getActualMinimum(Calendar.DAY_OF_MONTH);// 获取本月第一天的号数
            System.out.println("本月最后一天:" + lastDay + ", 本月第一天:" + firstDay);
    
            // 获取毫秒数
            long timeInMillis = calendar.getTimeInMillis();// 返回此Calendar的时间值,以毫秒为单位
            int firstDayOfWeek = calendar.getFirstDayOfWeek();// 获取一个星期中的第一天
            System.out.println(firstDayOfWeek);
            TimeZone timeZone = calendar.getTimeZone();// 获取时区
            System.out.println(timeZone.getDisplayName());
        }
    }

    更多相关内容
  • LunarCalendar返回农历(阴历)日期的JAR包 根据指定日期计算对应农历日期(这个计算方法是网上找的,最初的作者是谁已经无法考证了,感谢网络资源吧!),本人封装成好用的JAR包后发不出来,供大家免费下载! ...
  • Java 的日历类Calendar

    千次阅读 2021-06-28 19:36:13
    Calendar目录 一、概述 ​ java.util.Calendar类是一个抽象类, 无法通过直接实例化得到对象 ,并且它是java日期处理的核心类之一。Calendar类为操作日历的类。日历字段包含YEAR、MONTH、DAY_OF_MONTH、HOUR等,它们...

    Calendar目录

    一、概述

    ​ java.util.Calendar类是一个抽象类, 无法通过直接实例化得到对象 ,并且它是java日期处理的核心类之一。Calendar类为操作日历的类。日历字段包含YEAR、MONTH、DAY_OF_MONTH、HOUR等,它们都是Calendar类的静态常量。

    创建实例对象如下 ,默认当前日期。

    Calendar calendar = Calendar.getInstance();
    System.out.println(cal.getTime());//Mon Jun 28 19:30:31 CST 2021
    

    二、常量

    //指示年
    Calendar.YEAR      
    //指示月份
    Calendar.MONTH      
    //指示当前时间为多少号(日历式的多少号)
    Calendar.DATE      
    //指示小时(12小时制)
    Calendar.HOUR      
    //指示小时(24小时制)
    Calendar.HOUR_OF_DAY   
    //指示分钟数
    Calendar.MINUTE    
    //指示秒数
    Calendar.SECOND    
    //指示毫秒
    Calendar.MILLISECOND   
    //当前时间是所在当前月的第几个星期(日历式的第几周)
    Calendar.WEEK_OF_MONTH 
    //当前时间是所在当前年的第几个星期
    Calendar.WEEK_OF_YEAR 
    //当前时间是所在当前月的第几个星期,以月份天数为标准,一个月的1号为第一周,8号为第二周
    Calendar.DAY_OF_WEEK_IN_MONTH 
    //一周7天当中,当前时间是星期几
    Calendar.DAY_OF_WEEK     
    //指示一年中的第几天
    Calendar.DAY_OF_YEAR   
    //指示一月中的第几天,结果等同于Calendar.DATE
    Calendar.DAY_OF_MONTH     
    //指示上午还是下午
    Calendar.AM_PM 
    //周天
    Calendar.SUNDAY   
    //周一
    Calendar.MONDAY   
    //周二
    Calendar.TUESDAY 
    //周三
    Calendar.WEDNESDAY
    //周四
    Calendar.THURSDAY  
    //周五
    Calendar.FRIDAY  
    //周六
    Calendar.SATURDAY 
    

    三、取日历的值

    //获得年、月、日、时、分、秒、毫秒
    ca.get(Calendar.YEAR);
    ca.get(Calendar.MONTH);
    ca.get(Calendar.DATE);
    ca.get(Calendar.HOUR_OF_DAY);
    ca.get(Calendar.MINUTE);
    ca.get(Calendar.SECOND);
    ca.get(Calendar.MILLISECOND);
    
    //当前时间是所在当前月的第几个星期(日历式的第几周)
    ca.get(Calendar.WEEK_OF_MONTH); 
    //当前时间是所在当前年的第几个星期(日历式的第几周)
    ca.get(Calendar.WEEK_OF_YEAR)); 
    //当前时间是所在当前月的第几个星期,以月份天数为标准,一个月的1号为第一周,8号为第二周
    ca.get(Calendar.DAY_OF_WEEK_IN_MONTH);
    //一周7天当中,当前时间是星期几, 返回结果为1-7
    ca.get(Calendar.DAY_OF_WEEK);
    
     
    //一年中的第几天
    ca.get(Calendar.DAY_OF_YEAR);
    
    //判断当前时间是AM,还是PM,若是AM返回结果为0,若是PM返回结果为1
    ca.get(Calendar.AM_PM); 
    

    四、设置日历字段的值。

    set(int field, int value);
    set(int year, int month, int day);
    set(int year, int month, int day, int hour, int minute);
    set(int year, int month, int day, int hour, int minute, int second);
    设置年、月、日、时、分、秒、毫秒
    月份的正常值范围为0-110表示一月,以此类推。日期的正常值范围为1-31,结尾数字视月份而定。
    //2021-06-28 00:00:00
    Calendar ca = Calendar.getInstance();
    ca.set(Calendar.YEAR,2021);
    ca.set(Calendar.MONTH,06); 
    ca.set(Calendar.DATE,28);
    ca.set(Calendar.HOUR_OF_DAY,0);
    ca.set(Calendar.MINUTE,0);
    ca.set(Calendar.SECOND,0);
    

    五、日历可以前后设置

    //2020-12-31
    ca.set(Calendar.YEAR,2021);
    ca.set(Calendar.MONTH,0); 
    //设置为0天,指向上月的最后一天
    ca.set(Calendar.DATE,0); 
    
    //2020-12-30
    ca.set(Calendar.YEAR,2021);
    ca.set(Calendar.MONTH,0); 
    ca.set(Calendar.DATE,-1);
    
    //10:09:59
    ca.set(Calendar.HOUR_OF_DAY,10);
    ca.set(Calendar.MINUTE,10);
    ca.set(Calendar.SECOND,-1); 
    
    //09:58:59
    ca.set(Calendar.HOUR_OF_DAY,10);
    ca.set(Calendar.MINUTE,-1);
    ca.set(Calendar.SECOND,-1); 
    
    将Calendar日期对象指向当前周的某一天
    //将日历对象指向当前周的周天
    Calendar ca = Calendar.getInstance();
    //第二个参数的取值范围是表示周一到周天的七个静态常量
    ca.set(Calendar.DAY_OF_WEEK,Calendar.SUNDAY);
    

    六、日历的计算加减

    Calendar ca = Calendar.getInstance();
    ca.set(Calendar.YEAR,2020);
    //当前日历年份加一
    ca.add(Calendar.YEAR,1);
    System.out.println(ca.get(Calendar.YEAR)); //2021
    
    //当前日历年份减一
    ca.add(Calendar.YEAR,-1);
    System.out.println(ca.get(Calendar.YEAR)); //2019
    
    ca.set(Calendar.MONTH,10);
    //当前日历月份加一
    ca.add(Calendar.MONTH,1);
    System.out.println(ca.get(Calendar.MONTH)); //11
    
    //当前日历月份减一
    ca.add(Calendar.MONTH,-1);
    System.out.println(ca.get(Calendar.MONTH)); //10
    Calendar ca = Calendar.getInstance();
    ca.set(Calendar.DAY_OF_MONTH,10);
    

    七、日历的比较

    after方法

    判断Calendar日期对象表示的时间是否在另一个日期对象表示的时间之后,返回true或false。例如2020年在。

    Calendar cal = Calendar.getInstance();
    Calendar future = Calendar.getInstance();
    future.set(Calendar.YEAR, 2030);
    System.out.println(future.after(cal)); //true
    

    before方法

    判断Calendar日期对象表示的时间是否在另一个日期对象表示的时间之前,返回true或false。例如2019年在2020年之前。

    Calendar cal = Calendar.getInstance();
    Calendar future = Calendar.getInstance();
    future.set(Calendar.YEAR, 2020);
    System.out.println(cal.before(future)); //true
    

    clear方法

    该方法可以将所有日历字段的值和时间值(从历元至现在的毫秒偏移量)设置为初始状态。一般使用set方法之前,必须先clear一下,否则很多信息会继承自系统当前时间。

    Calendar cal = Calendar.getInstance();
    System.out.println(cal.getTime()); //Mon Jun 28 19:25:46 CST 2021
    cal.clear();
    System.out.println(cal.getTime()); //Thu Jan 01 00:00:00 CST 1970
    

    clone方法

    创建并返回一个Calendar日期对象的副本,返回结果为Object类型。副本和原日期对象互不影响。

    compareTo方法

    比较当前Calendar日期对象与另一个Calendar日期对象表示的时间值大小(毫秒偏移量),返回结果为0、1或-1。其中0表示两个日期对象表示的时间值相等,-1表示当前Calendar日期对象在另一个Calendar日期对象表示的时间之前。1表示当前Calendar日期对象在另一个Calendar日期对象表示的时间之后。

    Calendar cal1 = new GregorianCalendar(2015, 8, 15);
    Calendar cal2 = new GregorianCalendar(2008, 1, 02);
    int ret0 = cal1.compareTo(cal2); 
    int ret1 = cal2.compareTo(cal1); 
    System.out.println(ret0); // 1
    System.out.println(ret1); //-1
    

    equals****方法

    将Calendar日期对象与另一个Calendar日期对象比较,返回true或false。

    getActualMaximum****方法

    返回指定日历字段可能拥有的实际最大值。

    Calendar ca = Calendar.getInstance();

    //返回当前月最大天数

    System.out.println(ca.getActualMaximum(Calendar.DAY_OF_MONTH));

    System.out.println(ca.getActualMaximum(Calendar.DATE));

    //返回23

    System.out.println(ca.getActualMaximum(Calendar.HOUR_OF_DAY));

    //返回11

    System.out.println(ca.getActualMaximum(Calendar.HOUR));

    //返回当前月有多少周

    System.out.println(ca.getActualMaximum(Calendar.WEEK_OF_MONTH));

    //返回当前年度最大天数

    System.out.println(ca.getActualMaximum(Calendar.DAY_OF_YEAR));

    getActualMinimum方法

    返回指定日历字段可能拥有的实际最小值。

    Calendar ca = Calendar.getInstance();

    //返回当前月最小天数:1

    System.out.println(ca.getActualMinimum(Calendar.DAY_OF_MONTH));

    System.out.println(ca.getActualMinimum(Calendar.DATE));

    //返回0

    System.out.println(ca.getActualMinimum(Calendar.HOUR_OF_DAY));

    //返回0

    System.out.println(ca.getActualMinimum(Calendar.HOUR));

    //返回0

    System.out.println(ca.getActualMinimum(Calendar.WEEK_OF_MONTH));

    //返回当前年度最小天数:1

    System.out.println(ca.getActualMinimum(Calendar.DAY_OF_YEAR));

    getInstance****方法

    使用默认时区和语言环境获得一个日历。实例化Calendar日期对象,默认为当前系统时间。返回一个默认用当前的语言环境和时区初始化的GregorianCalendar对象。

    Calendar ca = Calendar.getInstance();

    getMaximum****方法

    返回指定日历字段的理论最大值。

    //如果当前时间为2019-09-01

    Calendar ca = Calendar.getInstance();

    System.out.println(ca.getMaximum(Calendar.DAY_OF_MONTH)); //31, 理论最大值

    System.out.println(ca.getActualMaximum(Calendar.DAY_OF_MONTH)); //30, 实际最大值

    getMinimum****方法

    返回指定日历字段的理论最小值。

    getTime****方法

    将Calendar日期对象转换为Date对象。

    Calendar ca = Calendar.getInstance();

    Date d = ca.getTime();

    setTime****方法

    将Date对象表示的时间值设置给Calendar日期对象。

    Calendar ca = Calendar.getInstance();

    ca.setTime(new Date());

    getTimeInMillis方法

    返回Calendar日期对象的时间戳。

    Calendar ca = Calendar.getInstance();

    System.out.println(ca.getTimeInMillis()); //1567334892295

    setTimeInMillis****方法

    用给定long值设置日历的当前时间。

    Calendar ca = Calendar.getInstance();

    ca.setTimeInMillis(500000);

    System.out.println(ca.getTime());

    roll****方法 ----> void roll(int field, boolean up)

    在指定日历字段上添加或减去单个时间单元,不更改更大的字段。

    //如果当前时间是2019-09-01

    Calendar ca = Calendar.getInstance();

    System.out.println("Month is " + ca.get(Calendar.MONTH));

    ca.roll(Calendar.MONTH, false); //月份减一

    System.out.println("Month is " + ca.get(Calendar.MONTH));

    ca.roll(Calendar.MONTH, true); //月份加一

    ca.roll(Calendar.MONTH, true); //月份加一

    System.out.println("Month is " + ca.get(Calendar.MONTH));

    //假如今天周三

    Calendar ca = Calendar.getInstance();

    System.out.println(ca.get(Calendar.DAY_OF_WEEK)); //4

    ca.roll(Calendar.DAY_OF_WEEK, false);

    System.out.println(ca.get(Calendar.DAY_OF_WEEK)); //3

    roll****方法 ----> void roll(int field, int amount)

    在指定日历字段上添加或减去指定的时间单元,不更改更大的字段。

    //如果当前时间是2019-09-01

    Calendar ca = Calendar.getInstance();

    System.out.println("Month is " + ca.get(Calendar.MONTH));

    ca.roll(Calendar.MONTH, -2); //月份减2

    System.out.println("Month is " + ca.get(Calendar.MONTH));

    //假如今天周三

    Calendar ca = Calendar.getInstance();

    System.out.println(ca.get(Calendar.DAY_OF_WEEK)); //4

    ca.roll(Calendar.DAY_OF_WEEK, -2);

    System.out.println(ca.get(Calendar.DAY_OF_WEEK)); //2

    七天制星期

    Calendar类规定一周的七天分别用静态常量1-7表示,其中1表示周天,7表示周六。Calendar类使用两个参数定义了特定于语言环境的七天制星期,其一星期的第一天,其二第一个星期的最少天数。

    setMinimaldaysinfirstweek()

    设置一年或一月中第一个星期所需的最少天数,取值范围为1-7,默认值为1,无返回值。

    //如果当前日期为2019-08-02,周五

    Calendar ca = Calendar.getInstance();

    System.out.println(ca.get(Calendar.WEEK_OF_MONTH)); //1

    ca.setMinimalDaysInFirstWeek(3);

    System.out.println(ca.get(Calendar.WEEK_OF_MONTH)); //1

    ca.setMinimalDaysInFirstWeek(4);

    System.out.println(ca.get(Calendar.WEEK_OF_MONTH)); //0

    getMinimalDaysInFirstWeek()

    获取一年或一月中第一个星期的最少天数。

    Calendar ca = Calendar.getInstance();

    System.out.println(ca.getMinimalDaysInFirstWeek()); //1

    setFirstDayOfWeek()

    默认一周的第一天是星期日(用静态常量1表示),结束时间是星期六(用静态常量7表示)。该方法可以设置星期几为一周的第一天,不会影响表示周一到周天的七个静态常量。

    Calendar ca = Calendar.getInstance();

    //设置周一为一周的第一天

    ca.setFirstDayOfWeek(Calendar.MONDAY);

    修改一周的第一天会影响如下代码的执行结果。

    ca.get(Calendar.WEEK_OF_MONTH); //当前时间是所在当前月的第几个星期(日历式的第几周)

    ca.get(Calendar.WEEK_OF_YEAR)); //当前时间是所在当前年的第几个星期(日历式的第几周)

    /**

    * 如果当前日期为2019-08-02,周五

    */

    Calendar ca = Calendar.getInstance();

    //设置一年或一月中第一周最少4天

    ca.setMinimalDaysInFirstWeek(4);

    System.out.println(ca.get(Calendar.WEEK_OF_MONTH)); //0

    //设置周一为一星期的第一天

    ca.setFirstDayOfWeek(Calendar.MONDAY);

    System.out.println(ca.get(Calendar.WEEK_OF_MONTH)); //1

    getFirstDayOfWeek()

    返回一周的第一天。

    Calendar ca = Calendar.getInstance();

    System.out.println(ca.getFirstDayOfWeek());

    四、实例

    将日历时间调整到0时0分0秒0毫秒

    public static Calendar toZero(Calendar ca){

    ca.set(Calendar.HOUR_OF_DAY, 0);

    ca.set(Calendar.MINUTE, 0);

    ca.set(Calendar.SECOND, 0);

    ca.set(Calendar.MILLISECOND, 0);

    return ca;

    }

    获取某月所有日期

    public static List monthToDates(Date dt){

    //创建list列表

    List dts = new ArrayList();

    //创建日历

    Calendar ca = Calendar.getInstance();

    //设置时间

    ca.setTime(dt);

    //将时间调整到当前日历月份最后一天

    ca.set(ca.get(Calendar.YEAR),ca.get(Calendar.MONTH)+1, 0);

    //获取当前日历月份的实际总天数

    int dayNumOfMonth = ca.get(Calendar.DAY_OF_MONTH);

    //将日历时间指向当前日历月份的一号

    ca.set(Calendar.DAY_OF_MONTH, 1);

    for (int i = 0; i < dayNumOfMonth; i++, ca.add(Calendar.DATE, 1)) {

    ​ //设置为0时0分0秒0毫秒

    ​ ca.set(Calendar.HOUR_OF_DAY, 0);

    ​ ca.set(Calendar.MINUTE, 0);

    ​ ca.set(Calendar.SECOND, 0);

    ​ ca.set(Calendar.MILLISECOND, 0);

    ​ //将Calendar日期对象转换为Date时间对象,保存到提前创建的列表中

    ​ Date d = ca.getTime();

    ​ dts.add(d);

    }

    return dts;

    }

    获取某月第一天

    public static Date getFstDayOfMonth(Date dt) {

    //创建日历

    Calendar ca = Calendar.getInstance();

    //设置时间

    ca.setTime(dt);

    //将日历时间调整到1号0时0分0秒

    ca.set(Calendar.DAY_OF_MONTH, 1);

    ca.set(Calendar.HOUR_OF_DAY, 0);

    ca.set(Calendar.MINUTE, 0);

    ca.set(Calendar.SECOND, 0);

    ca.set(Calendar.MILLISECOND, 0);

    //返回结果

    return ca.getTime();

    }

    获取某月最后一天

    public static Date getLstDayOfMonth(Date dt) {

    //创建日历

    Calendar ca = Calendar.getInstance();

    //设置时间

    ca.setTime(dt);

    //将日历时间调整到上月最后一天

    ca.set(Calendar.DAY_OF_MONTH, 0);

    //将日历时间加一个月

    ca.add(Calendar.MONTH, 1);

    //将日历时间调整到0时0分0秒

    ca.set(Calendar.HOUR_OF_DAY, 0);

    ca.set(Calendar.MINUTE, 0);

    ca.set(Calendar.SECOND, 0);

    ca.set(Calendar.MILLISECOND, 0);

    //返回结果

    return ca.getTime();

    }

    判断是不是当前月

    public static boolean isNowMonth(Date date) {

    //获取当前月第一天

    Date fst = getFstDayOfMonth(new Date());

    //获取目标月第一天

    Date fstOfDate = getFstDayOfMonth(date);

    //判断是否相等

    if(fst.equals(fstOfDate)) return true;

    return false;

    }

    获取本周的第一天

    public static Date getFstDayOfWeek(Date dt) {

    //创建日历

    Calendar ca = Calendar.getInstance();

    //设置时间

    ca.setTime(dt);

    //设置周一为每周的第一天

    ca.setFirstDayOfWeek(Calendar.MONDAY);

    //设置一年或一月中第一周最少七天

    ca.setMinimalDaysInFirstWeek(7);

    //将Calendar日期对象指向本周的周一

    ca.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);

    //将日历时间调整为0时0分0秒

    ca.set(Calendar.HOUR_OF_DAY, 0);

    ca.set(Calendar.MINUTE, 0);

    ca.set(Calendar.SECOND, 0);

    ca.set(Calendar.MILLISECOND, 0);

    //返回结果

    return ca.getTime();

    }

    获取本周所有的日期,按时间先后排序

    public static List mondayToDates(Date dt){

    //创建列表

    List dts = new ArrayList();

    //创建日历

    Calendar ca = Calendar.getInstance();

    //设置时间

    ca.setTime(dt);

    //设置周一为每周的第一天

    ca.setFirstDayOfWeek(Calendar.MONDAY);

    //将Calendar日期对象指向本周的周一

    ca.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);

    for (int i = 0; i < 7; i++, ca.add(Calendar.DATE, 1)) {

    ​ //将日历时间调整为0时0分0秒

    ​ ca.set(Calendar.HOUR_OF_DAY, 0);

    ​ ca.set(Calendar.MINUTE, 0);

    ​ ca.set(Calendar.SECOND, 0);

    ​ ca.set(Calendar.MILLISECOND, 0);

    ​ //将时间添加到list列表

    ​ dts.add(ca.getTime());

    }

    return dts;

    }

    获取n天后,负数表示几天前

    public static Date getDayAfterToday(Date date,int n) {

    //创建日历

    Calendar ca = Calendar.getInstance();

    //设置时间

    ca.setTime(date);

    //日历时间加n天或者减n天

    ca.add(Calendar.DAY_OF_YEAR, n);

    //将日历时间调整为0时0分0秒

    ca.set(Calendar.HOUR_OF_DAY, 0);

    ca.set(Calendar.MINUTE, 0);

    ca.set(Calendar.SECOND, 0);

    ca.set(Calendar.MILLISECOND, 0);

    //返回结果

    return ca.getTime();

    }

    计算两个日期相差的天数

    public int daysDiffer(String start, String end) throws Exception{

    SimpleDateFormat sdf = new SimpleDateFormat(“yyyy-MM-dd”);

    Date startDate = sdf.parse(start);

    Date endDate = sdf.parse(end);

    Calendar cal = Calendar.getInstance();

    cal.setTime(startDate);

    long timeStart = cal.getTimeInMillis();

    cal.setTime(endDate);

    long timeEnd = cal.getTimeInMillis();

    long ret = (timeEnd-timeStart)/(1000360024);

    return Integer.parseInt(String.valueOf(ret));

    }

    public int daysDiffer(Date dateStart,Date dateEnd){

    Calendar cal = Calendar.getInstance();

    cal.setTime(dateStart);

    long timeStart = cal.getTimeInMillis();

    cal.setTime(dateEnd);

    long timeEnd = cal.getTimeInMillis();

    long ret = (timeEnd-timeStart)/(1000360024);

    return Integer.parseInt(String.valueOf(ret));

    }

    五、GregorianCalendar类

    java中主要有两个日历类,其一抽象类java.util.Calendar,其二java.util.GregorianCalendar类(标准阳历)。Calendar类和GregorianCalendar类是父子关系。GregorianCalendar类继承自Calendar类,是Calendar类的一个实现类,提供了世界上大多数国家/地区的标准日历系统,是Calendar提供的一个实现标准阳历的具体工具。

    实例对象

    GregorianCalendar类用默认的地区和时区的当前日期和时间初始化对象,提供了如下构造函数。

    //初始化默认当前时刻的实例对象

    Calendar ca = new GregorianCalendar();

    //初始化具有指定日期设置的实例对象

    Calendar ca=new GregorianCanlendar(int year,int month,int date);

    Calendar ca=new GregorianCanlendar(int year,int month,int date,int hour,int minute);

    Calendar ca=new GregorianCanlendar(int year,int month,int date,int hour,int minute,int second);

    GregorianCalendar实例对象的用法主要继承自父类Calendar。

    展开全文
  • Calendar类简介

    万次阅读 多人点赞 2019-07-14 16:37:05
    Calendar类简介 Calendar是java util包下的一个工具类,提供了很方便的不同日期格式的处理。啥也不说了,直接撸代码: public static void main(String[] args) { System.out.println("------------Calendar无参...

    Calendar类简介

    Calendar是java util包下的一个工具类,提供了很方便的不同日期格式的处理。啥也不说了,直接撸代码:

    public static void main(String[] args) {
            
            System.out.println("------------Calendar无参构造------------");
            //Calendar对象,不传参数,默认为当前日期
            Calendar calendar =new GregorianCalendar();
            //获取当前年份
            System.out.println(calendar.get(Calendar.YEAR));
            //获取当前月份 从0开始,0代表一月,1代表二月,以此类推
            System.out.println(calendar.get(Calendar.MONTH));
            //获取当前日期 也可以使用DAY_OF_MONTH
            System.out.println(calendar.get(Calendar.DATE));
            //获取当前时 24小时进制
            System.out.println(calendar.get(Calendar.HOUR_OF_DAY));
            //获取当前分
            System.out.println(calendar.get(Calendar.MINUTE));
            //获取当前秒
            System.out.println(calendar.get(Calendar.SECOND));
    
            //获取今天是这个月的第几个星期
            System.out.println(calendar.get(Calendar.WEEK_OF_MONTH));
            //获取今天是星期几  1表示星期天,2表示星期一,以此类推
            System.out.println(calendar.get(Calendar.DAY_OF_WEEK));
    
    
            System.out.println("------------Calendar有参构造------------");
            /**
             * 有参构造 分别代表年月日时分秒,写法简单明了,很符合我们人类的思维
             * 注意月份的设置是从0开始的,这里设置的是月份是6,实际是设置了7月份
             */
            calendar =new GregorianCalendar(2019, 6, 14, 16, 15,30);
            /**
             * 除了在构造方法直接设置之外,也可以通过set方法设置
             * 第一个参数表示设置的参数类型,第二个表示具体值
             */
            calendar.set(Calendar.YEAR, 2000);
            calendar.set(Calendar.MONTH, 0);
            calendar.set(Calendar.DATE, 20);
            //...
    
    
            System.out.println("------------Calendar和Date转换------------");
            Date now = calendar.getTime();
            calendar.setTime(now);
    
    
            System.out.println("------------Calendar日期计算以及判断------------");
            calendar = new GregorianCalendar();
            Calendar calendar2 = new GregorianCalendar();
            calendar2.set(Calendar.YEAR, 2800);
            //是否在某个时间(calendar2)之后
            System.out.println(calendar.after(calendar2));
            //是否在某个时间(calendar2)之前
            System.out.println(calendar.before(calendar2));
            //增加多少年年,月日以及时分秒同理
            calendar.add(Calendar.YEAR, -10);
    
        }
    

    由上可见Calendar还是很好用的,具体的需求可自行封装相应的工具类。
    简介简介,就到这里吧~

    最后,附上一个日期工具类

    import java.sql.Timestamp;
    import java.text.SimpleDateFormat;
    import java.util.Calendar;
    import java.util.Date;
    
    /**
     * 日期工具类
     */
    public class DateUtils {
        public static final String DAFAULT_DATE_FORMAT = "yyyy-M-d";
        public static final String DATE_FORMAT = "yyyy-MM-dd";
        public static final String DAFAULT_DATETIME_FORMAT = "yyyy-M-d HH:mm:ss";
        public static final String DATETIME_FORMAT = "yyyy-MM-dd HH:mm:ss";
        public static final String DAFAULT_TIME_FORMAT = "HH:mm:ss";
    
        /**
         * 默认构造方法
         */
        private DateUtils() {
    
        }
    
        /**
         * 当前时间
         *
         * @return date
         */
        public static Date currentDate() {
            return Calendar.getInstance().getTime();
        }
    
        /**
         * 得到年
         *
         * @param c
         * @return
         */
        public static int getYear(Calendar c) {
            if (c != null) {
                return c.get(Calendar.YEAR);
            } else {
                return Calendar.getInstance().get(Calendar.YEAR);
            }
        }
    
        /**
         * 得到月份
         * 注意,这里的月份依然是从0开始的
         *
         * @param c
         * @return
         */
        public static int getMonth(Calendar c) {
            if (c != null) {
                return c.get(Calendar.MONTH) + 1;
            } else {
                return Calendar.getInstance().get(Calendar.MONTH) + 1;
            }
        }
    
        /**
         * 得到日期
         *
         * @param c
         * @return
         */
        public static int getDate(Calendar c) {
            if (c != null) {
                return c.get(Calendar.DATE);
            } else {
                return Calendar.getInstance().get(Calendar.DATE);
            }
        }
    
        /**
         * 得到星期
         *
         * @param c
         * @return
         */
        public static int getDay(Calendar c) {
            if (c != null) {
                return c.get(Calendar.DAY_OF_WEEK);
            } else {
                return Calendar.getInstance().get(Calendar.DAY_OF_WEEK);
            }
        }
    
        /**
         * 得到小时
         *
         * @param c
         * @return
         */
        public static int getHour(Calendar c) {
            if (c != null) {
                return c.get(Calendar.HOUR_OF_DAY);
            } else {
                return Calendar.getInstance().get(Calendar.HOUR_OF_DAY);
            }
        }
    
        /**
         * 得到分钟
         *
         * @param c
         * @return
         */
        public static int getMinute(Calendar c) {
            if (c != null) {
                return c.get(Calendar.MINUTE);
            } else {
                return Calendar.getInstance().get(Calendar.MINUTE);
            }
        }
    
        /**
         * 得到秒
         *
         * @param c
         * @return
         */
        public static int getSecond(Calendar c) {
            if (c != null) {
                return c.get(Calendar.SECOND);
            } else {
                return Calendar.getInstance().get(Calendar.SECOND);
            }
        }
    
        /**
         * 得到指定或者当前时间前n天的Calendar
         *
         * @param c
         * @param n
         * @return
         */
        public static Calendar beforeNDays(Calendar c, int n) {
            //偏移量,给定n天的毫秒数
            long offset = n * 24 * 60 * 60 * 1000;
            Calendar calendar = null;
            if (c != null) {
                calendar = c;
            } else {
                calendar = Calendar.getInstance();
            }
    
            calendar.setTimeInMillis(calendar.getTimeInMillis() - offset);
            return calendar;
        }
    
        /**
         * 得到指定或者当前时间后n天的Calendar
         *
         * @param c
         * @param n
         * @return
         */
        public static Calendar afterNDays(Calendar c, int n) {
            //偏移量,给定n天的毫秒数
            long offset = n * 24 * 60 * 60 * 1000;
            Calendar calendar = null;
            if (c != null) {
                calendar = c;
            } else {
                calendar = Calendar.getInstance();
            }
    
            calendar.setTimeInMillis(calendar.getTimeInMillis() + offset);
            return calendar;
        }
    
        /**
         * 指定日期加月份
         *
         * @param date      指定日期
         * @param addMonths 要加的月份数
         * @return Date 计算后的日期
         */
        public static Date addMonths(Date date, int addMonths) {
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(date);
            calendar.add(Calendar.MONTH, addMonths);
            return calendar.getTime();
        }
    
        /**
         * 当前日期加月份
         *
         * @param addMonths 要加的月份数
         * @return Date 计算后的日期
         */
        public static Date addMonths(int addMonths) {
            return addMonths(new Date(), addMonths);
        }
    
        /**
         * 指定日期加天
         *
         * @param date    指定日期
         * @param addDays 要加的天数
         * @return Date 计算后的日期
         */
        public static Date addDays(Date date, int addDays) {
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(date);
            calendar.add(Calendar.DATE, addDays);
            return calendar.getTime();
        }
    
        /**
         * 当前日期加天
         *
         * @param addDays 要加的天数
         * @return Date 计算后的日期
         */
        public static Date addDays(int addDays) {
            return addDays(new Date(), addDays);
        }
    
        /**
         * 指定日期加小时
         *
         * @param date     指定日期
         * @param addHours 要加的小时数
         * @return Date 计算后的日期
         */
        public static Date addHours(Date date, int addHours) {
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(date);
            calendar.add(Calendar.HOUR, addHours);
            return calendar.getTime();
        }
    
        /**
         * 当前日期加小时
         *
         * @param addHours 要加的小时数
         * @return Date 计算后的日期
         */
        public static Date addHours(int addHours) {
            return addHours(new Date(), addHours);
        }
    
        /**
         * 指定日期加分
         *
         * @param date       指定日期
         * @param addMinutes 要加的分数
         * @return Date 计算后的日期
         */
        public static Date addMinutes(Date date, int addMinutes) {
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(date);
            calendar.add(Calendar.MINUTE, addMinutes);
            return calendar.getTime();
        }
    
        /**
         * 当前日期加分
         *
         * @param addMinutes 要加的分数
         * @return Date 计算后的日期
         */
        public static Date addMinutes(int addMinutes) {
            return addMinutes(new Date(), addMinutes);
        }
    
        /**
         * 指定日期加秒
         *
         * @param date       指定日期
         * @param addSeconds 要加的秒数
         * @return Date 计算后的日期
         */
        public static Date addSeconds(Date date, int addSeconds) {
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(date);
            calendar.add(Calendar.SECOND, addSeconds);
            return calendar.getTime();
        }
    
        /**
         * 当前日期加秒
         *
         * @param addSeconds 要加的秒数
         * @return Date 计算后的日期
         */
        public static Date addSeconds(int addSeconds) {
            return addSeconds(new Date(), addSeconds);
        }
    
        /**
         * 昨天
         *
         * @param c
         * @return
         */
        public static Calendar yesterday(Calendar c) {
            long offset = 1 * 24 * 60 * 60 * 1000;
            Calendar calendar = null;
            if (c != null) {
                calendar = c;
            } else {
                calendar = Calendar.getInstance();
            }
            calendar.setTimeInMillis(calendar.getTimeInMillis() - offset);
            return calendar;
        }
    
        /**
         * 明天
         *
         * @param c
         * @return
         */
        public static Calendar tomorrow(Calendar c) {
            long offset = 1 * 24 * 60 * 60 * 1000;
            Calendar calendar = null;
            if (c != null) {
                calendar = c;
            } else {
                calendar = Calendar.getInstance();
            }
    
            calendar.setTimeInMillis(calendar.getTimeInMillis() + offset);
            return calendar;
        }
    
        /**
         * 得到指定或者当前时间前offset毫秒的Calendar
         *
         * @param c
         * @param offset
         * @return
         */
        public static Calendar before(Calendar c, long offset) {
            Calendar calendar = null;
            if (c != null) {
                calendar = c;
            } else {
                calendar = Calendar.getInstance();
            }
    
            calendar.setTimeInMillis(calendar.getTimeInMillis() - offset);
            return calendar;
        }
    
        /**
         * 得到指定或者当前时间前offset毫秒的Calendar
         *
         * @param c
         * @param offset
         * @return
         */
        public static Calendar after(Calendar c, long offset) {
            Calendar calendar = null;
            if (c != null) {
                calendar = c;
            } else {
                calendar = Calendar.getInstance();
            }
    
            calendar.setTimeInMillis(calendar.getTimeInMillis() - offset);
            return calendar;
        }
    
        /**
         * 日期格式化
         *
         * @param c
         * @param pattern
         * @return
         */
        public static String format(Calendar c, String pattern) {
            Calendar calendar = null;
            if (c != null) {
                calendar = c;
            } else {
                calendar = Calendar.getInstance();
            }
            if (pattern == null || pattern.equals("")) {
                pattern = DATETIME_FORMAT;
            }
            SimpleDateFormat sdf = new SimpleDateFormat(pattern);
    
            return sdf.format(calendar.getTime());
        }
    
        /**
         * 日期格式化
         *
         * @param date    日期
         * @param pattern 格式
         * @return String 格式化字符串
         */
        public static String format(Date date, String pattern) {
            Date tempDate = null;
            if (date != null) {
                tempDate = date;
            } else {
                tempDate = Calendar.getInstance().getTime();
            }
            if (pattern == null || pattern.equals("")) {
                pattern = DATETIME_FORMAT;
            }
            SimpleDateFormat sdf = new SimpleDateFormat(pattern);
    
            return sdf.format(tempDate);
        }
    
        /**
         * Date类型转换到Calendar类型
         *
         * @param d
         * @return
         */
        public static Calendar date2Calendar(Date d) {
            Calendar c = Calendar.getInstance();
            c.setTime(d);
            return c;
        }
    
        /**
         * Calendar类型转换到Date类型
         *
         * @param c
         * @return
         */
        public static Date calendar2Date(Calendar c) {
            return c.getTime();
        }
    
        /**
         * Date类型转换到Timestamp类型
         *
         * @param d
         * @return
         */
        public static Timestamp date2Timestamp(Date d) {
            return new Timestamp(d.getTime());
        }
    
        /**
         * Calendar类型转换到Timestamp类型
         *
         * @param c
         * @return
         */
        public static Timestamp calendar2Timestamp(Calendar c) {
            return new Timestamp(c.getTimeInMillis());
        }
    
        /**
         * Timestamp类型转换到Calendar类型
         *
         * @param ts
         * @return
         */
        public static Calendar timestamp2Calendar(Timestamp ts) {
            Calendar c = Calendar.getInstance();
            c.setTime(ts);
            return c;
        }
    
        /**
         * 得到当前时间的字符串表示
         * 格式2010-02-02 12:12:12
         *
         * @return
         */
        public static String getTimeString() {
            return format(Calendar.getInstance(), DATETIME_FORMAT);
        }
    
        /**
         * 标准日期格式字符串解析成Calendar对象
         *
         * @param s
         * @return
         */
        public static Calendar pars2Calender(String s) {
            Timestamp ts = Timestamp.valueOf(s);
            return timestamp2Calendar(ts);
        }
    
    }
    
    展开全文
  • calendar库:Python日历的处理与生成

    千次阅读 2021-04-12 18:26:20
    calendar库也是用于处理日期的库,像前面的某些函数返回星期是[1-7],有的是[0-6]。会给很多程序员在判断的时候造成不便。而calendar库能自己设定星期的规则,比如中国常用的每个星期从星期1开始,那么日历就可以...

    前言

    calendar库让你可以输出日历,它还提供了其它与日历相关的实用函数。本篇,就将详细讲解calendar库的使用规则。

    prmonth()与TextCalendar()

    prmonth()是一个简单的函数,可以生成月的格式文本输出。具体用法如下所示:

    import calendar
    
    c = calendar.TextCalendar(calendar.MONDAY)
    c.prmonth(2020, 4)
    

    运行之后,我们会得到一个日历字符串形式数据:
    日历

    可以看到,日历开始是从星期一开始的。这是因为我们通过函数TextCalendar()指定了日历的开始星期。这里,读者可以自行指定任意一个星期几。

    HTMLCalendar().formatmonth

    这里,我们直接替换掉上面的c.prmonth()。代码如下:

    import calendar
    
    c = calendar.TextCalendar(calendar.MONDAY)
    print(calendar.HTMLCalendar().formatmonth(2020,4))
    

    运行之后,我们会得到如下结果:
    HTMLCalendar

    这里,我们会直接返回HTML表格定义的日历格式。在使用Django开发时,这个方法非常好用。而且,细心的读者肯定看到了这里每一个标签都有class,在实际的使用中,可以通过CSS丰富这个日历的样式。

    其他方法

    一个一个方法讲解太麻烦了,博主这里整理了一个表格,专门列出了calendar库各个方法的使用规则:

    方法名参数意义
    weekday3个整型参数:年,月,日返回日期星期几[0-6]
    isleap1个整型年份用来判断是否时闰年
    leapdays2个整型年两个年份之间的闰年有多少个
    weekheader1个整型数字返回星期对应缩写,参数代表缩写英文的长度
    monthcalendar2个参数:整型年,月返回一个月的日历矩阵
    timegm1个struct_time结构体日期将日期转换为时间戳
    prmonth2个参数:整型年,月返回当月日历
    prcal1个参数:整型年份返回整年日历

    测试代码如下所示:

    import calendar, datetime
    
    c = calendar.TextCalendar(calendar.MONDAY)
    # 返回日期星期几[0-6]
    print(calendar.weekday(2021, 4, 12))
    # 用来判断是否时闰年
    print(calendar.isleap(2021))
    # 两个年份之间的闰年有多少
    print(calendar.leapdays(2000, 2050))
    # 返回星期对应缩写,参数代表缩写英文的长度
    print(calendar.weekheader(2))
    # 返回一个月的日历矩阵
    print(calendar.monthcalendar(2021, 4))
    # 将日期转换为时间戳
    print(calendar.timegm(datetime.datetime(2021, 4, 3).timetuple()))
    # 返回当月日历
    print(calendar.prmonth(2021, 4))
    # 返回整年日历
    print(calendar.prcal(2021))
    

    运行之后,效果如下:
    控制台输出
    这些都是常用的函数,但是其实calendar库还有许多迭代的函数提供大家使用,可以返回任意数据类型的元组或者列表。如下表所示:

    方法名参数意义
    yeardays2calendar2个整型参数:年,N月一个分组月行序列,元组为(月份号,星期几[0-6]),月份号为0时,不作数(下同),每3个月为一组数据
    yeardatescalendar2个整型参数:年,N月一个分组返回datetime.date日期列表,每N个月为一组数据
    yeardayscalendar2个整型参数:年,N月一个分组返回日期列表,每N个月为一组数据
    monthdatescalendar2个整型参数:年,月返回一个指定年月的周列表,列表日期类型为datetime.date
    monthdays2calendar2个整型参数:年,月直接返回元组列表,元组由月份号与星期几构成
    monthdayscalendar2个整型参数:年,月直接返回星期对应的日期列表
    itermonthdates2个整型参数:年,月迭代月份对应的日期
    itermonthdays22个整型参数:年,月迭代月份对应的星期元组,元组包括当月的月号以及星期几
    itermonthdays32个整型参数:年,月迭代月份对应的日历元组,以设定的星期开头,元组包括年月日
    itermonthdays42个整型参数:年,月迭代月份对应的日历元组,以设定的星期开头,元组包括年月日星期几
    itermonthdays2个整型参数:年,月迭代月份对应的月号整型,以设定的星期开头
    iterweekdays无参数迭代指定的星期数

    测试代码如下:

    import calendar, datetime
    
    c = calendar.TextCalendar(calendar.MONDAY)
    # 下面所有星期开始以上面指定的星期一为准
    # 月行序列,元组为(月份号,星期几[0-6]),月份号为0时,不作数(下同),每3个月为一组数据
    for i in c.yeardays2calendar(2021, width=3):
        print(i)
    # 返回datetime.date日期列表,每3个月为一组数据
    for i in c.yeardatescalendar(2021, 3):
        print(i)
    # 返回日期列表,每3个月为一组数据
    for i in c.yeardayscalendar(2021, 3):
        print(i)
    # 返回一个指定年月的周列表,列表日期类型为datetime.date
    for i in c.monthdatescalendar(2021, 3):
        print(i)
    # 直接返回元组列表,元组由月份号与星期几构成
    for i in c.monthdays2calendar(2021, 3):
        print(i, end="")
    print()
    # 直接返回星期对应的日期列表
    for i in c.monthdayscalendar(2021, 3):
        print(i, end="")
    print()
    # 迭代指定的星期数
    for i in c.iterweekdays():
        print(i, end="")
    print()
    # 迭代月份对应的日期
    for i in c.itermonthdates(2021, 4):
        print(i, end="")
    print()
    # 迭代月份对应的星期元组,元组包括当月的月号以及星期几
    for i in c.itermonthdays2(2021, 4):
        print(i, end="")
    print()
    # 迭代月份对应的日历元组,以星期1开头,元组包括年月日
    for i in c.itermonthdays3(2021, 4):
        print(i, end="")
    print()
    # 迭代月份对应的日历元组,以星期1开头,元组包括年月日星期几
    for i in c.itermonthdays4(2021, 4):
        print(i, end="")
    # 迭代月份对应的月号整型,以星期1开头
    print()
    for i in c.itermonthdays(2021, 4):
        print(i, end="")
    

    运行之后,效果如下:
    日历迭代

    实战(获取每月第2个星期3日期)

    假如你现在的公司每月的第2个星期3都要召开大会,那么怎么提前获取日期提醒自己呢?calendar库实现这种操作非常的容易。具体代码如下所示:

    import calendar
    
    for month in range(1, 13):
        # 返回一个月的日历矩阵
        c = calendar.monthcalendar(2021, month)
        first_week = c[0]
        second_week = c[1]
        third_week = c[2]
        if first_week[calendar.WEDNESDAY] == 0:
            myDate = second_week[calendar.WEDNESDAY]
        else:
            myDate = third_week[calendar.WEDNESDAY]
        print(calendar.month_abbr[month], myDate)
    

    运行之后,效果如下:
    每个月第2个星期3

    本地化环境

    上面我们返回的日历大多都是英文的。这在中文网页中是不是显示的非常不友好。没关系,我们可以使用本地化环境函数LocaleTextCalendar或LocaleHTMLCalendar实现中文日历的显示。

    具体代码如下:

    import calendar
    
    c = calendar.LocaleTextCalendar(locale="zh_CN")
    c.prmonth(2021, 4)
    
    c = calendar.LocaleHTMLCalendar(locale="zh_CN")
    print(c.formatmonth(2021, 4))
    

    运行之后,效果如下:
    中文日历

    展开全文
  • Calendar 获取指定时间

    千次阅读 2020-07-08 15:54:21
    import java.util.Calendar; public class DateTurnUtils { // 这周最后一天 public Calendar getThisWeekLastDay() { Calendar cal = getThisWeekFirstDay(); cal.add(Calendar.DAY_OF_WEEK, 6);
  • Calendar 获取当前时间- 获取年月日 时区转换 1、获取当前时间 Calendar calendar=Calendar.getInstance(); calendar.getTime(); 调用抽象类中的静态方法getInstance来返回一个当前的calendar对象。Calendar...
  • Java中Calendar基本使用

    万次阅读 2021-09-20 14:55:52
    Java中Calendar基本使用 Calendar中的常用日历字段 日历字段 Value YEAR 当前年份 MONTH 当前月份( 注:初始值是从0开始,所以得到的比实际月份小1月) DATE 一个月中的某天 WEEK_OF_YEAR 当前年中的第...
  • Calendar日期类常用使用方法

    千次阅读 2019-06-11 11:56:37
    Calendar获取今天、昨天、近三天、近一周、近一月、本周、上周、本月、上月、本季度、上季度、本年、上一年开始时间和结束时间 /** * 获取今日开始时间和结束时间 * @param condition * @return ...
  • 一. LVGL GUI按键矩阵控件的概念 ...日历的主要部分称为 LV_CALENDAR_PART_BG 。它使用典型的背景样式属性绘制背景。 还有以下虚拟部分外: LV_CALENDAR_PART_HEADER 显示当前年和月名称的上部区域。它还具有用于移动
  • Java中的日期类Calendar的常用方法

    千次阅读 2022-03-08 20:04:59
    Calendar类可以使用set方法设置时间,get方法获取时间。可以用于 获取设置 年,月,日,星期 一、实例化Calendar  使用Calendar的静态方法getInstance()实例化对象。 Calendar c = Calendar.getInstance(); 二、...
  • microsoft calendar control 11.0.8161.0

    热门讨论 2013-03-31 03:29:53
    VB中的日历控件,microsoft calendar control 11.0.8161.0,请注意版本对应!
  • Android中Calendar类的用法总结

    千次阅读 2021-06-12 14:20:07
    Calendar是Android开发中需要获取时间时必不可少的一个工具类,通过这个类可以获得的时间信息还是很丰富的,下面做一个总结,以后使用的时候就不用总是去翻书或者查资料了。在获取时间之前要先获得Calendar这个类的...
  • Java Calendar类的时间操作

    千次阅读 2021-03-22 10:49:22
    Java Calendar 类时间操作,这也许是创建日历和管理最简单的一个方案,示范代码很简单,演示了获取时间,日期时间的累加和累减,以及比较。注意事项:Calendar 的 month 从 0 开始,也就是全年 12 个月由 0 ~ 11 ...
  • Calendar(线程不安全)

    千次阅读 2021-03-09 16:24:05
    基本:Calendar calendar =Calendar.getInstance();int year = calendar.get(Calendar.YEAR); //得到当前时间的年份int month = calendar.get(Calendar.MONTH) + 1;//获取当前时间的月,这里需要需要月份的范围为0~...
  • js日历(calendar

    千次阅读 2019-07-23 19:05:18
    效果还不错 View Code // JavaScript Document /* [Discuz!] (C)2001-2007 Comsenz Inc. ... This is NOT a freeware, use is subject to license terms ... $RCSfile: calendar.js,v $ $Revisio...
  • Calendar 日历

    千次阅读 2020-12-22 22:54:53
    更新记录1.3.14(2020-05-22)修复 自定义easycom规则,子组件提示未找到的Bug1.3.13(2020-05-22)修复 自定义easycom规则,子组件提示未找到的Bug查看更多Calendar 日历已经支持在nvue页面中使用日历组件,组件名:uni...
  • 写在前面 还记得大二上学期c++老师让我们自己写一个关于日期的方法,那叫一个折磨啊。如果掌握了Date和...Calendar类是一个抽象类,由于Calendar类是抽象类,且Calendar类的构造方法是protected的,所以无法使用C
  • Calendar时间操作常用方法

    千次阅读 2022-01-09 12:10:09
    获取当前系统时间 1. 使用Date方式 // 直接用Date获取当前系统时间,结果:Tue May 03 08:25:44 CST 2016 Date date = new Date(); // Date中的许多方法,例如获取某年、某月、某日等,以及...// 使用Calendar获取当前
  • Java中的时间日期类(Calendar、Date)

    千次阅读 2021-02-28 08:36:57
    Java中操作时间日期的类有:Date(日期)、Calendar(日历)、DateFormat(日期格式)。一、Datejava.util.Date,表示特定的瞬间,精确到毫秒。1、构造方法很久以前,Date类的构造方法有:Date(int year, int month, int ...
  • Java Calendar获取年、月、日、时间 Calendar c = Calendar.getInstance(TimeZone.getTimeZone("GMT+08:00")); //获取东八区时间 int year = c.get(Calendar.YEAR); //获取年 int month = c.get(Calendar.MONTH) +...
  • Java Calendar(日历类)

    千次阅读 2021-07-14 11:38:59
    Java Calendar类的使用总结 文章目录Java Calendar类的使用总结前言 前言
  • 使用 Calendar 计算时间

    千次阅读 2020-08-27 20:05:04
    使用 Calendar 计算时间 一. 类型转换 1.1 Date → Calendar public Calendar date2Calendar(Date date){ Calendar calendar = Calendar.getInstance(); calendar.setTime(date); return calendar; } 1.2 ...
  • Calendar 用法

    千次阅读 2018-06-08 14:48:51
    // 获取当日开始时间:13位的时间戳,如果想用时间戳工具转换去掉后三位即可Calendar cale = Calendar.getInstance();//获取年int year = c.get(Calendar.YEAR);//获取月份,0表示1月份int month = c.get(Calendar....
  • java中Calendar类的使用讲解

    千次阅读 2021-02-12 09:38:20
    Calendar类是我们在工作中经常用到时间相关的一个工具类;比如月初、月末、年初、年末、指定月份所在季度的季末等操作,对它有更深入的了解,在工作中会起到事半功倍的效果,下面就来了解一下吧!!!**一.Calendar...
  • JAVA Calendar详解

    万次阅读 2018-12-21 21:12:41
    究竟什么是一个 Calendar 呢?中文的翻译就是日历,那我们立刻可以想到我们生活中有阳(公)历、阴(农)历之分。它们的区别在哪呢? 比如有: 月份的定义 - 阳`(公)历 一年12 个月,每个月的天数各不同;阴(农)历,每个...
  • Java—java.util.calendar类详解

    千次阅读 多人点赞 2019-08-27 22:30:27
    目录 一、概述 二、静态常量 三、静态方法 四、实例 五、GregorianCalendar类 ...java.util.Calendar类是一个...日历字段包含YEAR、MONTH、DAY_OF_MONTH、HOUR等,它们都是Calendar类的静态常量。 二、静态常量...
  • Calendar的详细使用

    千次阅读 2021-04-01 20:08:25
    优秀是一种习惯 Calendar的详细使用 一、 如何创建 Calendar 对象 二、 字段详解 三、 设置值 四、 获取值 五、 运算值 六、 Calendar 对象间的比较 一、 如何创建 Calendar 对象 Calendar 是一个抽象类, 无法通过...
  • python calendar模块

    千次阅读 2021-02-03 08:52:06
    calendar模块中提供了三大类:一、calendar.Calendar(firstweekday=0)该类提供了许多生成器,如星期的生成器,某月日历生成器二、calendar.TextCalendar(firstweekday=0)该类提供了按月、按年生成日历字符串的方法。...
  • java 中的Calendar日历类

    千次阅读 2021-03-06 14:05:56
    一、java 中的Calendar日历类解析Calendar类是一个抽象类public abstract class Calendar implements Serializable, Cloneable, Comparable,它为特定时间与一组诸如YEAR、MONTH、DAY_OF_MONTH、HOUR等日历字段之间...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 317,748
精华内容 127,099
关键字:

calendar

友情链接: Appsicationsupporting.rar