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

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(Locale.Category.FORMAT));
}

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.getInstanceRef(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(Locale.Category.FORMAT);
        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[] dateTimePatterns = cachedLocaleData.get(loc);
        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.putIfAbsent(loc, dateTimePatterns);
        }
        formatData = DateFormatSymbols.getInstanceRef(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 (Date) defaultCenturyStart.clone();
}

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) 
{
        checkNegativeNumberExpression();
        int start = pos.index;
        int oldStart = start;
        int textLength = text.length();
        boolean[] ambiguousYear = {false};
        CalendarBuilder calb = new CalendarBuilder();
        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;
                // In Arabic, a minus sign for a negative number is put after
                // the number. Even in another locale, a minus sign can be
                // put after a number using DateFormat.setNumberFormat().
                // If both the minus sign and the field-delimiter are '-',
                // subParse() needs to determine whether a '-' after a number
                // in the given text is a delimiter or is a minus sign for the
                // preceding number. We give subParse() a clue based on the
                // information in compiledPattern.
                boolean useFollowingMinusSignAsDelimiter = false;
                if (i <  compiledPattern.length) {
                    int nextTag = compiledPattern[i]  > > > 8;
                    if (!(nextTag == TAG_QUOTE_ASCII_CHAR ||
                          nextTag == TAG_QUOTE_CHARS)) {
                        obeyCount = true;
                    }
                    if (hasFollowingMinusSign &&
                        (nextTag == TAG_QUOTE_ASCII_CHAR ||
                         nextTag == TAG_QUOTE_CHARS)) {
                        int c;
                        if (nextTag == TAG_QUOTE_ASCII_CHAR) {
                            c = compiledPattern[i] & 0xff;
                        } else {
                            c = compiledPattern[i+1];
                        }
                        if (c == minusSign) {
                            useFollowingMinusSignAsDelimiter = true;
                        }
                    }
                }
                start = subParse(text, start, tag, count, obeyCount,
                                 ambiguousYear, pos,
                                 useFollowingMinusSignAsDelimiter, calb);
                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;
        Date parsedDate;
        try {
            parsedDate = calb.establish(calendar).getTime();
            // If the year value is ambiguous,
            // then the two-digit year == the default start year
            if (ambiguousYear[0]) {
                if (parsedDate.before(defaultCenturyStart)) {
                    parsedDate = calb.addYear(100).establish(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.

This parsing operation uses the calendar to produce a {@code Date}. All of the {@code calendar}'s date-time fields are {@linkplain Calendar#clear() cleared} before parsing, and the {@code calendar}'s default values of the date-time fields are used for any missing date-time information. For example, the year value of the parsed {@code Date} is 1970 with GregorianCalendar if no year value is given from the parsing operation. The {@code TimeZone} value may be overwritten, depending on the given pattern and the time zone value in {@code text}. Any {@code TimeZone} value that has previously been set by a call to setTimeZone may need to be restored for further operations.

 public  void set2DigitYearStart(Date startDate) 
{
        parseAmbiguousDatesAsAfter(new Date(startDate.getTime()));
}

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.