Movatterモバイル変換

java.lang.Object
- com.ibm.icu.text.UnicodeFilter
- - com.ibm.icu.text.UnicodeSet

All Implemented Interfaces:: UnicodeMatcher,Freezable<UnicodeSet>,Cloneable,Comparable<UnicodeSet>,Iterable<String>

public classUnicodeSetextendsUnicodeFilterimplementsIterable<String>,Comparable<UnicodeSet>,Freezable<UnicodeSet>

A mutable set of Unicode characters and multicharacter strings. Objects of this class representcharacter 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 theoperand API that allows the caller to modify the value of aUnicodeSet object. It conforms to Java 2'sjava.util.Set interface, althoughUnicodeSet does not actually implement that interface. All methods ofSet are supported, with the modification that they take a character range or single character instead of anObject, and they take aUnicodeSet instead of aCollection. The operand API may be thought of in terms of boolean logic: a boolean OR is implemented byadd, a boolean AND is implemented byretain, a boolean XOR is implemented bycomplement taking an argument, and a boolean NOT is implemented bycomplement with no argument. In terms of traditional set theory function names,add is a union,retain is an intersection,remove is an asymmetric difference, andcomplement with no argument is a set complement with respect to the superset rangeMIN_VALUE-MAX_VALUE

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

Pattern syntax

Patterns are accepted by the constructors and theapplyPattern() methods and returned by thetoPattern() 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 https://unicode-org.github.io/icu/userguide/strings/unicodeset. 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.

Since ICU 70, "[^...]", "[:^foo]", "\P{foo}", and "[:binaryProperty=No:]" perform a “code point complement” (all code points minus the original set), removing all multicharacter strings, equivalent to .complement().removeAllStrings() . Thecomplement() API function continues to perform a symmetric difference with all code points and thus retains all multicharacter strings.

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 bypat1 andpat2
`[[pat1]&[pat2]]`	The intersection of sets specified bypat1 andpat2
`[[pat1]-[pat2]]`	The asymmetric difference of sets specified bypat1 andpat2
`[: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 charactersnot having the given Unicode property

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 := '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'a' | 'b' | 'c' | 'd' | 'e' | 'f'
property := a Unicode property set pattern

Legend:
a := b a may be replaced byb
a? zero or one instance ofa
a* one or more instances ofa
a | b eithera orb
'a' the literal string between the quotes

To iterate over contents ofUnicodeSet, the following are available:

to iterate over the ranges:ranges(),rangeStream()
to iterate over the strings:strings(),stringStream()
to iterate over the code points:codePoints(),codePointStream()
to iterate over the entire contents in a single loop: this class itself isIterable, or usestream().
All of these method are, however, not particularly efficient, since they convert each individual code point to aString.

The iterators and streams methods work as expected in idiomatic Java usage.
TheUnicodeSetIterator cannot be used infor loops, and it is not very Java-idiomatic, because it is old. But it might be faster in certain use cases. We recommend that you measure in performance sensitive code.

To replace, count elements, or delete spans, seeUnicodeSetSpanner.

Author:: Alan Liu
See Also:: UnicodeSetIterator,UnicodeSetSpanner
Status:: Stable ICU 2.0.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`UnicodeSet.ComparisonStyle` Comparison style enums used by`compareTo(UnicodeSet, ComparisonStyle)`.
`static class`	`UnicodeSet.EntryRange` A struct-like class used for iteration through ranges, for faster iteration than by String.
`static class`	`UnicodeSet.SpanCondition` Argument values for whether span() and similar functions continue while the current character is contained vs.
`static class`	`UnicodeSet.XSymbolTable` Internal class for customizing UnicodeSet parsing of properties.

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`ADD_CASE_MAPPINGS` Adds all case mappings for each element in the set.
`staticUnicodeSet`	`ALL_CODE_POINTS` Constant for the set of all code points.
`static int`	`CASE` Deprecated. ICU 73 Use`CASE_INSENSITIVE` instead.
`static int`	`CASE_INSENSITIVE` Enable case insensitive matching.
`staticUnicodeSet`	`EMPTY` Constant for the empty set.
`static int`	`IGNORE_SPACE` Bitmask for constructor and applyPattern() indicating that white space should be ignored.
`static int`	`MAX_VALUE` Maximum value that can be stored in a UnicodeSet.
`static int`	`MIN_VALUE` Minimum value that can be stored in a UnicodeSet.
`static int`	`SIMPLE_CASE_INSENSITIVE` Enable case insensitive matching.

Fields inherited from interface com.ibm.icu.text.UnicodeMatcher
ETHER,U_MATCH,U_MISMATCH,U_PARTIAL_MATCH

Constructor Summary

Constructors
Constructor and Description
`UnicodeSet()` Constructs an empty set.
`UnicodeSet(int... pairs)` Quickly constructs a set from a set of ranges <s0, e0, s1, e1, s2, e2, ..., sn, en>.
`UnicodeSet(int start, int end)` Constructs a set containing the given range.
`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.
`UnicodeSet(UnicodeSet other)` Constructs a copy of an existing set.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`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.
`UnicodeSet`	`add(CharSequence s)` Adds the specified multicharacter to this set if it is not already present.
`UnicodeSet`	`add(int c)` Adds the specified character to this set if it is not already present.
`UnicodeSet`	`add(int start, int end)` Adds the specified range 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`	`addAll(CharSequence s)` Adds each of the characters in this string to the set.
`UnicodeSet`	`addAll(int start, int end)` Adds all characters in range (uses preferred naming convention).
`UnicodeSet`	`addAll(Iterable<?> source)` Add a collection (as strings) into this UnicodeSet.
`<T extendsCharSequence> UnicodeSet`	`addAll(T... collection)`
`UnicodeSet`	`addAll(UnicodeSet c)` Adds all of the elements in the specified set to this set if they're not already present.
`static <T> T[]`	`addAllTo(Iterable<T> source, T[] target)` Utility for adding the contents of an iterable to a collection.
`static <T,U extendsCollection<T>> U`	`addAllTo(Iterable<T> source, U target)` Utility for adding the contents of an iterable to a collection.
`String[]`	`addAllTo(String[] target)` Add the contents of the UnicodeSet (as strings) into a collection.
`<T extendsCollection<String>> T`	`addAllTo(T target)` Add the contents of the UnicodeSet (as strings) into a collection.
`UnicodeSet`	`addBridges(UnicodeSet dontCare)` Deprecated. This API is ICU internal only.
`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.
`UnicodeSet`	`applyPattern(String pattern)` Modifies this set to represent the set specified by the given pattern.
`UnicodeSet`	`applyPattern(String pattern, boolean ignoreWhitespace)` Modifies this set to represent the set specified by the given pattern, optionally ignoring whitespace.
`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,ParsePosition pos,SymbolTable symbols, int options)` Deprecated. This API is ICU internal only.
`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.
`Iterable<Integer>`	`codePoints()` Returns an`Iterable` for iteration over all the code points in this set.
`IntStream`	`codePointStream()` Returns an`IntStream` of Unicode code point values from this`UnicodeSet`.
`UnicodeSet`	`compact()` Reallocate this objects internal structures to take up the least possible space, without changing this object's value.
`static int`	`compare(CharSequence string, int codePoint)` Utility to compare a string to a code point.
`static <T extendsComparable<T>> int`	`compare(Collection<T> collection1,Collection<T> collection2,UnicodeSet.ComparisonStyle style)` Utility to compare two collections, optionally by size, and then lexicographically.
`static int`	`compare(int codePoint,CharSequence string)` Utility to compare a string to a code point.
`static <T extendsComparable<T>> int`	`compare(Iterable<T> collection1,Iterable<T> collection2)` Utility to compare two iterables.
`static <T extendsComparable<T>> int`	`compare(Iterator<T> first,Iterator<T> other)` Deprecated. This API is ICU internal only.
`int`	`compareTo(Iterable<String> other)`
`int`	`compareTo(UnicodeSet o)` Compares UnicodeSets, where shorter come first, and otherwise lexicographically (according to the comparison of the first characters that differ).
`int`	`compareTo(UnicodeSet o,UnicodeSet.ComparisonStyle style)` Compares UnicodeSets, in three different ways.
`UnicodeSet`	`complement()` This is equivalent to`complement(MIN_VALUE, MAX_VALUE)`.
`UnicodeSet`	`complement(CharSequence s)` Complement the specified string in this set.
`UnicodeSet`	`complement(int c)` Complements the specified character in this set.
`UnicodeSet`	`complement(int start, int end)` Complements the specified range in this set.
`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(CharSequence s)` Returns`true` if this set contains the given multicharacter string.
`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.
`<T extendsCharSequence> 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.
`boolean`	`containsAll(UnicodeSet b)` Returns true if this set contains all the characters and strings of the given set.
`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.
`<T extendsCharSequence> 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`	`containsSome(CharSequence s)` Returns true if this set contains one or more of the characters of the given string.
`boolean`	`containsSome(int start, int end)` Returns true if this set contains one or more of the characters in the given range.
`<T extendsCharSequence> boolean`	`containsSome(Iterable<T> collection)`
`boolean`	`containsSome(UnicodeSet s)` Returns true if this set contains one or more of the characters and strings of the given set.
`boolean`	`equals(Object o)` Compares the specified object with this set for equality.
`int`	`findIn(CharSequence value, int fromIndex, boolean findNot)` Deprecated. This API is ICU internal only. Use span instead.
`int`	`findLastIn(CharSequence value, int fromIndex, boolean findNot)` Deprecated. This API is ICU internal only. Use spanBack instead.
`UnicodeSet`	`freeze()` Freeze this class, according to the Freezable interface.
`staticUnicodeSet`	`from(CharSequence s)` Makes a set from a multicharacter string.
`staticUnicodeSet`	`fromAll(CharSequence s)` Makes a set from each of the characters in the string.
`staticUnicodeSet.XSymbolTable`	`getDefaultXSymbolTable()` Deprecated. This API is ICU internal only.
`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.
`String`	`getRegexEquivalent()` Deprecated. This API is ICU internal only.
`static int`	`getSingleCodePoint(CharSequence s)` Deprecated. This API is ICU internal only.
`int`	`hashCode()` Returns the hash code value for this set.
`boolean`	`hasStrings()`
`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().
`int`	`matchesAt(CharSequence text, int offset)` Deprecated. This API is ICU internal only.
`boolean`	`matchesIndexValue(int v)` Implementation of UnicodeMatcher API.
`Iterable<UnicodeSet.EntryRange>`	`ranges()` Provide for faster iteration than by String.
`Stream<UnicodeSet.EntryRange>`	`rangeStream()` Returns a`Stream` of`UnicodeSet.EntryRange` values from this`UnicodeSet`.
`UnicodeSet`	`remove(CharSequence s)` Removes the specified string from this set if it is present.
`UnicodeSet`	`remove(int c)` Removes the specified character from this set if it is present.
`UnicodeSet`	`remove(int start, int end)` Removes the specified range from this set if it is present.
`UnicodeSet`	`removeAll(CharSequence s)` Remove EACH of the characters in this string.
`<T extendsCharSequence> UnicodeSet`	`removeAll(Iterable<T> collection)`
`UnicodeSet`	`removeAll(UnicodeSet c)` Removes from this set all of its elements that are contained in the specified set.
`UnicodeSet`	`removeAllStrings()` Remove all strings from this UnicodeSet
`static boolean`	`resemblesPattern(String pattern, int pos)` Return true if the given position, in the given pattern, appears to be the start of a UnicodeSet pattern.
`UnicodeSet`	`retain(CharSequence cs)` Retain the specified string in this set if it is present.
`UnicodeSet`	`retain(int c)` Retain the specified character from this set if it is present.
`UnicodeSet`	`retain(int start, int end)` Retain only the elements in this set that are contained in the specified range.
`UnicodeSet`	`retainAll(CharSequence s)` Retains EACH of the characters in this string.
`<T extendsCharSequence> UnicodeSet`	`retainAll(Iterable<T> collection)`
`UnicodeSet`	`retainAll(UnicodeSet c)` Retains only the elements in this set that are contained in the specified set.
`UnicodeSet`	`set(int start, int end)` Make this object represent the range`start - end`.
`UnicodeSet`	`set(UnicodeSet other)` Make this object represent the same set as`other`.
`static void`	`setDefaultXSymbolTable(UnicodeSet.XSymbolTable xSymbolTable)` Deprecated. This API is ICU internal only.
`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`	`spanAndCount(CharSequence s, int start,UnicodeSet.SpanCondition spanCondition,OutputInt outCount)` Deprecated. This API is ICU internal only.
`int`	`spanBack(CharSequence s, int fromIndex,UnicodeSet.SpanCondition spanCondition)` Span a string backwards (from the fromIndex) using this UnicodeSet.
`int`	`spanBack(CharSequence s,UnicodeSet.SpanCondition spanCondition)` Span a string backwards (from the end) using this UnicodeSet.
`Stream<String>`	`stream()` Returns a stream of`String` values from this`UnicodeSet`.
`Collection<String>`	`strings()` For iterating through the strings in the set.
`Stream<String>`	`stringStream()` Returns a`Stream` of`String` values from this`UnicodeSet`.
`String`	`stripFrom(CharSequence source, boolean matches)` Deprecated. This API is ICU internal only. Use replaceFrom.
`staticString[]`	`toArray(UnicodeSet set)` Add the contents of the UnicodeSet (as strings) into an array.
`String`	`toPattern(boolean escapeUnprintable)` Returns a string representation of this set.
`String`	`toString()` Return a programmer-readable string representation of this object.

Methods inherited from class java.lang.Object
finalize,getClass,notify,notifyAll,wait,wait,wait

Methods inherited from interface java.lang.Iterable
forEach,spliterator

- Field Detail
  - EMPTY
```
public static final UnicodeSet EMPTY
```
    Constant for the empty set.
    Status:
    Stable ICU 4.8.
  - ALL_CODE_POINTS
```
public static final 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.)
    Status:
    Stable ICU 4.8.
  - MIN_VALUE
```
public static final int MIN_VALUE
```
    Minimum value that can be stored in a UnicodeSet.
    See Also:
    Constant Field Values
    Status:
    Stable ICU 2.0.
  - MAX_VALUE
```
public static final int MAX_VALUE
```
    Maximum value that can be stored in a UnicodeSet.
    See Also:
    Constant Field Values
    Status:
    Stable ICU 2.0.
  - IGNORE_SPACE
```
public static final 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.
    See Also:
    Constant Field Values
    Status:
    Stable ICU 3.8.
  - CASE
```
@Deprecatedpublic static final int CASE
```
    Deprecated. ICU 73 UseCASE_INSENSITIVE instead.
    Alias forCASE_INSENSITIVE.
    See Also:
    Constant Field Values
  - CASE_INSENSITIVE
```
public static final int CASE_INSENSITIVE
```
    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 long s) for 's'.
    This value is an options bit set value for some constructors, applyPattern(), and closeOver(). It can be ORed together with other, unrelated options.
    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.
    See Also:
    Constant Field Values
    Status:
    Stable ICU 3.4.
  - ADD_CASE_MAPPINGS
```
public static final int ADD_CASE_MAPPINGS
```
    Adds all case mappings for each element in the set. This adds the full lower-, title-, and uppercase mappings as well as the full case folding of each existing element in the set.
    This value is an options bit set value for some constructors, applyPattern(), and closeOver(). It can be ORed together with other, unrelated options.
    Unlike the “case insensitive” options, this does not perform a closure. For example, it does not add 'ſ' (U+017F long s) for 's', 'K' (U+212A Kelvin sign) for 'k', or replace set strings by their case-folded versions.
    See Also:
    Constant Field Values
    Status:
    Stable ICU 3.4.
  - SIMPLE_CASE_INSENSITIVE
```
public static final int SIMPLE_CASE_INSENSITIVE
```
    Enable case insensitive matching. Same asCASE_INSENSITIVE but using only Simple_Case_Folding (scf) mappings, which map each code point to one code point, not full Case_Folding (cf) mappings, which map some code points to multiple code points.
    This is designed for case-insensitive matches, for example in certain regular expression implementations where only Simple_Case_Folding mappings are used, such as in ECMAScript (JavaScript) regular expressions.
    This value is an options bit set value for some constructors, applyPattern(), and closeOver(). It can be ORed together with other, unrelated options.
    See Also:
    Constant Field Values
    Status:
    Stable ICU 73.
- Constructor Detail
  - UnicodeSet
```
public UnicodeSet()
```
    Constructs an empty set.
    Status:
    Stable ICU 2.0.
  - UnicodeSet
```
public UnicodeSet(UnicodeSet other)
```
    Constructs a copy of an existing set.
    Status:
    Stable ICU 2.0.
  - UnicodeSet
```
public UnicodeSet(int start,                  int end)
```
    Constructs a set containing the given range. Ifend > start then an empty set is created.
    Parameters:
    start - first character, inclusive, of range
    end - last character, inclusive, of range
    Status:
    Stable ICU 2.0.
  - UnicodeSet
```
public UnicodeSet(int... pairs)
```
    Quickly constructs a set from a set of ranges <s0, e0, s1, e1, s2, e2, ..., sn, en>. There must be an even number of integers, and they must be all greater than zero, all less than or equal to Character.MAX_CODE_POINT. In each pair (..., si, ei, ...) it must be true that si <= ei Between adjacent pairs (...ei, sj...), it must be true that ei+1 < sj
    Parameters:
    pairs - pairs of character representing ranges
    Status:
    Stable ICU 4.4.
  - UnicodeSet
```
public UnicodeSet(String pattern)
```
    Constructs a set from the given pattern. See the class description for the syntax of the pattern language. Whitespace is ignored.
    Parameters:
    pattern - a string specifying what characters are in the set
    Throws:
    IllegalArgumentException - if the pattern contains a syntax error.
    Status:
    Stable ICU 2.0.
  - UnicodeSet
```
public UnicodeSet(String pattern,                  boolean ignoreWhitespace)
```
    Constructs a set from the given pattern. See the class description for the syntax of the pattern language.
    Parameters:
    pattern - a string specifying what characters are in the set
    ignoreWhitespace - if true, ignore Unicode Pattern_White_Space characters
    Throws:
    IllegalArgumentException - if the pattern contains a syntax error.
    Status:
    Stable ICU 2.0.
  - UnicodeSet
```
public UnicodeSet(String pattern,                  int options)
```
    Constructs a set from the given pattern. See the class description for the syntax of the pattern language.
    Parameters:
    pattern - a string specifying what characters are in the set
    options - a bitmask indicating which options to apply. Valid options areIGNORE_SPACE and at most one ofCASE_INSENSITIVE,ADD_CASE_MAPPINGS,SIMPLE_CASE_INSENSITIVE. These case options are mutually exclusive.
    Throws:
    IllegalArgumentException - if the pattern contains a syntax error.
    Status:
    Stable ICU 3.8.
  - UnicodeSet
```
public UnicodeSet(String pattern,ParsePosition pos,SymbolTable symbols)
```
    Constructs a set from the given pattern. See the class description for the syntax of the pattern language.
    Parameters:
    pattern - a string specifying what characters are in the set
    pos - on input, the position in pattern at which to start parsing. On output, the position after the last character parsed.
    symbols - a symbol table mapping variables to char[] arrays and chars to UnicodeSets
    Throws:
    IllegalArgumentException - if the pattern contains a syntax error.
    Status:
    Stable ICU 2.0.
  - UnicodeSet
```
public UnicodeSet(String pattern,ParsePosition pos,SymbolTable symbols,                  int options)
```
    Constructs a set from the given pattern. See the class description for the syntax of the pattern language.
    Parameters:
    pattern - a string specifying what characters are in the set
    pos - on input, the position in pattern at which to start parsing. On output, the position after the last character parsed.
    symbols - a symbol table mapping variables to char[] arrays and chars to UnicodeSets
    options - a bitmask indicating which options to apply. Valid options areIGNORE_SPACE and at most one ofCASE_INSENSITIVE,ADD_CASE_MAPPINGS,SIMPLE_CASE_INSENSITIVE. These case options are mutually exclusive.
    Throws:
    IllegalArgumentException - if the pattern contains a syntax error.
    Status:
    Stable ICU 3.2.
- Method Detail
  - clone
```
public Object clone()
```
    Return a new set that is equivalent to this one.
    Overrides:
    clone in class Object
    Status:
    Stable ICU 2.0.
  - set
```
public UnicodeSet set(int start,                      int end)
```
    Make this object represent the rangestart - end. Ifstart > end then this object is set to an empty range.
    Parameters:
    start - first character in the set, inclusive
    end - last character in the set, inclusive
    Status:
    Stable ICU 2.0.
  - set
```
public UnicodeSet set(UnicodeSet other)
```
    Make this object represent the same set asother.
    Parameters:
    other - aUnicodeSet whose value will be copied to this object
    Status:
    Stable ICU 2.0.
  - applyPattern
```
public final UnicodeSet applyPattern(String pattern)
```
    Modifies this set to represent the set specified by the given pattern. See the class description for the syntax of the pattern language. Whitespace is ignored.
    Parameters:
    pattern - a string specifying what characters are in the set
    Throws:
    IllegalArgumentException - if the pattern contains a syntax error.
    Status:
    Stable ICU 2.0.
  - applyPattern
```
public UnicodeSet applyPattern(String pattern,                               boolean ignoreWhitespace)
```
    Modifies this set to represent the set specified by the given pattern, optionally ignoring whitespace. See the class description for the syntax of the pattern language.
    Parameters:
    pattern - a string specifying what characters are in the set
    ignoreWhitespace - if true then Unicode Pattern_White_Space characters are ignored
    Throws:
    IllegalArgumentException - if the pattern contains a syntax error.
    Status:
    Stable ICU 2.0.
  - applyPattern
```
public UnicodeSet applyPattern(String pattern,                               int options)
```
    Modifies this set to represent the set specified by the given pattern, optionally ignoring whitespace. See the class description for the syntax of the pattern language.
    Parameters:
    pattern - a string specifying what characters are in the set
    options - a bitmask indicating which options to apply. Valid options areIGNORE_SPACE and at most one ofCASE_INSENSITIVE,ADD_CASE_MAPPINGS,SIMPLE_CASE_INSENSITIVE. These case options are mutually exclusive.
    Throws:
    IllegalArgumentException - if the pattern contains a syntax error.
    Status:
    Stable ICU 3.8.
  - resemblesPattern
```
public static boolean resemblesPattern(String pattern,                                       int pos)
```
    Return true if the given position, in the given pattern, appears to be the start of a UnicodeSet pattern.
    Status:
    Stable ICU 2.0.
  - toPattern
```
public String toPattern(boolean escapeUnprintable)
```
    Returns a string representation of this set. If the result of calling this function is passed to a UnicodeSet constructor, it will produce another set that is equal to this one.
    Specified by:
    toPattern in interface UnicodeMatcher
    Parameters:
    escapeUnprintable - if true then convert unprintable character to their hex escape representations, \\uxxxx or \\Uxxxxxxxx. Unprintable characters are those other than U+000A, U+0020..U+007E.
    Status:
    Stable ICU 2.0.
  - _generatePattern
```
public StringBuffer _generatePattern(StringBuffer result,                                     boolean escapeUnprintable)
```
    Generate and append a string representation of this set to result. This does not use this.pat, the cleaned up copy of the string passed to applyPattern().
    Parameters:
    result - the buffer into which to generate the pattern
    escapeUnprintable - escape unprintable characters if true
    Status:
    Stable ICU 2.0.
  - _generatePattern
```
public StringBuffer _generatePattern(StringBuffer result,                                     boolean escapeUnprintable,                                     boolean includeStrings)
```
    Generate and append a string representation of this set to result. This does not use this.pat, the cleaned up copy of the string passed to applyPattern().
    Parameters:
    result - the buffer into which to generate the pattern
    escapeUnprintable - escape unprintable characters if true
    includeStrings - if false, doesn't include the strings.
    Status:
    Stable ICU 3.8.
  - size
```
public 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.
    Returns:
    the number of elements in this set (its cardinality).
    Status:
    Stable ICU 2.0.
  - isEmpty
```
public boolean isEmpty()
```
    Returnstrue if this set contains no elements.
    Returns:
    true if this set contains no elements.
    Status:
    Stable ICU 2.0.
  - hasStrings
```
public boolean hasStrings()
```
    Returns:
    true if this set contains multi-character strings or the empty string.
    Status:
    Stable ICU 70.
  - matchesIndexValue
```
public boolean matchesIndexValue(int v)
```
    Implementation of UnicodeMatcher API. Returnstrue if this set contains any character whose low byte is the given value. This is used byRuleBasedTransliterator for indexing.
    Specified by:
    matchesIndexValue in interface UnicodeMatcher
    Status:
    Stable ICU 2.0.
  - matches
```
public int matches(Replaceable text,                   int[] offset,                   int limit,                   boolean incremental)
```
    Implementation of UnicodeMatcher.matches(). Always matches the longest possible multichar string.
    Specified by:
    matches in interface UnicodeMatcher
    Overrides:
    matches in class UnicodeFilter
    Parameters:
    text - the text to be matched
    offset - 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 - 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 - if true, then assume further characters may be inserted at limit and check for partial matching. Otherwise assume the text as given is complete.
    Returns:
    a match degree value indicating a full match, a partial match, or a mismatch. If incremental is false then U_PARTIAL_MATCH should never be returned.
    Status:
    Stable ICU 2.0.
  - matchesAt
```
@Deprecatedpublic int matchesAt(CharSequence text,                                 int offset)
```
    Deprecated. This API is ICU internal only.
    Tests whether the text matches at the offset. If so, returns the end of the longest substring that it matches. If not, returns -1.
    Status:
    Internal.
  - addMatchSetTo
```
public void addMatchSetTo(UnicodeSet toUnionTo)
```
    Implementation of UnicodeMatcher API. Union the set of all characters that may be matched by this object into the given set.
    Specified by:
    addMatchSetTo in interface UnicodeMatcher
    Parameters:
    toUnionTo - the set into which to union the source characters
    Status:
    Stable ICU 2.2.
  - indexOf
```
public int indexOf(int c)
```
    Returns the index of the given character within this set, where the set is ordered by ascending code point. If the character is not in this set, return -1. The inverse of this method ischarAt().
    Returns:
    an index from 0..size()-1, or -1
    Status:
    Stable ICU 2.0.
  - charAt
```
public int charAt(int index)
```
    Returns the character at the given index within this set, where the set is ordered by ascending code point. If the index is out of range, return -1. The inverse of this method isindexOf().
    Parameters:
    index - an index from 0..size()-1
    Returns:
    the character at the given index, or -1.
    Status:
    Stable ICU 2.0.
  - add
```
public UnicodeSet add(int start,                      int end)
```
    Adds the specified range to this set if it is not already present. If this set already contains the specified range, the call leaves this set unchanged. Ifstart > end then an empty range is added, leaving the set unchanged.
    Parameters:
    start - first character, inclusive, of range to be added to this set.
    end - last character, inclusive, of range to be added to this set.
    Status:
    Stable ICU 2.0.
  - addAll
```
public UnicodeSet addAll(int start,                         int end)
```
    Adds all characters in range (uses preferred naming convention).
    Parameters:
    start - The index of where to start on adding all characters.
    end - The index of where to end on adding all characters.
    Returns:
    a reference to this object
    Status:
    Stable ICU 4.4.
  - add
```
public final UnicodeSet add(int c)
```
    Adds the specified character to this set if it is not already present. If this set already contains the specified character, the call leaves this set unchanged.
    Status:
    Stable ICU 2.0.
  - add
```
public final UnicodeSet add(CharSequence s)
```
    Adds the specified multicharacter to this set if it is not already present. If this set already contains the multicharacter, the call leaves this set unchanged. Thus "ch" => {"ch"}
    Parameters:
    s - the source string
    Returns:
    this object, for chaining
    Status:
    Stable ICU 2.0.
  - addAll
```
public final UnicodeSet addAll(CharSequence s)
```
    Adds each of the characters in this string to the set. Thus "ch" => {"c", "h"} If this set already any particular character, it has no effect on that character.
    Parameters:
    s - the source string
    Returns:
    this object, for chaining
    Status:
    Stable ICU 2.0.
  - retainAll
```
public final UnicodeSet retainAll(CharSequence s)
```
    Retains EACH of the characters in this string. Note: "ch" == {"c", "h"} If this set already any particular character, it has no effect on that character.
    Parameters:
    s - the source string
    Returns:
    this object, for chaining
    Status:
    Stable ICU 2.0.
  - complementAll
```
public final UnicodeSet complementAll(CharSequence s)
```
    Complement EACH of the characters in this string. Note: "ch" == {"c", "h"} If this set already any particular character, it has no effect on that character.
    Parameters:
    s - the source string
    Returns:
    this object, for chaining
    Status:
    Stable ICU 2.0.
  - removeAll
```
public final UnicodeSet removeAll(CharSequence s)
```
    Remove EACH of the characters in this string. Note: "ch" == {"c", "h"} If this set already any particular character, it has no effect on that character.
    Parameters:
    s - the source string
    Returns:
    this object, for chaining
    Status:
    Stable ICU 2.0.
  - removeAllStrings
```
public final UnicodeSet removeAllStrings()
```
    Remove all strings from this UnicodeSet
    Returns:
    this object, for chaining
    Status:
    Stable ICU 4.2.
  - from
```
public static UnicodeSet from(CharSequence s)
```
    Makes a set from a multicharacter string. Thus "ch" => {"ch"}
    Parameters:
    s - the source string
    Returns:
    a newly created set containing the given string
    Status:
    Stable ICU 2.0.
  - fromAll
```
public static UnicodeSet fromAll(CharSequence s)
```
    Makes a set from each of the characters in the string. Thus "ch" => {"c", "h"}
    Parameters:
    s - the source string
    Returns:
    a newly created set containing the given characters
    Status:
    Stable ICU 2.0.
  - retain
```
public UnicodeSet retain(int start,                         int end)
```
    Retain only the elements in this set that are contained in the specified range. Ifstart > end then an empty range is retained, leaving the set empty.
    Parameters:
    start - first character, inclusive, of range
    end - last character, inclusive, of range
    Status:
    Stable ICU 2.0.
  - retain
```
public final UnicodeSet retain(int c)
```
    Retain the specified character from this set if it is present. Upon return this set will be empty if it did not contain c, or will only contain c if it did contain c.
    Parameters:
    c - the character to be retained
    Returns:
    this object, for chaining
    Status:
    Stable ICU 2.0.
  - retain
```
public final UnicodeSet retain(CharSequence cs)
```
    Retain the specified string in this set if it is present. Upon return this set will be empty if it did not contain s, or will only contain s if it did contain s.
    Parameters:
    cs - the string to be retained
    Returns:
    this object, for chaining
    Status:
    Stable ICU 2.0.
  - remove
```
public UnicodeSet remove(int start,                         int end)
```
    Removes the specified range from this set if it is present. The set will not contain the specified range once the call returns. Ifstart > end then an empty range is removed, leaving the set unchanged.
    Parameters:
    start - first character, inclusive, of range to be removed from this set.
    end - last character, inclusive, of range to be removed from this set.
    Status:
    Stable ICU 2.0.
  - remove
```
public final UnicodeSet remove(int c)
```
    Removes the specified character from this set if it is present. The set will not contain the specified character once the call returns.
    Parameters:
    c - the character to be removed
    Returns:
    this object, for chaining
    Status:
    Stable ICU 2.0.
  - remove
```
public final UnicodeSet remove(CharSequence s)
```
    Removes the specified string from this set if it is present. The set will not contain the specified string once the call returns.
    Parameters:
    s - the string to be removed
    Returns:
    this object, for chaining
    Status:
    Stable ICU 2.0.
  - complement
```
public UnicodeSet complement(int start,                             int end)
```
    Complements the specified range in this set. Any character in the range will be removed if it is in this set, or will be added if it is not in this set. Ifstart > end then an empty range is complemented, leaving the set unchanged.
    Parameters:
    start - first character, inclusive, of range
    end - last character, inclusive, of range
    Status:
    Stable ICU 2.0.
  - complement
```
public final UnicodeSet complement(int c)
```
    Complements the specified character in this set. The character will be removed if it is in this set, or will be added if it is not in this set.
    Status:
    Stable ICU 2.0.
  - complement
```
public UnicodeSet complement()
```
    This is equivalent tocomplement(MIN_VALUE, MAX_VALUE).
    Note: This performs a symmetric difference with all code pointsand thus retains all multicharacter strings. In order to achieve a “code point complement” (all code points minus this set), the easiest is to .complement().removeAllStrings() .
    Status:
    Stable ICU 2.0.
  - complement
```
public final UnicodeSet complement(CharSequence s)
```
    Complement the specified string in this set. The set will not contain the specified string once the call returns.
    Parameters:
    s - the string to complement
    Returns:
    this object, for chaining
    Status:
    Stable ICU 2.0.
  - contains
```
public boolean contains(int c)
```
    Returns true if this set contains the given character.
    Specified by:
    contains in class UnicodeFilter
    Parameters:
    c - character to be checked for containment
    Returns:
    true if the test condition is met
    Status:
    Stable ICU 2.0.
  - contains
```
public boolean contains(int start,                        int end)
```
    Returns true if this set contains every character of the given range.
    Parameters:
    start - first character, inclusive, of the range
    end - last character, inclusive, of the range
    Returns:
    true if the test condition is met
    Status:
    Stable ICU 2.0.
  - contains
```
public final boolean contains(CharSequence s)
```
    Returnstrue if this set contains the given multicharacter string.
    Parameters:
    s - string to be checked for containment
    Returns:
    true if this set contains the specified string
    Status:
    Stable ICU 2.0.
  - containsAll
```
public boolean containsAll(UnicodeSet b)
```
    Returns true if this set contains all the characters and strings of the given set.
    Parameters:
    b - set to be checked for containment
    Returns:
    true if the test condition is met
    Status:
    Stable ICU 2.0.
  - containsAll
```
public boolean containsAll(String s)
```
    Returns true if there is a partition of the string such that this set contains each of the partitioned strings. For example, for the Unicode set [a{bc}{cd}]
    containsAll is true for each of: "a", "bc", ""cdbca"
    containsAll is false for each of: "acb", "bcda", "bcx"
    Parameters:
    s - string containing characters to be checked for containment
    Returns:
    true if the test condition is met
    Status:
    Stable ICU 2.0.
  - getRegexEquivalent
```
@Deprecatedpublic String getRegexEquivalent()
```
    Deprecated. This API is ICU internal only.
    Get the Regex equivalent for this UnicodeSet
    Returns:
    regex pattern equivalent to this UnicodeSet
    Status:
    Internal.
  - containsNone
```
public boolean containsNone(int start,                            int end)
```
    Returns true if this set contains none of the characters of the given range.
    Parameters:
    start - first character, inclusive, of the range
    end - last character, inclusive, of the range
    Returns:
    true if the test condition is met
    Status:
    Stable ICU 2.0.
  - containsNone
```
public boolean containsNone(UnicodeSet b)
```
    Returns true if none of the characters or strings in this UnicodeSet appears in the string. For example, for the Unicode set [a{bc}{cd}]
    containsNone is true for: "xy", "cb"
    containsNone is false for: "a", "bc", "bcd"
    Parameters:
    b - set to be checked for containment
    Returns:
    true if the test condition is met
    Status:
    Stable ICU 2.0.
  - containsNone
```
public boolean containsNone(CharSequence s)
```
    Returns true if this set contains none of the characters of the given string.
    Parameters:
    s - string containing characters to be checked for containment
    Returns:
    true if the test condition is met
    Status:
    Stable ICU 2.0.
  - containsSome
```
public final boolean containsSome(int start,                                  int end)
```
    Returns true if this set contains one or more of the characters in the given range.
    Parameters:
    start - first character, inclusive, of the range
    end - last character, inclusive, of the range
    Returns:
    true if the condition is met
    Status:
    Stable ICU 2.0.
  - containsSome
```
public final boolean containsSome(UnicodeSet s)
```
    Returns true if this set contains one or more of the characters and strings of the given set.
    Parameters:
    s - set to be checked for containment
    Returns:
    true if the condition is met
    Status:
    Stable ICU 2.0.
  - containsSome
```
public final boolean containsSome(CharSequence s)
```
    Returns true if this set contains one or more of the characters of the given string.
    Parameters:
    s - string containing characters to be checked for containment
    Returns:
    true if the condition is met
    Status:
    Stable ICU 2.0.
  - addAll
```
public UnicodeSet addAll(UnicodeSet c)
```
    Adds all of the elements in the specified set to this set if they're not already present. This operation effectively modifies this set so that its value is theunion of the two sets. The behavior of this operation is unspecified if the specified collection is modified while the operation is in progress.
    Parameters:
    c - set whose elements are to be added to this set.
    Status:
    Stable ICU 2.0.
  - retainAll
```
public UnicodeSet retainAll(UnicodeSet c)
```
    Retains only the elements in this set that are contained in the specified set. In other words, removes from this set all of its elements that are not contained in the specified set. This operation effectively modifies this set so that its value is theintersection of the two sets.
    Parameters:
    c - set that defines which elements this set will retain.
    Status:
    Stable ICU 2.0.
  - removeAll
```
public UnicodeSet removeAll(UnicodeSet c)
```
    Removes from this set all of its elements that are contained in the specified set. This operation effectively modifies this set so that its value is theasymmetric set difference of the two sets.
    Parameters:
    c - set that defines which elements will be removed from this set.
    Status:
    Stable ICU 2.0.
  - complementAll
```
public UnicodeSet complementAll(UnicodeSet c)
```
    Complements in this set all elements contained in the specified set. Any character in the other set will be removed if it is in this set, or will be added if it is not in this set.
    Parameters:
    c - set that defines which elements will be complemented from this set.
    Status:
    Stable ICU 2.0.
  - clear
```
public UnicodeSet clear()
```
    Removes all of the elements from this set. This set will be empty after this call returns.
    Status:
    Stable ICU 2.0.
  - getRangeCount
```
public int getRangeCount()
```
    Iteration method that returns the number of ranges contained in this set.
    See Also:
    getRangeStart(int),getRangeEnd(int)
    Status:
    Stable ICU 2.0.
  - getRangeStart
```
public int getRangeStart(int index)
```
    Iteration method that returns the first character in the specified range of this set.
    Throws:
    ArrayIndexOutOfBoundsException - if index is outside the range0..getRangeCount()-1
    See Also:
    getRangeCount(),getRangeEnd(int)
    Status:
    Stable ICU 2.0.
  - getRangeEnd
```
public int getRangeEnd(int index)
```
    Iteration method that returns the last character in the specified range of this set.
    Throws:
    ArrayIndexOutOfBoundsException - if index is outside the range0..getRangeCount()-1
    See Also:
    getRangeStart(int),getRangeEnd(int)
    Status:
    Stable ICU 2.0.
  - compact
```
public UnicodeSet compact()
```
    Reallocate this objects internal structures to take up the least possible space, without changing this object's value.
    Status:
    Stable ICU 2.0.
  - equals
```
public boolean equals(Object o)
```
    Compares the specified object with this set for equality. Returnstrue if the specified object is also a set, the two sets have the same size, and every member of the specified set is contained in this set (or equivalently, every member of this set is contained in the specified set).
    Overrides:
    equals in class Object
    Parameters:
    o - Object to be compared for equality with this set.
    Returns:
    true if the specified Object is equal to this set.
    Status:
    Stable ICU 2.0.
  - hashCode
```
public int hashCode()
```
    Returns the hash code value for this set.
    Overrides:
    hashCode in class Object
    Returns:
    the hash code value for this set.
    See Also:
    Object.hashCode()
    Status:
    Stable ICU 2.0.
  - toString
```
public String toString()
```
    Return a programmer-readable string representation of this object.
    Overrides:
    toString in class Object
    Status:
    Stable ICU 2.0.
  - applyPattern
```
@Deprecatedpublic UnicodeSet applyPattern(String pattern,ParsePosition pos,SymbolTable symbols,                                           int options)
```
    Deprecated. This API is ICU internal only.
    Parses the given pattern, starting at the given position. The character at pattern.charAt(pos.getIndex()) must be '[', or the parse fails. Parsing continues until the corresponding closing ']'. If a syntax error is encountered between the opening and closing brace, the parse fails. Upon return from a successful parse, the ParsePosition is updated to point to the character following the closing ']', and an inversion list for the parsed pattern is returned. This method calls itself recursively to parse embedded subpatterns.
    Parameters:
    pattern - the string containing the pattern to be parsed. The portion of the string from pos.getIndex(), which must be a '[', to the corresponding closing ']', is parsed.
    pos - upon entry, the position at which to being parsing. The character at pattern.charAt(pos.getIndex()) must be a '['. Upon return from a successful parse, pos.getIndex() is either the character after the closing ']' of the parsed pattern, or pattern.length() if the closing ']' is the last character of the pattern string.
    Returns:
    an inversion list for the parsed substring ofpattern
    Throws:
    IllegalArgumentException - if the parse fails.
    Status:
    Internal.
  - addAllTo
```
public <T extendsCollection<String>> T addAllTo(T target)
```
    Add the contents of the UnicodeSet (as strings) into a collection.
    Parameters:
    target - collection to add into
    Status:
    Stable ICU 4.4.
  - addAllTo
```
public String[] addAllTo(String[] target)
```
    Add the contents of the UnicodeSet (as strings) into a collection.
    Parameters:
    target - collection to add into
    Status:
    Stable ICU 4.4.
  - toArray
```
public static String[] toArray(UnicodeSet set)
```
    Add the contents of the UnicodeSet (as strings) into an array.
    Status:
    Stable ICU 4.4.
  - add
```
public UnicodeSet add(Iterable<?> source)
```
    Add the contents of the collection (as strings) into this UnicodeSet. The collection must not contain null.
    Parameters:
    source - the collection to add
    Returns:
    a reference to this object
    Status:
    Stable ICU 4.4.
  - addAll
```
public UnicodeSet addAll(Iterable<?> source)
```
    Add a collection (as strings) into this UnicodeSet. Uses standard naming convention.
    Parameters:
    source - collection to add into
    Returns:
    a reference to this object
    Status:
    Stable ICU 4.4.
  - applyIntPropertyValue
```
public 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. Prior contents of this set are lost.
    Parameters:
    prop - 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 - 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.
    Returns:
    a reference to this set
    Status:
    Stable ICU 2.4.
  - applyPropertyAlias
```
public UnicodeSet applyPropertyAlias(String propertyAlias,String valueAlias)
```
    Modifies this set to contain those code points which have the given value for the given property. Prior contents of this set are lost.
    Parameters:
    propertyAlias - a property alias, either short or long. The name is matched loosely. See PropertyAliases.txt for names and a description of loose matching. If the value string is empty, then this string is interpreted as either a General_Category value alias, a Script value alias, a binary property alias, or a special ID. Special IDs are matched loosely and correspond to the following sets: "ANY" = [\\u0000-\\U0010FFFF], "ASCII" = [\\u0000-\\u007F].
    valueAlias - a value alias, either short or long. The name is matched loosely. See PropertyValueAliases.txt for names and a description of loose matching. In addition to aliases listed, numeric values and canonical combining classes may be expressed numerically, e.g., ("nv", "0.5") or ("ccc", "220"). The value string may also be empty.
    Returns:
    a reference to this set
    Status:
    Stable ICU 2.4.
  - applyPropertyAlias
```
public 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. Prior contents of this set are lost.
    Parameters:
    propertyAlias - A string of the property alias.
    valueAlias - A string of the value alias.
    symbols - if not null, then symbols are first called to see if a property is available. If true, then everything else is skipped.
    Returns:
    this set
    Status:
    Stable ICU 3.2.
  - closeOver
```
public UnicodeSet closeOver(int attribute)
```
    Close this set over the given attribute. For the attributeCASE_INSENSITIVE, the result is to modify this set so that:
    1. For each character or string 'a' in this set, all strings 'b' such that foldCase(a) == foldCase(b) are added to this set. (For most 'a' that are single characters, 'b' will have b.length() == 1.)
    2. For each string 'e' in the resulting set, if e != foldCase(e), 'e' will be removed.
    Example: [aqß{Bc}{bC}{Fi}] => [aAqQßﬁ{ss}{bc}{fi}]
    (Here foldCase(x) refers to the operation UCharacter.foldCase(x, true), and a == b actually denotes a.equals(b), not pointer comparison.)
    Parameters:
    attribute - bitmask for attributes to close over. Valid options: At most one ofCASE_INSENSITIVE,ADD_CASE_MAPPINGS,SIMPLE_CASE_INSENSITIVE. These case options are mutually exclusive. Unrelated options bits are ignored.
    Returns:
    a reference to this set.
    Status:
    Stable ICU 3.8.
  - isFrozen
```
public boolean isFrozen()
```
    Is this frozen, according to the Freezable interface?
    Specified by:
    isFrozen in interface Freezable<UnicodeSet>
    Returns:
    value
    Status:
    Stable ICU 3.8.
  - freeze
```
public UnicodeSet freeze()
```
    Freeze this class, according to the Freezable interface.
    Specified by:
    freeze in interface Freezable<UnicodeSet>
    Returns:
    this
    Status:
    Stable ICU 4.4.
  - span
```
public int span(CharSequence s,UnicodeSet.SpanCondition spanCondition)
```
    Span a string using this UnicodeSet.
    To replace, count elements, or delete spans, seeUnicodeSetSpanner.
    Parameters:
    s - The string to be spanned
    spanCondition - The span condition
    Returns:
    the length of the span
    Status:
    Stable ICU 4.4.
  - span
```
public int span(CharSequence s,                int start,UnicodeSet.SpanCondition spanCondition)
```
    Span a string using this UnicodeSet. If the start index is less than 0, span will start from 0. If the start index is greater than the string length, span returns the string length.
    To replace, count elements, or delete spans, seeUnicodeSetSpanner.
    Parameters:
    s - The string to be spanned
    start - The start index that the span begins
    spanCondition - The span condition
    Returns:
    the string index which ends the span (i.e. exclusive)
    Status:
    Stable ICU 4.4.
  - spanAndCount
```
@Deprecatedpublic int spanAndCount(CharSequence s,                                    int start,UnicodeSet.SpanCondition spanCondition,OutputInt outCount)
```
    Deprecated. This API is ICU internal only.
    Same as span() but also counts the smallest number of set elements on any path across the span.
    To replace, count elements, or delete spans, seeUnicodeSetSpanner.
    Parameters:
    outCount - An output-only object (must not be null) for returning the count.
    Returns:
    the limit (exclusive end) of the span
    Status:
    Internal.
  - spanBack
```
public int spanBack(CharSequence s,UnicodeSet.SpanCondition spanCondition)
```
    Span a string backwards (from the end) using this UnicodeSet.
    To replace, count elements, or delete spans, seeUnicodeSetSpanner.
    Parameters:
    s - The string to be spanned
    spanCondition - The span condition
    Returns:
    The string index which starts the span (i.e. inclusive).
    Status:
    Stable ICU 4.4.
  - spanBack
```
public int spanBack(CharSequence s,                    int fromIndex,UnicodeSet.SpanCondition spanCondition)
```
    Span a string backwards (from the fromIndex) using this UnicodeSet. If the fromIndex is less than 0, spanBack will return 0. If fromIndex is greater than the string length, spanBack will start from the string length.
    To replace, count elements, or delete spans, seeUnicodeSetSpanner.
    Parameters:
    s - The string to be spanned
    fromIndex - The index of the char (exclusive) that the string should be spanned backwards
    spanCondition - The span condition
    Returns:
    The string index which starts the span (i.e. inclusive).
    Status:
    Stable ICU 4.4.
  - cloneAsThawed
```
public UnicodeSet cloneAsThawed()
```
    Clone a thawed version of this class, according to the Freezable interface.
    Specified by:
    cloneAsThawed in interface Freezable<UnicodeSet>
    Returns:
    the clone, not frozen
    Status:
    Stable ICU 4.4.
  - ranges
```
public Iterable<UnicodeSet.EntryRange> ranges()
```
    Provide for faster iteration than by String. Returns an Iterable/Iterator over ranges of code points. The UnicodeSet must not be altered during the iteration. The EntryRange instance is the same each time; the contents are just reset.
    Warning:To iterate over the full contents, you have to also iterate over the strings.
    Warning:For speed, UnicodeSet iteration does not check for concurrent modification. Do not alter the UnicodeSet while iterating.
```
 // Sample code for (EntryRange range : us1.ranges()) {     // do something with code points between range.codepoint and range.codepointEnd; } for (String s : us1.strings()) {     // do something with each string; }
```
    Status:
    Stable ICU 54.
  - iterator
```
public Iterator<String> iterator()
```
    Returns a string iterator. Uses the same order of iteration asUnicodeSetIterator.
    Warning:For speed, UnicodeSet iteration does not check for concurrent modification. Do not alter the UnicodeSet while iterating.
    Specified by:
    iterator in interface Iterable<String>
    See Also:
    Set.iterator()
    Status:
    Stable ICU 4.4.
  - containsAll
```
public <T extendsCharSequence> boolean containsAll(Iterable<T> collection)
```
    See Also:
    containsAll(com.ibm.icu.text.UnicodeSet)
    Status:
    Stable ICU 4.4.
  - containsNone
```
public <T extendsCharSequence> boolean containsNone(Iterable<T> collection)
```
    See Also:
    containsNone(com.ibm.icu.text.UnicodeSet)
    Status:
    Stable ICU 4.4.
  - containsSome
```
public final <T extendsCharSequence> boolean containsSome(Iterable<T> collection)
```
    See Also:
    containsAll(com.ibm.icu.text.UnicodeSet)
    Status:
    Stable ICU 4.4.
  - addAll
```
public <T extendsCharSequence> UnicodeSet addAll(T... collection)
```
    See Also:
    addAll(com.ibm.icu.text.UnicodeSet)
    Status:
    Stable ICU 4.4.
  - removeAll
```
public <T extendsCharSequence> UnicodeSet removeAll(Iterable<T> collection)
```
    See Also:
    removeAll(com.ibm.icu.text.UnicodeSet)
    Status:
    Stable ICU 4.4.
  - retainAll
```
public <T extendsCharSequence> UnicodeSet retainAll(Iterable<T> collection)
```
    See Also:
    retainAll(com.ibm.icu.text.UnicodeSet)
    Status:
    Stable ICU 4.4.
  - compareTo
```
public int compareTo(UnicodeSet o)
```
    Compares UnicodeSets, where shorter come first, and otherwise lexicographically (according to the comparison of the first characters that differ).
    Specified by:
    compareTo in interface Comparable<UnicodeSet>
    See Also:
    Comparable.compareTo(java.lang.Object)
    Status:
    Stable ICU 4.4.
  - compareTo
```
public int compareTo(UnicodeSet o,UnicodeSet.ComparisonStyle style)
```
    Compares UnicodeSets, in three different ways.
    See Also:
    Comparable.compareTo(java.lang.Object)
    Status:
    Stable ICU 4.4.
  - compareTo
```
public int compareTo(Iterable<String> other)
```
    Status:
    Stable ICU 4.4.
  - compare
```
public static int compare(CharSequence string,                          int codePoint)
```
    Utility to compare a string to a code point. Same results as turning the code point into a string (with the [ugly] new StringBuilder().appendCodePoint(codepoint).toString()) and comparing, but much faster (no object creation). Actually, there is one difference; a null compares as less. Note that this (=String) order is UTF-16 order --not code point order.
    Status:
    Stable ICU 4.4.
  - compare
```
public static int compare(int codePoint,CharSequence string)
```
    Utility to compare a string to a code point. Same results as turning the code point into a string and comparing, but much faster (no object creation). Actually, there is one difference; a null compares as less. Note that this (=String) order is UTF-16 order --not code point order.
    Status:
    Stable ICU 4.4.
  - compare
```
public static <T extendsComparable<T>> int compare(Iterable<T> collection1,Iterable<T> collection2)
```
    Utility to compare two iterables. Warning: the ordering in iterables is important. For Collections that are ordered, like Lists, that is expected. However, Sets in Java violate Leibniz's law when it comes to iteration. That means that sets can't be compared directly with this method, unless they are TreeSets without (or with the same) comparator. Unfortunately, it is impossible to reliably detect in Java whether subclass of Collection satisfies the right criteria, so it is left to the user to avoid those circumstances.
    Status:
    Stable ICU 4.4.
  - compare
```
@Deprecatedpublic static <T extendsComparable<T>> int compare(Iterator<T> first,Iterator<T> other)
```
    Deprecated. This API is ICU internal only.
    Utility to compare two iterators. Warning: the ordering in iterables is important. For Collections that are ordered, like Lists, that is expected. However, Sets in Java violate Leibniz's law when it comes to iteration. That means that sets can't be compared directly with this method, unless they are TreeSets without (or with the same) comparator. Unfortunately, it is impossible to reliably detect in Java whether subclass of Collection satisfies the right criteria, so it is left to the user to avoid those circumstances.
    Status:
    Internal.
  - compare
```
public static <T extendsComparable<T>> int compare(Collection<T> collection1,Collection<T> collection2,UnicodeSet.ComparisonStyle style)
```
    Utility to compare two collections, optionally by size, and then lexicographically.
    Status:
    Stable ICU 4.4.
  - addAllTo
```
public static <T,U extendsCollection<T>> U addAllTo(Iterable<T> source,                                                     U target)
```
    Utility for adding the contents of an iterable to a collection.
    Status:
    Stable ICU 4.4.
  - addAllTo
```
public static <T> T[] addAllTo(Iterable<T> source,                               T[] target)
```
    Utility for adding the contents of an iterable to a collection.
    Status:
    Stable ICU 4.4.
  - strings
```
public Collection<String> strings()
```
    For iterating through the strings in the set. Example:
```
 for (String key : myUnicodeSet.strings()) {   doSomethingWith(key); }
```
    Status:
    Stable ICU 4.4.
  - getSingleCodePoint
```
@Deprecatedpublic static int getSingleCodePoint(CharSequence s)
```
    Deprecated. This API is ICU internal only.
    Return the value of the first code point, if the string is exactly one code point. Otherwise return Integer.MAX_VALUE.
    Status:
    Internal.
  - addBridges
```
@Deprecatedpublic UnicodeSet addBridges(UnicodeSet dontCare)
```
    Deprecated. This API is ICU internal only.
    Simplify the ranges in a Unicode set by merging any ranges that are only separated by characters in the dontCare set. For example, the ranges: \\u2E80-\\u2E99\\u2E9B-\\u2EF3\\u2F00-\\u2FD5\\u2FF0-\\u2FFB\\u3000-\\u303E change to \\u2E80-\\u303E if the dontCare set includes unassigned characters (for a particular version of Unicode).
    Parameters:
    dontCare - Set with the don't-care characters for spanning
    Returns:
    the input set, modified
    Status:
    Internal.
  - findIn
```
@Deprecatedpublic int findIn(CharSequence value,                              int fromIndex,                              boolean findNot)
```
    Deprecated. This API is ICU internal only. Use span instead.
    Find the first index at or after fromIndex where the UnicodeSet matches at that index. If findNot is true, then reverse the sense of the match: find the first place where the UnicodeSet doesn't match. If there is no match, length is returned.
    Status:
    Internal.
  - findLastIn
```
@Deprecatedpublic int findLastIn(CharSequence value,                                  int fromIndex,                                  boolean findNot)
```
    Deprecated. This API is ICU internal only. Use spanBack instead.
    Find the last index before fromIndex where the UnicodeSet matches at that index. If findNot is true, then reverse the sense of the match: find the last place where the UnicodeSet doesn't match. If there is no match, -1 is returned. BEFORE index is not in the UnicodeSet.
    Status:
    Internal.
  - stripFrom
```
@Deprecatedpublic String stripFrom(CharSequence source,                                    boolean matches)
```
    Deprecated. This API is ICU internal only. Use replaceFrom.
    Strips code points from source. If matches is true, script all that matchthis. If matches is false, then strip all thatdon't match.
    Parameters:
    source - The source of the CharSequence to strip from.
    matches - A boolean to either strip all that matches or don't match with the current UnicodeSet object.
    Returns:
    The string after it has been stripped.
    Status:
    Internal.
  - getDefaultXSymbolTable
```
@Deprecatedpublic static UnicodeSet.XSymbolTable getDefaultXSymbolTable()
```
    Deprecated. This API is ICU internal only.
    Get the default symbol table. Null means ordinary processing. For internal use only.
    Returns:
    the symbol table
    Status:
    Internal.
  - setDefaultXSymbolTable
```
@Deprecatedpublic static void setDefaultXSymbolTable(UnicodeSet.XSymbolTable xSymbolTable)
```
    Deprecated. This API is ICU internal only.
    Set the default symbol table. Null means ordinary processing. For internal use only. Will affect all subsequent parsing of UnicodeSets.
    WARNING: If this function is used with a UnicodeProperty, and the Unassigned characters (gc=Cn) are different than in ICU, you MUST callUnicodeProperty.ResetCacheProperties afterwards. If you then callUnicodeSet.setDefaultXSymbolTable with null to clear the value, you MUST also callUnicodeProperty.ResetCacheProperties.
    Parameters:
    xSymbolTable - the new default symbol table.
    Status:
    Internal.
  - rangeStream
```
public Stream<UnicodeSet.EntryRange> rangeStream()
```
    Returns aStream ofUnicodeSet.EntryRange values from thisUnicodeSet.
    Warnings:
    - TheUnicodeSet.EntryRange instance is the same each time; the contents are just reset.
    - To iterate over the full contents, you have to also iterate over the strings.
    - For speed,UnicodeSet iteration does not check for concurrent modification.
      Do not alter theUnicodeSet while iterating.
    Returns:
    aStream ofUnicodeSet.EntryRange
    Status:
    Draft ICU 76.
  - stringStream
```
public Stream<String> stringStream()
```
    Returns aStream ofString values from thisUnicodeSet.
    Warnings:
    - To iterate over the full contents, you have to also iterate over the ranges or code points.
    - For speed,UnicodeSet iteration does not check for concurrent modification.
      Do not alter theUnicodeSet while iterating.
    Returns:
    aStream ofString
    Status:
    Draft ICU 76.
  - codePointStream
```
public IntStream codePointStream()
```
    Returns anIntStream of Unicode code point values from thisUnicodeSet.
    Warnings:
    - To iterate over the full contents, you have to also iterate over the strings.
    - For speed,UnicodeSet iteration does not check for concurrent modification.
      Do not alter theUnicodeSet while iterating.
    Returns:
    anIntStream of Unicode code point values
    Status:
    Draft ICU 76.
  - stream
```
public Stream<String> stream()
```
    Returns a stream ofString values from thisUnicodeSet.
    Warnings:
    - To iterate over the full contents, you have to also iterate over the strings.
    - For speed,UnicodeSet iteration does not check for concurrent modification.
      Do not alter theUnicodeSet while iterating.
    Returns:
    aStream ofString
    Status:
    Draft ICU 76.
  - codePoints
```
public Iterable<Integer> codePoints()
```
    Returns anIterable for iteration over all the code points in this set.
    Warnings:
    - This is a convenience method, but comes with a performance penalty because it boxesint intoInteger.
      For an efficient but old alternative useUnicodeSetIterator.next().
    - To iterate over the full contents, you have to also iterate over the strings.
    - For speed,UnicodeSet iteration does not check for concurrent modification.
      Do not alter theUnicodeSet while iterating.
    Returns:
    anIterable over all the code points
    Status:
    Draft ICU 76.

`[]`	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 :=`	`'0' \| '1' \| '2' \| '3' \| '4' \| '5' \| '6' \| '7' \| '8' \| '9' \| 'A' \| 'B' \| 'C' \| 'D' \| 'E' \| 'F' \| 'a' \| 'b' \| 'c' \| 'd' \| 'e' \| 'f'`
`property :=`	a Unicode property set pattern

Movatterモバイル変換

Class UnicodeSet

Nested Class Summary

Field Summary

Fields inherited from interface com.ibm.icu.text.UnicodeMatcher

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.lang.Iterable

Field Detail

EMPTY

ALL_CODE_POINTS

MIN_VALUE

MAX_VALUE

IGNORE_SPACE

CASE

CASE_INSENSITIVE

ADD_CASE_MAPPINGS

SIMPLE_CASE_INSENSITIVE

Constructor Detail

UnicodeSet

UnicodeSet

UnicodeSet

UnicodeSet

UnicodeSet

UnicodeSet

UnicodeSet

UnicodeSet

UnicodeSet

Method Detail

clone

set

set

applyPattern

applyPattern

applyPattern

resemblesPattern

toPattern

_generatePattern

_generatePattern

size

isEmpty

hasStrings

matchesIndexValue

matches

matchesAt

addMatchSetTo

indexOf

charAt

add

addAll

add

add

addAll

retainAll

complementAll

removeAll

removeAllStrings

from

fromAll

retain

retain

retain

remove

remove

remove

complement

complement

complement

complement

contains

contains

contains

containsAll

containsAll

getRegexEquivalent

containsNone

containsNone

containsNone

containsSome