public SimpleDateFormat() 
{
                                            
        this(SHORT, SHORT, Locale.getDefault());
}

Constructs a SimpleDateFormat using the default pattern and date format symbols for the default locale. Note: This constructor may not support all locales. For full coverage, use the factory methods in the DateFormat class.

 public SimpleDateFormat(String pattern) 
{
        this(pattern, Locale.getDefault());
}

Constructs a SimpleDateFormat using the given pattern and the default date format symbols for the default locale. Note: This constructor may not support all locales. For full coverage, use the factory methods in the DateFormat class.

Parameters:

pattern - the pattern describing the date and time format

Throws:

NullPointerException - if the given pattern is null

IllegalArgumentException - if the given pattern is invalid

exception: NullPointerException - if the given pattern is null

exception: IllegalArgumentException - if the given pattern is invalid

 public SimpleDateFormat(String pattern,
    Locale locale) 
{
        if (pattern == null || locale == null) {
            throw new NullPointerException();
        }
        initializeCalendar(locale);
        this.pattern = pattern;
        this.formatData = DateFormatSymbols.getInstance(locale);
        this.locale = locale;
        initialize(locale);
}

Constructs a SimpleDateFormat using the given pattern and the default date format symbols for the given locale. Note: This constructor may not support all locales. For full coverage, use the factory methods in the DateFormat class.

Parameters:

pattern - the pattern describing the date and time format

locale - the locale whose date format symbols should be used

Throws:

NullPointerException - if the given pattern or locale is null

IllegalArgumentException - if the given pattern is invalid

exception: NullPointerException - if the given pattern or locale is null

exception: IllegalArgumentException - if the given pattern is invalid

 public SimpleDateFormat(String pattern,
    DateFormatSymbols formatSymbols) 
{
        if (pattern == null || formatSymbols == null) {
            throw new NullPointerException();
        }
        this.pattern = pattern;
        this.formatData = (DateFormatSymbols) formatSymbols.clone();
        this.locale = Locale.getDefault();
        initializeCalendar(this.locale);
        initialize(this.locale);
        useDateFormatSymbols = true;
}

Constructs a SimpleDateFormat using the given pattern and date format symbols.

Parameters:

pattern - the pattern describing the date and time format

formatSymbols - the date format symbols to be used for formatting

Throws:

NullPointerException - if the given pattern or formatSymbols is null

IllegalArgumentException - if the given pattern is invalid

exception: NullPointerException - if the given pattern or formatSymbols is null

exception: IllegalArgumentException - if the given pattern is invalid

 SimpleDateFormat(int timeStyle,
    int dateStyle,
    Locale loc) 
{
        if (loc == null) {
            throw new NullPointerException();
        }
        this.locale = loc;
        // initialize calendar and related fields
        initializeCalendar(loc);
        /* try the cache first */
        String key = getKey();
        String[] dateTimePatterns = cachedLocaleData.get(key);
        if (dateTimePatterns == null) { /* cache miss */
            ResourceBundle r = LocaleData.getDateFormatData(loc);
            if (!isGregorianCalendar()) {
                try {
                    dateTimePatterns = r.getStringArray(getCalendarName() + ".DateTimePatterns");
                } catch (MissingResourceException e) {
                }
            }
            if (dateTimePatterns == null) {
                dateTimePatterns = r.getStringArray("DateTimePatterns");
            }
            /* update cache */
            cachedLocaleData.put(key, dateTimePatterns);
        }
        formatData = DateFormatSymbols.getInstance(loc);
        if ((timeStyle  >= 0) && (dateStyle  >= 0)) {
            Object[] dateTimeArgs = {dateTimePatterns[timeStyle],
                                     dateTimePatterns[dateStyle + 4]};
            pattern = MessageFormat.format(dateTimePatterns[8], dateTimeArgs);
        }
        else if (timeStyle  >= 0) {
            pattern = dateTimePatterns[timeStyle];
        }
        else if (dateStyle  >= 0) {
            pattern = dateTimePatterns[dateStyle + 4];
        }
        else {
            throw new IllegalArgumentException("No date or time style specified");
        }
        initialize(loc);
}

 public  void applyLocalizedPattern(String pattern) 
{
         String p = translatePattern(pattern,
                                     formatData.getLocalPatternChars(),
                                     DateFormatSymbols.patternChars);
         compiledPattern = compile(p);
         this.pattern = p;
}

Applies the given localized pattern string to this date format.

 public  void applyPattern(String pattern) 
{
        compiledPattern = compile(pattern);
        this.pattern = pattern;
}

Applies the given pattern string to this date format.

 public Object clone() 
{
        SimpleDateFormat other = (SimpleDateFormat) super.clone();
        other.formatData = (DateFormatSymbols) formatData.clone();
        return other;
}

Creates a copy of this SimpleDateFormat. This also clones the format's date format symbols.

 public boolean equals(Object obj) 
{
        if (!super.equals(obj)) return false; // super does class check
        SimpleDateFormat that = (SimpleDateFormat) obj;
        return (pattern.equals(that.pattern)
                && formatData.equals(that.formatData));
}

Compares the given object with this SimpleDateFormat for equality.

 public StringBuffer format(Date date,
    StringBuffer toAppendTo,
    FieldPosition pos) 
{
        pos.beginIndex = pos.endIndex = 0;
        return format(date, toAppendTo, pos.getFieldDelegate());
}

Formats the given Date into a date/time string and appends the result to the given StringBuffer.

 public AttributedCharacterIterator formatToCharacterIterator(Object obj) 
{
        StringBuffer sb = new StringBuffer();
        CharacterIteratorFieldDelegate delegate = new
                         CharacterIteratorFieldDelegate();
        if (obj instanceof Date) {
            format((Date)obj, sb, delegate);
        }
        else if (obj instanceof Number) {
            format(new Date(((Number)obj).longValue()), sb, delegate);
        }
        else if (obj == null) {
            throw new NullPointerException(
                   "formatToCharacterIterator must be passed non-null object");
        }
        else {
            throw new IllegalArgumentException(
                             "Cannot format given Object as a Date");
        }
        return delegate.getIterator(sb.toString());
}

Formats an Object producing an AttributedCharacterIterator. You can use the returned AttributedCharacterIterator to build the resulting String, as well as to determine information about the resulting String.

Each attribute key of the AttributedCharacterIterator will be of type DateFormat.Field, with the corresponding attribute value being the same as the attribute key.

 public Date get2DigitYearStart() 
{
        return defaultCenturyStart;
}

Returns the beginning date of the 100-year period 2-digit years are interpreted as being within.

 public DateFormatSymbols getDateFormatSymbols() 
{
        return (DateFormatSymbols)formatData.clone();
}

Gets a copy of the date and time format symbols of this date format.

 public int hashCode() 
{
        return pattern.hashCode();
        // just enough fields for a reasonable distribution
}

Returns the hash code value for this SimpleDateFormat object.

 public Date parse(String text,
    ParsePosition pos) 
{
        int start = pos.index;
        int oldStart = start;
        int textLength = text.length();
        calendar.clear(); // Clears all the time fields
        boolean[] ambiguousYear = {false};
        for (int i = 0; i <  compiledPattern.length; ) {
            int tag = compiledPattern[i]  > > > 8;
            int count = compiledPattern[i++] & 0xff;
            if (count == 255) {
                count = compiledPattern[i++] < <  16;
                count |= compiledPattern[i++];
            }
            switch (tag) {
            case TAG_QUOTE_ASCII_CHAR:
                if (start  >= textLength || text.charAt(start) != (char)count) {
                    pos.index = oldStart;
                    pos.errorIndex = start;
                    return null;
                }
                start++;
                break;
            case TAG_QUOTE_CHARS:
                while (count--  > 0) {
                    if (start  >= textLength || text.charAt(start) != compiledPattern[i++]) {
                        pos.index = oldStart;
                        pos.errorIndex = start;
                        return null;
                    }
                    start++;
                }
                break;
            default:
                // Peek the next pattern to determine if we need to
                // obey the number of pattern letters for
                // parsing. It's required when parsing contiguous
                // digit text (e.g., "20010704") with a pattern which
                // has no delimiters between fields, like "yyyyMMdd".
                boolean obeyCount = false;
                if (i <  compiledPattern.length) {
                    int nextTag = compiledPattern[i]  > > > 8;
                    if (!(nextTag == TAG_QUOTE_ASCII_CHAR || nextTag == TAG_QUOTE_CHARS)) {
                        obeyCount = true;
                    }
                }
                start = subParse(text, start, tag, count, obeyCount,
                                 ambiguousYear, pos);
                if (start <  0) {
                    pos.index = oldStart;
                    return null;
                }
            }
        }
        // At this point the fields of Calendar have been set.  Calendar
        // will fill in default values for missing fields when the time
        // is computed.
        pos.index = start;
        // This part is a problem:  When we call parsedDate.after, we compute the time.
        // Take the date April 3 2004 at 2:30 am.  When this is first set up, the year
        // will be wrong if we're parsing a 2-digit year pattern.  It will be 1904.
        // April 3 1904 is a Sunday (unlike 2004) so it is the DST onset day.  2:30 am
        // is therefore an "impossible" time, since the time goes from 1:59 to 3:00 am
        // on that day.  It is therefore parsed out to fields as 3:30 am.  Then we
        // add 100 years, and get April 3 2004 at 3:30 am.  Note that April 3 2004 is
        // a Saturday, so it can have a 2:30 am -- and it should. [LIU]
        /*
        Date parsedDate = calendar.getTime();
        if( ambiguousYear[0] && !parsedDate.after(defaultCenturyStart) ) {
            calendar.add(Calendar.YEAR, 100);
            parsedDate = calendar.getTime();
        }
        */
        // Because of the above condition, save off the fields in case we need to readjust.
        // The procedure we use here is not particularly efficient, but there is no other
        // way to do this given the API restrictions present in Calendar.  We minimize
        // inefficiency by only performing this computation when it might apply, that is,
        // when the two-digit year is equal to the start year, and thus might fall at the
        // front or the back of the default century.  This only works because we adjust
        // the year correctly to start with in other cases -- see subParse().
        Date parsedDate;
        try {
            if (ambiguousYear[0]) // If this is true then the two-digit year == the default start year
            {
                // We need a copy of the fields, and we need to avoid triggering a call to
                // complete(), which will recalculate the fields.  Since we can't access
                // the fields[] array in Calendar, we clone the entire object.  This will
                // stop working if Calendar.clone() is ever rewritten to call complete().
                Calendar savedCalendar = (Calendar)calendar.clone();
                parsedDate = calendar.getTime();
                if (parsedDate.before(defaultCenturyStart))
                {
                    // We can't use add here because that does a complete() first.
                    savedCalendar.set(Calendar.YEAR, defaultCenturyStartYear + 100);
                    parsedDate = savedCalendar.getTime();
                }
            }
            else parsedDate = calendar.getTime();
        }
        // An IllegalArgumentException will be thrown by Calendar.getTime()
        // if any fields are out of range, e.g., MONTH == 17.
        catch (IllegalArgumentException e) {
            pos.errorIndex = start;
            pos.index = oldStart;
            return null;
        }
        return parsedDate;
}

Parses text from a string to produce a Date.

The method attempts to parse text starting at the index given by pos. If parsing succeeds, then the index of pos is updated to the index after the last character used (parsing does not necessarily use all characters up to the end of the string), and the parsed date is returned. The updated pos can be used to indicate the starting point for the next call to this method. If an error occurs, then the index of pos is not changed, the error index of pos is set to the index of the character where the error occurred, and null is returned.

 public  void set2DigitYearStart(Date startDate) 
{
        parseAmbiguousDatesAsAfter(startDate);
}

Sets the 100-year period 2-digit years will be interpreted as being in to begin on the date the user specifies.

 public  void setDateFormatSymbols(DateFormatSymbols newFormatSymbols) 
{
        this.formatData = (DateFormatSymbols)newFormatSymbols.clone();
        useDateFormatSymbols = true;
}

Sets the date and time format symbols of this date format.

 public String toLocalizedPattern() 
{
        return translatePattern(pattern,
                                DateFormatSymbols.patternChars,
                                formatData.getLocalPatternChars());
}

Returns a localized pattern string describing this date format.

 public String toPattern() 
{
        return pattern;
}

Returns a pattern string describing this date format.