java的calendar类常见日期处理

最新推荐文章于 2023-06-17 13:11:32 发布
最新推荐文章于 2023-06-17 13:11:32 发布
阅读量342 收藏 2
点赞数
分类专栏： java基础
包含功能:
1.获取当前月的上一个月
2.得到当前月的第一天，返回2016-06-01这样的字符串
3.获取当前年的第一个月，返回2016-01这样的数据
4.获取当前年已过的所有季度的集合(季度包含的月份未完则也算入)
5.获取昨天
6.获取指定时间范围内的所有日期
7.获取指定时间范围内的所有月份
8.获取指定日期范围的所有周的周一到周日，格式为周一~周日，如2016-09-19为周一，2016-09-25为周天，返回结果为[2016-09-19~2016-09-25]
9.获取当前日期的前index天(以当前日期开始计算) index = -6表示当天日期的前7天 index = -29表示当前日期的前30天
10.获取当天
11.获取最近3个月开始日期(包含当前月所在月)
12.获取指定日期为星期几
13.获取指定日期所在月的第一天
14.获取指定日期所在月的最后一天
15.获取指定日期所在周的周一

16.获取指定日期所在周的周日

17.获取当前时间到月末的秒数


[java]  view plain  copy
  1. /** 
  2.      * 得到当前月的上一个月，返回2016-06这样的字符串 
  3.      */  
  4.     public static String getLastMonth() {  
  5.         Calendar cal = Calendar.getInstance();  
  6.         cal.add(Calendar.MONTH, -1);  
  7.         SimpleDateFormat format = new SimpleDateFormat("yyyy-MM");  
  8.         String date = format.format(cal.getTime());  
  9.         return date;  
  10.     }  
  11.   
  12.     /** 
  13.      * 得到当前月的第一天，返回2016-06-01这样的字符串 
  14.      *  
  15.      * @return 
  16.      */  
  17.     public static String getCurrentMonthFirstDay() {  
  18.         Calendar c = Calendar.getInstance();  
  19.         c.add(Calendar.MONTH, 0);  
  20.         c.set(Calendar.DAY_OF_MONTH, 1);// 设置为1号,当前日期既为本月第一天  
  21.         SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");  
  22.         String first = format.format(c.getTime());  
  23.         return first;  
  24.     }  
  25.   
  26.     public static String getCurrentMonthTheLastDay() {  
  27.         Calendar c = Calendar.getInstance();  
  28.         c.set(Calendar.DAY_OF_MONTH, c.getActualMaximum(Calendar.DAY_OF_MONTH));  
  29.         return dateToStr(c.getTime(), "yyyy-MM-dd");  
  30.     }  
  31.   
  32.     /** 
  33.      * 获取当前年的第一个月，返回2016-01这样的数据 
  34.      *  
  35.      * @return 
  36.      */  
  37.     public static String getCurrentYearFirstMonth() {  
  38.         Calendar c = Calendar.getInstance();  
  39.         c.add(Calendar.YEAR, 0);  
  40.         c.set(Calendar.DAY_OF_YEAR, 1);  
  41.         SimpleDateFormat format = new SimpleDateFormat("yyyy-MM");  
  42.         String first = format.format(c.getTime());  
  43.         return first;  
  44.     }  
  45.   
  46.     /** 
  47.      * 获取当前年已过的所有季度的集合(季度包含的月份未完则也算入)<String> 
  48.      */  
  49.     public static List<String> getAllQuarterOfThisYear() {  
  50.         List<String> quarters = new ArrayList<String>();  
  51.         Calendar cal = Calendar.getInstance();  
  52.         int year = cal.get(Calendar.YEAR);  
  53.         int month = cal.get(Calendar.MONTH) + 1;  
  54.         if (month > 9) {  
  55.             quarters.add(year + "-" + 1);  
  56.             quarters.add(year + "-" + 2);  
  57.             quarters.add(year + "-" + 3);  
  58.             quarters.add(year + "-" + 4);  
  59.             return quarters;  
  60.         }  
  61.         if (month > 6 && month <= 9) {  
  62.             quarters.add(year + "-" + 1);  
  63.             quarters.add(year + "-" + 2);  
  64.             quarters.add(year + "-" + 3);  
  65.             return quarters;  
  66.         }  
  67.         if (month > 3 && month <= 6) {  
  68.             quarters.add(year + "-" + 1);  
  69.             quarters.add(year + "-" + 2);  
  70.             return quarters;  
  71.         }  
  72.         if (month >= 1 && month <= 3) {  
  73.             quarters.add(year + "-" + 1);  
  74.             return quarters;  
  75.         }  
  76.         return null;  
  77.     }  
  78.   
  79.     /** 
  80.      * 获取昨天 
  81.      *  
  82.      * @return 
  83.      */  
  84.     public static String getYesterDay() {  
  85.         Calendar cal = Calendar.getInstance();  
  86.         cal.add(Calendar.DATE, -1);  
  87.         String yesterday = new SimpleDateFormat("yyyy-MM-dd").format(cal.getTime());  
  88.         return yesterday;  
  89.     }  
  90.   
  91.     /** 
  92.      * 获取指定时间范围内的所有日期 
  93.      *  
  94.      * @param startDate 
  95.      *            (format="2016-06-01") 
  96.      * @param endDate 
  97.      *            (format="2016-07-12") 
  98.      * @return 
  99.      * @throws ParseException 
  100.      */  
  101.     public static List<String> getDaysBetween(String startDate, String endDate) {  
  102.         SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");  
  103.         List<String> result = new ArrayList<String>();  
  104.         result.add(startDate);  
  105.         try {  
  106.             Calendar calBegin = Calendar.getInstance();  
  107.             // 使用给定的 Date 设置此 Calendar 的时间  
  108.             Date begin = format.parse(startDate);  
  109.             calBegin.setTime(begin);  
  110.             Calendar calEnd = Calendar.getInstance();  
  111.             // 使用给定的 Date 设置此 Calendar 的时间  
  112.             Date end = format.parse(endDate);  
  113.             calEnd.setTime(end);  
  114.             // 测试此日期是否在指定日期之后  
  115.             while (end.after(calBegin.getTime())) {  
  116.                 // 根据日历的规则，为给定的日历字段添加或减去指定的时间量  
  117.                 calBegin.add(Calendar.DAY_OF_MONTH, 1);  
  118.                 result.add(format.format(calBegin.getTime()));  
  119.             }  
  120.         } catch (Exception e) {  
  121.             e.printStackTrace();  
  122.         }  
  123.         return result;  
  124.     }  
  125.   
  126.     /** 
  127.      * 获取指定时间范围内的所有月份 
  128.      *  
  129.      * @param startDate(format="2016-06") 
  130.      * @param endDate(format="2016-08") 
  131.      * @return 
  132.      * @throws ParseException 
  133.      */  
  134.     public static List<String> getMonthsBetween(String startDate, String endDate) {  
  135.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM");  
  136.         List<String> result = new ArrayList<String>();  
  137.         try {  
  138.             Calendar calBegin = Calendar.getInstance();  
  139.             Calendar calEnd = Calendar.getInstance();  
  140.             calBegin.setTime(sdf.parse(startDate));  
  141.             calBegin.set(calBegin.get(Calendar.YEAR), calBegin.get(Calendar.MONTH), 1);  
  142.             calEnd.setTime(sdf.parse(endDate));  
  143.             calEnd.set(calEnd.get(Calendar.YEAR), calEnd.get(Calendar.MONTH), 2);  
  144.             Calendar curr = calBegin;  
  145.             while (curr.before(calEnd)) {  
  146.                 result.add(sdf.format(curr.getTime()));  
  147.                 curr.add(Calendar.MONTH, 1);  
  148.             }  
  149.         } catch (Exception e) {  
  150.             e.printStackTrace();  
  151.         }  
  152.         return result;  
  153.     }  
  154.   
  155.     /** 
  156.      * 获取指定日期范围的所有周的周一~周日，格式为周一~周日，如2016-09-19为周一，2016-09-25为周天，返回结果为[2016-09-19 
  157.      * ~2016-09-25] 
  158.      *  
  159.      * @param startDate 
  160.      *            起始时间(2016-09-19) 
  161.      * @param endDate 
  162.      *            结束时间(2016-09-25) 
  163.      * @return 
  164.      * @throws ParseException 
  165.      */  
  166.     public static List<String> getWeeksBetween(String startDate, String endDate) {  
  167.         // startDate不能大于endDate  
  168.         List<String> result = new ArrayList<String>();  
  169.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); // 设置时间格式  
  170.         try {  
  171.             Calendar calBegin = Calendar.getInstance();  
  172.             // 使用给定的 Date 设置此 Calendar 的时间  
  173.             Date begin = sdf.parse(startDate);  
  174.             calBegin.setTime(begin);  
  175.             int dayWeek = calBegin.get(Calendar.DAY_OF_WEEK);// 获得当前日期是一个星期的第几天  
  176.             if (1 == dayWeek) {  
  177.                 calBegin.add(Calendar.DAY_OF_MONTH, -1);  
  178.             }  
  179.             calBegin.setFirstDayOfWeek(Calendar.MONDAY);// 设置一个星期的第一天，按中国的习惯一个星期的第一天是星期一  
  180.             Calendar calEnd = Calendar.getInstance();  
  181.             // 使用给定的 Date 设置此 Calendar 的时间  
  182.             Date end = sdf.parse(endDate);  
  183.             calEnd.setTime(end);  
  184.             // 测试此日期是否在指定日期之后  
  185.             while (end.after(calBegin.getTime())) {  
  186.                 // 根据日历的规则，为给定的日历字段添加或减去指定的时间量  
  187.                 calBegin.add(Calendar.DAY_OF_MONTH, 1);  
  188.                 int day = calBegin.get(Calendar.DAY_OF_WEEK);// 获得当前日期是一个星期的第几天  
  189.                 calBegin.add(Calendar.DATE, calBegin.getFirstDayOfWeek() - day);// 根据日历的规则，给当前日期减去星期几与一个星期第一天的差值  
  190.                 // 获取周一  
  191.                 String monday = sdf.format(calBegin.getTime());  
  192.                 calBegin.add(Calendar.DATE, 6);  
  193.                 // 获取周日  
  194.                 String sunday = sdf.format(calBegin.getTime());  
  195.                 result.add(monday + "~" + sunday);  
  196.             }  
  197.         } catch (Exception e) {  
  198.             e.printStackTrace();  
  199.         }  
  200.         return result;  
  201.     }  
  202.   
  203.     /** 
  204.      * 获取当前日期的前index天(以当前日期开始计算) index = -6表示当天日期的前7天 index = -29表示当前日期的前30天 
  205.      *  
  206.      * @return 
  207.      */  
  208.     public static String getLastIndexDayStr(int index) {  
  209.         Date now = new Date();  
  210.         Calendar c = Calendar.getInstance();  
  211.         c.setTime(now);  
  212.         c.add(Calendar.DAY_OF_MONTH, index);  
  213.         return dateToStr(c.getTime(), "yyyy-MM-dd");  
  214.     }  
  215.   
  216.     /** 
  217.      * 获取当天 
  218.      */  
  219.     public static String getTodayStr() {  
  220.         Date now = new Date();  
  221.         return dateToStr(now, "yyyy-MM-dd");  
  222.     }  
  223.   
  224.     /** 
  225.      * 获取最近3个月开始日期(包含当前月所有月) 
  226.      *  
  227.      * @return 
  228.      */  
  229.     public static String getLast3MonthsStartDateStr() {  
  230.         Date now = new Date();  
  231.         Calendar c = Calendar.getInstance();  
  232.         c.setTime(now);  
  233.         c.add(Calendar.MONTH, -2);  
  234.         return dateToStr(c.getTime(), "yyyy-MM") + "-01";  
  235.     }  
  236.   
  237.     /** 
  238.      * 获取星期几 
  239.      * @param dateStr 
  240.      * @return 
  241.      */  
  242.     public static String getWeekNameOfDate(String dateStr) {  
  243.         SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");  
  244.         Calendar c = Calendar.getInstance();  
  245.         try {  
  246.             c.setTime(format.parse(dateStr));  
  247.         } catch (ParseException e) {  
  248.             e.printStackTrace();  
  249.         }  
  250.         int dayForWeek = 0;  
  251.         if (c.get(Calendar.DAY_OF_WEEK) == 1) {  
  252.             dayForWeek = 7;  
  253.         } else {  
  254.             dayForWeek = c.get(Calendar.DAY_OF_WEEK) - 1;  
  255.         }  
  256.         String result = "";  
  257.         switch (dayForWeek) {  
  258.         case 1:  
  259.             result = "星期一";  
  260.             break;  
  261.         case 2:  
  262.             result = "星期二";  
  263.             break;  
  264.         case 3:  
  265.             result = "星期三";  
  266.             break;  
  267.         case 4:  
  268.             result = "星期四";  
  269.             break;  
  270.         case 5:  
  271.             result = "星期五";  
  272.             break;  
  273.         case 6:  
  274.             result = "星期六";  
  275.             break;  
  276.         case 7:  
  277.             result = "星期天";  
  278.             break;  
  279.         }  
  280.         return result;  
  281.     }  
  282.   
  283.     /** 
  284.      * 获取指定日期所在月的第一天 
  285.      *  
  286.      * @param date 
  287.      * @return yyyy-MM-dd 
  288.      */  
  289.     public static String getMonthStartDate(String date) {  
  290.         try {  
  291.             Calendar calendar = Calendar.getInstance();  
  292.             SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");  
  293.             calendar.setTime(format.parse(date));  
  294.             calendar.set(Calendar.DAY_OF_MONTH, calendar.getActualMinimum(Calendar.DAY_OF_MONTH));  
  295.             return format.format(calendar.getTime());  
  296.         } catch (ParseException e) {  
  297.             e.printStackTrace();  
  298.         }  
  299.         return null;  
  300.     }  
  301.   
  302.     /** 
  303.      * 获取指定日期所在月的最后一天 
  304.      *  
  305.      * @param date 
  306.      * @return yyyy--MM-dd 
  307.      */  
  308.     public static String getMonthEndDate(String date) {  
  309.         try {  
  310.             Calendar calendar = Calendar.getInstance();  
  311.             SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");  
  312.             calendar.setTime(format.parse(date));  
  313.             calendar.set(Calendar.DAY_OF_MONTH, calendar.getActualMaximum(Calendar.DAY_OF_MONTH));  
  314.             return format.format(calendar.getTime());  
  315.         } catch (ParseException e) {  
  316.             e.printStackTrace();  
  317.         }  
  318.         return null;  
  319.     }  
  320.   
  321.     /** 
  322.      * 获取指定日期所在周的周一 
  323.      * @param date 
  324.      * @return yyyy-MM-dd 
  325.      */  
  326.     public static String getMondayOfDate(String date) {  
  327.         try {  
  328.             SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); // 设置时间格式  
  329.             Calendar cal = Calendar.getInstance();  
  330.             cal.setTime(sdf.parse(date));  
  331.             int dayWeek = cal.get(Calendar.DAY_OF_WEEK);// 获得当前日期是一个星期的第几天  
  332.             if (1 == dayWeek) {  
  333.                 cal.add(Calendar.DAY_OF_MONTH, -1);  
  334.             }  
  335.             cal.setFirstDayOfWeek(Calendar.MONDAY);// 设置一个星期的第一天，按中国的习惯一个星期的第一天是星期一  
  336.             int day = cal.get(Calendar.DAY_OF_WEEK);// 获得当前日期是一个星期的第几天  
  337.             cal.add(Calendar.DATE, cal.getFirstDayOfWeek() - day);  
  338.             return sdf.format(cal.getTime());  
  339.         } catch (ParseException e) {  
  340.             e.printStackTrace();  
  341.         }  
  342.         return null;  
  343.     }  
  344.   
  345.     /** 
  346.      * 获取指定日期所在周的周日 
  347.      * @param date 
  348.      * @return yyyy-MM-dd 
  349.      */  
  350.     public static String getSundayOfDate(String date) {  
  351.         try {  
  352.             SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); // 设置时间格式  
  353.             Calendar cal = Calendar.getInstance();  
  354.             cal.setTime(sdf.parse(date));  
  355.             int dayWeek = cal.get(Calendar.DAY_OF_WEEK);// 获得当前日期是一个星期的第几天  
  356.             if (1 == dayWeek) {  
  357.                 cal.add(Calendar.DAY_OF_MONTH, -1);  
  358.             }  
  359.             cal.setFirstDayOfWeek(Calendar.MONDAY);// 设置一个星期的第一天，按中国的习惯一个星期的第一天是星期一  
  360.             int day = cal.get(Calendar.DAY_OF_WEEK);// 获得当前日期是一个星期的第几天  
  361.             cal.add(Calendar.DATE, cal.getFirstDayOfWeek()-day);//根据日历的规则，给当前日期减去星期几与一个星期第一天的差值   
  362.             cal.add(Calendar.DATE, 6);  
  363.             return sdf.format(cal.getTime());  
  364.         } catch (ParseException e) {  
  365.             e.printStackTrace();  
  366.         }  
  367.         return null;  
  368.     }  
[java]  view plain  copy
  1. **  
  2. <span style="white-space:pre">  </span> * 获取月末到当前时间的秒数  
  3. <span style="white-space:pre">  </span> */  
  4. <span style="white-space:pre">  </span>public static long getSecondsBetweenEndMothToNow() {  
  5. <span style="white-space:pre">      </span>Calendar c = Calendar.getInstance();  
  6. <span style="white-space:pre">      </span>c = Calendar.getInstance();    
  7.         c.add(Calendar.MONTH, 1);    
  8.         c.set(Calendar.DAY_OF_MONTH, 0);  
  9.         SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");   
  10.         String lastday = format.format(c.getTime());  
  11.         lastday = lastday + " 23:59:59";  
  12.         Date last = null;  
  13.         long sec = 0;  
  14. <span style="white-space:pre">      </span>try {  
  15. <span style="white-space:pre">          </span>last = format.parse(lastday);  
  16. <span style="white-space:pre">          </span>long diff = last.getTime() - System.currentTimeMillis();  
  17. <span style="white-space:pre">          </span>sec = diff / 1000;  
  18. <span style="white-space:pre">      </span>} catch (ParseException e) {  
  19. <span style="white-space:pre">          </span>e.printStackTrace();  
  20. <span style="white-space:pre">      </span>}  
  21. <span style="white-space:pre">      </span>return sec;  
  22. <span style="white-space:pre">  </span>}  
西瓜557
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA时间日期处理类实例
09-03
在Java编程语言中，时间日期处理是常见的任务，涉及到对日期和时间的增减、比较、格式化等操作。在给定的实例中，我们看到了一个名为`AccountDate`的类，它提供了一些方法来处理日期相关的操作。下面将详细解释这个...
java日期处理工具类
09-02
在Java编程语言中，日期处理是常见的任务，涉及到各种场景如日志记录、数据分析、报表生成等。Java提供了多种处理日期的工具类，包括`java.util.Date`、`java.text.SimpleDateFormat`以及`java.util.Calendar`。本文...
日期时间处理Calendar类使用
chenhanxu7855的博客
03-02 204
public InvPlanData adjustQuarterTime(InvPlanData invPlanData, Integer start, Integer end) { Calendar cal = Calendar.getInstance(); cal.setTime(invPlanData.getPlanStartDate()); cal.set(Cale...
java中的日历_Java中日历类Calendar的使用
weixin_39872257的博客
02-16 44
Java中日历类Calendar的使用：import java.util.Calendar;import java.util.GregorianCalendar;public class calendarTest {public static void main(String[] args) {Calendar calendar=Calendar.getInstance();System.out....
Java 日历类Calendar用法
Gfeiyv的博客
11-22 327
它也是一个抽象类，不能直接创建对象，里面包含很多静态变量静态方法，这些都可以直接被类名直接调用，其中有一个静态方法特别神奇，可以返回子类的对象名，public Calender getInstance()(使用默认时区和时间返回一个日历) 形成一种多态Calendar c=Calendar.getInstance(),返回的子类对象直接赋值给它 ...
Java Calendar类
博客
06-09 2279
Calendar类是一个抽象类，它为毫秒值与YEAR、MONTH等日历字段之间的转换提供了一些方法，并为操作日历字段提供了一些方法。 1、Calendar日历字段 1.1、Calendar.YEAR 年份 1.2、Calendar.MONTH 月份 1.3、Calendar.DATE 日期 1.4、Calendar.DAY_OF_MONTH 日期 1.5、Calendar.HO...
java日期 Calendar类的使用
HGS的博客
10-18 212
举例： import java.text.SimpleDateFormat; import java.util.Calendar; import java.util.Date; public class HelloWorld { public static void main(String[] args) { // 创建Calendar对象 Calendar c...
Java中的日期和时间类以及Calendar类用法详解
09-03
Java提供了多种类来处理日期和时间，其中Date类和Calendar类是最基础也是最常用的。下面将详细介绍这两个类的用法。 首先，Date类是Java中处理日期和时间的基础类，它位于java.util包内。Date类有多个构造方法，但...
Java-Java处理日期和时间教程
最新发布
11-13
首先，Java 8之前，主要依赖`java.util.Date`和`java.util.Calendar`类来处理日期和时间。`Date`类代表了具体的时刻，而`Calendar`类是一个抽象类，提供了日期和时间的操作方法，如获取年份、月份等。然而，这两个类...
Java处理日期时间的方法汇总
08-31
在Java编程中，处理日期和时间是常见的任务。Java提供了多种方法来操作日期时间，其中`java.util.Calendar`是一个核心的类。本文将详细介绍如何使用`Calendar`类进行日期时间的处理。 首先，`Calendar`类是一个抽象...
Calendar 设置周一为每周第一天
不知有鱼的博客
07-13 2733
Calendar calendar = Calendar.getInstance(); // 设置周一为每周第一天 calendar.setFirstDayOfWeek(Calendar.MONDAY);
JAVA Calendar设置周一为第一天
热门推荐
技术之旅：一位项目管理者的编程视角与项目管理洞见；
12-25 1万+
package com.thinkgem.jeesite.modules.sys.utils; import java.text.SimpleDateFormat; import java.util.ArrayList; import java.util.Calendar; import java.util.Date; import java.util.GregorianCalendar; im
Calendar代替Date类获取当前年月日,getYear,getMonth,getDay
05-31 4204
// 通过getInstance获取当前日期calendar实例 Calendar calendar = Calendar.getInstance(); // Month需要+1才是目标月 System.out.println(calendar.get(Calendar.YEAR) + "年" + (calendar.get(Calendar.MONTH) + 1) + "月" + ca
Java通过cal.get(Calendar.MONTH)比真实月份少了一个月
行则将至
07-31 1万+
通过查阅资料之发现，这里月份是从0开始计算的，也就是说，月份是从0—11。
Java中Calendar日期类介绍
LiuQQ567的博客
06-17 9988
Calendar 类是一个抽象类，它为特定瞬间与 YEAR、MONTH、DAY_OF—MONTH、HOUR 等日历字段之间的转换提供了一些方法，并为操作日历字段（如获得下星期的日期） 提供了一些方法。创建 Calendar 对象不能使用 new 关键字，因为 Calendar 类是一个抽象类，但是它提供了一个getInstance() 方法来获得 Calendar类的对象。getInstance() 方法返回一个 Calendar 对象，其日历字段已由当前日期和时间初始化。
Calendar获取时间的月和日
lonely7345的专栏
04-26 4546
最近想自己用java做一个个人网站.其中一个功能是想通过生日的日期得到它的星座.由日期得到星座,星座主要由月和日决定.所以想获取日期的月份和日期.一开始使用new Date()测试,并用通过date.getMonth(),和date.getDay()获取,不过后来发现这两个访求是jdk1.1版本的,现在已经不用了,而且结果也不正确.所以改用了Calendar如下  Calend
JAVA Calendar类setFirstDayOfWeek和setMinimalDaysInFirstWeek
okyoung188的博客
12-06 2155
转自：http://www.it165.net/pro/html/201211/4230.html 关于JAVA的java.util.Calendar类里面的setFirstDayOfWeek()方法,我相信很多朋友都像我一样,误解了.认为设置了setFirstDayOfWeek(Calendar.MONDAY),再通过get(Calendar.DAY_OF_WEEK),如果是星期一的时候,就会
setFirstDayOfWeek 不起作用,疑惑?
12-12 3313
做项目的时候,遇到个问题,要根据传递的日期获取这个日期是一周中的第几天. 于是这么搞, SimpleDateFormat simpleDateFormat = DateTools.getSimpleDateFormat(); simpleDateFormat.applyPattern("yyyy-MM-dd"); Date parse = simpleDateFormat.parse
Java时间与日期处理：Date和Calendar类解析
以下是关于Java中时间、日期处理以及Math类的详细说明： **6.1 Date类** Date类位于`java.util`包中，它用于表示特定的瞬间，精确到毫秒。默认格式显示的是星期、月、日、小时、分钟、秒和年。创建Date对象时，可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值