java.util.Date Maven / Gradle / Ivy
/*
* 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;
/**
* The class Date represents a specific instant
* in time, with millisecond precision.
*
* Prior to JDK 1.1, the class Date 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
* Calendar class should be used to convert between dates and time
* fields and the DateFormat class should be used to format and
* parse date strings.
* The corresponding methods in Date are deprecated.
*
* Although the Date 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.
*
* 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
* not adjusted for leap seconds. An interesting source of
* further information is the U.S. Naval Observatory, particularly
* the Directorate of Time at:
*
* http://tycho.usno.navy.mil
*
*
* and their definitions of "Systems of Time" at:
*
* http://tycho.usno.navy.mil/systime.html
*
*
* In all methods of class Date that accept or return
* year, month, date, hours, minutes, and seconds values, the
* following representations are used:
*
* - A year y is represented by the integer
* y
- 1900.
* - A month is represented by an integer from 0 to 11; 0 is January,
* 1 is February, and so forth; thus 11 is December.
*
- A date (day of month) is represented by an integer from 1 to 31
* in the usual manner.
*
- 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.
*
- A minute is represented by an integer from 0 to 59 in the usual manner.
*
- 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.
*
*
* 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
{
private static final BaseCalendar gcal = new BaseCalendar();
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.Datum 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 Date 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 Date 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 Date object and initializes it so that
* it represents midnight, local time, at the beginning of the day
* specified by the year, month, and
* date 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 Calendar.set(year + 1900, month, date)
* or GregorianCalendar(year + 1900, month, date).
*/
@Deprecated
public Date(int year, int month, int date) {
this(year, month, date, 0, 0, 0);
}
/**
* Allocates a Date object and initializes it so that
* it represents the instant at the start of the minute specified by
* the year, month, date,
* hrs, and min 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 Calendar.set(year + 1900, month, date,
* hrs, min) or GregorianCalendar(year + 1900,
* month, date, hrs, min).
*/
@Deprecated
public Date(int year, int month, int date, int hrs, int min) {
this(year, month, date, hrs, min, 0);
}
/**
* Allocates a Date object and initializes it so that
* it represents the instant at the start of the second specified
* by the year, month, date,
* hrs, min, and sec 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 Calendar.set(year + 1900, month, date,
* hrs, min, sec) or GregorianCalendar(year + 1900,
* month, date, hrs, min, sec).
*/
@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 += month / 12;
month = month % 12;
}
BaseCalendar cal = getCalendarSystem(y);
cdate = (BaseCalendar.Datum) cal.newCalendarDate(TimeZone.getDefaultRef());
cdate.setNormalizedDate(y, month + 1, date).setTimeOfDay(hrs, min, sec, 0);
getTimeImpl();
cdate = null;
}
/**
* Allocates a Date object and initializes it so that
* it represents the date and time indicated by the string
* s, 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 DateFormat.parse(String s).
*/
@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.Datum) 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 Date 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 Calendar.set(year + 1900, month, date,
* hrs, min, sec) or GregorianCalendar(year + 1900,
* month, date, hrs, min, sec), using a UTC
* TimeZone, followed by Calendar.getTime().getTime().
*/
@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 += month / 12;
month = month % 12;
}
int m = month + 1;
BaseCalendar cal = getCalendarSystem(y);
BaseCalendar.Datum udate = (BaseCalendar.Datum) 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 s 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
* IllegalArgumentException is thrown.
*
* 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.
*
* The string s is processed from left to right, looking for
* data of interest. Any material in s that is within the
* ASCII parenthesis characters ( and ) is ignored.
* Parentheses may be nested. Otherwise, the only characters permitted
* within s are these ASCII characters:
*
* abcdefghijklmnopqrstuvwxyz
* ABCDEFGHIJKLMNOPQRSTUVWXYZ
* 0123456789,+-:/
* and whitespace characters.
* A consecutive sequence of decimal digits is treated as a decimal
* number:
* - If a number is preceded by + or - 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 - means a westward offset. Time zone offsets
* are always relative to UTC (Greenwich). Thus, for example,
* -5 occurring in the string would mean "five hours west
* of Greenwich" and +0430 would mean "four hours and
* thirty minutes east of Greenwich." It is permitted for the
* string to specify GMT, UT, or UTC
* redundantly-for example, GMT-5 or utc+0430.
*
- The number is regarded as a year number if one of the
* following conditions is true:
*
* - The number is equal to or greater than 70 and followed by a
* space, comma, slash, or end of string
*
- The number is less than 70, and both a month and a day of
* the month have already been recognized
*
* 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}.
* - 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.
*
- 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 0
* to 11), unless a month has already been recognized, in
* which case it is regarded as a day of the month.
*
- 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.
* A consecutive sequence of letters is regarded as a word and treated
* as follows:
* - A word that matches AM, ignoring case, is ignored (but
* the parse fails if an hour has not been recognized or is less
* than 1 or greater than 12).
*
- A word that matches PM, ignoring case, adds 12
* to the hour (but the parse fails if an hour has not been
* recognized or is less than 1 or greater than 12).
*
- Any word that matches any prefix of SUNDAY, MONDAY, TUESDAY,
* WEDNESDAY, THURSDAY, FRIDAY, or SATURDAY, ignoring
* case, is ignored. For example, sat, Friday, TUE, and
* Thurs are ignored.
*
- Otherwise, any word that matches any prefix of JANUARY,
* FEBRUARY, MARCH, APRIL, MAY, JUNE, JULY, AUGUST, SEPTEMBER,
* OCTOBER, NOVEMBER, or DECEMBER, ignoring case, and
* considering them in the order given here, is recognized as
* specifying a month and is converted to a number (0 to
* 11). For example, aug, Sept, april, and
* NOV are recognized as months. So is Ma, which
* is recognized as MARCH, not MAY.
*
- Any word that matches GMT, UT, or UTC, ignoring
* case, is treated as referring to UTC.
*
- Any word that matches EST, CST, MST, or PST,
* 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 EDT, CDT,
* MDT, or PDT, ignoring case, is recognized as
* referring to the same time zone, respectively, during daylight
* saving time.
* 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 DateFormat.parse(String s).
*/
@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
n = -n;
if (tzoffset != 0 && tzoffset != -1)
break syntax;
tzoffset = n;
} else if (n >= 70)
if (year != Integer.MIN_VALUE)
break syntax;
else if (c <= ' ' || c == ',' || c == '/' || i >= limit)
// year = n < 1900 ? n : n - 1900;
year = n;
else
break syntax;
else if (c == ':')
if (hour < 0)
hour = (byte) n;
else if (min < 0)
min = (byte) n;
else
break syntax;
else if (c == '/')
if (mon < 0)
mon = (byte) (n - 1);
else if (mday < 0)
mday = (byte) n;
else
break syntax;
else if (i < limit && c != ',' && c > ' ' && c != '-')
break syntax;
else if (hour >= 0 && min < 0)
min = (byte) n;
else if (min >= 0 && sec < 0)
sec = (byte) n;
else if (mday < 0)
mday = (byte) n;
// Handle two-digit years < 70 (70-99 handled above).
else if (year == Integer.MIN_VALUE && mon >= 0 && mday >= 0)
year = n;
else
break syntax;
prevc = 0;
} else if (c == '/' || c == ':' || c == '+' || c == '-')
prevc = c;
else {
int st = i - 1;
while (i < limit) {
c = s.charAt(i);
if (!('A' <= c && c <= 'Z' || 'a' <= c && c <= 'z'))
break;
i++;
}
if (i <= st + 1)
break syntax;
int k;
for (k = wtb.length; --k >= 0;)
if (wtb[k].regionMatches(true, 0, s, st, i - st)) {
int action = ttb[k];
if (action != 0) {
if (action == 1) { // pm
if (hour > 12 || hour < 1)
break syntax;
else if (hour < 12)
hour += 12;
} else if (action == 14) { // am
if (hour > 12 || hour < 1)
break syntax;
else if (hour == 12)
hour = 0;
} else if (action <= 13) { // month!
if (mon < 0)
mon = (byte) (action - 2);
else
break syntax;
} else {
tzoffset = action - 10000;
}
}
break;
}
if (k < 0)
break syntax;
prevc = 0;
}
}
if (year == Integer.MIN_VALUE || mon < 0 || mday < 0)
break syntax;
// Parse 2-digit years within the correct default century.
if (year < 100) {
synchronized (Date.class) {
if (defaultCenturyStart == 0) {
defaultCenturyStart = gcal.getCalendarDate().getYear() - 80;
}
}
year += (defaultCenturyStart / 100) * 100;
if (year < defaultCenturyStart) year += 100;
}
if (sec < 0)
sec = 0;
if (min < 0)
min = 0;
if (hour < 0)
hour = 0;
BaseCalendar cal = getCalendarSystem(year);
if (tzoffset == -1) { // no time zone specified, have to use local
BaseCalendar.Datum ldate = (BaseCalendar.Datum) cal.newCalendarDate(TimeZone.getDefaultRef());
ldate.setDate(year, mon + 1, mday);
ldate.setTimeOfDay(hour, min, sec, 0);
return cal.getTime(ldate);
}
BaseCalendar.Datum udate = (BaseCalendar.Datum) cal.newCalendarDate(null); // no time zone
udate.setDate(year, mon + 1, mday);
udate.setTimeOfDay(hour, min, sec, 0);
return cal.getTime(udate) + tzoffset * (60 * 1000);
}
// syntax error
throw new IllegalArgumentException();
}
private final static String wtb[] = {
"am", "pm",
"monday", "tuesday", "wednesday", "thursday", "friday",
"saturday", "sunday",
"january", "february", "march", "april", "may", "june",
"july", "august", "september", "october", "november", "december",
"gmt", "ut", "utc", "est", "edt", "cst", "cdt",
"mst", "mdt", "pst", "pdt"
};
private final static int ttb[] = {
14, 1, 0, 0, 0, 0, 0, 0, 0,
2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
10000 + 0, 10000 + 0, 10000 + 0, // GMT/UT/UTC
10000 + 5 * 60, 10000 + 4 * 60, // EST/EDT
10000 + 6 * 60, 10000 + 5 * 60, // CST/CDT
10000 + 7 * 60, 10000 + 6 * 60, // MST/MDT
10000 + 8 * 60, 10000 + 7 * 60 // PST/PDT
};
/**
* Returns a value that is the result of subtracting 1900 from the
* year that contains or begins with the instant in time represented
* by this Date object, as interpreted in the local
* time zone.
*
* @return the year represented by this date, minus 1900.
* @see java.util.Calendar
* @deprecated As of JDK version 1.1,
* replaced by Calendar.get(Calendar.YEAR) - 1900.
*/
@Deprecated
public int getYear() {
return normalize().getYear() - 1900;
}
/**
* Sets the year of this Date object to be the specified
* value plus 1900. This Date object is modified so
* that it represents a point in time within the specified year,
* with the month, date, hour, minute, and second the same as
* before, as interpreted in the local time zone. (Of course, if
* the date was February 29, for example, and the year is set to a
* non-leap year, then the new date will be treated as if it were
* on March 1.)
*
* @param year the year value.
* @see java.util.Calendar
* @deprecated As of JDK version 1.1,
* replaced by Calendar.set(Calendar.YEAR, year + 1900).
*/
@Deprecated
public void setYear(int year) {
getCalendarDate().setNormalizedYear(year + 1900);
}
/**
* Returns a number representing the month that contains or begins
* with the instant in time represented by this Date object.
* The value returned is between 0 and 11,
* with the value 0 representing January.
*
* @return the month represented by this date.
* @see java.util.Calendar
* @deprecated As of JDK version 1.1,
* replaced by Calendar.get(Calendar.MONTH).
*/
@Deprecated
public int getMonth() {
return normalize().getMonth() - 1; // adjust 1-based to 0-based
}
/**
* Sets the month of this date to the specified value. This
* Date object is modified so that it represents a point
* in time within the specified month, with the year, date, hour,
* minute, and second the same as before, as interpreted in the
* local time zone. If the date was October 31, for example, and
* the month is set to June, then the new date will be treated as
* if it were on July 1, because June has only 30 days.
*
* @param month the month value between 0-11.
* @see java.util.Calendar
* @deprecated As of JDK version 1.1,
* replaced by Calendar.set(Calendar.MONTH, int month).
*/
@Deprecated
public void setMonth(int month) {
int y = 0;
if (month >= 12) {
y = month / 12;
month %= 12;
} else if (month < 0) {
y = month / 12;
month = month % 12;
}
BaseCalendar.Datum d = getCalendarDate();
if (y != 0) {
d.setNormalizedYear(d.getNormalizedYear() + y);
}
d.setMonth(month + 1); // adjust 0-based to 1-based month numbering
}
/**
* Returns the day of the month represented by this Date object.
* The value returned is between 1 and 31
* representing the day of the month that contains or begins with the
* instant in time represented by this Date object, as
* interpreted in the local time zone.
*
* @return the day of the month represented by this date.
* @see java.util.Calendar
* @deprecated As of JDK version 1.1,
* replaced by Calendar.get(Calendar.DAY_OF_MONTH).
* @deprecated
*/
@Deprecated
public int getDate() {
return normalize().getDayOfMonth();
}
/**
* Sets the day of the month of this Date object to the
* specified value. This Date object is modified so that
* it represents a point in time within the specified day of the
* month, with the year, month, hour, minute, and second the same
* as before, as interpreted in the local time zone. If the date
* was April 30, for example, and the date is set to 31, then it
* will be treated as if it were on May 1, because April has only
* 30 days.
*
* @param date the day of the month value between 1-31.
* @see java.util.Calendar
* @deprecated As of JDK version 1.1,
* replaced by Calendar.set(Calendar.DAY_OF_MONTH, int date).
*/
@Deprecated
public void setDate(int date) {
getCalendarDate().setDayOfMonth(date);
}
/**
* Returns the day of the week represented by this date. The
* returned value (0 = Sunday, 1 = Monday,
* 2 = Tuesday, 3 = Wednesday, 4 =
* Thursday, 5 = Friday, 6 = Saturday)
* represents the day of the week that contains or begins with
* the instant in time represented by this Date object,
* as interpreted in the local time zone.
*
* @return the day of the week represented by this date.
* @see java.util.Calendar
* @deprecated As of JDK version 1.1,
* replaced by Calendar.get(Calendar.DAY_OF_WEEK).
*/
@Deprecated
public int getDay() {
return normalize().getDayOfWeek() - 7;//gcal.SUNDAY;
}
/**
* Returns the hour represented by this Date object. The
* returned value is a number (0 through 23)
* representing the hour within the day that contains or begins
* with the instant in time represented by this Date
* object, as interpreted in the local time zone.
*
* @return the hour represented by this date.
* @see java.util.Calendar
* @deprecated As of JDK version 1.1,
* replaced by Calendar.get(Calendar.HOUR_OF_DAY).
*/
@Deprecated
public int getHours() {
return normalize().getHours();
}
/**
* Sets the hour of this Date object to the specified value.
* This Date object is modified so that it represents a point
* in time within the specified hour of the day, with the year, month,
* date, minute, and second the same as before, as interpreted in the
* local time zone.
*
* @param hours the hour value.
* @see java.util.Calendar
* @deprecated As of JDK version 1.1,
* replaced by Calendar.set(Calendar.HOUR_OF_DAY, int hours).
*/
@Deprecated
public void setHours(int hours) {
getCalendarDate().setHours(hours);
}
/**
* Returns the number of minutes past the hour represented by this date,
* as interpreted in the local time zone.
* The value returned is between 0 and 59.
*
* @return the number of minutes past the hour represented by this date.
* @see java.util.Calendar
* @deprecated As of JDK version 1.1,
* replaced by Calendar.get(Calendar.MINUTE).
*/
@Deprecated
public int getMinutes() {
return normalize().getMinutes();
}
/**
* Sets the minutes of this Date object to the specified value.
* This Date object is modified so that it represents a point
* in time within the specified minute of the hour, with the year, month,
* date, hour, and second the same as before, as interpreted in the
* local time zone.
*
* @param minutes the value of the minutes.
* @see java.util.Calendar
* @deprecated As of JDK version 1.1,
* replaced by Calendar.set(Calendar.MINUTE, int minutes).
*/
@Deprecated
public void setMinutes(int minutes) {
getCalendarDate().setMinutes(minutes);
}
/**
* Returns the number of seconds past the minute represented by this date.
* The value returned is between 0 and 61. The
* values 60 and 61 can only occur on those
* Java Virtual Machines that take leap seconds into account.
*
* @return the number of seconds past the minute represented by this date.
* @see java.util.Calendar
* @deprecated As of JDK version 1.1,
* replaced by Calendar.get(Calendar.SECOND).
*/
@Deprecated
public int getSeconds() {
return normalize().getSeconds();
}
/**
* Sets the seconds of this Date to the specified value.
* This Date object is modified so that it represents a
* point in time within the specified second of the minute, with
* the year, month, date, hour, and minute the same as before, as
* interpreted in the local time zone.
*
* @param seconds the seconds value.
* @see java.util.Calendar
* @deprecated As of JDK version 1.1,
* replaced by Calendar.set(Calendar.SECOND, int seconds).
*/
@Deprecated
public void setSeconds(int seconds) {
getCalendarDate().setSeconds(seconds);
}
/**
* Returns the number of milliseconds since January 1, 1970, 00:00:00 GMT
* represented by this Date 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;
}
/**
* Sets this Date object to represent a point in time that is
* time milliseconds after January 1, 1970 00:00:00 GMT.
*
* @param time the number of milliseconds.
*/
public void setTime(long time) {
fastTime = time;
cdate = null;
}
/**
* Tests if this date is before the specified date.
*
* @param when a date.
* @return true if and only if the instant of time
* represented by this Date object is strictly
* earlier than the instant represented by when;
* false otherwise.
* @exception NullPointerException if when is null.
*/
public boolean before(Date when) {
return getMillisOf(this) < getMillisOf(when);
}
/**
* Tests if this date is after the specified date.
*
* @param when a date.
* @return true if and only if the instant represented
* by this Date object is strictly later than the
* instant represented by when;
* false otherwise.
* @exception NullPointerException if when is null.
*/
public boolean after(Date when) {
return getMillisOf(this) > getMillisOf(when);
}
/**
* Compares two dates for equality.
* The result is true if and only if the argument is
* not null and is a Date object that
* represents the same point in time, to the millisecond, as this object.
*
* Thus, two Date objects are equal if and only if the
* getTime method returns the same long
* value for both.
*
* @param obj the object to compare with.
* @return true if the objects are the same;
* false otherwise.
* @see java.util.Date#getTime()
*/
public boolean equals(Object obj) {
return obj instanceof Date && getTime() == ((Date) obj).getTime();
}
/**
* Returns the millisecond value of this Date object
* without affecting its internal state.
*/
static final long getMillisOf(Date date) {
if (date.cdate == null || date.cdate.isNormalized()) {
return date.fastTime;
}
BaseCalendar.Datum d = (BaseCalendar.Datum) date.cdate.clone();
return gcal.getTime(d);
}
/**
* Compares two Dates for ordering.
*
* @param anotherDate the Date to be compared.
* @return the value 0 if the argument Date is equal to
* this Date; a value less than 0 if this Date
* is before the Date argument; and a value greater than
* 0 if this Date is after the Date argument.
* @since 1.2
* @exception NullPointerException if anotherDate is null.
*/
public int compareTo(Date anotherDate) {
long thisTime = getMillisOf(this);
long anotherTime = getMillisOf(anotherDate);
return (thisTimelong
* value returned by the {@link Date#getTime}
* method. That is, the hash code is the value of the expression:
*
* (int)(this.getTime()^(this.getTime() >>> 32))
*
* @return a hash code value for this object.
*/
public int hashCode() {
long ht = this.getTime();
return (int) ht ^ (int) (ht >> 32);
}
/**
* Converts this Date object to a String
* of the form:
*
* dow mon dd hh:mm:ss zzz yyyy
* where:
* - dow is the day of the week (Sun, Mon, Tue, Wed,
* Thu, Fri, Sat).
*
- mon is the month (Jan, Feb, Mar, Apr, May, Jun,
* Jul, Aug, Sep, Oct, Nov, Dec).
*
- dd is the day of the month (01 through
* 31), as two decimal digits.
*
- hh is the hour of the day (00 through
* 23), as two decimal digits.
*
- mm is the minute within the hour (00 through
* 59), as two decimal digits.
*
- ss is the second within the minute (00 through
* 61, as two decimal digits.
*
- zzz is the time zone (and may reflect daylight saving
* time). Standard time zone abbreviations include those
* recognized by the method parse. If time zone
* information is not available, then zzz is empty -
* that is, it consists of no characters at all.
*
- yyyy is the year, as four decimal digits.
*
*
* @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.Datum date = normalize();
StringBuilder sb = new StringBuilder(28);
int index = date.getDayOfWeek();
if (index == 7) {
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(), zi.SHORT, Locale.US)); // zzz
// } else {
// sb.append("GMT");
// }
sb.append(' ').append(date.getYear()); // yyyy
return sb.toString();
}
/**
* Converts the given name to its 3-letter abbreviation (e.g.,
* "monday" -> "Mon") and stored the abbreviation in the given
* StringBuilder.
*/
private static final StringBuilder convertToAbbr(StringBuilder sb, String name) {
sb.append(Character.toUpperCase(name.charAt(0)));
sb.append(name.charAt(1)).append(name.charAt(2));
return sb;
}
/**
* Creates a string representation of this Date object in an
* implementation-dependent form. The intent is that the form should
* be familiar to the user of the Java application, wherever it may
* happen to be running. The intent is comparable to that of the
* "%c" format supported by the strftime()
* function of ISO C.
*
* @return a string representation of this date, using the locale
* conventions.
* @see java.text.DateFormat
* @see java.util.Date#toString()
* @see java.util.Date#toGMTString()
* @deprecated As of JDK version 1.1,
* replaced by DateFormat.format(Date date).
*/
@Deprecated
public String toLocaleString() {
DateFormat formatter = DateFormat.getDateTimeInstance();
return formatter.format(this);
}
/**
* Creates a string representation of this Date object of
* the form:
*
* d mon yyyy hh:mm:ss GMT
-
*
- d is the day of the month (1 through 31), * as one or two decimal digits. *
- mon is the month (Jan, Feb, Mar, Apr, May, Jun, Jul, * Aug, Sep, Oct, Nov, Dec). *
- yyyy is the year, as four decimal digits. *
- hh is the hour of the day (00 through 23), * as two decimal digits. *
- mm is the minute within the hour (00 through * 59), as two decimal digits. *
- ss is the second within the minute (00 through * 61), as two decimal digits. *
- GMT is exactly the ASCII letters "GMT" to indicate * Greenwich Mean Time. *
* The result does not depend on the local time zone.
*
* @return a string representation of this date, using the Internet GMT
* conventions.
* @see java.text.DateFormat
* @see java.util.Date#toString()
* @see java.util.Date#toLocaleString()
* @deprecated As of JDK version 1.1,
* replaced by DateFormat.format(Date date), using a
* GMT TimeZone.
*/
@Deprecated
public String toGMTString() {
// d MMM yyyy HH:mm:ss 'GMT'
long t = getTime();
BaseCalendar cal = getCalendarSystem(t);
StringBuilder sb = new StringBuilder(32);
// BaseCalendar.Datum date =
// (BaseCalendar.Datum) cal.getCalendarDate(getTime(), (TimeZone)null);
// CalendarUtils.sprintf0d(sb, date.getDayOfMonth(), 1).append(' '); // d
// convertToAbbr(sb, wtb[date.getMonth() - 1 + 2 + 7]).append(' '); // MMM
// sb.append(date.getYear()).append(' '); // yyyy
// CalendarUtils.sprintf0d(sb, date.getHours(), 2).append(':'); // HH
// CalendarUtils.sprintf0d(sb, date.getMinutes(), 2).append(':'); // mm
// CalendarUtils.sprintf0d(sb, date.getSeconds(), 2); // ss
sb.append(" GMT"); // ' GMT'
return sb.toString();
}
/**
* Returns the offset, measured in minutes, for the local time zone
* relative to UTC that is appropriate for the time represented by
* this Date object.
*
* For example, in Massachusetts, five time zones west of Greenwich: *
* new Date(96, 1, 14).getTimezoneOffset() returns 300
* new Date(96, 5, 1).getTimezoneOffset() returns 240* This method produces the same result as if it computed: *
* (this.getTime() - UTC(this.getYear(),
* this.getMonth(),
* this.getDate(),
* this.getHours(),
* this.getMinutes(),
* this.getSeconds())) / (60 * 1000)
* -(Calendar.get(Calendar.ZONE_OFFSET) +
* Calendar.get(Calendar.DST_OFFSET)) / (60 * 1000).
*/
@Deprecated
public int getTimezoneOffset() {
int zoneOffset;
if (cdate == null) {
TimeZone tz = TimeZone.getDefaultRef();
zoneOffset = tz.getOffset(fastTime);
} else {
normalize();
zoneOffset = cdate.getZoneOffset();
}
return -zoneOffset/60000; // convert to minutes
}
private final BaseCalendar.Datum getCalendarDate() {
if (cdate == null) {
// BaseCalendar cal = getCalendarSystem(fastTime);
// cdate = (BaseCalendar.Datum) cal.getCalendarDate(fastTime,
// TimeZone.getDefaultRef());
}
return cdate;
}
private final BaseCalendar.Datum normalize() {
if (cdate == null) {
// BaseCalendar cal = getCalendarSystem(fastTime);
// cdate = (BaseCalendar.Datum) 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;
}
// fastTime and the returned data are in sync upon return.
private final BaseCalendar.Datum normalize(BaseCalendar.Datum date) {
int y = date.getNormalizedYear();
int m = date.getMonth();
int d = date.getDayOfMonth();
int hh = date.getHours();
int mm = date.getMinutes();
int ss = date.getSeconds();
int ms = date.getMillis();
TimeZone tz = date.getZone();
// If the specified year can't be handled using a long value
// in milliseconds, GregorianCalendar is used for full
// compatibility with underflow and overflow. This is required
// by some JCK tests. The limits are based max year values -
// years that can be represented by max values of d, hh, mm,
// ss and ms. Also, let GregorianCalendar handle the default
// cutover year so that we don't need to worry about the
// transition here.
// if (y == 1582 || y > 280000000 || y < -280000000) {
// if (tz == null) {
// tz = TimeZone.getTimeZone("GMT");
// }
// GregorianCalendar gc = new GregorianCalendar(tz);
// gc.clear();
// gc.set(gc.MILLISECOND, ms);
// gc.set(y, m-1, d, hh, mm, ss);
// fastTime = gc.getTimeInMillis();
// BaseCalendar cal = getCalendarSystem(fastTime);
// date = (BaseCalendar.Datum) cal.getCalendarDate(fastTime, tz);
// return date;
// }
BaseCalendar cal = getCalendarSystem(y);
if (cal != getCalendarSystem(date)) {
date = (BaseCalendar.Datum) cal.newCalendarDate(tz);
date.setNormalizedDate(y, m, d).setTimeOfDay(hh, mm, ss, ms);
}
// Perform the GregorianCalendar-style normalization.
fastTime = cal.getTime(date);
// In case the normalized date requires the other calendar
// system, we need to recalculate it using the other one.
BaseCalendar ncal = getCalendarSystem(fastTime);
if (ncal != cal) {
date = (BaseCalendar.Datum) ncal.newCalendarDate(tz);
date.setNormalizedDate(y, m, d).setTimeOfDay(hh, mm, ss, ms);
fastTime = ncal.getTime(date);
}
return date;
}
/**
* Returns the Gregorian or Julian calendar system to use with the
* given date. Use Gregorian from October 15, 1582.
*
* @param year normalized calendar year (not -1900)
* @return the CalendarSystem to use for the specified date
*/
private static final BaseCalendar getCalendarSystem(int year) {
if (year >= 1582) {
return gcal;
}
return getJulianCalendar();
}
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();
}
private static final BaseCalendar getCalendarSystem(BaseCalendar.Datum cdate) {
if (jcal == null) {
return gcal;
}
if (cdate.getEra() != null) {
return jcal;
}
return gcal;
}
synchronized private static final BaseCalendar getJulianCalendar() {
if (jcal == null) {
// jcal = (BaseCalendar) CalendarSystem.forName("julian");
}
return jcal;
}
/**
* Save the state of this object to a stream (i.e., serialize it).
*
* @serialData The value returned by getTime()
* is emitted (long). This represents the offset from
* January 1, 1970, 00:00:00 GMT in milliseconds.
*/
private void writeObject(ObjectOutputStream s)
throws IOException
{
s.writeLong(getTimeImpl());
}
/**
* Reconstitute this object from a stream (i.e., deserialize it).
*/
private void readObject(ObjectInputStream s)
throws IOException, ClassNotFoundException
{
fastTime = s.readLong();
}
static final class BaseCalendar {
Datum newCalendarDate(TimeZone t) {
return new Datum();
}
Datum getNthDayOfWeek(int a, int b, Datum c) {
return new Datum();
}
Datum getCalendarDate() {
return new Datum();
}
int getTime(Datum udate) {
return 0;
}
int getMonthLength(Datum cdate) {
return 0;
}
void getCalendarDate(long l, Datum cdate) {
}
static class Datum implements Cloneable {
public Datum clone() {
return new Datum();
}
Datum setNormalizedDate(int y, int i, int date) {
return this;
}
void setTimeOfDay(int hrs, int min, int sec, int i) {
}
int getYear() {
return 0;
}
void setDate(int year, int i, int mday) {
}
void setNormalizedYear(int i) {
}
int getMonth() {
return 0;
}
int getNormalizedYear() {
return 0;
}
void setMonth(int i) {
}
int getDayOfMonth() {
return 0;
}
void setDayOfMonth(int date) {
}
int getDayOfWeek() {
return 0;
}
int getHours() {
return 0;
}
void setHours(int hours) {
}
int getMinutes() {
return 0;
}
void setMinutes(int minutes) {
}
int getSeconds() {
return 0;
}
void setSeconds(int seconds) {
}
boolean isNormalized() {
return false;
}
Object getEra() {
return this;
}
int getMillis() {
return 0;
}
TimeZone getZone() {
return TimeZone.NO_TIMEZONE;
}
int getZoneOffset() {
return 0;
}
}
}
}