Most visited

Recently visited

Results for

Added in API level 1

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

RuleBasedCollator

public class RuleBasedCollator
extends Collator

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

RuleBasedCollator类是RuleBasedCollator的一个具体子类，它提供了一个简单的数据驱动的表Collator器。通过这个课程，您可以创建一个基于表格的定制Collator 。 RuleBasedCollator映射字符以排序键。

RuleBasedCollator对效率有以下限制（其他子类可用于更复杂的语言）：

If a special collation rule controlled by a <modifier> is specified it applies to the whole collator object.
All non-mentioned characters are at the end of the collation order.

整理表由整理规则列表组成，其中每个规则是以下三种形式之一：

    <modifier>
    <relation> <text-argument>
    <reset> <text-argument>

The definitions of the rule elements is as follows:

Text-Argument: A text-argument is any sequence of characters, excluding special characters (that is, common whitespace characters [0009-000D, 0020] and rule syntax characters [0021-002F, 003A-0040, 005B-0060, 007B-007E]). If those characters are desired, you can put them in single quotes (e.g. ampersand => '&'). Note that unquoted white space characters are ignored; e.g. b c is treated as bc.
Modifier: There are currently two modifiers that turn on special collation rules.
- '@' : Turns on backwards sorting of accents (secondary differences), as in French.
- '!' : 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.
'@'：表示重音符号向后排列，如法语。
Relation: The relations are the following:
- '<' : Greater, as a letter difference (primary)
- ';' : Greater, as an accent difference (secondary)
- ',' : Greater, as a case difference (tertiary)
- '=' : Equal
Reset: There is a single reset which is used primarily for contractions and expansions, but which can also be used to add a modification at the end of a set of rules.
'＆'：表示下一条规则跟随重置文本参数排序的位置。

这听起来比实践中更复杂。例如，以下是表达同一事物的等效方式：

 a < b < c
 a < b & b < c
 a < c & a < b

Notice that the order is important, as the subsequent item goes immediately after the text-argument. The following are not equivalent:

 a < b & a < c
 a < c & a < b

Either the text-argument must already be present in the sequence, or some initial substring of the text-argument must be present. (e.g. "a < b & ae < e" is valid since "a" is present in the sequence before "ae" is reset). In this latter case, "ae" is not entered and treated as a single character; instead, "e" is sorted as if it were expanded to two characters: "a" followed by an "e". This difference appears in natural languages: in traditional Spanish "ch" is treated as though it contracts to a single character (expressed as "c < ch < d"), while in traditional German a-umlaut is treated as though it expanded to two characters (expressed as "a,A < b,B ... &ae;\u00e3&AE;\u00c3"). [\u00e3 and \u00c3 are, of course, the escape sequences for a-umlaut.]

可忽略的字符

对于可忽略的字符，第一条规则必须以关系开始（我们上面使用的例子实际上是片段;“a <b”实际上应该是“<a <b”）。但是，如果第一个关系不是“<”，那么直到第一个“<”的所有文本参数都是可以忽略的。例如，“， - <a <b”使“ - ”成为一个可以忽略的字符，正如我们前面在“黑鸟”一词中所看到的那样。在不同语言的样本中，您会发现大部分口音都是可以忽略的。

规范化和口音

RuleBasedCollator自动处理其规则表，以包括重音字符的预先组合字符和组合字符版本。即使提供的规则字符串只包含基本字符和单独的组合重音字符，预先组合的重音符号也会在表中与规则字符串中的所有规范组合字符匹配。

这允许您使用RuleBasedCollator来比较重音字符串，即使在collator设置为NO_DECOMPOSITION时也是如此。但是有两个警告。首先，如果要整理的字符串包含可能不是规范顺序的组合序列，则应该将整理器设置为CANONICAL_DECOMPOSITION或FULL_DECOMPOSITION以启用组合序列的排序。其次，如果字符串包含具有兼容性分解的字符（例如全角和半角表单），则必须使用FULL_DECOMPOSITION，因为规则表仅包含规范映射。

错误

以下是错误：

A text-argument contains unquoted punctuation symbols (e.g. "a < b-c < d").
A relation or reset character not followed by a text-argument (e.g. "a < ,b").
A reset where the text-argument (or an initial substring of the text-argument) is not already in the sequence. (e.g. "a < b & e < f")

If you produce one of these errors, a RuleBasedCollator throws a ParseException.

例子

简单：“<a <b <c <d”

挪威语：“<a，A <b，B <c，C <d，D <e，E <f，F <g，G <h，H <i， L <m，M <n，N <0，O <p，P <q，Q <r，R <s，S <t，T <u，U <v， y，y <z，z <\ u00E6，\ u00C6 <\ u00F8，\ u00D8 <\ u00E5 = a \ u003A，\ u00C5 = A \ u30A; aa，AA“

要创建一个RuleBasedCollator有适合您的需要的专门规则对象，在构造RuleBasedCollator与包含在规则String对象。例如：

 String simple = "< a< b< c< d";
 RuleBasedCollator mySimple = new RuleBasedCollator(simple);

Or:

 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" +
                    "< \u00E6, \u00C6" +     // Latin letter ae & AE
                    "< \u00F8, \u00D8" +     // Latin letter o & O with stroke
                    "< \u00E5 = a\u030A," +  // Latin letter a with ring above
                    "  \u00C5 = A\u030A;" +  // Latin letter A with ring above
                    "  aa, AA";
 RuleBasedCollator myNorwegian = new RuleBasedCollator(Norwegian);

可以通过连接规则字符串来创建新的整理规则字符串。例如，由getRules()返回的规则可以连接在一起以组合多个RuleBasedCollator 。

以下示例演示如何更改非间距重音的顺序，

 // old rule
 String oldRules = "=\u0301;\u0300;\u0302;\u0308"    // main accents
                 + ";\u0327;\u0303;\u0304;\u0305"    // main accents
                 + ";\u0306;\u0307;\u0309;\u030A"    // main accents
                 + ";\u030B;\u030C;\u030D;\u030E"    // main accents
                 + ";\u030F;\u0310;\u0311;\u0312"    // main accents
                 + "< 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);

也可以看看：

Collator
CollationElementIterator

Summary

Inherited constants

From class java.text.Collator

Public constructors
`RuleBasedCollator(String rules)` RuleBasedCollator构造函数。

Public methods
`Object`	`clone()` 标准覆盖; 语义没有变化。
`int`	`compare(String source, String target)` 根据排序规则比较存储在两个不同字符串中的字符数据。
`boolean`	`equals(Object obj)` 比较两个排序对象的相等性。
`CollationElementIterator`	`getCollationElementIterator(String source)` 为给定的字符串返回一个CollationElementIterator。
`CollationElementIterator`	`getCollationElementIterator(CharacterIterator source)` 为给定的字符串返回一个CollationElementIterator。
`CollationKey`	`getCollationKey(String source)` 将字符串转换为一系列可与CollationKey.compareTo进行比较的字符。
`String`	`getRules()` 获取排序规则对象的基于表格的规则。
`int`	`hashCode()` 为基于表格的排序规则对象生成散列码

Inherited methods

From class java.text.Collator

`Object`	`clone()` 返回一个具有与此collator相同分解模式和强度值的新整理器。
`int`	`compare(Object o1, Object o2)` 比较它的两个命令。
`abstract int`	`compare(String source, String target)` 根据此Collator的归类规则将源字符串与目标字符串进行比较。
`boolean`	`equals(String source, String target)` 基于此Collator排序规则比较两个字符串相等的便捷方法。
`boolean`	`equals(Object that)` 比较两名校友的平等。
`static Locale[]`	`getAvailableLocales()` 返回 `getInstance`方法可返回本地化实例的所有语言环境的数组。
`abstract CollationKey`	`getCollationKey(String source)` 将字符串转换为一系列可以按位与其他CollationKeys进行比较的位。
`int`	`getDecomposition()` 获取此Collator的分解模式。
`static Collator`	`getInstance()` 获取当前默认语言环境的Collator。
`static Collator`	`getInstance(Locale desiredLocale)` 获取所需语言环境的Collator。
`int`	`getStrength()` 返回此Collator的强度属性。
`abstract int`	`hashCode()` 为此Collator生成哈希码。
`void`	`setDecomposition(int decompositionMode)` 设置此Collator的分解模式。
`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)` 接受从 `int`类型中提取 `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`进行比较的 `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`排序键的函数返回字典顺序比较器。

Public constructors