Save This Page
Home » openjdk-7 » java » text » [javadoc | source]
java.text
public class: RuleBasedCollator [javadoc | source]
java.lang.Object
   java.text.Collator
      java.text.RuleBasedCollator

All Implemented Interfaces:
    Cloneable, Comparator

The RuleBasedCollator class is a concrete subclass of Collator that provides a simple, data-driven, table collator. With this class you can create a customized table-based Collator. RuleBasedCollator maps characters to sort keys.

RuleBasedCollator has the following restrictions for efficiency (other subclasses may be used for more complex languages) :

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

The collation table is composed of a list of collation rules, where each rule is of one of three forms:

   <modifier>
   <relation> <text-argument>
   <reset> <text-argument>
The definitions of the rule elements is as follows:

This sounds more complicated than it is in practice. For example, the following are equivalent ways of expressing the same thing:

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.]

Ignorable Characters

For ignorable characters, the first rule must start with a relation (the examples we have used above are really fragments; "a < b" really should be "< a < b"). If, however, the first relation is not "<", then all the all text-arguments up to the first "<" are ignorable. For example, ", - < a < b" makes "-" an ignorable character, as we saw earlier in the word "black-birds". In the samples for different languages, you see that most accents are ignorable.

Normalization and Accents

RuleBasedCollator automatically processes its rule table to include both pre-composed and combining-character versions of accented characters. Even if the provided rule string contains only base characters and separate combining accent characters, the pre-composed accented characters matching all canonical combinations of characters from the rule string will be entered in the table.

This allows you to use a RuleBasedCollator to compare accented strings even when the collator is set to NO_DECOMPOSITION. There are two caveats, however. First, if the strings to be collated contain combining sequences that may not be in canonical order, you should set the collator to CANONICAL_DECOMPOSITION or FULL_DECOMPOSITION to enable sorting of combining sequences. Second, if the strings contain characters with compatibility decompositions (such as full-width and half-width forms), you must use FULL_DECOMPOSITION, since the rule tables only include canonical mappings.

Errors

The following are errors:

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

Examples

Simple: "< a < b < c < d"

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 < \u00F8, \u00D8 < \u00E5 = a\u030A, \u00C5 = A\u030A; aa, AA"

To create a RuleBasedCollator object with specialized rules tailored to your needs, you construct the RuleBasedCollator with the rules contained in a String object. For example:

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);

A new collation rules string can be created by concatenating rules strings. For example, the rules returned by #getRules() could be concatenated to combine multiple RuleBasedCollators.

The following example demonstrates how to change the order of non-spacing accents,

// 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);
Field Summary
static final  int CHARINDEX     
static final  int EXPANDCHARINDEX     
static final  int CONTRACTCHARINDEX     
static final  int UNMAPPED     
Fields inherited from java.text.Collator:
PRIMARY,  SECONDARY,  TERTIARY,  IDENTICAL,  NO_DECOMPOSITION,  CANONICAL_DECOMPOSITION,  FULL_DECOMPOSITION,  LESS,  EQUAL,  GREATER
Constructor:
 public RuleBasedCollator(String rules) throws ParseException 
    RuleBasedCollator constructor. This takes the table rules and builds a collation table out of them. Please see RuleBasedCollator class description for more details on the collation rule syntax.
    Parameters:
    rules - the collation rules to build the collation table from.
    Throws:
    ParseException - A format exception will be thrown if the build process of the rules fails. For example, build rule "a < ? < d" will cause the constructor to throw the ParseException because the '?' is not quoted.
    Also see:
    java.util.Locale
    exception: ParseException - A format exception will be thrown if the build process of the rules fails. For example, build rule "a < ? < d" will cause the constructor to throw the ParseException because the '?' is not quoted.
 RuleBasedCollator(String rules,
    int decomp) throws ParseException 
    RuleBasedCollator constructor. This takes the table rules and builds a collation table out of them. Please see RuleBasedCollator class description for more details on the collation rule syntax.
    Parameters:
    rules - the collation rules to build the collation table from.
    decomp - the decomposition strength used to build the collation table and to perform comparisons.
    Throws:
    ParseException - A format exception will be thrown if the build process of the rules fails. For example, build rule "a < ? < d" will cause the constructor to throw the ParseException because the '?' is not quoted.
    Also see:
    java.util.Locale
    exception: ParseException - A format exception will be thrown if the build process of the rules fails. For example, build rule "a < ? < d" will cause the constructor to throw the ParseException because the '?' is not quoted.
Method from java.text.RuleBasedCollator Summary:
clone,   compare,   equals,   getCollationElementIterator,   getCollationElementIterator,   getCollationKey,   getRules,   getTables,   hashCode
Methods from java.text.Collator:
clone,   compare,   compare,   equals,   equals,   getAvailableLocales,   getCollationKey,   getDecomposition,   getInstance,   getInstance,   getStrength,   hashCode,   setDecomposition,   setStrength
Methods from java.lang.Object:
clone,   equals,   finalize,   getClass,   hashCode,   notify,   notifyAll,   toString,   wait,   wait,   wait
Method from java.text.RuleBasedCollator Detail:
 public Object clone() 
    Standard override; no change in semantics.
 public synchronized int compare(String source,
    String target) 
    Compares the character data stored in two different strings based on the collation rules. Returns information about whether a string is less than, greater than or equal to another string in a language. This can be overriden in a subclass.
 public boolean equals(Object obj) 
    Compares the equality of two collation objects.
 public CollationElementIterator getCollationElementIterator(String source) 
    Return a CollationElementIterator for the given String.
 public CollationElementIterator getCollationElementIterator(CharacterIterator source) 
    Return a CollationElementIterator for the given String.
 public synchronized CollationKey getCollationKey(String source) 
    Transforms the string into a series of characters that can be compared with CollationKey.compareTo. This overrides java.text.Collator.getCollationKey. It can be overriden in a subclass.
 public String getRules() 
    Gets the table-based rules for the collation object.
 RBCollationTables getTables() 
    Allows CollationElementIterator access to the tables object
 public int hashCode() 
    Generates the hash code for the table-based collation object