简介

  • Date是一个日期相关的类
  • 一般我们都是使用Date来存储日期，如数据库的日期类型

  • 我们操作的会是将其进行格式化，格式化参见下面几篇

    源码

    1. public class Date
    2.   implements java.io.Serializable, Cloneable, Comparable<Date>
    3. {
    4.   private static final BaseCalendar gcal =
    5.       CalendarSystem.getGregorianCalendar();
    6.   private static BaseCalendar jcal;
    8.   private transient long fastTime;
    10.   private transient BaseCalendar.Date cdate;
    12.   private static int defaultCenturyStart;
    14.   private static final long serialVersionUID = 7523967970034938905L;
    16.   // 无参构造方法 ，调用System的静态方法获取系统时间的毫秒数
    17.   public Date() {
    18.       this(System.currentTimeMillis());
    19.   }
    21.   // 根据毫秒设置时间
    22.   public Date(long date) {
    23.       fastTime = date;
    24.   }
    26.   // 根据年月日设置时间
    27.   @Deprecated
    28.   public Date(int year, int month, int date) {
    29.       this(year, month, date, 0, 0, 0);
    30.   }
    32.   // 年月日时分
    33.   @Deprecated
    34.   public Date(int year, int month, int date, int hrs, int min) {
    35.       this(year, month, date, hrs, min, 0);
    36.   }
    37.   // 年月日时分秒
    38.   @Deprecated
    39.   public Date(int year, int month, int date, int hrs, int min, int sec) {
    40.       // 注意是从 1900 + year
    41.       int y = year + 1900;
    42.       // month is 0-based. So we have to normalize month to support Long.MAX_VALUE.
    43.       if (month >= 12) {
    44.           y += month / 12;
    45.           month %= 12;
    46.       } else if (month < 0) {
    47.           y += CalendarUtils.floorDivide(month, 12);
    48.           month = CalendarUtils.mod(month, 12);
    49.       }
    50.       BaseCalendar cal = getCalendarSystem(y);
    51.       cdate = (BaseCalendar.Date) cal.newCalendarDate(TimeZone.getDefaultRef());
    52.       cdate.setNormalizedDate(y, month + 1, date).setTimeOfDay(hrs, min, sec, 0);
    53.       getTimeImpl();
    54.       cdate = null;
    55.   }
    57.   // toString 方法
    58.   @Deprecated
    59.   public Date(String s) {
    60.       this(parse(s));
    61.   }
    63.   public Object clone() {
    64.       Date d = null;
    65.       try {
    66.           d = (Date)super.clone();
    67.           if (cdate != null) {
    68.               d.cdate = (BaseCalendar.Date) cdate.clone();
    69.           }
    70.       } catch (CloneNotSupportedException e) {} // Won't happen
    71.       return d;
    72.   }
    74.   // 获得时间的自1970年1月1日的毫秒数
    75.   @Deprecated
    76.   public static long UTC(int year, int month, int date,
    77.                          int hrs, int min, int sec) {
    78.       int y = year + 1900;
    79.       // month is 0-based. So we have to normalize month to support Long.MAX_VALUE.
    80.       if (month >= 12) {
    81.           y += month / 12;
    82.           month %= 12;
    83.       } else if (month < 0) {
    84.           y += CalendarUtils.floorDivide(month, 12);
    85.           month = CalendarUtils.mod(month, 12);
    86.       }
    87.       int m = month + 1;
    88.       BaseCalendar cal = getCalendarSystem(y);
    89.       BaseCalendar.Date udate = (BaseCalendar.Date) cal.newCalendarDate(null);
    90.       udate.setNormalizedDate(y, m, date).setTimeOfDay(hrs, min, sec, 0);
    92.       // Use a Date instance to perform normalization. Its fastTime
    93.       // is the UTC value after the normalization.
    94.       Date d = new Date(0);
    95.       d.normalize(udate);
    96.       return d.fastTime;
    97.   }
    99.   // 日期转换方法
    100.   @Deprecated
    101.   public static long parse(String s) {
    102.       int year = Integer.MIN_VALUE;
    103.       int mon = -1;
    104.       int mday = -1;
    105.       int hour = -1;
    106.       int min = -1;
    107.       int sec = -1;
    108.       int millis = -1;
    109.       int c = -1;
    110.       int i = 0;
    111.       int n = -1;
    112.       int wst = -1;
    113.       int tzoffset = -1;
    114.       int prevc = 0;
    115.       syntax:
    116.       {
    117.           if (s == null)
    118.               break syntax;
    119.           int limit = s.length();
    120.           while (i < limit) {
    121.               c = s.charAt(i);
    122.               i++;
    123.               if (c <= ' ' || c == ',')
    124.                   continue;
    125.               if (c == '(') { // skip comments
    126.                   int depth = 1;
    127.                   while (i < limit) {
    128.                       c = s.charAt(i);
    129.                       i++;
    130.                       if (c == '(') depth++;
    131.                       else if (c == ')')
    132.                           if (--depth <= 0)
    133.                               break;
    134.                   }
    135.                   continue;
    136.               }
    137.               if ('0' <= c && c <= '9') {
    138.                   n = c - '0';
    139.                   while (i < limit && '0' <= (c = s.charAt(i)) && c <= '9') {
    140.                       n = n * 10 + c - '0';
    141.                       i++;
    142.                   }
    143.                   if (prevc == '+' || prevc == '-' && year != Integer.MIN_VALUE) {
    144.                       // timezone offset
    145.                       if (n < 24)
    146.                           n = n * 60; // EG. "GMT-3"
    147.                       else
    148.                           n = n % 100 + n / 100 * 60; // eg "GMT-0430"
    149.                       if (prevc == '+')   // plus means east of GMT
    150.                           n = -n;
    151.                       if (tzoffset != 0 && tzoffset != -1)
    152.                           break syntax;
    153.                       tzoffset = n;
    154.                   } else if (n >= 70)
    155.                       if (year != Integer.MIN_VALUE)
    156.                           break syntax;
    157.                   else if (c <= ' ' || c == ',' || c == '/' || i >= limit)
    158.                       // year = n < 1900 ? n : n - 1900;
    159.                       year = n;
    160.                   else
    161.                       break syntax;
    162.                   else if (c == ':')
    163.                       if (hour < 0)
    164.                           hour = (byte) n;
    165.                   else if (min < 0)
    166.                       min = (byte) n;
    167.                   else
    168.                       break syntax;
    169.                   else if (c == '/')
    170.                       if (mon < 0)
    171.                           mon = (byte) (n - 1);
    172.                   else if (mday < 0)
    173.                       mday = (byte) n;
    174.                   else
    175.                       break syntax;
    176.                   else if (i < limit && c != ',' && c > ' ' && c != '-')
    177.                       break syntax;
    178.                   else if (hour >= 0 && min < 0)
    179.                       min = (byte) n;
    180.                   else if (min >= 0 && sec < 0)
    181.                       sec = (byte) n;
    182.                   else if (mday < 0)
    183.                       mday = (byte) n;
    184.                   // Handle two-digit years < 70 (70-99 handled above).
    185.                   else if (year == Integer.MIN_VALUE && mon >= 0 && mday >= 0)
    186.                       year = n;
    187.                   else
    188.                       break syntax;
    189.                   prevc = 0;
    190.               } else if (c == '/' || c == ':' || c == '+' || c == '-')
    191.                   prevc = c;
    192.               else {
    193.                   int st = i - 1;
    194.                   while (i < limit) {
    195.                       c = s.charAt(i);
    196.                       if (!('A' <= c && c <= 'Z' || 'a' <= c && c <= 'z'))
    197.                           break;
    198.                       i++;
    199.                   }
    200.                   if (i <= st + 1)
    201.                       break syntax;
    202.                   int k;
    203.                   for (k = wtb.length; --k >= 0;)
    204.                       if (wtb[k].regionMatches(true, 0, s, st, i - st)) {
    205.                           int action = ttb[k];
    206.                           if (action != 0) {
    207.                               if (action == 1) {  // pm
    208.                                   if (hour > 12 || hour < 1)
    209.                                       break syntax;
    210.                                   else if (hour < 12)
    211.                                       hour += 12;
    212.                               } else if (action == 14) {  // am
    213.                                   if (hour > 12 || hour < 1)
    214.                                       break syntax;
    215.                                   else if (hour == 12)
    216.                                       hour = 0;
    217.                               } else if (action <= 13) {  // month!
    218.                                   if (mon < 0)
    219.                                       mon = (byte) (action - 2);
    220.                                   else
    221.                                       break syntax;
    222.                               } else {
    223.                                   tzoffset = action - 10000;
    224.                               }
    225.                           }
    226.                           break;
    227.                       }
    228.                   if (k < 0)
    229.                       break syntax;
    230.                   prevc = 0;
    231.               }
    232.           }
    233.           if (year == Integer.MIN_VALUE || mon < 0 || mday < 0)
    234.               break syntax;
    235.           // Parse 2-digit years within the correct default century.
    236.           if (year < 100) {
    237.               synchronized (Date.class) {
    238.                   if (defaultCenturyStart == 0) {
    239.                       defaultCenturyStart = gcal.getCalendarDate().getYear() - 80;
    240.                   }
    241.               }
    242.               year += (defaultCenturyStart / 100) * 100;
    243.               if (year < defaultCenturyStart) year += 100;
    244.           }
    245.           if (sec < 0)
    246.               sec = 0;
    247.           if (min < 0)
    248.               min = 0;
    249.           if (hour < 0)
    250.               hour = 0;
    251.           BaseCalendar cal = getCalendarSystem(year);
    252.           if (tzoffset == -1)  { // no time zone specified, have to use local
    253.               BaseCalendar.Date ldate = (BaseCalendar.Date) cal.newCalendarDate(TimeZone.getDefaultRef());
    254.               ldate.setDate(year, mon + 1, mday);
    255.               ldate.setTimeOfDay(hour, min, sec, 0);
    256.               return cal.getTime(ldate);
    257.           }
    258.           BaseCalendar.Date udate = (BaseCalendar.Date) cal.newCalendarDate(null); // no time zone
    259.           udate.setDate(year, mon + 1, mday);
    260.           udate.setTimeOfDay(hour, min, sec, 0);
    261.           return cal.getTime(udate) + tzoffset * (60 * 1000);
    262.       }
    263.       // syntax error
    264.       throw new IllegalArgumentException();
    265.   }
    267.   private final static String wtb[] = {
    268.       "am", "pm",
    269.       "monday", "tuesday", "wednesday", "thursday", "friday",
    270.       "saturday", "sunday",
    271.       "january", "february", "march", "april", "may", "june",
    272.       "july", "august", "september", "october", "november", "december",
    273.       "gmt", "ut", "utc", "est", "edt", "cst", "cdt",
    274.       "mst", "mdt", "pst", "pdt"
    275.   };
    276.   private final static int ttb[] = {
    277.       14, 1, 0, 0, 0, 0, 0, 0, 0,
    278.       2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
    279.       10000 + 0, 10000 + 0, 10000 + 0,    // GMT/UT/UTC
    280.       10000 + 5 * 60, 10000 + 4 * 60,     // EST/EDT
    281.       10000 + 6 * 60, 10000 + 5 * 60,     // CST/CDT
    282.       10000 + 7 * 60, 10000 + 6 * 60,     // MST/MDT
    283.       10000 + 8 * 60, 10000 + 7 * 60      // PST/PDT
    284.   };
    286.   // 获取年
    287.   @Deprecated
    288.   public int getYear() {
    289.       return normalize().getYear() - 1900;
    290.   }
    292.   // 设置年
    293.   @Deprecated
    294.   public void setYear(int year) {
    295.       getCalendarDate().setNormalizedYear(year + 1900);
    296.   }
    298.   // 返回月
    299.   @Deprecated
    300.   public int getMonth() {
    301.       return normalize().getMonth() - 1; // adjust 1-based to 0-based
    302.   }
    304.   // 设置月 
    305.   public void setMonth(int month) {
    306.       int y = 0;
    307.       if (month >= 12) {
    308.           y = month / 12;
    309.           month %= 12;
    310.       } else if (month < 0) {
    311.           y = CalendarUtils.floorDivide(month, 12);
    312.           month = CalendarUtils.mod(month, 12);
    313.       }
    314.       BaseCalendar.Date d = getCalendarDate();
    315.       if (y != 0) {
    316.           d.setNormalizedYear(d.getNormalizedYear() + y);
    317.       }
    318.       d.setMonth(month + 1); // adjust 0-based to 1-based month numbering
    319.   }
    321.   // 获取月的第几天
    322.   @Deprecated
    323.   public int getDate() {
    324.       return normalize().getDayOfMonth();
    325.   }
    327.   // 设置月的第几天
    328.   @Deprecated
    329.   public void setDate(int date) {
    330.       getCalendarDate().setDayOfMonth(date);
    331.   }
    333.   // 获取返回该日期是星期几。 返回值（0 =星期日，1 =周一，2 =周二，3 =周三，4 =周四，5 =周五，6 =星期六）
    334.   // 表示包含或与此代表了时间的瞬间开始的一周中的一天Date对象在本地时区解释。
    335.   @Deprecated
    336.   public int getDay() {
    337.       return normalize().getDayOfWeek() - BaseCalendar.SUNDAY;
    338.   }
    340.   // （0至23）
    341.   @Deprecated
    342.   public int getHours() {
    343.       return normalize().getHours();
    344.   }
    346.   @Deprecated
    347.   public void setHours(int hours) {
    348.       getCalendarDate().setHours(hours);
    349.   }
    350.   @Deprecated
    351.   public int getMinutes() {
    352.       return normalize().getMinutes();
    353.   }
    354.   @Deprecated
    355.   public void setMinutes(int minutes) {
    356.       getCalendarDate().setMinutes(minutes);
    357.   }
    358.   @Deprecated
    359.   public int getSeconds() {
    360.       return normalize().getSeconds();
    361.   }
    363.   @Deprecated
    364.   public void setSeconds(int seconds) {
    365.       getCalendarDate().setSeconds(seconds);
    366.   }
    368.   //获取毫秒数
    369.   public long getTime() {
    370.       return getTimeImpl();
    371.   }
    373.   private final long getTimeImpl() {
    374.       if (cdate != null && !cdate.isNormalized()) {
    375.           normalize();
    376.       }
    377.       return fastTime;
    378.   }
    380.   // 设置时间的毫秒数
    381.   public void setTime(long time) {
    382.       fastTime = time;
    383.       cdate = null;
    384.   }
    386.   public boolean before(Date when) {
    387.       return getMillisOf(this) < getMillisOf(when);
    388.   }
    390.   public boolean after(Date when) {
    391.       return getMillisOf(this) > getMillisOf(when);
    392.   }
    394.   public boolean equals(Object obj) {
    395.       return obj instanceof Date && getTime() == ((Date) obj).getTime();
    396.   }
    398.   static final long getMillisOf(Date date) {
    399.       if (date.cdate == null || date.cdate.isNormalized()) {
    400.           return date.fastTime;
    401.       }
    402.       BaseCalendar.Date d = (BaseCalendar.Date) date.cdate.clone();
    403.       return gcal.getTime(d);
    404.   }
    406.   public int compareTo(Date anotherDate) {
    407.       long thisTime = getMillisOf(this);
    408.       long anotherTime = getMillisOf(anotherDate);
    409.       return (thisTime<anotherTime ? -1 : (thisTime==anotherTime ? 0 : 1));
    410.   }
    412.   public int hashCode() {
    413.       long ht = this.getTime();
    414.       return (int) ht ^ (int) (ht >> 32);
    415.   }
    417.   public String toString() {
    418.       // "EEE MMM dd HH:mm:ss zzz yyyy";
    419.       BaseCalendar.Date date = normalize();
    420.       StringBuilder sb = new StringBuilder(28);
    421.       int index = date.getDayOfWeek();
    422.       if (index == BaseCalendar.SUNDAY) {
    423.           index = 8;
    424.       }
    425.       convertToAbbr(sb, wtb[index]).append(' ');                        // EEE
    426.       convertToAbbr(sb, wtb[date.getMonth() - 1 + 2 + 7]).append(' ');  // MMM
    427.       CalendarUtils.sprintf0d(sb, date.getDayOfMonth(), 2).append(' '); // dd
    429.       CalendarUtils.sprintf0d(sb, date.getHours(), 2).append(':');   // HH
    430.       CalendarUtils.sprintf0d(sb, date.getMinutes(), 2).append(':'); // mm
    431.       CalendarUtils.sprintf0d(sb, date.getSeconds(), 2).append(' '); // ss
    432.       TimeZone zi = date.getZone();
    433.       if (zi != null) {
    434.           sb.append(zi.getDisplayName(date.isDaylightTime(), TimeZone.SHORT, Locale.US)); // zzz
    435.       } else {
    436.           sb.append("GMT");
    437.       }
    438.       sb.append(' ').append(date.getYear());  // yyyy
    439.       return sb.toString();
    440.   }
    442.   private static final StringBuilder convertToAbbr(StringBuilder sb, String name) {
    443.       sb.append(Character.toUpperCase(name.charAt(0)));
    444.       sb.append(name.charAt(1)).append(name.charAt(2));
    445.       return sb;
    446.   }
    448.   @Deprecated
    449.   public String toLocaleString() {
    450.       DateFormat formatter = DateFormat.getDateTimeInstance();
    451.       return formatter.format(this);
    452.   }
    454.   @Deprecated
    455.   public String toGMTString() {
    456.       // d MMM yyyy HH:mm:ss 'GMT'
    457.       long t = getTime();
    458.       BaseCalendar cal = getCalendarSystem(t);
    459.       BaseCalendar.Date date =
    460.           (BaseCalendar.Date) cal.getCalendarDate(getTime(), (TimeZone)null);
    461.       StringBuilder sb = new StringBuilder(32);
    462.       CalendarUtils.sprintf0d(sb, date.getDayOfMonth(), 1).append(' '); // d
    463.       convertToAbbr(sb, wtb[date.getMonth() - 1 + 2 + 7]).append(' ');  // MMM
    464.       sb.append(date.getYear()).append(' ');                            // yyyy
    465.       CalendarUtils.sprintf0d(sb, date.getHours(), 2).append(':');      // HH
    466.       CalendarUtils.sprintf0d(sb, date.getMinutes(), 2).append(':');    // mm
    467.       CalendarUtils.sprintf0d(sb, date.getSeconds(), 2);                // ss
    468.       sb.append(" GMT");                                                // ' GMT'
    469.       return sb.toString();
    470.   }
    472.   @Deprecated
    473.   public int getTimezoneOffset() {
    474.       int zoneOffset;
    475.       if (cdate == null) {
    476.           TimeZone tz = TimeZone.getDefaultRef();
    477.           if (tz instanceof ZoneInfo) {
    478.               zoneOffset = ((ZoneInfo)tz).getOffsets(fastTime, null);
    479.           } else {
    480.               zoneOffset = tz.getOffset(fastTime);
    481.           }
    482.       } else {
    483.           normalize();
    484.           zoneOffset = cdate.getZoneOffset();
    485.       }
    486.       return -zoneOffset/60000;  // convert to minutes
    487.   }
    489.   private final BaseCalendar.Date getCalendarDate() {
    490.       if (cdate == null) {
    491.           BaseCalendar cal = getCalendarSystem(fastTime);
    492.           cdate = (BaseCalendar.Date) cal.getCalendarDate(fastTime,
    493.                                                           TimeZone.getDefaultRef());
    494.       }
    495.       return cdate;
    496.   }
    498.   private final BaseCalendar.Date normalize() {
    499.       if (cdate == null) {
    500.           BaseCalendar cal = getCalendarSystem(fastTime);
    501.           cdate = (BaseCalendar.Date) cal.getCalendarDate(fastTime,
    502.                                                           TimeZone.getDefaultRef());
    503.           return cdate;
    504.       }
    506.       // Normalize cdate with the TimeZone in cdate first. This is
    507.       // required for the compatible behavior.
    508.       if (!cdate.isNormalized()) {
    509.           cdate = normalize(cdate);
    510.       }
    512.       // If the default TimeZone has changed, then recalculate the
    513.       // fields with the new TimeZone.
    514.       TimeZone tz = TimeZone.getDefaultRef();
    515.       if (tz != cdate.getZone()) {
    516.           cdate.setZone(tz);
    517.           CalendarSystem cal = getCalendarSystem(cdate);
    518.           cal.getCalendarDate(fastTime, cdate);
    519.       }
    520.       return cdate;
    521.   }
    523.   // fastTime and the returned data are in sync upon return.
    524.   private final BaseCalendar.Date normalize(BaseCalendar.Date date) {
    525.       int y = date.getNormalizedYear();
    526.       int m = date.getMonth();
    527.       int d = date.getDayOfMonth();
    528.       int hh = date.getHours();
    529.       int mm = date.getMinutes();
    530.       int ss = date.getSeconds();
    531.       int ms = date.getMillis();
    532.       TimeZone tz = date.getZone();
    533.       if (y == 1582 || y > 280000000 || y < -280000000) {
    534.           if (tz == null) {
    535.               tz = TimeZone.getTimeZone("GMT");
    536.           }
    537.           GregorianCalendar gc = new GregorianCalendar(tz);
    538.           gc.clear();
    539.           gc.set(GregorianCalendar.MILLISECOND, ms);
    540.           gc.set(y, m-1, d, hh, mm, ss);
    541.           fastTime = gc.getTimeInMillis();
    542.           BaseCalendar cal = getCalendarSystem(fastTime);
    543.           date = (BaseCalendar.Date) cal.getCalendarDate(fastTime, tz);
    544.           return date;
    545.       }
    547.       BaseCalendar cal = getCalendarSystem(y);
    548.       if (cal != getCalendarSystem(date)) {
    549.           date = (BaseCalendar.Date) cal.newCalendarDate(tz);
    550.           date.setNormalizedDate(y, m, d).setTimeOfDay(hh, mm, ss, ms);
    551.       }
    552.       // Perform the GregorianCalendar-style normalization.
    553.       fastTime = cal.getTime(date);
    555.       // In case the normalized date requires the other calendar
    556.       // system, we need to recalculate it using the other one.
    557.       BaseCalendar ncal = getCalendarSystem(fastTime);
    558.       if (ncal != cal) {
    559.           date = (BaseCalendar.Date) ncal.newCalendarDate(tz);
    560.           date.setNormalizedDate(y, m, d).setTimeOfDay(hh, mm, ss, ms);
    561.           fastTime = ncal.getTime(date);
    562.       }
    563.       return date;
    564.   }
    565.   private static final BaseCalendar getCalendarSystem(int year) {
    566.       if (year >= 1582) {
    567.           return gcal;
    568.       }
    569.       return getJulianCalendar();
    570.   }
    572.   private static final BaseCalendar getCalendarSystem(long utc) {
    573.       // Quickly check if the time stamp given by `utc' is the Epoch
    574.       // or later. If it's before 1970, we convert the cutover to
    575.       // local time to compare.
    576.       if (utc >= 0
    577.           || utc >= GregorianCalendar.DEFAULT_GREGORIAN_CUTOVER
    578.           - TimeZone.getDefaultRef().getOffset(utc)) {
    579.           return gcal;
    580.       }
    581.       return getJulianCalendar();
    582.   }
    584.   private static final BaseCalendar getCalendarSystem(BaseCalendar.Date cdate) {
    585.       if (jcal == null) {
    586.           return gcal;
    587.       }
    588.       if (cdate.getEra() != null) {
    589.           return jcal;
    590.       }
    591.       return gcal;
    592.   }
    594.   synchronized private static final BaseCalendar getJulianCalendar() {
    595.       if (jcal == null) {
    596.           jcal = (BaseCalendar) CalendarSystem.forName("julian");
    597.       }
    598.       return jcal;
    599.   }
    601.   private void writeObject(ObjectOutputStream s)
    602.       throws IOException
    603.   {
    604.       s.writeLong(getTimeImpl());
    605.   }
    607.   private void readObject(ObjectInputStream s)
    608.       throws IOException, ClassNotFoundException
    609.   {
    610.       fastTime = s.readLong();
    611.   }
    612.   public static Date from(Instant instant) {
    613.       try {
    614.           return new Date(instant.toEpochMilli());
    615.       } catch (ArithmeticException ex) {
    616.           throw new IllegalArgumentException(ex);
    617.       }
    618.   }
    620.   public Instant toInstant() {
    621.       return Instant.ofEpochMilli(getTime());
    622.   }
    623. }