Most visited

Recently visited

Results for

Added in API level 24

Summary: Inherited Constants | Ctors | Methods | Inherited Methods | [Expand All]

RuleBasedCollator

public final class RuleBasedCollator
extends Collator

java.lang.Object
↳	android.icu.text.Collator
	↳	android.icu.text.RuleBasedCollator

RuleBasedCollator是Collator的具体子类。它允许通过用户指定的规则集对Collator进行自定义。 RuleBasedCollator设计为完全符合Unicode Collation Algorithm (UCA)并符合ISO 14651。

Collator只有在冻结时才是线程安全的。参见{ isFrozen()和Freezable 。

强烈建议用户在使用此类之前阅读 User Guide以获取有关整理服务的更多信息。

通过调用基类Collator中的getInstance（Locale）工厂方法，从一个语言环境创建一个RuleBasedCollator。 Collator.getInstance（Locale）根据参数locale定义的排序规则创建一个RuleBasedCollator对象。如果需要自定义排序规则排序或属性，请使用具有适当规则的RuleBasedCollator（String）构造函数。定制的RuleBasedCollator将根据CLDR根归类进行排序，同时相应地重新调整指定规则中字符的属性和顺序。

RuleBasedCollator为ICU支持的大多数区域设置提供正确的整理顺序。如果区域设置的特定数据不可用，那么订单最终会回落到CLDR root sort order 。

有关整理规则语法和有关自定义的详细信息，请参阅用户指南的 Collation customization部分。

请注意 ，Java和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.

例子

创建自定义的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);

这个类不是可分类的

Summary

Inherited constants

From class android.icu.text.Collator

Public constructors
`RuleBasedCollator(String rules)` 构造函数接受自定义的参数规则。

Public constructors

RuleBasedCollator(String rules)

构造函数接受自定义的参数规则。

Public methods
`Object`	`clone()` 克隆RuleBasedCollator
`RuleBasedCollator`	`cloneAsThawed()` 提供克隆操作。
`int`	`compare(String source, String target)` 根据RuleBasedCollator的排序规则，强度和分解模式，将源文本字符串与目标文本字符串进行比较。
`boolean`	`equals(Object obj)` 比较两个Collator对象的相等性。
`Collator`	`freeze()` 冻结整理者。
`CollationElementIterator`	`getCollationElementIterator(UCharacterIterator source)` 为给定的UCharacterIterator返回一个CollationElementIterator。
`CollationElementIterator`	`getCollationElementIterator(String source)` 为给定的字符串返回一个CollationElementIterator。
`CollationElementIterator`	`getCollationElementIterator(CharacterIterator source)` 为给定的CharacterIterator返回一个CollationElementIterator。
`CollationKey`	`getCollationKey(String source)` 从此RuleBasedCollator获取参数字符串源的整理键。
`void`	`getContractionsAndExpansions(UnicodeSet contractions, UnicodeSet expansions, boolean addPrefixes)` 获取包含缩放和/或扩展的整理器的unicode集
`int`	`getDecomposition()` 返回此Collator的分解模式。
`int`	`getMaxVariable()` [icu]返回字符受备用处理行为影响的最大重新排序组。
`boolean`	`getNumericCollation()` 检索数字排序规则值的方法。
`int[]`	`getReorderCodes()` 检索该整理器的重新排序代码。
`String`	`getRules()` 获取此RuleBasedCollator的归类裁剪规则。
`String`	`getRules(boolean fullrules)` 返回当前规则。
`int`	`getStrength()` 返回此Collator的强度属性。
`UnicodeSet`	`getTailoredSet()` 获取一个UnicodeSet，其中包含在该配页器中定制的所有字符和序列。
`VersionInfo`	`getUCAVersion()` 获取该collator对象的UCA版本。
`int`	`getVariableTop()` [icu]获取Collator的变量top值。
`VersionInfo`	`getVersion()` 获取这个collator对象的版本。
`int`	`hashCode()` 为此RuleBasedCollator生成唯一的哈希码。
`boolean`	`isAlternateHandlingShifted()` 检查备用处理行为是否为UCA定义的SHIFTED或NON_IGNORABLE。
`boolean`	`isCaseLevel()` 检查案例级别是否设置为true。
`boolean`	`isFrenchCollation()` 检查法语归类是否设置为true。
`boolean`	`isFrozen()` 确定对象是否被冻结。
`boolean`	`isLowerCaseFirst()` 如果小写字符在相应的大写字符之前排序，则返回true。
`boolean`	`isUpperCaseFirst()` 如果大写字符在相应的小写字符之前排序，则返回true。
`void`	`setAlternateHandlingDefault()` 在构建RuleBasedCollator期间，将备用处理模式设置为初始模式。
`void`	`setAlternateHandlingShifted(boolean shifted)` 将QUATERNARY强度的替代处理设置为移位或不可忽略。
`final void`	`setCaseFirstDefault()` 将案例优先模式设置为在构建RuleBasedCollator期间设置的初始模式。
`void`	`setCaseLevel(boolean flag)` 当案例级别设置为真时，在SECONDARY和TERTIARY权重之间形成额外的权重，称为案例级别。
`void`	`setCaseLevelDefault()` 将案例级别模式设置为在构建RuleBasedCollator期间设置的初始模式。
`void`	`setDecomposition(int decomposition)` 设置此Collator的分解模式。
`void`	`setDecompositionDefault()` 将分解模式设置为在构建RuleBasedCollator期间设置的初始模式。
`void`	`setFrenchCollation(boolean flag)` 设置用于法语整理的SECONDARY权重方向。
`void`	`setFrenchCollationDefault()` 在构建RuleBasedCollator期间，将法语归类模式设置为初始模式。
`void`	`setLowerCaseFirst(boolean lowerfirst)` 设置小写字母的顺序，以便在大写字母之前排序，强度为TERTIARY。
`RuleBasedCollator`	`setMaxVariable(int group)` [icu]将变量top设置为指定重排序组的顶部。
`void`	`setNumericCollation(boolean flag)` [icu]打开数字排序规则时，此Collator根据数字值对数字进行排序。
`void`	`setNumericCollationDefault()` 将数字排序规则设置为其默认值的方法。
`void`	`setReorderCodes(int... order)` 设置该整理器的重新排序代码。
`void`	`setStrength(int newStrength)` 设置此Collator的强度属性。
`void`	`setStrengthDefault()` 将排序强度设置为在构建RuleBasedCollator期间设置的初始模式。
`void`	`setUpperCaseFirst(boolean upperfirst)` 设置大写字符是否在小写字符之前进行排序，反之亦然，强度为TERTIARY。

Inherited methods

From class android.icu.text.Collator

`Object`	`clone()` 克隆整理器。
`Collator`	`cloneAsThawed()` 提供克隆操作。
`int`	`compare(Object source, Object target)` 将源对象与目标对象进行比较。
`abstract int`	`compare(String source, String target)` 根据此Collator的规则，强度和分解模式将源文本字符串与目标文本字符串进行比较。
`boolean`	`equals(String source, String target)` 使用此Collator的规则，强度和分解模式比较两个文本字符串的相等性。
`boolean`	`equals(Object obj)` 比较两个Collator对象的相等性。
`Collator`	`freeze()` 冻结整理者。
`static Locale[]`	`getAvailableLocales()` 返回安装了collators的语言环境集合，作为Locale对象。
`static final ULocale[]`	`getAvailableULocales()` [icu]返回安装了collators的语言环境集合，如ULocale对象。
`abstract CollationKey`	`getCollationKey(String source)` 将字符串转换为适用于高效重复比较的整理键。
`int`	`getDecomposition()` 返回此Collator的分解模式。
`static String`	`getDisplayName(Locale objectLocale, Locale displayLocale)` [icu]返回objectLocale的collator的名称，已针对displayLocale进行了本地化。
`static String`	`getDisplayName(ULocale objectLocale)` [icu]返回objectLocale的collator的名称，本地化为默认的 `DISPLAY`语言环境。
`static String`	`getDisplayName(ULocale objectLocale, ULocale displayLocale)` [icu]返回objectLocale的collator的名称，已针对displayLocale进行了本地化。
`static String`	`getDisplayName(Locale objectLocale)` [icu]返回objectLocale的collator的名称，本地化为默认的 `DISPLAY`语言环境。
`static int[]`	`getEquivalentReorderCodes(int reorderCode)` 检索与给定的重新订购代码分组的所有重新订购代码。
`static final ULocale`	`getFunctionalEquivalent(String keyword, ULocale locID)` [icu]针对整理服务，针对给定的请求语言环境返回相对于给定关键字的功能上等效的语言环境。
`static final ULocale`	`getFunctionalEquivalent(String keyword, ULocale locID, boolean[] isAvailable)` [icu]针对整理服务，针对给定的请求语言环境返回相对于给定关键字的功能上等效的语言环境。
`static final Collator`	`getInstance()` 返回当前默认语言环境的Collator。
`static final Collator`	`getInstance(Locale locale)` 返回所需语言环境的Collator。
`static final Collator`	`getInstance(ULocale locale)` [icu]返回所需语言环境的Collator。
`static final String[]`	`getKeywordValues(String keyword)` [icu]给定关键字，返回当前正在使用的关键字的所有值的数组。
`static final String[]`	`getKeywordValuesForLocale(String key, ULocale locale, boolean commonlyUsed)` [icu]给定一个键和一个语言环境，以一个首选顺序返回一个字符串值数组，它会产生变化。
`static final String[]`	`getKeywords()` [icu]返回与整理相关的所有可能关键字的数组。
`int`	`getMaxVariable()` [icu]返回字符受备用处理行为影响的最大重新排序组。
`int[]`	`getReorderCodes()` 检索该整理器的重新排序代码。
`int`	`getStrength()` 返回此Collator的强度属性。
`UnicodeSet`	`getTailoredSet()` [icu]返回一个UnicodeSet，其中包含在该调整器中定制的所有字符和序列。
`abstract VersionInfo`	`getUCAVersion()` [icu]返回此collator对象的UCA版本。
`abstract int`	`getVariableTop()` [icu]获取Collator的变量top值。
`abstract VersionInfo`	`getVersion()` [icu]返回此collator对象的版本。
`boolean`	`isFrozen()` 确定对象是否被冻结。
`void`	`setDecomposition(int decomposition)` 设置此Collator的分解模式。
`Collator`	`setMaxVariable(int group)` [icu]将变量top设置为指定重排序组的顶部。
`void`	`setReorderCodes(int... order)` 设置该整理器的重新排序代码。
`void`	`setStrength(int newStrength)` 设置此Collator的强度属性。

From class java.lang.Object

From interface java.util.Comparator

`abstract int`	`compare(Object o1, Object o2)` 比较它的两个命令。
`static <T, U> Comparator<Object>`	`comparing(Function<? super T, ? extends U> keyExtractor, Comparator<? super U> keyComparator)` 接受从类型 `T`中提取排序键的 `T` ，并返回 `Comparator<T>` ，该排序键通过使用指定的 `Comparator`排序键进行比较。
`static <T, U extends Comparable<? super U>> Comparator<Object>`	`comparing(Function<? super T, ? extends U> keyExtractor)` 接受从 `Comparable`类型中提取 `Comparable`排序键的 `T` ，并返回 `Comparator<T>` ，该排序键用该排序键进行比较。
`static <T> Comparator<Object>`	`comparingDouble(ToDoubleFunction<? super T> keyExtractor)` 接受从 `double`类型中提取 `double`排序键的 `T` ，并返回 `Comparator<T>` ，该排序键通过该排序键进行比较。
`static <T> Comparator<Object>`	`comparingInt(ToIntFunction<? super T> keyExtractor)` 接受从类型 `T`中提取 `int`排序键的 `T` ，并返回一个 `Comparator<T>` ，该排序键用该排序键进行比较。
`static <T> Comparator<Object>`	`comparingLong(ToLongFunction<? super T> keyExtractor)` 接受从 `long`类型中提取 `long`排序键的 `T` ，并返回 `Comparator<T>` ，该排序键通过该排序键进行比较。
`abstract boolean`	`equals(Object obj)` 指示某个其他对象是否“等于”此比较器。
`static <T extends Comparable<? super T>> Comparator<T>`	`naturalOrder()` 返回比较器，以自然顺序比较 `Comparable`对象。
`static <T> Comparator<Object>`	`nullsFirst(Comparator<? super T> comparator)` 返回一个空值友好的比较器， `null`视为小于非空值。
`static <T> Comparator<Object>`	`nullsLast(Comparator<? super T> comparator)` 返回一个空值友好的比较器， `null`视为大于非空值。
`static <T extends Comparable<? super T>> Comparator<T>`	`reverseOrder()` 返回一个强制自然顺序反转的比较器。
`default Comparator<Object>`	`reversed()` 返回一个比较器，强制该比较器的反向排序。
`default <U extends Comparable<? super U>> Comparator<Object>`	`thenComparing(Function<? super T, ? extends U> keyExtractor)` 返回具有提取 `Comparable`排序键的函数的字典顺序比较器。
`default <U> Comparator<Object>`	`thenComparing(Function<? super T, ? extends U> keyExtractor, Comparator<? super U> keyComparator)` 返回一个字典顺序比较器，其中包含一个提取与给定的 `Comparator`进行比较的密钥的函数。
`default Comparator<Object>`	`thenComparing(Comparator<? super T> other)` 用另一个比较器返回词典顺序比较器。
`default Comparator<Object>`	`thenComparingDouble(ToDoubleFunction<? super T> keyExtractor)` 使用提取 `double`排序键的函数返回字典顺序比较器。
`default Comparator<Object>`	`thenComparingInt(ToIntFunction<? super T> keyExtractor)` 返回一个字典顺序比较器，其中包含一个提取 `int`排序键的函数。
`default Comparator<Object>`	`thenComparingLong(ToLongFunction<? super T> keyExtractor)` 使用提取 `long`排序键的函数返回字典顺序比较器。

From interface android.icu.util.Freezable

Public constructors

RuleBasedCollator

Added in API level 24

RuleBasedCollator (String rules)

构造函数接受自定义的参数规则。整理器将基于CLDR根整理，以及参数规则中指定的字符的属性和重新排序。

有关规则语法的详细信息，请参阅用户指南的 Collation Customization部分。

Parameters
`rules`	`String`: the collation rules to build the collation table from.

Throws
`ParseException`	and IOException thrown. ParseException thrown when argument rules have an invalid syntax. IOException thrown when an error occurred while reading internal data.
`异常`

Public methods

clone

Added in API level 24

Object clone ()

克隆RuleBasedCollator

Returns
`Object`	a new instance of this RuleBasedCollator object

Throws
`CloneNotSupportedException`

cloneAsThawed

Added in API level 24

RuleBasedCollator cloneAsThawed ()

提供克隆操作。任何克隆都是最初解冻的。

Returns
`RuleBasedCollator`

compare

Added in API level 24

int compare (String source, 
                String target)

根据RuleBasedCollator的排序规则，强度和分解模式，将源文本字符串与目标文本字符串进行比较。根据源字符串是否小于，等于或大于目标字符串，返回小于，等于或大于零的整数。有关使用示例，请参阅Collator类描述。

一般建议：
如果要对相同的字符串进行多次比较，为字符串生成CollationKeys并使用CollationKey.compareTo（CollationKey）进行比较会更有效。如果速度性能非常关键并且要减少对象实例化，则可以通过生成RawCollationKey形式的更简单的键并将此RawCollationKey对象与方法RuleBasedCollator.getRawCollationKey重用来实现进一步的优化。内部字节表示可以通过RawCollationKey直接访问并存储以供将来使用。与CollationKey类似，RawCollationKey为关键比较提供了一种方法RawCollationKey.compareTo。如果每个字符串仅比较一次，则使用方法RuleBasedCollator.compare（String，String）将会有更好的性能。

Parameters
`source`	`String`: the source text String.
`target`	`String`: the target text String.

Returns
`int`	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.

也可以看看：

equals

Added in API level 24

boolean equals (Object obj)

比较两个Collator对象的相等性。如果Collator对象具有相同的排序（排序和搜索）行为，则它们是相等的。

基类检查null和相等类型。子类应该重写。

Parameters
`obj`	`Object`: the Collator to compare to.

Returns
`boolean`	true if this Collator has exactly the same collation behavior as obj, false otherwise.

freeze

Added in API level 24

Collator freeze ()

冻结整理者。

Returns
`Collator`	the collator itself.

getCollationElementIterator

Added in API level 24

CollationElementIterator getCollationElementIterator (UCharacterIterator source)

为给定的UCharacterIterator返回一个CollationElementIterator。源迭代器的完整性将被保留，因为将创建一个新副本供使用。

Parameters
`source`	`UCharacterIterator`

Returns
`CollationElementIterator`

也可以看看：

CollationElementIterator

getCollationElementIterator

Added in API level 24

CollationElementIterator getCollationElementIterator (String source)

为给定的字符串返回一个CollationElementIterator。

Parameters
`source`	`String`

Returns
`CollationElementIterator`

也可以看看：

CollationElementIterator

getCollationElementIterator

Added in API level 24

CollationElementIterator getCollationElementIterator (CharacterIterator source)

为给定的CharacterIterator返回一个CollationElementIterator。源迭代器的完整性将被保留，因为将创建一个新副本供使用。

Parameters
`source`	`CharacterIterator`

Returns
`CollationElementIterator`

也可以看看：

CollationElementIterator

getCollationKey

Added in API level 24

CollationKey getCollationKey (String source)

从此RuleBasedCollator获取参数字符串源的整理键。

一般建议：
如果要对相同的字符串进行多次比较，为字符串生成CollationKeys并使用CollationKey.compareTo（CollationKey）进行比较会更有效。如果每个字符串仅比较一次，则使用方法RuleBasedCollator.compare（String，String）将会有更好的性能。

请参阅类文档以获取有关CollationKeys的说明。

Parameters
`source`	`String`: the text String to be transformed into a collation key.

Returns
`CollationKey`	the CollationKey for the given String based on this RuleBasedCollator's collation rules. If the source String is null, a null CollationKey is returned.

也可以看看：

getContractionsAndExpansions

Added in API level 24

void getContractionsAndExpansions (UnicodeSet contractions, 
                UnicodeSet expansions, 
                boolean addPrefixes)

获取包含缩放和/或扩展的整理器的unicode集

Parameters
`contractions`	`UnicodeSet`: if not null, set to contain contractions
`expansions`	`UnicodeSet`: if not null, set to contain expansions
`addPrefixes`	`boolean`: add the prefix contextual elements to contractions

Throws
`异常`	Throws an exception if any errors occurs.

getDecomposition

Added in API level 24

int getDecomposition ()

返回此Collator的分解模式。分解模式决定如何处理由Unicode组成的字符。

有关更多详细信息，请参阅Collator类描述。

Returns
`int`	the decomposition mode

也可以看看：

getMaxVariable

Added in API level 24

int getMaxVariable ()

[icu]返回字符受备用处理行为影响的最大重新排序组。

Returns
`int`	the maximum variable reordering group.

也可以看看：

setMaxVariable(int)

getNumericCollation

Added in API level 24

boolean getNumericCollation ()

检索数字排序规则值的方法。打开数字排序规则时，此分档器会为数字子字符串的数值生成排序规则关键字。这是一种让'100'在AFTER'2'后分类的方法

Returns
`boolean`	true if numeric collation is turned on, false otherwise

也可以看看：

getReorderCodes

Added in API level 24

int[] getReorderCodes ()

检索该整理器的重新排序代码。这些重新排序的代码是UScript代码和ReorderCodes的组合。

Returns
`int[]`	a copy of the reordering codes for this collator; if none are set then returns an empty array

也可以看看：

getRules

Added in API level 24

String getRules ()

获取此RuleBasedCollator的归类裁剪规则。等同于String getRules（false）。

Returns
`String`	the collation tailoring rules

也可以看看：

getRules(boolean)

getRules

Added in API level 24

String getRules (boolean fullrules)

返回当前规则。参数定义是否返回完整规则（根整理+定制）规则或仅裁剪。

根整理规则是根整理器排序顺序的近似值 。它们几乎从不在运行时使用或有用，并且可以从数据中删除。见User Guide: Collation Customization, Building on Existing Locales

通常应该使用 getRules() 。

Parameters
`fullrules`	`boolean`: true if the rules that defines the full set of collation order is required, otherwise false for returning only the tailored rules

Returns
`String`	the current rules that defines this Collator.

也可以看看：

getRules()

getStrength

Added in API level 24

int getStrength ()

返回此Collator的强度属性。强度属性决定了认为重要的最小差异水平。

[icu]注意：这可以返回QUERERNARY的强度，这是JDK版本不支持的。

有关更多详细信息，请参阅Collator类描述。

Returns
`int`	this Collator's current strength attribute.

也可以看看：

getTailoredSet

Added in API level 24

UnicodeSet getTailoredSet ()

获取一个UnicodeSet，其中包含在该配页器中定制的所有字符和序列。

Returns
`UnicodeSet`	a pointer to a UnicodeSet object containing all the code points and sequences that may sort differently than in the root collator.

getUCAVersion

Added in API level 24

VersionInfo getUCAVersion ()

获取该collator对象的UCA版本。

Returns
`VersionInfo`	the version object associated with this collator

getVariableTop

Added in API level 24

int getVariableTop ()

[icu]获取Collator的变量top值。

Returns
`int`	the variable top primary weight

也可以看看：

getMaxVariable()

getVersion

Added in API level 24

VersionInfo getVersion ()

获取这个collator对象的版本。

Returns
`VersionInfo`	the version object associated with this collator

hashCode

Added in API level 24

int hashCode ()

为此RuleBasedCollator生成唯一的哈希码。

Returns
`int`	the unique hash code for this Collator

isAlternateHandlingShifted

Added in API level 24

boolean isAlternateHandlingShifted ()

检查备用处理行为是否为UCA定义的SHIFTED或NON_IGNORABLE。如果返回值为true，则Collator的备用处理属性为SHIFTED。否则，如果返回值为false，则Collator的备用处理属性为NON_IGNORABLE有关更多详细信息，请参阅setAlternateHandlingShifted（boolean）。

Returns
`boolean`	true or false

也可以看看：

isCaseLevel

Added in API level 24

boolean isCaseLevel ()

检查案例级别是否设置为true。有关详细信息，请参阅setCaseLevel（布尔值）。

Returns
`boolean`	the case level mode

也可以看看：

isFrenchCollation

Added in API level 24

boolean isFrenchCollation ()

检查法语归类是否设置为true。有关详细信息，请参阅setFrenchCollation（布尔值）。

Returns
`boolean`	true if French Collation is set to true, false otherwise

也可以看看：

isFrozen

Added in API level 24

boolean isFrozen ()

确定对象是否被冻结。

解冻的Collator是可变的，不是线程安全的。冻结的Collator是不可变的并且是线程安全的。

Returns
`boolean`

isLowerCaseFirst

Added in API level 24

boolean isLowerCaseFirst ()

如果小写字符在相应的大写字符之前排序，则返回true。有关详细信息，请参阅setCaseFirst（boolean）。

Returns
`boolean`	true lower cased characters are sorted before upper cased characters, false otherwise

也可以看看：

isUpperCaseFirst

Added in API level 24

boolean isUpperCaseFirst ()

如果大写字符在相应的小写字符之前排序，则返回true。有关详细信息，请参阅setCaseFirst（boolean）。

Returns
`boolean`	true if upper cased characters are sorted before lower cased characters, false otherwise

也可以看看：

setAlternateHandlingDefault

Added in API level 24

void setAlternateHandlingDefault ()

在构建RuleBasedCollator期间，将备用处理模式设置为初始模式。有关更多详细信息，请参阅setAlternateHandling（boolean）。

也可以看看：

setAlternateHandlingShifted

Added in API level 24

void setAlternateHandlingShifted (boolean shifted)

将QUATERNARY强度的替代处理设置为移位或不可忽略。请参阅Variable Weighting上的UCA定义。此属性仅在设置QUATERNARY强度时有效。此模式的默认值为false，对应于UCA中的NON_IGNORABLE模式。在NON_IGNORABLE模式下，RuleBasedCollator以相同的方式使用不可忽略的主权重处理所有代码点。如果模式设置为true，则行为与UCA中定义的SHIFTED相对应，这会导致PRIMARY顺序等于或低于变量顶部值的代码点在PRIMARY顺序中被忽略并移至QUATERNARY顺序。

Parameters
`shifted`	`boolean`: true if SHIFTED behavior for alternate handling is desired, false for the NON_IGNORABLE behavior.

也可以看看：

setCaseFirstDefault

Added in API level 24

void setCaseFirstDefault ()

将案例优先模式设置为在构建RuleBasedCollator期间设置的初始模式。有关更多详细信息，请参阅setUpperCaseFirst（boolean）和setLowerCaseFirst（boolean）。

也可以看看：

setCaseLevel

Added in API level 24

void setCaseLevel (boolean flag)

当案例级别设置为真时，在SECONDARY和TERTIARY权重之间形成额外的权重，称为案例级别。案例级别用于区分大小日本假名字符。案例级别也可以用于其他情况。例如区分某些拼音字符。默认值为false，这意味着不会生成大小写级别。案例级别的内容受案例第一模式的影响。忽略字符串中重音差异的一种简单方法是将强度设置为PRIMARY并启用大小写级别。

有关更多信息，请参阅 case level部分。

Parameters
`flag`	`boolean`: true if case level sorting is required, false otherwise

也可以看看：

setCaseLevelDefault()
isCaseLevel()

setCaseLevelDefault

Added in API level 24

void setCaseLevelDefault ()

将案例级别模式设置为在构建RuleBasedCollator期间设置的初始模式。有关更多详细信息，请参阅setCaseLevel（boolean）。

也可以看看：

setCaseLevel(boolean)
isCaseLevel()

setDecomposition

Added in API level 24

void setDecomposition (int decomposition)

设置此Collator的分解模式。通过使用CANONICAL_DECOMPOSITION设置此分解属性，Collator可以正确处理未标准化的文本，产生与文本标准化相同的结果。如果设置了NO_DECOMPOSITION，则用户有责任确保所有文本在比较前或获取CollationKey之前已经处于适当的形式。调整分解模式允许用户选择更快和更完整的整理行为。

由于许多世界语言不需要文本标准化，因此大多数语言环境都将NO_DECOMPOSITION设置为默认分解模式。 Collator的默认分解模式是NO_DECOMPOSITON，除非用于创建Collator的语言环境另有指定。

有关分解模式的描述，请参阅getDecomposition。

Parameters
`decomposition`	`int`: the new decomposition mode

Throws
`IllegalArgumentException`	If the given value is not a valid decomposition mode.

也可以看看：

setDecompositionDefault

Added in API level 24

void setDecompositionDefault ()

将分解模式设置为在构建RuleBasedCollator期间设置的初始模式。有关更多详细信息，请参阅setDecomposition（int）。

也可以看看：

setFrenchCollation

Added in API level 24

void setFrenchCollation (boolean flag)

设置用于法语整理的SECONDARY权重方向。默认值为false，按照它们出现的顺序处理SECONDARY权重。如果设置为true，SECONDARY权重将向后排序。有关更多信息，请参阅French collation部分。

Parameters
`flag`	`boolean`: true to set the French collation on, false to set it off

也可以看看：

setFrenchCollationDefault

Added in API level 24

void setFrenchCollationDefault ()

在构建RuleBasedCollator期间，将法语归类模式设置为初始模式。有关更多详细信息，请参阅setFrenchCollation（boolean）。

也可以看看：

setLowerCaseFirst

Added in API level 24

void setLowerCaseFirst (boolean lowerfirst)

设置小写字母的顺序，以便在大写字母之前排序，强度为TERTIARY。默认模式为false。如果设置为true，那么RuleBasedCollator将在较低的字符之前对较低的字符进行排序。否则，如果设置为false，则RuleBasedCollator将忽略大小写首选项。

Parameters
`lowerfirst`	`boolean`: true for sorting lower cased characters before upper cased characters, false to ignore case preferences.

也可以看看：

setMaxVariable

Added in API level 24

RuleBasedCollator setMaxVariable (int group)

[icu]将变量top设置为指定重排序组的顶部。变量top决定了受备用处理行为影响的最高排序字符。如果该属性设置为NON_IGNORABLE，那么变量top不起作用。

Parameters
`group`	`int`: 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
`RuleBasedCollator`	this

也可以看看：

getMaxVariable()

setNumericCollation

Added in API level 24

void setNumericCollation (boolean flag)

[icu]打开数字排序规则时，此Collator根据数字值对数字进行排序。

这是一种让'100'在AFTER'2'后分类的方法。请注意，可以作为单个单位处理的最长数字子字符串是254位数（不包括前导零）。如果数字子字符串长于该数字，超出限制的数字将被视为单独的数字子字符串。

在这个意义上的“数字”是具有General_Category = Nd的代码点，其不包括带圈的数字，罗马数字等。仅考虑连续的数字子字符串，即不带分隔符的非负数整数。不支持加号/减号，小数点，指数等。

Parameters
`flag`	`boolean`: true to turn numeric collation on and false to turn it off

也可以看看：

setNumericCollationDefault

Added in API level 24

void setNumericCollationDefault ()

将数字排序规则设置为其默认值的方法。

也可以看看：

setReorderCodes

Added in API level 24

void setReorderCodes (int... order)

设置该整理器的重新排序代码。排序重新排序允许脚本和其他一组字符相对于彼此移动。这种重新排序是在DUCET / CLDR标准整理顺序的基础上完成的。重新排序可以指定要放置在排序顺序的开始和/或结束处的组。这些组使用UScript代码和Collator.ReorderCodes条目进行指定。

默认情况下，重新排序为订单开始指定的代码按照几个特殊的非脚本块之后的顺序排列。这些特殊的字符组是空格，标点符号，货币和数字。这些特殊群体以Collator.ReorderCodes条目表示。如果在重新排序中明确指定了这些特殊组，则脚本组可以与这些特殊的非脚本组混合。

特殊代码OTHERS表示在给定的重排序代码列表中未明确提及的任何脚本。任何在OTHERS之后的事情都会按照给定的顺序进行重新排序。

特殊重排序代码DEFAULT将重新排列该配页器的重新排序为该配页器的默认值。默认的重新排序可能是DUCET / CLDR顺序，或者可能是根据资源数据或规则创建此配页器时指定的重新排序。 DEFAULT代码必须是使用它时提供的唯一代码。如果不是，则会抛出IllegalArgumentException 。

特殊订货代码NONE将删除该整理器的任何重新订购。设置不重新排序的结果将是使用DUCET / CLDR排序。 NONE代码必须是使用它时提供的唯一代码。

Parameters
`order`	`int`: the reordering codes to apply to this collator; if this is null or an empty array then this clears any existing reordering

Throws
`IllegalArgumentException`	if the reordering codes are malformed in any way (e.g. duplicates, multiple reset codes, overlapping equivalent scripts)

也可以看看：

setStrength

Added in API level 24

void setStrength (int newStrength)

设置此Collator的强度属性。强度属性决定了比较过程中认为重要的最小差异水平。

有关使用示例，请参阅Collator类描述。

Parameters
`newStrength`	`int`: the new strength value.

Throws
`IllegalArgumentException`	If the new strength value is not one of PRIMARY, SECONDARY, TERTIARY, QUATERNARY or IDENTICAL.

也可以看看：

setStrengthDefault

Added in API level 24

void setStrengthDefault ()

将排序强度设置为在构建RuleBasedCollator期间设置的初始模式。有关更多详细信息，请参阅setStrength（int）。

也可以看看：

setStrength(int)
getStrength()

setUpperCaseFirst

Added in API level 24

void setUpperCaseFirst (boolean upperfirst)

设置大写字符是否在小写字符之前进行排序，反之亦然，强度为TERTIARY。默认模式为false，所以小写字符在大写字符之前排序。如果为true，则首先对大写字符进行排序。

Parameters
`upperfirst`	`boolean`: true to sort uppercase characters before lowercase characters, false to sort lowercase characters before uppercase characters

也可以看看：