Also see:

java.text.Collator#setStrength
java.text.Collator#getStrength

Also see:

java.text.Collator#setStrength
java.text.Collator#getStrength

Also see:

java.text.Collator#setStrength
java.text.Collator#getStrength

Also see:

java.text.Collator#getDecomposition
java.text.Collator#setDecomposition

CANONICAL_DECOMPOSITION corresponds to Normalization Form D as described in Unicode Technical Report #15.

Also see:

java.text.Collator#getDecomposition
java.text.Collator#setDecomposition

FULL_DECOMPOSITION corresponds to Normalization Form KD as described in Unicode Technical Report #15.

Also see:

java.text.Collator#getDecomposition
java.text.Collator#setDecomposition

Also see:

java.text.Collator#compare

Also see:

java.text.Collator#compare

Also see:

java.text.Collator#compare

 protected Collator() 
{
        strength = TERTIARY;
        decmp = CANONICAL_DECOMPOSITION;
}

Default constructor. This constructor is protected so subclasses can get access to it. Users typically create a Collator sub-class by calling the factory method getInstance.

Also see:

java.text.Collator#getInstance

 public Object clone() 
{
        try {
            return (Collator)super.clone();
        } catch (CloneNotSupportedException e) {
            throw new InternalError();
        }
}

Overrides Cloneable

 abstract public int compare(String source,
    String target)
Compares the source string to the target string according to the
collation rules for this Collator. Returns an integer less than,
equal to or greater than zero depending on whether the source String is
less than, equal to or greater than the target string. See the Collator
class description for an example of use.

For a one time comparison, this method has the best performance. If a
given String will be involved in multiple comparisons, CollationKey.compareTo
has the best performance. See the Collator class description for an example
using CollationKeys.

 public int compare(Object o1,
    Object o2) 
{
    return compare((String)o1, (String)o2);
}

Compares its two arguments for order. Returns a negative integer, zero, or a positive integer as the first argument is less than, equal to, or greater than the second.

This implementation merely returns compare((String)o1, (String)o2) .

 public boolean equals(Object that) 
{
        if (this == that) return true;
        if (that == null) return false;
        if (getClass() != that.getClass()) return false;
        Collator other = (Collator) that;
        return ((strength == other.strength) &&
                (decmp == other.decmp));
}

Compares the equality of two Collators.

 public boolean equals(String source,
    String target) 
{
        return (compare(source, target) == Collator.EQUAL);
}

Convenience method for comparing the equality of two strings based on this Collator's collation rules.

 public static synchronized Locale[] getAvailableLocales() 
{
        LocaleServiceProviderPool pool =
            LocaleServiceProviderPool.getPool(CollatorProvider.class);
        return pool.getAvailableLocales();
}

Returns an array of all locales for which the getInstance methods of this class can return localized instances. The returned array represents the union of locales supported by the Java runtime and by installed CollatorProvider implementations. It must contain at least a Locale instance equal to Locale.US .

 abstract public CollationKey getCollationKey(String source)
Transforms the String into a series of bits that can be compared bitwise
to other CollationKeys. CollationKeys provide better performance than
Collator.compare when Strings are involved in multiple comparisons.
See the Collator class description for an example using CollationKeys.

 public synchronized int getDecomposition() 
{
        return decmp;
}

Get the decomposition mode of this Collator. Decomposition mode determines how Unicode composed characters are handled. Adjusting decomposition mode allows the user to select between faster and more complete collation behavior.

The three values for decomposition mode are:

• NO_DECOMPOSITION,
• CANONICAL_DECOMPOSITION
• FULL_DECOMPOSITION.
See the documentation for these three constants for a description of their meaning.

 public static synchronized Collator getInstance() 
{
                                   
        return getInstance(Locale.getDefault());
}

Gets the Collator for the current default locale. The default locale is determined by java.util.Locale.getDefault.

 public static synchronized Collator getInstance(Locale desiredLocale) 
{
        Collator result = (Collator) cache.get(desiredLocale);
        if (result != null) {
                 return (Collator)result.clone();  // make the world safe
        }
        // Check whether a provider can provide an implementation that's closer
        // to the requested locale than what the Java runtime itself can provide.
        LocaleServiceProviderPool pool =
            LocaleServiceProviderPool.getPool(CollatorProvider.class);
        if (pool.hasProviders()) {
            Collator providersInstance = pool.getLocalizedObject(
                                            CollatorGetter.INSTANCE,
                                            desiredLocale,
                                            desiredLocale);
            if (providersInstance != null) {
                return providersInstance;
            }
        }
        // Load the resource of the desired locale from resource
        // manager.
        String colString = "";
        try {
            ResourceBundle resource = LocaleData.getCollationData(desiredLocale);
            colString = resource.getString("Rule");
        } catch (MissingResourceException e) {
            // Use default values
        }
        try
        {
            result = new RuleBasedCollator( CollationRules.DEFAULTRULES +
                                            colString,
                                            CANONICAL_DECOMPOSITION );
        }
        catch(ParseException foo)
        {
            // predefined tables should contain correct grammar
            try {
                result = new RuleBasedCollator( CollationRules.DEFAULTRULES );
            } catch (ParseException bar) {
                // do nothing
            }
        }
        // Now that RuleBasedCollator adds expansions for pre-composed characters
        // into their decomposed equivalents, the default collators don't need
        // to have decomposition turned on.  Laura, 5/5/98, bug 4114077
        result.setDecomposition(NO_DECOMPOSITION);
        cache.put(desiredLocale,result);
        return (Collator)result.clone();
}

Gets the Collator for the desired locale.

 public synchronized int getStrength() 
{
        return strength;
}

Returns this Collator's strength property. The strength property determines the minimum level of difference considered significant during comparison. See the Collator class description for an example of use.

 abstract public int hashCode()
Generates the hash code for this Collator.

 public synchronized  void setDecomposition(int decompositionMode) 
{
        if ((decompositionMode != NO_DECOMPOSITION) &&
            (decompositionMode != CANONICAL_DECOMPOSITION) &&
            (decompositionMode != FULL_DECOMPOSITION))
            throw new IllegalArgumentException("Wrong decomposition mode.");
        decmp = decompositionMode;
}

Set the decomposition mode of this Collator. See getDecomposition for a description of decomposition mode.

 public synchronized  void setStrength(int newStrength) 
{
        if ((newStrength != PRIMARY) &&
            (newStrength != SECONDARY) &&
            (newStrength != TERTIARY) &&
            (newStrength != IDENTICAL))
            throw new IllegalArgumentException("Incorrect comparison level.");
        strength = newStrength;
}

Sets this Collator's strength property. The strength property determines the minimum level of difference considered significant during comparison. See the Collator class description for an example of use.