CharMatcher

Matches any character.

Determines whether a character is ASCII, meaning that its code point is less than 128.

Determines whether a character is a digit according to Unicode.

Determines whether a character is invisible; that is, if its Unicode category is any of SPACE_SEPARATOR, LINE_SEPARATOR, PARAGRAPH_SEPARATOR, CONTROL, FORMAT, SURROGATE, and PRIVATE_USE according to ICU4J.

Determines whether a character is a digit according to Java's definition. If you only care to match ASCII digits, you can use inRange('0', '9').

Determines whether a character is an ISO control character according to isISOControl(char).

Determines whether a character is a letter according to Java's definition. If you only care to match letters of the Latin alphabet, you can use inRange('a', 'z').or(inRange('A', 'Z')).

Determines whether a character is a letter or digit according to Java's definition.

Determines whether a character is lower case according to Java's definition.

Determines whether a character is upper case according to Java's definition.

Determines whether a character is whitespace according to Java's definition; it is usually preferable to use WHITESPACE. See a comparison of several definitions of "whitespace" at go/white+space.

Determines whether a character is whitespace according to an arbitrary definition used by StringUtil for years. Most likely you don't want to use this. See a comparison of several definitions of "whitespace" at go/white+space.

Matches no characters.

Determines whether a character is whitespace according to the latest Unicode standard, as illustrated here. This is not the same definition used by other Java APIs. See a comparison of several definitions of "whitespace" at go/white+space. Note: as the Unicode definition evolves, we will modify this constant to keep it up to date.

Returns a matcher that matches any character matched by both this matcher and other.

Returns a char matcher that matches any character present in the given character sequence.

Returns true if this matcher matches the given character.

Returns a string copy of the input character sequence, with each group of consecutive characters that match this matcher replaced by a single replacement character. For example:

   CharMatcher.anyOf("eko").collapseFrom("bookkeeper", '-')

The default implementation uses indexIn(CharSequence) to find the first matching character, then iterates the remainder of the sequence calling matches(char) for each character.

Returns the number of matching characters found in a character sequence.

Returns a matcher with identical behavior to the given Character-based predicate, but which operates on primitive char instances instead.

Returns a char matcher that matches any character in a given range (both endpoints are inclusive). For example, to match any lowercase letter of the English alphabet, use CharMatcher.inRange('a', 'z').

Returns the index of the first matching character in a character sequence, or -1 if no matching character is present.

The default implementation iterates over the sequence in forward order calling matches(char) for each character.

Returns the index of the first matching character in a character sequence, starting from a given position, or -1 if no character matches after that position.

The default implementation iterates over the sequence in forward order, beginning at start, calling matches(char) for each character.

Returns a char matcher that matches only one specified character.

Returns a char matcher that matches any character except the one specified.

To negate another CharMatcher, use negate().

Returns the index of the last matching character in a character sequence, or -1 if no matching character is present.

The default implementation iterates over the sequence in reverse order calling matches(char) for each character.

Determines a true or false value for the given character.

Returns true if a character sequence contains only matching characters.

The default implementation iterates over the sequence, invoking matches(char) for each character, until this returns false or the end is reached.

Returns true if a character sequence contains no matching characters.

The default implementation iterates over the sequence, invoking matches(char) for each character, until this returns false or the end is reached.

Returns a matcher that matches any character not matched by this matcher.

Returns a char matcher that matches any character not present in the given character sequence.

Returns a matcher that matches any character matched by either this matcher or other.

Returns a char matcher functionally equivalent to this one, but with its configuration cached in an eight-kilobyte bit array. In some situations this produces a matcher which is faster to query than the original; your mileage may vary.

The default implementation creates a new bit array and passes it to setBits(LookupTable).

Returns a string containing all non-matching characters of a character sequence, in order. For example:

   CharMatcher.is('a').removeFrom("bazaar")

Returns a string copy of the input character sequence, with each character that matches this matcher replaced by a given replacement character. For example:

   CharMatcher.is('a').replaceFrom("radar", 'o')

The default implementation uses indexIn(CharSequence) to find the first matching character, then iterates the remainder of the sequence calling matches(char) for each character.

Returns a string copy of the input character sequence, with each character that matches this matcher replaced by a given replacement sequence. For example:

   CharMatcher.is('a').replaceFrom("yaha", "oo")

Note: If the replacement is a fixed string with only one character, you are better off calling replaceFrom(CharSequence, char) directly.

Returns a string containing all matching characters of a character sequence, in order. For example:

   CharMatcher.is('a').retainFrom("bazaar")

Collapses groups of matching characters exactly as collapseFrom(CharSequence, char) does, except that groups of matching characters at the start or end of the sequence are removed without replacement.

Returns a substring of the input character sequence that omits all characters this matcher matches from the beginning and from the end of the string. For example:

 CharMatcher.anyOf("ab").trimFrom("abacatbab")

Note that

   CharMatcher.inRange('\0', ' ').trimFrom(str)

Returns a substring of the input character sequence that omits all characters this matcher matches from the beginning of the string. For example:

 CharMatcher.anyOf("ab").trimLeadingFrom("abacatbab")

Returns a substring of the input character sequence that omits all characters this matcher matches from the end of the string. For example:

 CharMatcher.anyOf("ab").trimTrailingFrom("abacatbab")

For use by implementors; sets the bit corresponding to each character ('\0' to '￿') that matches this matcher in the given bit array, leaving all other bits untouched.

The default implementation loops over every possible character value, invoking matches(char) for each one.