Most visited

Recently visited

Results for

Added in API level 24

UnicodeSet

public class UnicodeSet
extends UnicodeFilter implements Iterable<String>, Comparable<UnicodeSet>, Freezable<UnicodeSet>

java.lang.Object
↳	android.icu.text.UnicodeFilter
	↳	android.icu.text.UnicodeSet

A mutable set of Unicode characters and multicharacter strings. Objects of this class represent character classes used in regular expressions. A character specifies a subset of Unicode code points. Legal code points are U+0000 to U+10FFFF, inclusive. Note: method freeze() will not only make the set immutable, but also makes important methods much higher performance: contains(c), containsNone(...), span(...), spanBack(...) etc. After the object is frozen, any subsequent call that wants to change the object will throw UnsupportedOperationException.

The UnicodeSet class is not designed to be subclassed.

UnicodeSet supports two APIs. The first is the operand API that allows the caller to modify the value of a UnicodeSet object. It conforms to Java 2's java.util.Set interface, although UnicodeSet does not actually implement that interface. All methods of Set are supported, with the modification that they take a character range or single character instead of an Object, and they take a UnicodeSet instead of a Collection. The operand API may be thought of in terms of boolean logic: a boolean OR is implemented by add, a boolean AND is implemented by retain, a boolean XOR is implemented by complement taking an argument, and a boolean NOT is implemented by complement with no argument. In terms of traditional set theory function names, add is a union, retain is an intersection, remove is an asymmetric difference, and complement with no argument is a set complement with respect to the superset range MIN_VALUE-MAX_VALUE

The second API is the applyPattern()/toPattern() API from the java.text.Format-derived classes. Unlike the methods that add characters, add categories, and control the logic of the set, the method applyPattern() sets all attributes of a UnicodeSet at once, based on a string pattern.

Pattern syntax

Patterns are accepted by the constructors and the applyPattern() methods and returned by the toPattern() method. These patterns follow a syntax similar to that employed by version 8 regular expression character classes. Here are some simple examples:

[] No characters
[a] The character 'a'
[ae] The characters 'a' and 'e'

[a-e] The characters 'a' through 'e' inclusive, in Unicode code point order

[\\u4E01] The character U+4E01

[a{ab}{ac}] The character 'a' and the multicharacter strings "ab" and "ac"

[\p{Lu}] All characters in the general category Uppercase Letter

Any character may be preceded by a backslash in order to remove any special meaning. White space characters, as defined by the Unicode Pattern_White_Space property, are ignored, unless they are escaped.

Property patterns specify a set of characters having a certain property as defined by the Unicode standard. Both the POSIX-like "[:Lu:]" and the Perl-like syntax "\p{Lu}" are recognized. For a complete list of supported property patterns, see the User's Guide for UnicodeSet at http://www.icu-project.org/userguide/unicodeSet.html. Actual determination of property data is defined by the underlying Unicode database as implemented by UCharacter.

Patterns specify individual characters, ranges of characters, and Unicode property sets. When elements are concatenated, they specify their union. To complement a set, place a '^' immediately after the opening '['. Property patterns are inverted by modifying their delimiters; "[:^foo]" and "\P{foo}". In any other location, '^' has no special meaning.

Ranges are indicated by placing two a '-' between two characters, as in "a-z". This specifies the range of all characters from the left to the right, in Unicode order. If the left character is greater than or equal to the right character it is a syntax error. If a '-' occurs as the first character after the opening '[' or '[^', or if it occurs as the last character before the closing ']', then it is taken as a literal. Thus "[a\\-b]", "[-ab]", and "[ab-]" all indicate the same set of three characters, 'a', 'b', and '-'.

Sets may be intersected using the '&' operator or the asymmetric set difference may be taken using the '-' operator, for example, "[[:L:]&[\\u0000-\\u0FFF]]" indicates the set of all Unicode letters with values less than 4096. Operators ('&' and '|') have equal precedence and bind left-to-right. Thus "[[:L:]-[a-z]-[\\u0100-\\u01FF]]" is equivalent to "[[[:L:]-[a-z]]-[\\u0100-\\u01FF]]". This only really matters for difference; intersection is commutative.

`[a]`	The set containing 'a'
`[a-z]`	The set containing 'a' through 'z' and all letters in between, in Unicode order
`[^a-z]`	The set containing all characters but 'a' through 'z', that is, U+0000 through 'a'-1 and 'z'+1 through U+10FFFF
`[[pat1][pat2]]`	The union of sets specified by pat1 and pat2
`[[pat1]&[pat2]]`	The intersection of sets specified by pat1 and pat2
`[[pat1]-[pat2]]`	The asymmetric difference of sets specified by pat1 and pat2
`[:Lu:] or \p{Lu}`	The set of characters having the specified Unicode property; in this case, Unicode uppercase letters
`[:^Lu:] or \P{Lu}`	The set of characters not having the given Unicode property

Warning: you cannot add an empty string ("") to a UnicodeSet.

Formal syntax

pattern := ('[' '^'? item* ']') | property

item := char | (char '-' char) | pattern-expr

pattern-expr := pattern | pattern-expr pattern | pattern-expr op pattern

op := '&' | '-'

special := '[' | ']' | '-'

char := any character that is notspecial | ('\\'any character) | ('\u' hex hex hex hex)

hex := any character for which Character.digit(c, 16) returns a non-negative result

property := a Unicode property set pattern

Legend:

a := b a may be replaced by b

a? zero or one instance of a

a* one or more instances of a

a | b either a or b

'a' the literal string between the quotes

To iterate over contents of UnicodeSet, the following are available:

ranges() to iterate through the ranges
strings() to iterate through the strings
iterator() to iterate through the entire contents in a single loop. That method is, however, not particularly efficient, since it "boxes" each code point into a String.

All of the above can be used in for loops. The UnicodeSetIterator can also be used, but not in for loops.

To replace, count elements, or delete spans, see UnicodeSetSpanner.

See also:

Summary

Nested classes
`enum`	`UnicodeSet.ComparisonStyle` Comparison style enums used by `compareTo(UnicodeSet, ComparisonStyle)`.
`class`	`UnicodeSet.EntryRange` A struct-like class used for iteration through ranges, for faster iteration than by String.
`enum`	`UnicodeSet.SpanCondition` Argument values for whether span() and similar functions continue while the current character is contained vs.

Constants
`int`	`ADD_CASE_MAPPINGS` Bitmask for constructor, applyPattern(), and closeOver() indicating letter case.
`int`	`CASE` Bitmask for constructor, applyPattern(), and closeOver() indicating letter case.
`int`	`CASE_INSENSITIVE` Alias for UnicodeSet.CASE, for ease of porting from C++ where ICU4C also has both USET_CASE and USET_CASE_INSENSITIVE (see uset.h).
`int`	`IGNORE_SPACE` Bitmask for constructor and applyPattern() indicating that white space should be ignored.
`int`	`MAX_VALUE` Maximum value that can be stored in a UnicodeSet.
`int`	`MIN_VALUE` Minimum value that can be stored in a UnicodeSet.

Inherited constants

From interface


    android.icu.text.UnicodeMatcher

Fields
`public static final UnicodeSet`	`ALL_CODE_POINTS` Constant for the set of all code points.
`public static final UnicodeSet`	`EMPTY` Constant for the empty set.

Public constructors
`UnicodeSet()` Constructs an empty set.
`UnicodeSet(UnicodeSet other)` Constructs a copy of an existing set.
`UnicodeSet(int start, int end)` Constructs a set containing the given range.
`UnicodeSet(int... pairs)` Quickly constructs a set from a set of ranges <s0, e0, s1, e1, s2, e2, ..., sn, en>.
`UnicodeSet(String pattern)` Constructs a set from the given pattern.
`UnicodeSet(String pattern, boolean ignoreWhitespace)` Constructs a set from the given pattern.
`UnicodeSet(String pattern, int options)` Constructs a set from the given pattern.
`UnicodeSet(String pattern, ParsePosition pos, SymbolTable symbols)` Constructs a set from the given pattern.
`UnicodeSet(String pattern, ParsePosition pos, SymbolTable symbols, int options)` Constructs a set from the given pattern.

Public methods
`StringBuffer`	`_generatePattern(StringBuffer result, boolean escapeUnprintable)` Generate and append a string representation of this set to result.
`StringBuffer`	`_generatePattern(StringBuffer result, boolean escapeUnprintable, boolean includeStrings)` Generate and append a string representation of this set to result.
`final UnicodeSet`	`add(int c)` Adds the specified character to this set if it is not already present.
`final UnicodeSet`	`add(CharSequence s)` Adds the specified multicharacter to this set if it is not already present.
`UnicodeSet`	`add(Iterable<?> source)` Add the contents of the collection (as strings) into this UnicodeSet.
`UnicodeSet`	`add(int start, int end)` Adds the specified range to this set if it is not already present.
`<T extends CharSequence> UnicodeSet`	`addAll(T... collection)`
`UnicodeSet`	`addAll(int start, int end)` Adds all characters in range (uses preferred naming convention).
`UnicodeSet`	`addAll(UnicodeSet c)` Adds all of the elements in the specified set to this set if they're not already present.
`final UnicodeSet`	`addAll(CharSequence s)` Adds each of the characters in this string to the set.
`UnicodeSet`	`addAll(Iterable<?> source)` Add a collection (as strings) into this UnicodeSet.
`<T extends Collection<String>> T`	`addAllTo(T target)` Add the contents of the UnicodeSet (as strings) into a collection.
`void`	`addMatchSetTo(UnicodeSet toUnionTo)` Implementation of UnicodeMatcher API.
`UnicodeSet`	`applyIntPropertyValue(int prop, int value)` Modifies this set to contain those code points which have the given value for the given binary or enumerated property, as returned by UCharacter.getIntPropertyValue.
`final UnicodeSet`	`applyPattern(String pattern)` Modifies this set to represent the set specified by the given pattern.
`UnicodeSet`	`applyPattern(String pattern, int options)` Modifies this set to represent the set specified by the given pattern, optionally ignoring whitespace.
`UnicodeSet`	`applyPattern(String pattern, boolean ignoreWhitespace)` Modifies this set to represent the set specified by the given pattern, optionally ignoring whitespace.
`UnicodeSet`	`applyPropertyAlias(String propertyAlias, String valueAlias)` Modifies this set to contain those code points which have the given value for the given property.
`UnicodeSet`	`applyPropertyAlias(String propertyAlias, String valueAlias, SymbolTable symbols)` Modifies this set to contain those code points which have the given value for the given property.
`int`	`charAt(int index)` Returns the character at the given index within this set, where the set is ordered by ascending code point.
`UnicodeSet`	`clear()` Removes all of the elements from this set.
`Object`	`clone()` Return a new set that is equivalent to this one.
`UnicodeSet`	`cloneAsThawed()` Clone a thawed version of this class, according to the Freezable interface.
`UnicodeSet`	`closeOver(int attribute)` Close this set over the given attribute.
`UnicodeSet`	`compact()` Reallocate this objects internal structures to take up the least possible space, without changing this object's value.
`int`	`compareTo(UnicodeSet o)` Compares UnicodeSets, where shorter come first, and otherwise lexigraphically (according to the comparison of the first characters that differ).
`int`	`compareTo(UnicodeSet o, UnicodeSet.ComparisonStyle style)` Compares UnicodeSets, in three different ways.
`int`	`compareTo(Iterable<String> other)`
`UnicodeSet`	`complement(int start, int end)` Complements the specified range in this set.
`UnicodeSet`	`complement()` This is equivalent to `complement(MIN_VALUE, MAX_VALUE)`.
`final UnicodeSet`	`complement(CharSequence s)` Complement the specified string in this set.
`final UnicodeSet`	`complement(int c)` Complements the specified character in this set.
`final UnicodeSet`	`complementAll(CharSequence s)` Complement EACH of the characters in this string.
`UnicodeSet`	`complementAll(UnicodeSet c)` Complements in this set all elements contained in the specified set.
`boolean`	`contains(int c)` Returns true if this set contains the given character.
`boolean`	`contains(int start, int end)` Returns true if this set contains every character of the given range.
`final boolean`	`contains(CharSequence s)` Returns `true` if this set contains the given multicharacter string.
`boolean`	`containsAll(UnicodeSet b)` Returns true if this set contains all the characters and strings of the given set.
`<T extends CharSequence> boolean`	`containsAll(Iterable<T> collection)`
`boolean`	`containsAll(String s)` Returns true if there is a partition of the string such that this set contains each of the partitioned strings.
`<T extends CharSequence> boolean`	`containsNone(Iterable<T> collection)`
`boolean`	`containsNone(UnicodeSet b)` Returns true if none of the characters or strings in this UnicodeSet appears in the string.
`boolean`	`containsNone(CharSequence s)` Returns true if this set contains none of the characters of the given string.
`boolean`	`containsNone(int start, int end)` Returns true if this set contains none of the characters of the given range.
`final boolean`	`containsSome(UnicodeSet s)` Returns true if this set contains one or more of the characters and strings of the given set.
`final boolean`	`containsSome(CharSequence s)` Returns true if this set contains one or more of the characters of the given string.
`final <T extends CharSequence> boolean`	`containsSome(Iterable<T> collection)`
`final boolean`	`containsSome(int start, int end)` Returns true if this set contains one or more of the characters in the given range.
`boolean`	`equals(Object o)` Compares the specified object with this set for equality.
`UnicodeSet`	`freeze()` Freeze this class, according to the Freezable interface.
`static UnicodeSet`	`from(CharSequence s)` Makes a set from a multicharacter string.
`static UnicodeSet`	`fromAll(CharSequence s)` Makes a set from each of the characters in the string.
`int`	`getRangeCount()` Iteration method that returns the number of ranges contained in this set.
`int`	`getRangeEnd(int index)` Iteration method that returns the last character in the specified range of this set.
`int`	`getRangeStart(int index)` Iteration method that returns the first character in the specified range of this set.
`int`	`hashCode()` Returns the hash code value for this set.
`int`	`indexOf(int c)` Returns the index of the given character within this set, where the set is ordered by ascending code point.
`boolean`	`isEmpty()` Returns `true` if this set contains no elements.
`boolean`	`isFrozen()` Is this frozen, according to the Freezable interface?
`Iterator<String>`	`iterator()` Returns a string iterator.
`int`	`matches(Replaceable text, int[] offset, int limit, boolean incremental)` Implementation of UnicodeMatcher.matches().
`boolean`	`matchesIndexValue(int v)` Implementation of UnicodeMatcher API.
`Iterable<UnicodeSet.EntryRange>`	`ranges()` Provide for faster iteration than by String.
`UnicodeSet`	`remove(int start, int end)` Removes the specified range from this set if it is present.
`final UnicodeSet`	`remove(CharSequence s)` Removes the specified string from this set if it is present.
`final UnicodeSet`	`remove(int c)` Removes the specified character from this set if it is present.
`<T extends CharSequence> UnicodeSet`	`removeAll(Iterable<T> collection)`
`UnicodeSet`	`removeAll(UnicodeSet c)` Removes from this set all of its elements that are contained in the specified set.
`final UnicodeSet`	`removeAll(CharSequence s)` Remove EACH of the characters in this string.
`final UnicodeSet`	`removeAllStrings()` Remove all strings from this UnicodeSet
`UnicodeSet`	`retain(int start, int end)` Retain only the elements in this set that are contained in the specified range.
`final UnicodeSet`	`retain(CharSequence cs)` Retain the specified string in this set if it is present.
`final UnicodeSet`	`retain(int c)` Retain the specified character from this set if it is present.
`final UnicodeSet`	`retainAll(CharSequence s)` Retains EACH of the characters in this string.
`UnicodeSet`	`retainAll(UnicodeSet c)` Retains only the elements in this set that are contained in the specified set.
`<T extends CharSequence> UnicodeSet`	`retainAll(Iterable<T> collection)`
`UnicodeSet`	`set(UnicodeSet other)` Make this object represent the same set as `other`.
`UnicodeSet`	`set(int start, int end)` Make this object represent the range `start - end`.
`int`	`size()` Returns the number of elements in this set (its cardinality) Note than the elements of a set may include both individual codepoints and strings.
`int`	`span(CharSequence s, int start, UnicodeSet.SpanCondition spanCondition)` Span a string using this UnicodeSet.
`int`	`span(CharSequence s, UnicodeSet.SpanCondition spanCondition)` Span a string using this UnicodeSet.
`int`	`spanBack(CharSequence s, UnicodeSet.SpanCondition spanCondition)` Span a string backwards (from the end) using this UnicodeSet.
`int`	`spanBack(CharSequence s, int fromIndex, UnicodeSet.SpanCondition spanCondition)` Span a string backwards (from the fromIndex) using this UnicodeSet.
`Collection<String>`	`strings()` For iterating through the strings in the set.
`String`	`toPattern(boolean escapeUnprintable)` Returns a string representation of this set.
`String`	`toString()` Return a programmer-readable string representation of this object.

Inherited methods

From class


  
    android.icu.text.UnicodeFilter

From class


  
    java.lang.Object

`Object`	`clone()` Creates and returns a copy of this object.
`boolean`	`equals(Object obj)` Indicates whether some other object is "equal to" this one.
`void`	`finalize()` Called by the garbage collector on an object when garbage collection determines that there are no more references to the object.
`final Class<?>`	`getClass()` Returns the runtime class of this `Object`.
`int`	`hashCode()` Returns a hash code value for the object.
`final void`	`notify()` Wakes up a single thread that is waiting on this object's monitor.
`final void`	`notifyAll()` Wakes up all threads that are waiting on this object's monitor.
`String`	`toString()` Returns a string representation of the object.
`final void`	`wait(long millis, int nanos)` Causes the current thread to wait until another thread invokes the `notify()` method or the `notifyAll()` method for this object, or some other thread interrupts the current thread, or a certain amount of real time has elapsed.
`final void`	`wait(long millis)` Causes the current thread to wait until either another thread invokes the `notify()` method or the `notifyAll()` method for this object, or a specified amount of time has elapsed.
`final void`	`wait()` Causes the current thread to wait until another thread invokes the `notify()` method or the `notifyAll()` method for this object.

From interface


  
    android.icu.text.UnicodeMatcher

From interface


  
    java.lang.Iterable

From interface


  
    java.lang.Comparable

From interface


  
    android.icu.util.Freezable

Constants

ADD_CASE_MAPPINGS

Added in API level 24

int ADD_CASE_MAPPINGS

Constant Value: 4 (0x00000004)

CASE

Added in API level 24

int CASE

Bitmask for constructor, applyPattern(), and closeOver() indicating letter case. This may be ORed together with other selectors. Enable case insensitive matching. E.g., "[ab]" with this flag will match 'a', 'A', 'b', and 'B'. "[^ab]" with this flag will match all except 'a', 'A', 'b', and 'B'. This performs a full closure over case mappings, e.g. U+017F for s. The resulting set is a superset of the input for the code points but not for the strings. It performs a case mapping closure of the code points and adds full case folding strings for the code points, and reduces strings of the original set to their full case folding equivalents. This is designed for case-insensitive matches, for example in regular expressions. The full code point case closure allows checking of an input character directly against the closure set. Strings are matched by comparing the case-folded form from the closure set with an incremental case folding of the string in question. The closure set will also contain single code points if the original set contained case-equivalent strings (like U+00DF for "ss" or "Ss" etc.). This is not necessary (that is, redundant) for the above matching method but results in the same closure sets regardless of whether the original set contained the code point or a string.

Constant Value: 2 (0x00000002)

CASE_INSENSITIVE

Added in API level 24

int CASE_INSENSITIVE

Alias for UnicodeSet.CASE, for ease of porting from C++ where ICU4C also has both USET_CASE and USET_CASE_INSENSITIVE (see uset.h).

See also:

CASE

Constant Value: 2 (0x00000002)

IGNORE_SPACE

Added in API level 24

int IGNORE_SPACE

Bitmask for constructor and applyPattern() indicating that white space should be ignored. If set, ignore Unicode Pattern_White_Space characters, unless they are quoted or escaped. This may be ORed together with other selectors.

Constant Value: 1 (0x00000001)

MAX_VALUE

Added in API level 24

int MAX_VALUE

Maximum value that can be stored in a UnicodeSet.

Constant Value: 1114111 (0x0010ffff)

MIN_VALUE

Added in API level 24

int MIN_VALUE

Minimum value that can be stored in a UnicodeSet.

Constant Value: 0 (0x00000000)

Fields

ALL_CODE_POINTS

Added in API level 24

UnicodeSet ALL_CODE_POINTS

Constant for the set of all code points. (Since UnicodeSets can include strings, does not include everything that a UnicodeSet can.)

EMPTY

Added in API level 24

UnicodeSet EMPTY

Constant for the empty set.

`[]`	No characters
`[a]`	The character 'a'
`[ae]`	The characters 'a' and 'e'
`[a-e]`	The characters 'a' through 'e' inclusive, in Unicode code point order
`[\\u4E01]`	The character U+4E01
`[a{ab}{ac}]`	The character 'a' and the multicharacter strings "ab" and "ac"
`[\p{Lu}]`	All characters in the general category Uppercase Letter

`pattern :=`	`('[' '^'? item* ']') \| property`
`item :=`	`char \| (char '-' char) \| pattern-expr`
`pattern-expr :=`	`pattern \| pattern-expr pattern \| pattern-expr op pattern`
`op :=`	`'&' \| '-'`
`special :=`	`'[' \| ']' \| '-'`
`char :=`	any character that is not`special \| ('\\'`any character`) \| ('\u' hex hex hex hex)`
`hex :=`	any character for which `Character.digit(c, 16)` returns a non-negative result
`property :=`	a Unicode property set pattern

Parameters
`start`	`int`: first character, inclusive, of range
`end`	`int`: last character, inclusive, of range

Parameters
`pattern`	`String`: a string specifying what characters are in the set
`ignoreWhitespace`	`boolean`: if true, ignore Unicode Pattern_White_Space characters

Parameters
`pattern`	`String`: a string specifying what characters are in the set
`options`	`int`: a bitmask indicating which options to apply. Valid options are IGNORE_SPACE and CASE.

Parameters
`pattern`	`String`: a string specifying what characters are in the set
`pos`	`ParsePosition`: on input, the position in pattern at which to start parsing. On output, the position after the last character parsed.
`symbols`	`SymbolTable`: a symbol table mapping variables to char[] arrays and chars to UnicodeSets

Parameters
`result`	`StringBuffer`: the buffer into which to generate the pattern
`escapeUnprintable`	`boolean`: escape unprintable characters if true

Parameters
`start`	`int`: The index of where to start on adding all characters.
`end`	`int`: The index of where to end on adding all characters.

Parameters
`prop`	`int`: a property in the range UProperty.BIN_START..UProperty.BIN_LIMIT-1 or UProperty.INT_START..UProperty.INT_LIMIT-1 or. UProperty.MASK_START..UProperty.MASK_LIMIT-1.
`value`	`int`: a value in the range UCharacter.getIntPropertyMinValue(prop).. UCharacter.getIntPropertyMaxValue(prop), with one exception. If prop is UProperty.GENERAL_CATEGORY_MASK, then value should not be a UCharacter.getType() result, but rather a mask value produced by logically ORing (1 << UCharacter.getType()) values together. This allows grouped categories such as [:L:] to be represented.

Parameters
`propertyAlias`	`String`: A string of the property alias.
`valueAlias`	`String`: A string of the value alias.
`symbols`	`SymbolTable`: if not null, then symbols are first called to see if a property is available. If true, then everything else is skipped.

Parameters
`start`	`int`: first character, inclusive, of the range
`end`	`int`: last character, inclusive, of the range

Parameters
`text`	`Replaceable`: the text to be matched
`offset`	`int`: on input, the index into text at which to begin matching. On output, the limit of the matched text. The number of matched characters is the output value of offset minus the input value. Offset should always point to the HIGH SURROGATE (leading code unit) of a pair of surrogates, both on entry and upon return.
`limit`	`int`: the limit index of text to be matched. Greater than offset for a forward direction match, less than offset for a backward direction match. The last character to be considered for matching will be text.charAt(limit-1) in the forward direction or text.charAt(limit+1) in the backward direction.
`incremental`	`boolean`: if TRUE, then assume further characters may be inserted at limit and check for partial matching. Otherwise assume the text as given is complete.

Parameters
`start`	`int`: first character in the set, inclusive
`end`	`int`: last character in the set, inclusive

Parameters
`s`	`CharSequence`: The string to be spanned
`start`	`int`: The start index that the span begins
`spanCondition`	`UnicodeSet.SpanCondition`: The span condition

Parameters
`s`	`CharSequence`: The string to be spanned
`fromIndex`	`int`: The index of the char (exclusive) that the string should be spanned backwards
`spanCondition`	`UnicodeSet.SpanCondition`: The span condition

Most visited

Recently visited

Results for

UnicodeSet

Summary

Nested classes

Constants

Inherited constants

Fields

Public constructors

Public methods

Inherited methods

Constants

ADD_CASE_MAPPINGS

CASE

CASE_INSENSITIVE

IGNORE_SPACE

MAX_VALUE

MIN_VALUE

Fields

ALL_CODE_POINTS

EMPTY

Public constructors

UnicodeSet

UnicodeSet

UnicodeSet

UnicodeSet

UnicodeSet

UnicodeSet

UnicodeSet

UnicodeSet

UnicodeSet

Public methods

_generatePattern

_generatePattern

add

add

add

add

addAll

addAll

addAll

addAll

addAll

addAllTo

addMatchSetTo

applyIntPropertyValue

applyPattern

applyPattern

applyPattern

applyPropertyAlias

applyPropertyAlias

charAt

clear

clone

cloneAsThawed

closeOver

compact

compareTo

compareTo

compareTo

complement

complement

complement

complement

complementAll

complementAll

contains

contains

contains

containsAll

containsAll

containsAll

containsNone

containsNone

containsNone

containsNone

containsSome

containsSome

containsSome