Class RuleBasedCollator

  • All Implemented Interfaces:
    Freezable<Collator>, java.lang.Cloneable, java.util.Comparator<java.lang.Object>

    public final class RuleBasedCollator
    extends Collator

    RuleBasedCollator is a concrete subclass of Collator. It allows customization of the Collator via user-specified rule sets. RuleBasedCollator is designed to be fully compliant to the Unicode Collation Algorithm (UCA) and conforms to ISO 14651.

    A Collator is thread-safe only when frozen. See isFrozen() and Freezable.

    Users are strongly encouraged to read the User Guide for more information about the collation service before using this class.

    Create a RuleBasedCollator from a locale by calling the getInstance(Locale) factory method in the base class Collator. Collator.getInstance(Locale) creates a RuleBasedCollator object based on the collation rules defined by the argument locale. If a customized collation ordering or attributes is required, use the RuleBasedCollator(String) constructor with the appropriate rules. The customized RuleBasedCollator will base its ordering on the CLDR root collation, while re-adjusting the attributes and orders of the characters in the specified rule accordingly.

    RuleBasedCollator provides correct collation orders for most locales supported in ICU. If specific data for a locale is not available, the orders eventually falls back to the CLDR root sort order.

    For information about the collation rule syntax and details about customization, please refer to the Collation customization section of the User Guide.

    Note that there are some differences between the Collation rule syntax used in Java and ICU4J:

    • According to the JDK documentation:
      Modifier '!' : Turns on Thai/Lao vowel-consonant swapping. If this rule is in force when a Thai vowel of the range \U0E40-\U0E44 precedes a Thai consonant of the range \U0E01-\U0E2E OR a Lao vowel of the range \U0EC0-\U0EC4 precedes a Lao consonant of the range \U0E81-\U0EAE then the vowel is placed after the consonant for collation purposes.
      If a rule is without the modifier '!', the Thai/Lao vowel-consonant swapping is not turned on.

      ICU4J's RuleBasedCollator does not support turning off the Thai/Lao vowel-consonant swapping, since the UCA clearly states that it has to be supported to ensure a correct sorting order. If a '!' is encountered, it is ignored.
    • As mentioned in the documentation of the base class Collator, compatibility decomposition mode is not supported.

    Examples

    Creating Customized RuleBasedCollators:

     String simple = "& a < b < c < d";
     RuleBasedCollator simpleCollator = new RuleBasedCollator(simple);
    
     String norwegian = "& a , A < b , B < c , C < d , D < e , E "
                        + "< f , F < g , G < h , H < i , I < j , "
                        + "J < k , K < l , L < m , M < n , N < "
                        + "o , O < p , P < q , Q <r , R <s , S < "
                        + "t , T < u , U < v , V < w , W < x , X "
                        + "< y , Y < z , Z < \u00E5 = a\u030A "
                        + ", \u00C5 = A\u030A ; aa , AA < \u00E6 "
                        + ", \u00C6 < \u00F8 , \u00D8";
     RuleBasedCollator norwegianCollator = new RuleBasedCollator(norwegian);
     
    Concatenating rules to combine Collators:
     // Create an en_US Collator object
     RuleBasedCollator en_USCollator = (RuleBasedCollator)
         Collator.getInstance(new Locale("en", "US", ""));
     // Create a da_DK Collator object
     RuleBasedCollator da_DKCollator = (RuleBasedCollator)
         Collator.getInstance(new Locale("da", "DK", ""));
     // Combine the two
     // First, get the collation rules from en_USCollator
     String en_USRules = en_USCollator.getRules();
     // Second, get the collation rules from da_DKCollator
     String da_DKRules = da_DKCollator.getRules();
     RuleBasedCollator newCollator =
                                 new RuleBasedCollator(en_USRules + da_DKRules);
     // newCollator has the combined rules
     
    Making changes to an existing RuleBasedCollator to create a new Collator object, by appending changes to the existing rule:
     // Create a new Collator object with additional rules
     String addRules = "& C < ch, cH, Ch, CH";
     RuleBasedCollator myCollator =
         new RuleBasedCollator(en_USCollator.getRules() + addRules);
     // myCollator contains the new rules
     
    How to change the order of non-spacing accents:
     // old rule with main accents
     String oldRules = "= \u0301 ; \u0300 ; \u0302 ; \u0308 "
                     + "; \u0327 ; \u0303 ; \u0304 ; \u0305 "
                     + "; \u0306 ; \u0307 ; \u0309 ; \u030A "
                     + "; \u030B ; \u030C ; \u030D ; \u030E "
                     + "; \u030F ; \u0310 ; \u0311 ; \u0312 "
                     + "< a , A ; ae, AE ; \u00e6 , \u00c6 "
                     + "< b , B < c, C < e, E & C < d , D";
     // change the order of accent characters
     String addOn = "& \u0300 ; \u0308 ; \u0302";
     RuleBasedCollator myCollator = new RuleBasedCollator(oldRules + addOn);
     
    Putting in a new primary ordering before the default setting, e.g. sort English characters before or after Japanese characters in the Japanese Collator:
     // get en_US Collator rules
     RuleBasedCollator en_USCollator
                            = (RuleBasedCollator)Collator.getInstance(Locale.US);
     // add a few Japanese characters to sort before English characters
     // suppose the last character before the first base letter 'a' in
     // the English collation rule is \u2212
     String jaString = "& \u2212 <\u3041, \u3042 <\u3043, "
                       + "\u3044";
     RuleBasedCollator myJapaneseCollator
                  = new RuleBasedCollator(en_USCollator.getRules() + jaString);
     

    This class is not subclassable

    • Constructor Detail

      • RuleBasedCollator

        public RuleBasedCollator​(java.lang.String rules)
                          throws java.lang.Exception

        Constructor that takes the argument rules for customization. The collator will be based on the CLDR root collation, with the attributes and re-ordering of the characters specified in the argument rules.

        See the User Guide's section on Collation Customization for details on the rule syntax.

        Parameters:
        rules - the collation rules to build the collation table from.
        Throws:
        java.text.ParseException - and IOException thrown. ParseException thrown when argument rules have an invalid syntax. IOException thrown when an error occurred while reading internal data.
        java.lang.Exception
    • Method Detail

      • internalBuildTailoring

        private final void internalBuildTailoring​(java.lang.String rules)
                                           throws java.lang.Exception
        Implements from-rule constructors.
        Parameters:
        rules - rule string
        Throws:
        java.lang.Exception
      • clone

        public java.lang.Object clone()
                               throws java.lang.CloneNotSupportedException
        Clones the RuleBasedCollator
        Overrides:
        clone in class Collator
        Returns:
        a new instance of this RuleBasedCollator object
        Throws:
        java.lang.CloneNotSupportedException
      • initMaxExpansions

        private final void initMaxExpansions()
      • getCollationElementIterator

        public CollationElementIterator getCollationElementIterator​(java.text.CharacterIterator source)
        Return a CollationElementIterator for the given CharacterIterator. The source iterator's integrity will be preserved since a new copy will be created for use.
        See Also:
        CollationElementIterator
      • isFrozen

        public boolean isFrozen()
        Determines whether the object has been frozen or not.

        An unfrozen Collator is mutable and not thread-safe. A frozen Collator is immutable and thread-safe.

        Specified by:
        isFrozen in interface Freezable<Collator>
        Overrides:
        isFrozen in class Collator
      • checkNotFrozen

        private void checkNotFrozen()
      • setHiraganaQuaternary

        @Deprecated
        public void setHiraganaQuaternary​(boolean flag)
        Deprecated.
        ICU 50 Implementation detail, cannot be set via API, was removed from implementation.
        Sets the Hiragana Quaternary mode to be on or off. When the Hiragana Quaternary mode is turned on, the collator positions Hiragana characters before all non-ignorable characters in QUATERNARY strength. This is to produce a correct JIS collation order, distinguishing between Katakana and Hiragana characters.

        This attribute was an implementation detail of the CLDR Japanese tailoring. Since ICU 50, this attribute is not settable any more via API functions. Since CLDR 25/ICU 53, explicit quaternary relations are used to achieve the same Japanese sort order.

        Parameters:
        flag - true if Hiragana Quaternary mode is to be on, false otherwise
        See Also:
        setHiraganaQuaternaryDefault(), isHiraganaQuaternary()
      • setHiraganaQuaternaryDefault

        @Deprecated
        public void setHiraganaQuaternaryDefault()
        Deprecated.
        ICU 50 Implementation detail, cannot be set via API, was removed from implementation.
        Sets the Hiragana Quaternary mode to the initial mode set during construction of the RuleBasedCollator. See setHiraganaQuaternary(boolean) for more details.

        This attribute was an implementation detail of the CLDR Japanese tailoring. Since ICU 50, this attribute is not settable any more via API functions. Since CLDR 25/ICU 53, explicit quaternary relations are used to achieve the same Japanese sort order.

        See Also:
        setHiraganaQuaternary(boolean), isHiraganaQuaternary()
      • setUpperCaseFirst

        public void setUpperCaseFirst​(boolean upperfirst)
        Sets whether uppercase characters sort before lowercase characters or vice versa, in strength TERTIARY. If false, lowercase characters sort before uppercase characters. If true, sort upper case characters first. The default setting in a Collator object depends on the locale data loaded from the resources. For most locales, the default is false, but for others, such as "da" or "mt", the default could be true.
        Parameters:
        upperfirst - true to sort uppercase characters before lowercase characters, false to sort lowercase characters before uppercase characters
        See Also:
        isLowerCaseFirst(), isUpperCaseFirst(), setLowerCaseFirst(boolean), setCaseFirstDefault()
      • setLowerCaseFirst

        public void setLowerCaseFirst​(boolean lowerfirst)
        Sets the orders of lower cased characters to sort before upper cased characters, in strength TERTIARY. If true is set, the RuleBasedCollator will sort lower cased characters before the upper cased ones. Otherwise, if false is set, the RuleBasedCollator will ignore case preferences. The default default setting in a Collator object depends on the locale data loaded from the resources.
        Parameters:
        lowerfirst - true for sorting lower cased characters before upper cased characters, false to ignore case preferences.
        See Also:
        isLowerCaseFirst(), isUpperCaseFirst(), setUpperCaseFirst(boolean), setCaseFirstDefault()
      • setCaseLevelDefault

        public void setCaseLevelDefault()
        Sets the case level mode to the initial mode set during construction of the RuleBasedCollator. See setCaseLevel(boolean) for more details.
        See Also:
        setCaseLevel(boolean), isCaseLevel()
      • setDecompositionDefault

        public void setDecompositionDefault()
        Sets the decomposition mode to the initial mode set during construction of the RuleBasedCollator. See setDecomposition(int) for more details.
        See Also:
        getDecomposition(), setDecomposition(int)
      • setFrenchCollationDefault

        public void setFrenchCollationDefault()
        Sets the French collation mode to the initial mode set during construction of the RuleBasedCollator. See setFrenchCollation(boolean) for more details.
        See Also:
        isFrenchCollation(), setFrenchCollation(boolean)
      • setStrengthDefault

        public void setStrengthDefault()
        Sets the collation strength to the initial mode set during the construction of the RuleBasedCollator. See setStrength(int) for more details.
        See Also:
        setStrength(int), getStrength()
      • setFrenchCollation

        public void setFrenchCollation​(boolean flag)
        Sets the mode for the direction of SECONDARY weights to be used in French collation. If set to false, which treats SECONDARY weights in the order they appear. If set to true, the SECONDARY weights will be sorted backwards. See the section on French collation for more information. The default setting in a Collator object depends on the locale data loaded from the resources. For example, for "fr_CA" locale, the default is true.
        Parameters:
        flag - true to set the French collation on, false to set it off
        See Also:
        isFrenchCollation(), setFrenchCollationDefault()
      • setAlternateHandlingShifted

        public void setAlternateHandlingShifted​(boolean shifted)
        Sets the alternate handling for QUATERNARY strength to be either shifted or non-ignorable. See the UCA definition on Variable Weighting. This attribute will only be effective when QUATERNARY strength is set. If the mode is set to false, it corresponds to the NON_IGNORABLE mode in UCA. In the NON_IGNORABLE mode, the RuleBasedCollator treats all the code points with non-ignorable primary weights in the same way. If the mode is set to true, the behavior corresponds to SHIFTED defined in UCA, this causes code points with PRIMARY orders that are equal or below the variable top value to be ignored in PRIMARY order and moved to the QUATERNARY order. The default setting in a Collator object depends on the locale data loaded from the resources. For most locales, the default is false, but for others, such as "th", the default could be true.
        Parameters:
        shifted - true if SHIFTED behavior for alternate handling is desired, false for the NON_IGNORABLE behavior.
        See Also:
        isAlternateHandlingShifted(), setAlternateHandlingDefault()
      • setCaseLevel

        public void setCaseLevel​(boolean flag)

        When case level is set to true, an additional weight is formed between the SECONDARY and TERTIARY weight, known as the case level. The case level is used to distinguish large and small Japanese Kana characters. Case level could also be used in other situations. For example to distinguish certain Pinyin characters. If the value is false, it means the case level is not generated. The contents of the case level are affected by the case first mode. A simple way to ignore accent differences in a string is to set the strength to PRIMARY and enable case level. The default setting in a Collator object depends on the locale data loaded from the resources.

        See the section on case level for more information.

        Parameters:
        flag - true if case level sorting is required, false otherwise
        See Also:
        setCaseLevelDefault(), isCaseLevel()
      • setDecomposition

        public void setDecomposition​(int decomposition)
        Sets the decomposition mode of this Collator. Setting this decomposition attribute with CANONICAL_DECOMPOSITION allows the Collator to handle un-normalized text properly, producing the same results as if the text were normalized. If NO_DECOMPOSITION is set, it is the user's responsibility to insure that all text is already in the appropriate form before a comparison or before getting a CollationKey. Adjusting decomposition mode allows the user to select between faster and more complete collation behavior.

        Since a great many of the world's languages do not require text normalization, most locales set NO_DECOMPOSITION as the default decomposition mode. The default decompositon mode for the Collator is NO_DECOMPOSITON, unless specified otherwise by the locale used to create the Collator.

        See getDecomposition for a description of decomposition mode.

        Overrides:
        setDecomposition in class Collator
        Parameters:
        decomposition - the new decomposition mode
        Throws:
        java.lang.IllegalArgumentException - If the given value is not a valid decomposition mode.
        See Also:
        getDecomposition(), Collator.NO_DECOMPOSITION, Collator.CANONICAL_DECOMPOSITION
      • setMaxVariable

        public RuleBasedCollator setMaxVariable​(int group)
        Sets the variable top to the top of the specified reordering group. The variable top determines the highest-sorting character which is affected by the alternate handling behavior. If that attribute is set to NON_IGNORABLE, then the variable top has no effect.
        Overrides:
        setMaxVariable in class Collator
        Parameters:
        group - one of Collator.ReorderCodes.SPACE, Collator.ReorderCodes.PUNCTUATION, Collator.ReorderCodes.SYMBOL, Collator.ReorderCodes.CURRENCY; or Collator.ReorderCodes.DEFAULT to restore the default max variable group
        Returns:
        this
        See Also:
        getMaxVariable()
      • getMaxVariable

        public int getMaxVariable()
        Returns the maximum reordering group whose characters are affected by the alternate handling behavior.
        Overrides:
        getMaxVariable in class Collator
        Returns:
        the maximum variable reordering group.
        See Also:
        setMaxVariable(int)
      • setVariableTop

        @Deprecated
        public int setVariableTop​(java.lang.String varTop)
        Deprecated.
        ICU 53 Call setMaxVariable(int) instead.
        Sets the variable top to the primary weight of the specified string.

        Beginning with ICU 53, the variable top is pinned to the top of one of the supported reordering groups, and it must not be beyond the last of those groups. See setMaxVariable(int).

        Specified by:
        setVariableTop in class Collator
        Parameters:
        varTop - one or more (if contraction) characters to which the variable top should be set
        Returns:
        variable top primary weight
        Throws:
        java.lang.IllegalArgumentException - is thrown if varTop argument is not a valid variable top element. A variable top element is invalid when
        • it is a contraction that does not exist in the Collation order
        • the variable top is beyond the last reordering group supported by setMaxVariable()
        • when the varTop argument is null or zero in length.
        See Also:
        getVariableTop(), setAlternateHandlingShifted(boolean)
      • setVariableTop

        @Deprecated
        public void setVariableTop​(int varTop)
        Deprecated.
        ICU 53 Call setMaxVariable() instead.
        Sets the variable top to the specified primary weight.

        Beginning with ICU 53, the variable top is pinned to the top of one of the supported reordering groups, and it must not be beyond the last of those groups. See setMaxVariable(int).

        Specified by:
        setVariableTop in class Collator
        Parameters:
        varTop - primary weight, as returned by setVariableTop or getVariableTop
        See Also:
        getVariableTop(), setVariableTop(String)
      • internalSetVariableTop

        private void internalSetVariableTop​(long varTop)
      • setNumericCollation

        public void setNumericCollation​(boolean flag)
        When numeric collation is turned on, this Collator makes substrings of digits sort according to their numeric values.

        This is a way to get '100' to sort AFTER '2'. Note that the longest digit substring that can be treated as a single unit is 254 digits (not counting leading zeros). If a digit substring is longer than that, the digits beyond the limit will be treated as a separate digit substring.

        A "digit" in this sense is a code point with General_Category=Nd, which does not include circled numbers, roman numerals, etc. Only a contiguous digit substring is considered, that is, non-negative integers without separators. There is no support for plus/minus signs, decimals, exponents, etc.

        Parameters:
        flag - true to turn numeric collation on and false to turn it off
        See Also:
        getNumericCollation(), setNumericCollationDefault()
      • setReorderCodes

        public void setReorderCodes​(int... order)
        Sets the reordering codes for this collator. Collation reordering allows scripts and some other groups of characters to be moved relative to each other. This reordering is done on top of the DUCET/CLDR standard collation order. Reordering can specify groups to be placed at the start and/or the end of the collation order. These groups are specified using UScript codes and Collator.ReorderCodes entries.

        By default, reordering codes specified for the start of the order are placed in the order given after several special non-script blocks. These special groups of characters are space, punctuation, symbol, currency, and digit. These special groups are represented with Collator.ReorderCodes entries. Script groups can be intermingled with these special non-script groups if those special groups are explicitly specified in the reordering.

        The special code OTHERS stands for any script that is not explicitly mentioned in the list of reordering codes given. Anything that is after OTHERS will go at the very end of the reordering in the order given.

        The special reorder code DEFAULT will reset the reordering for this collator to the default for this collator. The default reordering may be the DUCET/CLDR order or may be a reordering that was specified when this collator was created from resource data or from rules. The DEFAULT code must be the sole code supplied when it is used. If not, then an IllegalArgumentException will be thrown.

        The special reorder code NONE will remove any reordering for this collator. The result of setting no reordering will be to have the DUCET/CLDR ordering used. The NONE code must be the sole code supplied when it is used.

        Overrides:
        setReorderCodes in class Collator
        Parameters:
        order - the reordering codes to apply to this collator; if this is null or an empty array then this clears any existing reordering
        Throws:
        java.lang.IllegalArgumentException - if the reordering codes are malformed in any way (e.g. duplicates, multiple reset codes, overlapping equivalent scripts)
        See Also:
        getReorderCodes(), Collator.getEquivalentReorderCodes(int), Collator.ReorderCodes, UScript
      • setFastLatinOptions

        private void setFastLatinOptions​(CollationSettings ownedSettings)
      • getRules

        public java.lang.String getRules()
        Gets the collation tailoring rules for this RuleBasedCollator. Equivalent to String getRules(false).
        Returns:
        the collation tailoring rules
        See Also:
        getRules(boolean)
      • getRules

        public java.lang.String getRules​(boolean fullrules)
        Returns current rules. The argument defines whether full rules (root collation + tailored) rules are returned or just the tailoring.

        The root collation rules are an approximation of the root collator's sort order. They are almost never used or useful at runtime and can be removed from the data. See User Guide: Collation Customization, Building on Existing Locales

        getRules() should normally be used instead.

        Parameters:
        fullrules - true if the rules that defines the full set of collation order is required, otherwise false for returning only the tailored rules
        Returns:
        the current rules that defines this Collator.
        See Also:
        getRules()
      • getTailoredSet

        public UnicodeSet getTailoredSet()
        Get a UnicodeSet that contains all the characters and sequences tailored in this collator.
        Overrides:
        getTailoredSet in class Collator
        Returns:
        a pointer to a UnicodeSet object containing all the code points and sequences that may sort differently than in the root collator.
      • getContractionsAndExpansions

        public void getContractionsAndExpansions​(UnicodeSet contractions,
                                                 UnicodeSet expansions,
                                                 boolean addPrefixes)
                                          throws java.lang.Exception
        Gets unicode sets containing contractions and/or expansions of a collator
        Parameters:
        contractions - if not null, set to contain contractions
        expansions - if not null, set to contain expansions
        addPrefixes - add the prefix contextual elements to contractions
        Throws:
        java.lang.Exception - Throws an exception if any errors occurs.
      • internalAddContractions

        @Deprecated
        void internalAddContractions​(int c,
                                     UnicodeSet set)
        Deprecated.
        This API is ICU internal only.
        Adds the contractions that start with character c to the set. Ignores prefixes. Used by AlphabeticIndex.
      • getCollationKey

        public CollationKey getCollationKey​(java.lang.String source)

        Get a Collation key for the argument String source from this RuleBasedCollator.

        General recommendation:
        If comparison are to be done to the same String multiple times, it would be more efficient to generate CollationKeys for the Strings and use CollationKey.compareTo(CollationKey) for the comparisons. If the each Strings are compared to only once, using the method RuleBasedCollator.compare(String, String) will have a better performance.

        See the class documentation for an explanation about CollationKeys.

        Specified by:
        getCollationKey in class Collator
        Parameters:
        source - the text String to be transformed into a collation key.
        Returns:
        the CollationKey for the given String based on this RuleBasedCollator's collation rules. If the source String is null, a null CollationKey is returned.
        See Also:
        CollationKey, compare(String, String), getRawCollationKey(java.lang.String, com.ibm.icu.text.RawCollationKey)
      • getRawCollationKey

        public RawCollationKey getRawCollationKey​(java.lang.String source,
                                                  RawCollationKey key)
        Gets the simpler form of a CollationKey for the String source following the rules of this Collator and stores the result into the user provided argument key. If key has a internal byte array of length that's too small for the result, the internal byte array will be grown to the exact required size.
        Specified by:
        getRawCollationKey in class Collator
        Parameters:
        source - the text String to be transformed into a RawCollationKey
        key - output RawCollationKey to store results
        Returns:
        If key is null, a new instance of RawCollationKey will be created and returned, otherwise the user provided key will be returned.
        See Also:
        getCollationKey(java.lang.String), compare(String, String), RawCollationKey
      • simpleKeyLengthEstimate

        private int simpleKeyLengthEstimate​(java.lang.CharSequence source)
      • internalGetCEs

        @Deprecated
        public long[] internalGetCEs​(java.lang.CharSequence str)
        Deprecated.
        This API is ICU internal only.
        Returns the CEs for the string.
        Parameters:
        str - the string
      • isAlternateHandlingShifted

        public boolean isAlternateHandlingShifted()
        Checks if the alternate handling behavior is the UCA defined SHIFTED or NON_IGNORABLE. If return value is true, then the alternate handling attribute for the Collator is SHIFTED. Otherwise if return value is false, then the alternate handling attribute for the Collator is NON_IGNORABLE See setAlternateHandlingShifted(boolean) for more details.
        Returns:
        true or false
        See Also:
        setAlternateHandlingShifted(boolean), setAlternateHandlingDefault()
      • isFrenchCollation

        public boolean isFrenchCollation()
        Checks if French Collation is set to true. See setFrenchCollation(boolean) for details.
        Returns:
        true if French Collation is set to true, false otherwise
        See Also:
        setFrenchCollation(boolean), setFrenchCollationDefault()
      • isHiraganaQuaternary

        @Deprecated
        public boolean isHiraganaQuaternary()
        Deprecated.
        ICU 50 Implementation detail, cannot be set via API, was removed from implementation.
        Checks if the Hiragana Quaternary mode is set on. See setHiraganaQuaternary(boolean) for more details.

        This attribute was an implementation detail of the CLDR Japanese tailoring. Since ICU 50, this attribute is not settable any more via API functions. Since CLDR 25/ICU 53, explicit quaternary relations are used to achieve the same Japanese sort order.

        Returns:
        false
        See Also:
        setHiraganaQuaternaryDefault(), setHiraganaQuaternary(boolean)
      • getVariableTop

        public int getVariableTop()
        Gets the variable top value of a Collator.
        Specified by:
        getVariableTop in class Collator
        Returns:
        the variable top primary weight
        See Also:
        getMaxVariable()
      • getNumericCollation

        public boolean getNumericCollation()
        Method to retrieve the numeric collation value. When numeric collation is turned on, this Collator generates a collation key for the numeric value of substrings of digits. This is a way to get '100' to sort AFTER '2'
        Returns:
        true if numeric collation is turned on, false otherwise
        See Also:
        setNumericCollation(boolean), setNumericCollationDefault()
      • equals

        public boolean equals​(java.lang.Object obj)
        Compares the equality of two Collator objects. Collator objects are equal if they have the same collation (sorting & searching) behavior.

        The base class checks for null and for equal types. Subclasses should override.

        Specified by:
        equals in interface java.util.Comparator<java.lang.Object>
        Overrides:
        equals in class Collator
        Parameters:
        obj - the Collator to compare to.
        Returns:
        true if this Collator has exactly the same collation behavior as obj, false otherwise.
      • hashCode

        public int hashCode()
        Generates a unique hash code for this RuleBasedCollator.
        Overrides:
        hashCode in class Collator
        Returns:
        the unique hash code for this Collator
      • compare

        public int compare​(java.lang.String source,
                           java.lang.String target)
        Compares the source text String to the target text String according to the collation rules, strength and decomposition mode for this RuleBasedCollator. 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.

        General recommendation:
        If comparison are to be done to the same String multiple times, it would be more efficient to generate CollationKeys for the Strings and use CollationKey.compareTo(CollationKey) for the comparisons. If speed performance is critical and object instantiation is to be reduced, further optimization may be achieved by generating a simpler key of the form RawCollationKey and reusing this RawCollationKey object with the method RuleBasedCollator.getRawCollationKey. Internal byte representation can be directly accessed via RawCollationKey and stored for future use. Like CollationKey, RawCollationKey provides a method RawCollationKey.compareTo for key comparisons. If the each Strings are compared to only once, using the method RuleBasedCollator.compare(String, String) will have a better performance.

        Specified by:
        compare in class Collator
        Parameters:
        source - the source text String.
        target - the target text String.
        Returns:
        Returns an integer value. Value is less than zero if source is less than target, value is zero if source and target are equal, value is greater than zero if source is greater than target.
        See Also:
        CollationKey, getCollationKey(java.lang.String)
      • doCompare

        @Deprecated
        protected int doCompare​(java.lang.CharSequence left,
                                java.lang.CharSequence right)
        Deprecated.
        This API is ICU internal only.
        Compares two CharSequences.
        Overrides:
        doCompare in class Collator
      • isUnsafe

        final boolean isUnsafe​(int c)
        Tests whether a character is "unsafe" for use as a collation starting point.
        Parameters:
        c - code point or code unit
        Returns:
        true if c is unsafe
        See Also:
        CollationElementIterator.setOffset(int)
      • getVersion

        public VersionInfo getVersion()
        Get the version of this collator object.
        Specified by:
        getVersion in class Collator
        Returns:
        the version object associated with this collator
      • getUCAVersion

        public VersionInfo getUCAVersion()
        Get the UCA version of this collator object.
        Specified by:
        getUCAVersion in class Collator
        Returns:
        the version object associated with this collator
      • getLocale

        public ULocale getLocale​(ULocale.Type type)
        Returns the locale that was used to create this object, or null. This may may differ from the locale requested at the time of this object's creation. For example, if an object is created for locale en_US_CALIFORNIA, the actual data may be drawn from en (the actual locale), and en_US may be the most specific locale that exists (the valid locale).

        Note: This method will be implemented in ICU 3.0; ICU 2.8 contains a partial preview implementation. The actual locale is returned correctly, but the valid locale is not, in most cases.

        The base class method always returns ULocale.ROOT. Subclasses should override it if appropriate.

        Overrides:
        getLocale in class Collator
        Parameters:
        type - type of information requested, either ULocale.VALID_LOCALE or ULocale.ACTUAL_LOCALE.
        Returns:
        the information specified by type, or null if this object was not constructed from locale data.
        See Also:
        ULocale, ULocale.VALID_LOCALE, ULocale.ACTUAL_LOCALE
      • setLocale

        void setLocale​(ULocale valid,
                       ULocale actual)
        Set information about the locales that were used to create this object. If the object was not constructed from locale data, both arguments should be set to null. Otherwise, neither should be null. The actual locale must be at the same level or less specific than the valid locale. This method is intended for use by factories or other entities that create objects of this class.

        The base class method does nothing. Subclasses should override it if appropriate.

        Overrides:
        setLocale in class Collator
        Parameters:
        valid - the most specific locale containing any resource data, or null
        actual - the locale containing data used to construct this object, or null
        See Also:
        ULocale, ULocale.VALID_LOCALE, ULocale.ACTUAL_LOCALE