/* * Copyright (c) 1994, 2010, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ package java.util; import java.text.DateFormat;import java.io.IOException;import java.io.ObjectOutputStream;import java.io.ObjectInputStream;import java.lang.ref.SoftReference;import sun.util.calendar.BaseCalendar;import sun.util.calendar.CalendarDate;import sun.util.calendar.CalendarSystem;import sun.util.calendar.CalendarUtils;import sun.util.calendar.Era;import sun.util.calendar.Gregorian;import sun.util.calendar.ZoneInfo; /** * The class <code>Date</code> represents a specific instant * in time, with millisecond precision. * <p> * Prior to JDK 1.1, the class <code>Date</code> had two additional * functions. It allowed the interpretation of dates as year, month, day, hour, * minute, and second values. It also allowed the formatting and parsing * of date strings. Unfortunately, the API for these functions was not * amenable to internationalization. As of JDK 1.1, the * <code>Calendar</code> class should be used to convert between dates and time * fields and the <code>DateFormat</code> class should be used to format and * parse date strings. * The corresponding methods in <code>Date</code> are deprecated. * <p> * Although the <code>Date</code> class is intended to reflect * coordinated universal time (UTC), it may not do so exactly, * depending on the host environment of the Java Virtual Machine. * Nearly all modern operating systems assume that 1 day = * 24 × 60 × 60 = 86400 seconds * in all cases. In UTC, however, about once every year or two there * is an extra second, called a "leap second." The leap * second is always added as the last second of the day, and always * on December 31 or June 30. For example, the last minute of the * year 1995 was 61 seconds long, thanks to an added leap second. * Most computer clocks are not accurate enough to be able to reflect * the leap-second distinction. * <p> * Some computer standards are defined in terms of Greenwich mean * time (GMT), which is equivalent to universal time (UT). GMT is * the "civil" name for the standard; UT is the * "scientific" name for the same standard. The * distinction between UTC and UT is that UTC is based on an atomic * clock and UT is based on astronomical observations, which for all * practical purposes is an invisibly fine hair to split. Because the * earth's rotation is not uniform (it slows down and speeds up * in complicated ways), UT does not always flow uniformly. Leap * seconds are introduced as needed into UTC so as to keep UTC within * 0.9 seconds of UT1, which is a version of UT with certain * corrections applied. There are other time and date systems as * well; for example, the time scale used by the satellite-based * global positioning system (GPS) is synchronized to UTC but is * <i>not</i> adjusted for leap seconds. An interesting source of * further information is the U.S. Naval Observatory, particularly * the Directorate of Time at: * <blockquote><pre> * <a href=http://tycho.usno.navy.mil>http://tycho.usno.navy.mil</a> * </pre></blockquote> * <p> * and their definitions of "Systems of Time" at: * <blockquote><pre> * <a href=http://tycho.usno.navy.mil/systime.html>http://tycho.usno.navy.mil/systime.html</a> * </pre></blockquote> * <p> * In all methods of class <code>Date</code> that accept or return * year, month, date, hours, minutes, and seconds values, the * following representations are used: * <ul> * <li>A year <i>y</i> is represented by the integer * <i>y</i> <code>- 1900</code>. * <li>A month is represented by an integer from 0 to 11; 0 is January, * 1 is February, and so forth; thus 11 is December. * <li>A date (day of month) is represented by an integer from 1 to 31 * in the usual manner. * <li>An hour is represented by an integer from 0 to 23. Thus, the hour * from midnight to 1 a.m. is hour 0, and the hour from noon to 1 * p.m. is hour 12. * <li>A minute is represented by an integer from 0 to 59 in the usual manner. * <li>A second is represented by an integer from 0 to 61; the values 60 and * 61 occur only for leap seconds and even then only in Java * implementations that actually track leap seconds correctly. Because * of the manner in which leap seconds are currently introduced, it is * extremely unlikely that two leap seconds will occur in the same * minute, but this specification follows the date and time conventions * for ISO C. * </ul> * <p> * In all cases, arguments given to methods for these purposes need * not fall within the indicated ranges; for example, a date may be * specified as January 32 and is interpreted as meaning February 1. * * @author James Gosling * @author Arthur van Hoff * @author Alan Liu * @see java.text.DateFormat * @see java.util.Calendar * @see java.util.TimeZone * @since JDK1.0 */public class Date implements java.io.Serializable, Cloneable, Comparable<Date>{ 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; // Initialized just before the value is used. See parse(). private static int defaultCenturyStart; /* use serialVersionUID from modified java.util.Date for * interoperability with JDK1.1. The Date was modified to write * and read only the UTC time. */ private static final long serialVersionUID = 7523967970034938905L; /** * Allocates a <code>Date</code> object and initializes it so that * it represents the time at which it was allocated, measured to the * nearest millisecond. * * @see java.lang.System#currentTimeMillis() */ public Date() { this(System.currentTimeMillis()); } /** * Allocates a <code>Date</code> object and initializes it to * represent the specified number of milliseconds since the * standard base time known as "the epoch", namely January 1, * 1970, 00:00:00 GMT. * * @param date the milliseconds since January 1, 1970, 00:00:00 GMT. * @see java.lang.System#currentTimeMillis() */ public Date(long date) { fastTime = date; } /** * Allocates a <code>Date</code> object and initializes it so that * it represents midnight, local time, at the beginning of the day * specified by the <code>year</code>, <code>month</code>, and * <code>date</code> arguments. * * @param year the year minus 1900. * @param month the month between 0-11. * @param date the day of the month between 1-31. * @see java.util.Calendar * @deprecated As of JDK version 1.1, * replaced by <code>Calendar.set(year + 1900, month, date)</code> * or <code>GregorianCalendar(year + 1900, month, date)</code>. */ @Deprecated public Date(int year, int month, int date) { this(year, month, date, 0, 0, 0); } /** * Allocates a <code>Date</code> object and initializes it so that * it represents the instant at the start of the minute specified by * the <code>year</code>, <code>month</code>, <code>date</code>, * <code>hrs</code>, and <code>min</code> arguments, in the local * time zone. * * @param year the year minus 1900. * @param month the month between 0-11. * @param date the day of the month between 1-31. * @param hrs the hours between 0-23. * @param min the minutes between 0-59. * @see java.util.Calendar * @deprecated As of JDK version 1.1, * replaced by <code>Calendar.set(year + 1900, month, date, * hrs, min)</code> or <code>GregorianCalendar(year + 1900, * month, date, hrs, min)</code>. */ @Deprecated public Date(int year, int month, int date, int hrs, int min) { this(year, month, date, hrs, min, 0); } /** * Allocates a <code>Date</code> object and initializes it so that * it represents the instant at the start of the second specified * by the <code>year</code>, <code>month</code>, <code>date</code>, * <code>hrs</code>, <code>min</code>, and <code>sec</code> arguments, * in the local time zone. * * @param year the year minus 1900. * @param month the month between 0-11. * @param date the day of the month between 1-31. * @param hrs the hours between 0-23. * @param min the minutes between 0-59. * @param sec the seconds between 0-59. * @see java.util.Calendar * @deprecated As of JDK version 1.1, * replaced by <code>Calendar.set(year + 1900, month, date, * hrs, min, sec)</code> or <code>GregorianCalendar(year + 1900, * month, date, hrs, min, sec)</code>. */ @Deprecated public Date(int year, int month, int date, int hrs, int min, int sec) { int y = year + 1900; // month is 0-based. So we have to normalize month to support Long.MAX_VALUE. if (month >= 12) { y += month / 12; month %= 12; } else if (month < 0) { y += CalendarUtils.floorDivide(month, 12); month = CalendarUtils.mod(month, 12); } BaseCalendar cal = getCalendarSystem(y); cdate = (BaseCalendar.Date) cal.newCalendarDate(TimeZone.getDefaultRef()); cdate.setNormalizedDate(y, month + 1, date).setTimeOfDay(hrs, min, sec, 0); getTimeImpl(); cdate = null; } /** * Allocates a <code>Date</code> object and initializes it so that * it represents the date and time indicated by the string * <code>s</code>, which is interpreted as if by the * {@link Date#parse} method. * * @param s a string representation of the date. * @see java.text.DateFormat * @see java.util.Date#parse(java.lang.String) * @deprecated As of JDK version 1.1, * replaced by <code>DateFormat.parse(String s)</code>. */ @Deprecated public Date(String s) { this(parse(s)); } /** * Return a copy of this object. */ public Object clone() { Date d = null; try { d = (Date)super.clone(); if (cdate != null) { d.cdate = (BaseCalendar.Date) cdate.clone(); } } catch (CloneNotSupportedException e) {} // Won't happen return d; } /** * Determines the date and time based on the arguments. The * arguments are interpreted as a year, month, day of the month, * hour of the day, minute within the hour, and second within the * minute, exactly as for the <tt>Date</tt> constructor with six * arguments, except that the arguments are interpreted relative * to UTC rather than to the local time zone. The time indicated is * returned represented as the distance, measured in milliseconds, * of that time from the epoch (00:00:00 GMT on January 1, 1970). * * @param year the year minus 1900. * @param month the month between 0-11. * @param date the day of the month between 1-31. * @param hrs the hours between 0-23. * @param min the minutes between 0-59. * @param sec the seconds between 0-59. * @return the number of milliseconds since January 1, 1970, 00:00:00 GMT for * the date and time specified by the arguments. * @see java.util.Calendar * @deprecated As of JDK version 1.1, * replaced by <code>Calendar.set(year + 1900, month, date, * hrs, min, sec)</code> or <code>GregorianCalendar(year + 1900, * month, date, hrs, min, sec)</code>, using a UTC * <code>TimeZone</code>, followed by <code>Calendar.getTime().getTime()</code>. */ @Deprecated public static long UTC(int year, int month, int date, int hrs, int min, int sec) { int y = year + 1900; // month is 0-based. So we have to normalize month to support Long.MAX_VALUE. if (month >= 12) { y += month / 12; month %= 12; } else if (month < 0) { y += CalendarUtils.floorDivide(month, 12); month = CalendarUtils.mod(month, 12); } int m = month + 1; BaseCalendar cal = getCalendarSystem(y); BaseCalendar.Date udate = (BaseCalendar.Date) cal.newCalendarDate(null); udate.setNormalizedDate(y, m, date).setTimeOfDay(hrs, min, sec, 0); // Use a Date instance to perform normalization. Its fastTime // is the UTC value after the normalization. Date d = new Date(0); d.normalize(udate); return d.fastTime; } /** * Attempts to interpret the string <tt>s</tt> as a representation * of a date and time. If the attempt is successful, the time * indicated is returned represented as the distance, measured in * milliseconds, of that time from the epoch (00:00:00 GMT on * January 1, 1970). If the attempt fails, an * <tt>IllegalArgumentException</tt> is thrown. * <p> * It accepts many syntaxes; in particular, it recognizes the IETF * standard date syntax: "Sat, 12 Aug 1995 13:30:00 GMT". It also * understands the continental U.S. time-zone abbreviations, but for * general use, a time-zone offset should be used: "Sat, 12 Aug 1995 * 13:30:00 GMT+0430" (4 hours, 30 minutes west of the Greenwich * meridian). If no time zone is specified, the local time zone is * assumed. GMT and UTC are considered equivalent. * <p> * The string <tt>s</tt> is processed from left to right, looking for * data of interest. Any material in <tt>s</tt> that is within the * ASCII parenthesis characters <tt>(</tt> and <tt>)</tt> is ignored. * Parentheses may be nested. Otherwise, the only characters permitted * within <tt>s</tt> are these ASCII characters: * <blockquote><pre> * abcdefghijklmnopqrstuvwxyz * ABCDEFGHIJKLMNOPQRSTUVWXYZ * 0123456789,+-:/</pre></blockquote> * and whitespace characters.<p> * A consecutive sequence of decimal digits is treated as a decimal * number:<ul> * <li>If a number is preceded by <tt>+</tt> or <tt>-</tt> and a year * has already been recognized, then the number is a time-zone * offset. If the number is less than 24, it is an offset measured * in hours. Otherwise, it is regarded as an offset in minutes, * expressed in 24-hour time format without punctuation. A * preceding <tt>-</tt> means a westward offset. Time zone offsets * are always relative to UTC (Greenwich). Thus, for example, * <tt>-5</tt> occurring in the string would mean "five hours west * of Greenwich" and <tt>+0430</tt> would mean "four hours and * thirty minutes east of Greenwich." It is permitted for the * string to specify <tt>GMT</tt>, <tt>UT</tt>, or <tt>UTC</tt> * redundantly-for example, <tt>GMT-5</tt> or <tt>utc+0430</tt>. * <li>The number is regarded as a year number if one of the * following conditions is true: * <ul> * <li>The number is equal to or greater than 70 and followed by a * space, comma, slash, or end of string * <li>The number is less than 70, and both a month and a day of * the month have already been recognized</li> * </ul> * If the recognized year number is less than 100, it is * interpreted as an abbreviated year relative to a century of * which dates are within 80 years before and 19 years after * the time when the Date class is initialized. * After adjusting the year number, 1900 is subtracted from * it. For example, if the current year is 1999 then years in * the range 19 to 99 are assumed to mean 1919 to 1999, while * years from 0 to 18 are assumed to mean 2000 to 2018. Note * that this is slightly different from the interpretation of * years less than 100 that is used in {@link java.text.SimpleDateFormat}. * <li>If the number is followed by a colon, it is regarded as an hour, * unless an hour has already been recognized, in which case it is * regarded as a minute. * <li>If the number is followed by a slash, it is regarded as a month * (it is decreased by 1 to produce a number in the range <tt>0</tt> * to <tt>11</tt>), unless a month has already been recognized, in * which case it is regarded as a day of the month. * <li>If the number is followed by whitespace, a comma, a hyphen, or * end of string, then if an hour has been recognized but not a * minute, it is regarded as a minute; otherwise, if a minute has * been recognized but not a second, it is regarded as a second; * otherwise, it is regarded as a day of the month. </ul><p> * A consecutive sequence of letters is regarded as a word and treated * as follows:<ul> * <li>A word that matches <tt>AM</tt>, ignoring case, is ignored (but * the parse fails if an hour has not been recognized or is less * than <tt>1</tt> or greater than <tt>12</tt>). * <li>A word that matches <tt>PM</tt>, ignoring case, adds <tt>12</tt> * to the hour (but the parse fails if an hour has not been * recognized or is less than <tt>1</tt> or greater than <tt>12</tt>). * <li>Any word that matches any prefix of <tt>SUNDAY, MONDAY, TUESDAY, * WEDNESDAY, THURSDAY, FRIDAY</tt>, or <tt>SATURDAY</tt>, ignoring * case, is ignored. For example, <tt>sat, Friday, TUE</tt>, and * <tt>Thurs</tt> are ignored. * <li>Otherwise, any word that matches any prefix of <tt>JANUARY, * FEBRUARY, MARCH, APRIL, MAY, JUNE, JULY, AUGUST, SEPTEMBER, * OCTOBER, NOVEMBER</tt>, or <tt>DECEMBER</tt>, ignoring case, and * considering them in the order given here, is recognized as * specifying a month and is converted to a number (<tt>0</tt> to * <tt>11</tt>). For example, <tt>aug, Sept, april</tt>, and * <tt>NOV</tt> are recognized as months. So is <tt>Ma</tt>, which * is recognized as <tt>MARCH</tt>, not <tt>MAY</tt>. * <li>Any word that matches <tt>GMT, UT</tt>, or <tt>UTC</tt>, ignoring * case, is treated as referring to UTC. * <li>Any word that matches <tt>EST, CST, MST</tt>, or <tt>PST</tt>, * ignoring case, is recognized as referring to the time zone in * North America that is five, six, seven, or eight hours west of * Greenwich, respectively. Any word that matches <tt>EDT, CDT, * MDT</tt>, or <tt>PDT</tt>, ignoring case, is recognized as * referring to the same time zone, respectively, during daylight * saving time.</ul><p> * Once the entire string s has been scanned, it is converted to a time * result in one of two ways. If a time zone or time-zone offset has been * recognized, then the year, month, day of month, hour, minute, and * second are interpreted in UTC and then the time-zone offset is * applied. Otherwise, the year, month, day of month, hour, minute, and * second are interpreted in the local time zone. * * @param s a string to be parsed as a date. * @return the number of milliseconds since January 1, 1970, 00:00:00 GMT * represented by the string argument. * @see java.text.DateFormat * @deprecated As of JDK version 1.1, * replaced by <code>DateFormat.parse(String s)</code>. */ @Deprecated public static long parse(String s) { int year = Integer.MIN_VALUE; int mon = -1; int mday = -1; int hour = -1; int min = -1; int sec = -1; int millis = -1; int c = -1; int i = 0; int n = -1; int wst = -1; int tzoffset = -1; int prevc = 0; syntax: { if (s == null) break syntax; int limit = s.length(); while (i < limit) { c = s.charAt(i); i++; if (c <= ' ' || c == ',') continue; if (c == '(') { // skip comments int depth = 1; while (i < limit) { c = s.charAt(i); i++; if (c == '(') depth++; else if (c == ')') if (--depth <= 0) break; } continue; } if ('0' <= c && c <= '9') { n = c - '0'; while (i < limit && '0' <= (c = s.charAt(i)) && c <= '9') { n = n * 10 + c - '0'; i++; } if (prevc == '+' || prevc == '-' && year != Integer.MIN_VALUE) { // timezone offset if (n < 24) n = n * 60; // EG. "GMT-3" else n = n % 100 + n / 100 * 60; // eg "GMT-0430" if (prevc == '+') // plus means east of GMTLines 1–500 of 1331. Load more
/* * Copyright (c) 1994, 2010, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ package java.util; import java.text.DateFormat; import java.io.IOException; import java.io.ObjectOutputStream; import java.io.ObjectInputStream; import java.lang.ref.SoftReference; import sun.util.calendar.BaseCalendar; import sun.util.calendar.CalendarDate; import sun.util.calendar.CalendarSystem; import sun.util.calendar.CalendarUtils; import sun.util.calendar.Era; import sun.util.calendar.Gregorian; import sun.util.calendar.ZoneInfo; /** * The class <code>Date</code> represents a specific instant * in time, with millisecond precision. * <p> * Prior to JDK 1.1, the class <code>Date</code> had two additional * functions. It allowed the interpretation of dates as year, month, day, hour, * minute, and second values. It also allowed the formatting and parsing * of date strings. Unfortunately, the API for these functions was not * amenable to internationalization. As of JDK 1.1, the * <code>Calendar</code> class should be used to convert between dates and time * fields and the <code>DateFormat</code> class should be used to format and * parse date strings. * The corresponding methods in <code>Date</code> are deprecated. * <p> * Although the <code>Date</code> class is intended to reflect * coordinated universal time (UTC), it may not do so exactly, * depending on the host environment of the Java Virtual Machine. * Nearly all modern operating systems assume that 1 day = * 24 × 60 × 60 = 86400 seconds * in all cases. In UTC, however, about once every year or two there * is an extra second, called a "leap second." The leap * second is always added as the last second of the day, and always * on December 31 or June 30. For example, the last minute of the * year 1995 was 61 seconds long, thanks to an added leap second. * Most computer clocks are not accurate enough to be able to reflect * the leap-second distinction. * <p> * Some computer standards are defined in terms of Greenwich mean * time (GMT), which is equivalent to universal time (UT). GMT is * the "civil" name for the standard; UT is the * "scientific" name for the same standard. The * distinction between UTC and UT is that UTC is based on an atomic * clock and UT is based on astronomical observations, which for all * practical purposes is an invisibly fine hair to split. Because the * earth's rotation is not uniform (it slows down and speeds up * in complicated ways), UT does not always flow uniformly. Leap * seconds are introduced as needed into UTC so as to keep UTC within * 0.9 seconds of UT1, which is a version of UT with certain * corrections applied. There are other time and date systems as * well; for example, the time scale used by the satellite-based * global positioning system (GPS) is synchronized to UTC but is * <i>not</i> adjusted for leap seconds. An interesting source of * further information is the U.S. Naval Observatory, particularly * the Directorate of Time at: * <blockquote><pre> * <a href=http://tycho.usno.navy.mil>http://tycho.usno.navy.mil</a> * </pre></blockquote> * <p> * and their definitions of "Systems of Time" at: * <blockquote><pre> * <a href=http://tycho.usno.navy.mil/systime.html>http://tycho.usno.navy.mil/systime.html</a> * </pre></blockquote> * <p> * In all methods of class <code>Date</code> that accept or return * year, month, date, hours, minutes, and seconds values, the * following representations are used: * <ul> * <li>A year <i>y</i> is represented by the integer * <i>y</i> <code>- 1900</code>. * <li>A month is represented by an integer from 0 to 11; 0 is January, * 1 is February, and so forth; thus 11 is December. * <li>A date (day of month) is represented by an integer from 1 to 31 * in the usual manner. * <li>An hour is represented by an integer from 0 to 23. Thus, the hour * from midnight to 1 a.m. is hour 0, and the hour from noon to 1 * p.m. is hour 12. * <li>A minute is represented by an integer from 0 to 59 in the usual manner. * <li>A second is represented by an integer from 0 to 61; the values 60 and * 61 occur only for leap seconds and even then only in Java * implementations that actually track leap seconds correctly. Because * of the manner in which leap seconds are currently introduced, it is * extremely unlikely that two leap seconds will occur in the same * minute, but this specification follows the date and time conventions * for ISO C. * </ul> * <p> * In all cases, arguments given to methods for these purposes need * not fall within the indicated ranges; for example, a date may be * specified as January 32 and is interpreted as meaning February 1. * * @author James Gosling * @author Arthur van Hoff * @author Alan Liu * @see java.text.DateFormat * @see java.util.Calendar * @see java.util.TimeZone * @since JDK1.0 */ public class Date implements java.io.Serializable, Cloneable, Comparable<Date> { 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; // Initialized just before the value is used. See parse(). private static int defaultCenturyStart; /* use serialVersionUID from modified java.util.Date for * interoperability with JDK1.1. The Date was modified to write * and read only the UTC time. */ private static final long serialVersionUID = 7523967970034938905L; /** * Allocates a <code>Date</code> object and initializes it so that * it represents the time at which it was allocated, measured to the * nearest millisecond. * * @see java.lang.System#currentTimeMillis() */ public Date() { this(System.currentTimeMillis()); } /** * Allocates a <code>Date</code> object and initializes it to * represent the specified number of milliseconds since the * standard base time known as "the epoch", namely January 1, * 1970, 00:00:00 GMT. * * @param date the milliseconds since January 1, 1970, 00:00:00 GMT. * @see java.lang.System#currentTimeMillis() */ public Date(long date) { fastTime = date; } /** * Allocates a <code>Date</code> object and initializes it so that * it represents midnight, local time, at the beginning of the day * specified by the <code>year</code>, <code>month</code>, and * <code>date</code> arguments. * * @param year the year minus 1900. * @param month the month between 0-11. * @param date the day of the month between 1-31. * @see java.util.Calendar * @deprecated As of JDK version 1.1, * replaced by <code>Calendar.set(year + 1900, month, date)</code> * or <code>GregorianCalendar(year + 1900, month, date)</code>. */ @Deprecated public Date(int year, int month, int date) { this(year, month, date, 0, 0, 0); } /** * Allocates a <code>Date</code> object and initializes it so that * it represents the instant at the start of the minute specified by * the <code>year</code>, <code>month</code>, <code>date</code>, * <code>hrs</code>, and <code>min</code> arguments, in the local * time zone. * * @param year the year minus 1900. * @param month the month between 0-11. * @param date the day of the month between 1-31. * @param hrs the hours between 0-23. * @param min the minutes between 0-59. * @see java.util.Calendar * @deprecated As of JDK version 1.1, * replaced by <code>Calendar.set(year + 1900, month, date, * hrs, min)</code> or <code>GregorianCalendar(year + 1900, * month, date, hrs, min)</code>. */ @Deprecated public Date(int year, int month, int date, int hrs, int min) { this(year, month, date, hrs, min, 0); } /** * Allocates a <code>Date</code> object and initializes it so that * it represents the instant at the start of the second specified * by the <code>year</code>, <code>month</code>, <code>date</code>, * <code>hrs</code>, <code>min</code>, and <code>sec</code> arguments, * in the local time zone. * * @param year the year minus 1900. * @param month the month between 0-11. * @param date the day of the month between 1-31. * @param hrs the hours between 0-23. * @param min the minutes between 0-59. * @param sec the seconds between 0-59. * @see java.util.Calendar * @deprecated As of JDK version 1.1, * replaced by <code>Calendar.set(year + 1900, month, date, * hrs, min, sec)</code> or <code>GregorianCalendar(year + 1900, * month, date, hrs, min, sec)</code>. */ @Deprecated public Date(int year, int month, int date, int hrs, int min, int sec) { int y = year + 1900; // month is 0-based. So we have to normalize month to support Long.MAX_VALUE. if (month >= 12) { y += month / 12; month %= 12; } else if (month < 0) { y += CalendarUtils.floorDivide(month, 12); month = CalendarUtils.mod(month, 12); } BaseCalendar cal = getCalendarSystem(y); cdate = (BaseCalendar.Date) cal.newCalendarDate(TimeZone.getDefaultRef()); cdate.setNormalizedDate(y, month + 1, date).setTimeOfDay(hrs, min, sec, 0); getTimeImpl(); cdate = null; } /** * Allocates a <code>Date</code> object and initializes it so that * it represents the date and time indicated by the string * <code>s</code>, which is interpreted as if by the * {@link Date#parse} method. * * @param s a string representation of the date. * @see java.text.DateFormat * @see java.util.Date#parse(java.lang.String) * @deprecated As of JDK version 1.1, * replaced by <code>DateFormat.parse(String s)</code>. */ @Deprecated public Date(String s) { this(parse(s)); } /** * Return a copy of this object. */ public Object clone() { Date d = null; try { d = (Date)super.clone(); if (cdate != null) { d.cdate = (BaseCalendar.Date) cdate.clone(); } } catch (CloneNotSupportedException e) {} // Won't happen return d; } /** * Determines the date and time based on the arguments. The * arguments are interpreted as a year, month, day of the month, * hour of the day, minute within the hour, and second within the * minute, exactly as for the <tt>Date</tt> constructor with six * arguments, except that the arguments are interpreted relative * to UTC rather than to the local time zone. The time indicated is * returned represented as the distance, measured in milliseconds, * of that time from the epoch (00:00:00 GMT on January 1, 1970). * * @param year the year minus 1900. * @param month the month between 0-11. * @param date the day of the month between 1-31. * @param hrs the hours between 0-23. * @param min the minutes between 0-59. * @param sec the seconds between 0-59. * @return the number of milliseconds since January 1, 1970, 00:00:00 GMT for * the date and time specified by the arguments. * @see java.util.Calendar * @deprecated As of JDK version 1.1, * replaced by <code>Calendar.set(year + 1900, month, date, * hrs, min, sec)</code> or <code>GregorianCalendar(year + 1900, * month, date, hrs, min, sec)</code>, using a UTC * <code>TimeZone</code>, followed by <code>Calendar.getTime().getTime()</code>. */ @Deprecated public static long UTC(int year, int month, int date, int hrs, int min, int sec) { int y = year + 1900; // month is 0-based. So we have to normalize month to support Long.MAX_VALUE. if (month >= 12) { y += month / 12; month %= 12; } else if (month < 0) { y += CalendarUtils.floorDivide(month, 12); month = CalendarUtils.mod(month, 12); } int m = month + 1; BaseCalendar cal = getCalendarSystem(y); BaseCalendar.Date udate = (BaseCalendar.Date) cal.newCalendarDate(null); udate.setNormalizedDate(y, m, date).setTimeOfDay(hrs, min, sec, 0); // Use a Date instance to perform normalization. Its fastTime // is the UTC value after the normalization. Date d = new Date(0); d.normalize(udate); return d.fastTime; } /** * Attempts to interpret the string <tt>s</tt> as a representation * of a date and time. If the attempt is successful, the time * indicated is returned represented as the distance, measured in * milliseconds, of that time from the epoch (00:00:00 GMT on * January 1, 1970). If the attempt fails, an * <tt>IllegalArgumentException</tt> is thrown. * <p> * It accepts many syntaxes; in particular, it recognizes the IETF * standard date syntax: "Sat, 12 Aug 1995 13:30:00 GMT". It also * understands the continental U.S. time-zone abbreviations, but for * general use, a time-zone offset should be used: "Sat, 12 Aug 1995 * 13:30:00 GMT+0430" (4 hours, 30 minutes west of the Greenwich * meridian). If no time zone is specified, the local time zone is * assumed. GMT and UTC are considered equivalent. * <p> * The string <tt>s</tt> is processed from left to right, looking for * data of interest. Any material in <tt>s</tt> that is within the * ASCII parenthesis characters <tt>(</tt> and <tt>)</tt> is ignored. * Parentheses may be nested. Otherwise, the only characters permitted * within <tt>s</tt> are these ASCII characters: * <blockquote><pre> * abcdefghijklmnopqrstuvwxyz * ABCDEFGHIJKLMNOPQRSTUVWXYZ * 0123456789,+-:/</pre></blockquote> * and whitespace characters.<p> * A consecutive sequence of decimal digits is treated as a decimal * number:<ul> * <li>If a number is preceded by <tt>+</tt> or <tt>-</tt> and a year * has already been recognized, then the number is a time-zone * offset. If the number is less than 24, it is an offset measured * in hours. Otherwise, it is regarded as an offset in minutes, * expressed in 24-hour time format without punctuation. A * preceding <tt>-</tt> means a westward offset. Time zone offsets * are always relative to UTC (Greenwich). Thus, for example, * <tt>-5</tt> occurring in the string would mean "five hours west * of Greenwich" and <tt>+0430</tt> would mean "four hours and * thirty minutes east of Greenwich." It is permitted for the * string to specify <tt>GMT</tt>, <tt>UT</tt>, or <tt>UTC</tt> * redundantly-for example, <tt>GMT-5</tt> or <tt>utc+0430</tt>. * <li>The number is regarded as a year number if one of the * following conditions is true: * <ul> * <li>The number is equal to or greater than 70 and followed by a * space, comma, slash, or end of string * <li>The number is less than 70, and both a month and a day of * the month have already been recognized</li> * </ul> * If the recognized year number is less than 100, it is * interpreted as an abbreviated year relative to a century of * which dates are within 80 years before and 19 years after * the time when the Date class is initialized. * After adjusting the year number, 1900 is subtracted from * it. For example, if the current year is 1999 then years in * the range 19 to 99 are assumed to mean 1919 to 1999, while * years from 0 to 18 are assumed to mean 2000 to 2018. Note * that this is slightly different from the interpretation of * years less than 100 that is used in {@link java.text.SimpleDateFormat}. * <li>If the number is followed by a colon, it is regarded as an hour, * unless an hour has already been recognized, in which case it is * regarded as a minute. * <li>If the number is followed by a slash, it is regarded as a month * (it is decreased by 1 to produce a number in the range <tt>0</tt> * to <tt>11</tt>), unless a month has already been recognized, in * which case it is regarded as a day of the month. * <li>If the number is followed by whitespace, a comma, a hyphen, or * end of string, then if an hour has been recognized but not a * minute, it is regarded as a minute; otherwise, if a minute has * been recognized but not a second, it is regarded as a second; * otherwise, it is regarded as a day of the month. </ul><p> * A consecutive sequence of letters is regarded as a word and treated * as follows:<ul> * <li>A word that matches <tt>AM</tt>, ignoring case, is ignored (but * the parse fails if an hour has not been recognized or is less * than <tt>1</tt> or greater than <tt>12</tt>). * <li>A word that matches <tt>PM</tt>, ignoring case, adds <tt>12</tt> * to the hour (but the parse fails if an hour has not been * recognized or is less than <tt>1</tt> or greater than <tt>12</tt>). * <li>Any word that matches any prefix of <tt>SUNDAY, MONDAY, TUESDAY, * WEDNESDAY, THURSDAY, FRIDAY</tt>, or <tt>SATURDAY</tt>, ignoring * case, is ignored. For example, <tt>sat, Friday, TUE</tt>, and * <tt>Thurs</tt> are ignored. * <li>Otherwise, any word that matches any prefix of <tt>JANUARY, * FEBRUARY, MARCH, APRIL, MAY, JUNE, JULY, AUGUST, SEPTEMBER, * OCTOBER, NOVEMBER</tt>, or <tt>DECEMBER</tt>, ignoring case, and * considering them in the order given here, is recognized as * specifying a month and is converted to a number (<tt>0</tt> to * <tt>11</tt>). For example, <tt>aug, Sept, april</tt>, and * <tt>NOV</tt> are recognized as months. So is <tt>Ma</tt>, which * is recognized as <tt>MARCH</tt>, not <tt>MAY</tt>. * <li>Any word that matches <tt>GMT, UT</tt>, or <tt>UTC</tt>, ignoring * case, is treated as referring to UTC. * <li>Any word that matches <tt>EST, CST, MST</tt>, or <tt>PST</tt>, * ignoring case, is recognized as referring to the time zone in * North America that is five, six, seven, or eight hours west of * Greenwich, respectively. Any word that matches <tt>EDT, CDT, * MDT</tt>, or <tt>PDT</tt>, ignoring case, is recognized as * referring to the same time zone, respectively, during daylight * saving time.</ul><p> * Once the entire string s has been scanned, it is converted to a time * result in one of two ways. If a time zone or time-zone offset has been * recognized, then the year, month, day of month, hour, minute, and * second are interpreted in UTC and then the time-zone offset is * applied. Otherwise, the year, month, day of month, hour, minute, and * second are interpreted in the local time zone. * * @param s a string to be parsed as a date. * @return the number of milliseconds since January 1, 1970, 00:00:00 GMT * represented by the string argument. * @see java.text.DateFormat * @deprecated As of JDK version 1.1, * replaced by <code>DateFormat.parse(String s)</code>. */ @Deprecated public static long parse(String s) { int year = Integer.MIN_VALUE; int mon = -1; int mday = -1; int hour = -1; int min = -1; int sec = -1; int millis = -1; int c = -1; int i = 0; int n = -1; int wst = -1; int tzoffset = -1; int prevc = 0; syntax: { if (s == null) break syntax; int limit = s.length(); while (i < limit) { c = s.charAt(i); i++; if (c <= ' ' || c == ',') continue; if (c == '(') { // skip comments int depth = 1; while (i < limit) { c = s.charAt(i); i++; if (c == '(') depth++; else if (c == ')') if (--depth <= 0) break; } continue; } if ('0' <= c && c <= '9') { n = c - '0'; while (i < limit && '0' <= (c = s.charAt(i)) && c <= '9') { n = n * 10 + c - '0'; i++; } if (prevc == '+' || prevc == '-' && year != Integer.MIN_VALUE) { // timezone offset if (n < 24) n = n * 60; // EG. "GMT-3" else n = n % 100 + n / 100 * 60; // eg "GMT-0430" if (prevc == '+') // plus means east of GMT