JDK源码阅读-------自学笔记(十三)(java.text.DateFormat和SimpleDateFormat类)

时间相关类总图

                                     

• Date是学习的核心类,表示时间
• DateFormat用于对日期的字符串转化
• Calendar对于日期的转化,年月日对象的转化,日期表示和运算的时候使用
• Calendar实现类SimpleDateFormat和Calendar的GergorianCalendar

时间在计算机中的表示

• 时间是一维的,只有前后之分
• 计算机标准纪元,1970年1月1日 00:00:00,每走一个毫秒为一个单位 (科普:由于早期的计算机存储单位比较小,32位能表示的最长时间是68年，从1970年开始的话，加上68.1，实际最终到2038年01月19日03时14分07秒，便会到达最大时间，过了这个时间点，所有32位操作系统时间便会变为 10000000 00000000 00000000 00000000，算下来也就是1901年12月13日20时45分52秒，这样便会出现时间回归的现象，很多软件便会运行异常了。时间回归的现象相信随着64为操作系统的产生逐渐得到解决，因为用64位操作系统可以表示到 292,277,026,596年12月4日15时30分08秒，相信我们的N代子孙，哪怕地球毁灭那天都不用愁不够用了，因为这个时间已经是千亿年以后了。)
• 获取当前时刻的毫秒值
  

   long currentTimeMillis = System.currentTimeMillis();

实战

• 创建一个日期对象,包是java.util.Date
  

   Date date = new Date();

   

• 源码解析

                                

this(System.currentTimeMillis());相当于创建有参构造函数,并且赋值为当前毫秒值为对象的默认时间,相当于下边的构造方法

 public Date(long date) {
        fastTime = date;
 }

测试

        Date date = new Date(System.currentTimeMillis());

        Date date1 = new Date();

        System.out.println(date.getTime()==date1.getTime());

常用方法

• boolean after(Date when) 测试此日期是否在指定日期之后 核心思维:由于日期存储了当前时间的毫秒数,所以比较日期前后,可以使用getTime()的结果来进行比较得出

源码解析

• 源码
  

  /*
       * If cdate is null, then fastTime indicates the time in millis.
       * If cdate.isNormalized() is true, then fastTime and cdate are in
       * synch. Otherwise, fastTime is ignored, and cdate indicates the
       * time.
       */
      private transient BaseCalendar.Date cdate;
  
      /**
       * Tests if this date is after the specified date.
       *
       * @param   when   a date.
       * @return  <code>true</code> if and only if the instant represented
       *          by this <tt>Date</tt> object is strictly later than the
       *          instant represented by <tt>when</tt>;
       *          <code>false</code> otherwise.
       * @exception NullPointerException if <code>when</code> is null.
       */
      public boolean after(Date when) {
          return getMillisOf(this) > getMillisOf(when);
      }
  
  
      /**
       * Returns the millisecond value of this <code>Date</code> object
       * without affecting its internal state.
       */
      static final long getMillisOf(Date date) {
          if (date.cdate == null || date.cdate.isNormalized()) {
              return date.fastTime;
          }
          BaseCalendar.Date d = (BaseCalendar.Date) date.cdate.clone();
          return gcal.getTime(d);
      }

• 解析

        核心就是getMillisOf(Date date)这个方法之间的互相比较,getMillisOf(this) > getMillisOf(when)第一个this的对象的毫秒值是否大于when对象的毫秒追,是的话this对象的时间就晚于when的时间,即when对象的时间在this对象的时间之后.

测试

        Date date = new Date(2000);

        Date date1 = new Date();

        System.out.println(date1.after(date));

• booleanbefore(Date when) 测试此日期是否在指定日期之前。

源码解析

• 源码
  

      /*
       * If cdate is null, then fastTime indicates the time in millis.
       * If cdate.isNormalized() is true, then fastTime and cdate are in
       * synch. Otherwise, fastTime is ignored, and cdate indicates the
       * time.
       */
      private transient BaseCalendar.Date cdate;
  
       /**
       * Tests if this date is before the specified date.
       *
       * @param   when   a date.
       * @return  <code>true</code> if and only if the instant of time
       *            represented by this <tt>Date</tt> object is strictly
       *            earlier than the instant represented by <tt>when</tt>;
       *          <code>false</code> otherwise.
       * @exception NullPointerException if <code>when</code> is null.
       */
      public boolean before(Date when) {
          return getMillisOf(this) < getMillisOf(when);
      }
  
  
      /**
       * Returns the millisecond value of this <code>Date</code> object
       * without affecting its internal state.
       */
      static final long getMillisOf(Date date) {
          if (date.cdate == null || date.cdate.isNormalized()) {
              return date.fastTime;
          }
          BaseCalendar.Date d = (BaseCalendar.Date) date.cdate.clone();
          return gcal.getTime(d);
      }

• 解析

        核心就是getMillisOf(Date date)这个方法之间的互相比较,getMillisOf(this) < getMillisOf(when)第一个this的对象的毫秒值是否小于when对象的毫秒追,是的话this对象的时间就早于when的时间,即when对象的时间在this对象的时间之前.

测试

  
        Date date = new Date(2000);

        Date date1 = new Date();

        System.out.println(date.before(date1));

• boolean equals(Object obj) 比较两个日期的相等性。

源码解析

• 源码
  

       /**
       * Compares two dates for equality.
       * The result is <code>true</code> if and only if the argument is
       * not <code>null</code> and is a <code>Date</code> object that
       * represents the same point in time, to the millisecond, as this object.
       * <p>
       * Thus, two <code>Date</code> objects are equal if and only if the
       * <code>getTime</code> method returns the same <code>long</code>
       * value for both.
       *
       * @param   obj   the object to compare with.
       * @return  <code>true</code> if the objects are the same;
       *          <code>false</code> otherwise.
       * @see     java.util.Date#getTime()
       */
      public boolean equals(Object obj) {
          return obj instanceof Date && getTime() == ((Date) obj).getTime();
      }

• 解析

        通过核心方法equals(Object obj),核心判断 obj instanceof Date && getTime() == ((Date) obj).getTime();同时满足两个对象的类型相同,获取的getTime()毫秒值相同,就判断两个日期相等

测试

        Date date = new Date(2000);

        Date date1 = new Date();

        System.out.println(date.equals(date1));

• long getTime() 返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。

源码解析

• 源码
  

      // The default value of gregorianCutover.
      static final long DEFAULT_GREGORIAN_CUTOVER = -12219292800000L;
  
      private static final BaseCalendar gcal = CalendarSystem.getGregorianCalendar();
  
      private static BaseCalendar jcal;
  
      private transient long fastTime;
  
      /*
       * If cdate is null, then fastTime indicates the time in millis.
       * If cdate.isNormalized() is true, then fastTime and cdate are in
       * synch. Otherwise, fastTime is ignored, and cdate indicates the
       * time.
       */
      private transient BaseCalendar.Date cdate;
  
      /**
       * Returns the number of milliseconds since January 1, 1970, 00:00:00 GMT
       * represented by this <tt>Date</tt> object.
       *
       * @return  the number of milliseconds since January 1, 1970, 00:00:00 GMT
       *          represented by this date.
       */
      public long getTime() {
          return getTimeImpl();
      }
  
      private final long getTimeImpl() {
          if (cdate != null && !cdate.isNormalized()) {
              normalize();
          }
          return fastTime;
      }
  
  
      private final BaseCalendar.Date normalize() {
          if (cdate == null) {
              BaseCalendar cal = getCalendarSystem(fastTime);
              cdate = (BaseCalendar.Date) cal.getCalendarDate(fastTime,
                      TimeZone.getDefaultRef());
              return cdate;
          }
  
          // Normalize cdate with the TimeZone in cdate first. This is
          // required for the compatible behavior.
          if (!cdate.isNormalized()) {
              cdate = normalize(cdate);
          }
  
          // If the default TimeZone has changed, then recalculate the
          // fields with the new TimeZone.
          TimeZone tz = TimeZone.getDefaultRef();
          if (tz != cdate.getZone()) {
              cdate.setZone(tz);
              CalendarSystem cal = getCalendarSystem(cdate);
              cal.getCalendarDate(fastTime, cdate);
          }
          return cdate;
      }
  
      private static final BaseCalendar getCalendarSystem(long utc) {
          // Quickly check if the time stamp given by `utc' is the Epoch
          // or later. If it's before 1970, we convert the cutover to
          // local time to compare.
          if (utc >= 0
                  || utc >= GregorianCalendar.DEFAULT_GREGORIAN_CUTOVER
                  - TimeZone.getDefaultRef().getOffset(utc)) {
              return gcal;
          }
          return getJulianCalendar();
      }
  
  
      synchronized private static final BaseCalendar getJulianCalendar() {
          if (jcal == null) {
              jcal = (BaseCalendar) CalendarSystem.forName("julian");
          }
          return jcal;
      }

• 解析
  判断BaseCalendar是否为空,和它的格式是否符合设置的格式,为空和格式符合,就返回输入的毫秒值,不为空,不符合格式规范,进入normalize()方法,对BaseCalendar中的参数进行设置 GregorianCalendar.DEFAULTGREGORIANCUTOVER - TimeZone.getDefaultRef().getOffset(utc) 格里高利历默认时间减去系统时区默认的毫秒值时间
  getJulianCalendar()获取儒略历(Julian Calendar)"规则的时间
  normalize() 对象BaseCalendar为空的时候,获取 格里高利历默认时间减去系统时区默认的毫秒值时间或者儒略历(Julian Calendar)"规则的时间放入对象 再通过 cal.getCalendarDate的毫秒值和时区时间,获取对象日期,再通过对象的日期转化为毫秒值 不是标准格式(!cdate.isNormalized()),通过 cdate = normalize(cdate);,获取日期对象 tz != cdate.getZone() 当前对象是否是默认时区,判断时区是否被更改 时区更改了,改回当前的时区,然后通过对象获取日期
  目的,就是获取BaseCalendar对象,获取其相关日期的参数,然后转化为儒略历的时间计算方式

测试

        Date date = new Date(2000);

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

• String toString() 把此 Date 对象转换为以下形式的 String：

  dow mon dd hh:mm:ss zzz yyyy 其中： dow 是一周中的某一天 (Sun、 Mon、Tue、Wed、 Thu、 Fri、 Sat)

源码解析

• 源码
  

  /**
       * Converts this <code>Date</code> object to a <code>String</code>
       * of the form:
       * <blockquote><pre>
       * dow mon dd hh:mm:ss zzz yyyy</pre></blockquote>
       * where:<ul>
       * <li><tt>dow</tt> is the day of the week (<tt>Sun, Mon, Tue, Wed,
       *     Thu, Fri, Sat</tt>).
       * <li><tt>mon</tt> is the month (<tt>Jan, Feb, Mar, Apr, May, Jun,
       *     Jul, Aug, Sep, Oct, Nov, Dec</tt>).
       * <li><tt>dd</tt> is the day of the month (<tt>01</tt> through
       *     <tt>31</tt>), as two decimal digits.
       * <li><tt>hh</tt> is the hour of the day (<tt>00</tt> through
       *     <tt>23</tt>), as two decimal digits.
       * <li><tt>mm</tt> is the minute within the hour (<tt>00</tt> through
       *     <tt>59</tt>), as two decimal digits.
       * <li><tt>ss</tt> is the second within the minute (<tt>00</tt> through
       *     <tt>61</tt>, as two decimal digits.
       * <li><tt>zzz</tt> is the time zone (and may reflect daylight saving
       *     time). Standard time zone abbreviations include those
       *     recognized by the method <tt>parse</tt>. If time zone
       *     information is not available, then <tt>zzz</tt> is empty -
       *     that is, it consists of no characters at all.
       * <li><tt>yyyy</tt> is the year, as four decimal digits.
       * </ul>
       *
       * @return  a string representation of this date.
       * @see     java.util.Date#toLocaleString()
       * @see     java.util.Date#toGMTString()
       */
      public String toString() {
          // "EEE MMM dd HH:mm:ss zzz yyyy";
          BaseCalendar.Date date = normalize();
          StringBuilder sb = new StringBuilder(28);
          int index = date.getDayOfWeek();
          if (index == BaseCalendar.SUNDAY) {
              index = 8;
          }
          convertToAbbr(sb, wtb[index]).append(' ');                        // EEE
          convertToAbbr(sb, wtb[date.getMonth() - 1 + 2 + 7]).append(' ');  // MMM
          CalendarUtils.sprintf0d(sb, date.getDayOfMonth(), 2).append(' '); // dd
  
          CalendarUtils.sprintf0d(sb, date.getHours(), 2).append(':');   // HH
          CalendarUtils.sprintf0d(sb, date.getMinutes(), 2).append(':'); // mm
          CalendarUtils.sprintf0d(sb, date.getSeconds(), 2).append(' '); // ss
          TimeZone zi = date.getZone();
          if (zi != null) {
              sb.append(zi.getDisplayName(date.isDaylightTime(), TimeZone.SHORT, Locale.US)); // zzz
          } else {
              sb.append("GMT");
          }
          sb.append(' ').append(date.getYear());  // yyyy
          return sb.toString();
      }

• 解析

拼接字符串按照格式:EEE MMM dd HH:mm:ss zzz yyyy,获取周/月/日/时分秒/时区/年

测试

        Date date = new Date();

        System.out.println(date.toString());

 

注:
      大部分方法已经被取代了,不推荐使用了 JDK8,已经推出了新的LocalDate系列取代的新方案,

详情查阅 https://www.cnblogs.com/liuyangfirst/p/10076612.html