com.google.common.base

## Class CharMatcher

- java.lang.Object
- - com.google.common.base.CharMatcher

- All Implemented Interfaces:
    Predicate<java.lang.Character>

      @Beta
      @GwtCompatible(emulated=true)
      public abstract class CharMatcher
      extends java.lang.Object
      implements Predicate<java.lang.Character>

  Determines a true or false value for any Java `char` value, just as `Predicate` does for any `Object`. Also offers basic text processing methods based on this function. Implementations are strongly encouraged to be side-effect-free and immutable.

  Throughout the documentation of this class, the phrase "matching character" is used to mean "any character `c` for which `this.matches(c)` returns `true`".

  Note: This class deals only with `char` values; it does not understand supplementary Unicode code points in the range `0x10000` to `0x10FFFF`. Such logical characters are encoded into a `String` using surrogate pairs, and a `CharMatcher` treats these just as two separate characters.

  Example usages:

         String trimmed = whitespace().trimFrom(userInput);
         if (ascii().matchesAllOf(s)) { ... }

  See the Guava User Guide article on `CharMatcher`.

  Since:
    1.0

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static CharMatcher` | `ANY` Matches any character.
    `static CharMatcher` | `ASCII` Determines whether a character is ASCII, meaning that its code point is less than 128.
    `static CharMatcher` | `BREAKING_WHITESPACE` Determines whether a character is a breaking whitespace (that is, a whitespace which can be interpreted as a break between words for formatting purposes).
    `static CharMatcher` | `DIGIT` Determines whether a character is a digit according to Unicode.
    `static CharMatcher` | `INVISIBLE` 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.
    `static CharMatcher` | `JAVA_DIGIT` Determines whether a character is a digit according to Java's definition.
    `static CharMatcher` | `JAVA_ISO_CONTROL` Determines whether a character is an ISO control character as specified by `Character.isISOControl(char)`.
    `static CharMatcher` | `JAVA_LETTER` Determines whether a character is a letter according to Java's definition.
    `static CharMatcher` | `JAVA_LETTER_OR_DIGIT` Determines whether a character is a letter or digit according to Java's definition.
    `static CharMatcher` | `JAVA_LOWER_CASE` Determines whether a character is lower case according to Java's definition.
    `static CharMatcher` | `JAVA_UPPER_CASE` Determines whether a character is upper case according to Java's definition.
    `static CharMatcher` | `NONE` Matches no characters.
    `static CharMatcher` | `SINGLE_WIDTH` Determines whether a character is single-width (not double-width).
    `static CharMatcher` | `WHITESPACE` Determines whether a character is whitespace according to the latest Unicode standard, as illustrated here.

  - ### Constructor Summary

    Constructors
    Modifier | Constructor and Description
    --- | ---
    `protected` | `CharMatcher()` Constructor for use by subclasses.

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `CharMatcher` | `and(CharMatcher other)` Returns a matcher that matches any character matched by both this matcher and `other`.
    `static CharMatcher` | `any()` Matches any character.
    `static CharMatcher` | `anyOf(java.lang.CharSequence sequence)` Returns a `char` matcher that matches any character present in the given character sequence.
    `boolean` | `apply(java.lang.Character character)` Deprecated. Provided only to satisfy the `Predicate` interface; use `matches(char)` instead.
    `static CharMatcher` | `ascii()` Determines whether a character is ASCII, meaning that its code point is less than 128.
    `static CharMatcher` | `breakingWhitespace()` Determines whether a character is a breaking whitespace (that is, a whitespace which can be interpreted as a break between words for formatting purposes).
    `java.lang.String` | `collapseFrom(java.lang.CharSequence sequence, char replacement)` 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.
    `int` | `countIn(java.lang.CharSequence sequence)` Returns the number of matching characters found in a character sequence.
    `static CharMatcher` | `digit()` Determines whether a character is a digit according to Unicode.
    `static CharMatcher` | `forPredicate(Predicate<? super java.lang.Character> predicate)` Returns a matcher with identical behavior to the given `Character`-based predicate, but which operates on primitive `char` instances instead.
    `int` | `indexIn(java.lang.CharSequence sequence)` Returns the index of the first matching character in a character sequence, or `-1` if no matching character is present.
    `int` | `indexIn(java.lang.CharSequence sequence, int start)` 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.
    `static CharMatcher` | `inRange(char startInclusive, char endInclusive)` Returns a `char` matcher that matches any character in a given range (both endpoints are inclusive).
    `static CharMatcher` | `invisible()` 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.
    `static CharMatcher` | `is(char match)` Returns a `char` matcher that matches only one specified character.
    `static CharMatcher` | `isNot(char match)` Returns a `char` matcher that matches any character except the one specified.
    `static CharMatcher` | `javaDigit()` Determines whether a character is a digit according to Java's definition.
    `static CharMatcher` | `javaIsoControl()` Determines whether a character is an ISO control character as specified by `Character.isISOControl(char)`.
    `static CharMatcher` | `javaLetter()` Determines whether a character is a letter according to Java's definition.
    `static CharMatcher` | `javaLetterOrDigit()` Determines whether a character is a letter or digit according to Java's definition.
    `static CharMatcher` | `javaLowerCase()` Determines whether a character is lower case according to Java's definition.
    `static CharMatcher` | `javaUpperCase()` Determines whether a character is upper case according to Java's definition.
    `int` | `lastIndexIn(java.lang.CharSequence sequence)` Returns the index of the last matching character in a character sequence, or `-1` if no matching character is present.
    `abstract boolean` | `matches(char c)` Determines a true or false value for the given character.
    `boolean` | `matchesAllOf(java.lang.CharSequence sequence)` Returns `true` if a character sequence contains only matching characters.
    `boolean` | `matchesAnyOf(java.lang.CharSequence sequence)` Returns `true` if a character sequence contains at least one matching character.
    `boolean` | `matchesNoneOf(java.lang.CharSequence sequence)` Returns `true` if a character sequence contains no matching characters.
    `CharMatcher` | `negate()` Returns a matcher that matches any character not matched by this matcher.
    `static CharMatcher` | `none()` Matches no characters.
    `static CharMatcher` | `noneOf(java.lang.CharSequence sequence)` Returns a `char` matcher that matches any character not present in the given character sequence.
    `CharMatcher` | `or(CharMatcher other)` Returns a matcher that matches any character matched by either this matcher or `other`.
    `CharMatcher` | `precomputed()` Returns a `char` matcher functionally equivalent to this one, but which may be faster to query than the original; your mileage may vary.
    `java.lang.String` | `removeFrom(java.lang.CharSequence sequence)` Returns a string containing all non-matching characters of a character sequence, in order.
    `java.lang.String` | `replaceFrom(java.lang.CharSequence sequence, char replacement)` Returns a string copy of the input character sequence, with each character that matches this matcher replaced by a given replacement character.
    `java.lang.String` | `replaceFrom(java.lang.CharSequence sequence, java.lang.CharSequence replacement)` Returns a string copy of the input character sequence, with each character that matches this matcher replaced by a given replacement sequence.
    `java.lang.String` | `retainFrom(java.lang.CharSequence sequence)` Returns a string containing all matching characters of a character sequence, in order.
    `static CharMatcher` | `singleWidth()` Determines whether a character is single-width (not double-width).
    `java.lang.String` | `toString()` Returns a string representation of this `CharMatcher`, such as `CharMatcher.or(WHITESPACE, JAVA_DIGIT)`.
    `java.lang.String` | `trimAndCollapseFrom(java.lang.CharSequence sequence, char replacement)` Collapses groups of matching characters exactly as `collapseFrom(java.lang.CharSequence, char)` does, except that groups of matching characters at the start or end of the sequence are removed without replacement.
    `java.lang.String` | `trimFrom(java.lang.CharSequence sequence)` 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.
    `java.lang.String` | `trimLeadingFrom(java.lang.CharSequence sequence)` Returns a substring of the input character sequence that omits all characters this matcher matches from the beginning of the string.
    `java.lang.String` | `trimTrailingFrom(java.lang.CharSequence sequence)` Returns a substring of the input character sequence that omits all characters this matcher matches from the end of the string.
    `static CharMatcher` | `whitespace()` Determines whether a character is whitespace according to the latest Unicode standard, as illustrated here.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

    - ### Methods inherited from interface com.google.common.base.Predicate

      `equals`

- - ### Field Detail

    - #### WHITESPACE

          public static final CharMatcher WHITESPACE

      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".)

      Note: as the Unicode definition evolves, we will modify this constant to keep it up to date.

    - #### BREAKING_WHITESPACE

          public static final CharMatcher BREAKING_WHITESPACE

      Determines whether a character is a breaking whitespace (that is, a whitespace which can be interpreted as a break between words for formatting purposes). See `WHITESPACE` for a discussion of that term.
      Since:
        2.0

    - #### ASCII

          public static final CharMatcher ASCII

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

    - #### DIGIT

          public static final CharMatcher DIGIT

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

    - #### JAVA_DIGIT

          public static final CharMatcher JAVA_DIGIT

      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')`.

    - #### JAVA_LETTER

          public static final CharMatcher JAVA_LETTER

      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'))`.

    - #### JAVA_LETTER_OR_DIGIT

          public static final CharMatcher JAVA_LETTER_OR_DIGIT

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

    - #### JAVA_UPPER_CASE

          public static final CharMatcher JAVA_UPPER_CASE

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

    - #### JAVA_LOWER_CASE

          public static final CharMatcher JAVA_LOWER_CASE

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

    - #### JAVA_ISO_CONTROL

          public static final CharMatcher JAVA_ISO_CONTROL

      Determines whether a character is an ISO control character as specified by `Character.isISOControl(char)`.

    - #### INVISIBLE

          public static final CharMatcher INVISIBLE

      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.

    - #### SINGLE_WIDTH

          public static final CharMatcher SINGLE_WIDTH

      Determines whether a character is single-width (not double-width). When in doubt, this matcher errs on the side of returning `false` (that is, it tends to assume a character is double-width).

      Note: as the reference file evolves, we will modify this constant to keep it up to date.

    - #### ANY

          public static final CharMatcher ANY

      Matches any character.

    - #### NONE

          public static final CharMatcher NONE

      Matches no characters.

  - ### Constructor Detail

    - #### CharMatcher

          protected CharMatcher()

      Constructor for use by subclasses. When subclassing, you may want to override `toString()` to provide a useful description.

  - ### Method Detail

    - #### any

          public static CharMatcher any()

      Matches any character.
      Since:
        19.0 (since 1.0 as constant `ANY`)

    - #### none

          public static CharMatcher none()

      Matches no characters.
      Since:
        19.0 (since 1.0 as constant `NONE`)

    - #### whitespace

          public static CharMatcher whitespace()

      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".)

      Note: as the Unicode definition evolves, we will modify this matcher to keep it up to date.

      Since:
        19.0 (since 1.0 as constant `WHITESPACE`)

    - #### breakingWhitespace

          public static CharMatcher breakingWhitespace()

      Determines whether a character is a breaking whitespace (that is, a whitespace which can be interpreted as a break between words for formatting purposes). See `whitespace()` for a discussion of that term.
      Since:
        19.0 (since 2.0 as constant `BREAKING_WHITESPACE`)

    - #### ascii

          public static CharMatcher ascii()

      Determines whether a character is ASCII, meaning that its code point is less than 128.
      Since:
        19.0 (since 1.0 as constant `ASCII`)

    - #### digit

          public static CharMatcher digit()

      Determines whether a character is a digit according to Unicode. If you only care to match ASCII digits, you can use `inRange('0', '9')`.
      Since:
        19.0 (since 1.0 as constant `DIGIT`)

    - #### javaDigit

          public static CharMatcher javaDigit()

      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')`.
      Since:
        19.0 (since 1.0 as constant `JAVA_DIGIT`)

    - #### javaLetter

          public static CharMatcher javaLetter()

      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'))`.
      Since:
        19.0 (since 1.0 as constant `JAVA_LETTER`)

    - #### javaLetterOrDigit

          public static CharMatcher javaLetterOrDigit()

      Determines whether a character is a letter or digit according to Java's definition.
      Since:
        19.0 (since 1.0 as constant `JAVA_LETTER_OR_DIGIT`).

    - #### javaUpperCase

          public static CharMatcher javaUpperCase()

      Determines whether a character is upper case according to Java's definition.
      Since:
        19.0 (since 1.0 as constant `JAVA_UPPER_CASE`)

    - #### javaLowerCase

          public static CharMatcher javaLowerCase()

      Determines whether a character is lower case according to Java's definition.
      Since:
        19.0 (since 1.0 as constant `JAVA_LOWER_CASE`)

    - #### javaIsoControl

          public static CharMatcher javaIsoControl()

      Determines whether a character is an ISO control character as specified by `Character.isISOControl(char)`.
      Since:
        19.0 (since 1.0 as constant `JAVA_ISO_CONTROL`)

    - #### invisible

          public static CharMatcher invisible()

      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.
      Since:
        19.0 (since 1.0 as constant `INVISIBLE`)

    - #### singleWidth

          public static CharMatcher singleWidth()

      Determines whether a character is single-width (not double-width). When in doubt, this matcher errs on the side of returning `false` (that is, it tends to assume a character is double-width).

      Note: as the reference file evolves, we will modify this matcher to keep it up to date.

      Since:
        19.0 (since 1.0 as constant `SINGLE_WIDTH`)

    - #### is

          public static CharMatcher is(char match)

      Returns a `char` matcher that matches only one specified character.

    - #### isNot

          public static CharMatcher isNot(char match)

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

      To negate another `CharMatcher`, use `negate()`.

    - #### anyOf

          public static CharMatcher anyOf(java.lang.CharSequence sequence)

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

    - #### noneOf

          public static CharMatcher noneOf(java.lang.CharSequence sequence)

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

    - #### inRange

          public static CharMatcher inRange(char startInclusive,
                            char endInclusive)

      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')`.
      Throws:
        `java.lang.IllegalArgumentException` - if `endInclusive < startInclusive`

    - #### forPredicate

          public static CharMatcher forPredicate(Predicate<? super java.lang.Character> predicate)

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

    - #### matches

          public abstract boolean matches(char c)

      Determines a true or false value for the given character.

    - #### negate

          public CharMatcher negate()

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

    - #### and

          public CharMatcher and(CharMatcher other)

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

    - #### or

          public CharMatcher or(CharMatcher other)

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

    - #### precomputed

          public CharMatcher precomputed()

      Returns a `char` matcher functionally equivalent to this one, but which may be faster to query than the original; your mileage may vary. Precomputation takes time and is likely to be worthwhile only if the precomputed matcher is queried many thousands of times.

      This method has no effect (returns `this`) when called in GWT: it's unclear whether a precomputed matcher is faster, but it certainly consumes more memory, which doesn't seem like a worthwhile tradeoff in a browser.

    - #### matchesAnyOf

          public boolean matchesAnyOf(java.lang.CharSequence sequence)

      Returns `true` if a character sequence contains at least one matching character. Equivalent to `!matchesNoneOf(sequence)`.

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

      Parameters:
        `sequence` - the character sequence to examine, possibly empty
      Returns:
        `true` if this matcher matches at least one character in the sequence
      Since:
        8.0

    - #### matchesAllOf

          public boolean matchesAllOf(java.lang.CharSequence sequence)

      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.

      Parameters:
        `sequence` - the character sequence to examine, possibly empty
      Returns:
        `true` if this matcher matches every character in the sequence, including when the sequence is empty

    - #### matchesNoneOf

          public boolean matchesNoneOf(java.lang.CharSequence sequence)

      Returns `true` if a character sequence contains no matching characters. Equivalent to `!matchesAnyOf(sequence)`.

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

      Parameters:
        `sequence` - the character sequence to examine, possibly empty
      Returns:
        `true` if this matcher matches every character in the sequence, including when the sequence is empty

    - #### indexIn

          public int indexIn(java.lang.CharSequence sequence)

      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.

      Parameters:
        `sequence` - the character sequence to examine from the beginning
      Returns:
        an index, or `-1` if no character matches

    - #### indexIn

          public int indexIn(java.lang.CharSequence sequence,
                    int start)

      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.

      Parameters:
        `sequence` - the character sequence to examine
        `start` - the first index to examine; must be nonnegative and no greater than `sequence.length()`
      Returns:
        the index of the first matching character, guaranteed to be no less than `start`, or `-1` if no character matches
      Throws:
        `java.lang.IndexOutOfBoundsException` - if start is negative or greater than `sequence.length()`

    - #### lastIndexIn

          public int lastIndexIn(java.lang.CharSequence sequence)

      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.

      Parameters:
        `sequence` - the character sequence to examine from the end
      Returns:
        an index, or `-1` if no character matches

    - #### countIn

          public int countIn(java.lang.CharSequence sequence)

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

    - #### removeFrom

          @CheckReturnValue
          public java.lang.String removeFrom(java.lang.CharSequence sequence)

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

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

      ... returns `"bzr"`.

    - #### retainFrom

          @CheckReturnValue
          public java.lang.String retainFrom(java.lang.CharSequence sequence)

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

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

      ... returns `"aaa"`.

    - #### replaceFrom

          @CheckReturnValue
          public java.lang.String replaceFrom(java.lang.CharSequence sequence,
                                                      char replacement)

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

      ... returns `"rodor"`.

      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.

      Parameters:
        `sequence` - the character sequence to replace matching characters in
        `replacement` - the character to append to the result string in place of each matching character in `sequence`
      Returns:
        the new string

    - #### replaceFrom

          @CheckReturnValue
          public java.lang.String replaceFrom(java.lang.CharSequence sequence,
                                                      java.lang.CharSequence replacement)

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

      ... returns `"yoohoo"`.

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

      Parameters:
        `sequence` - the character sequence to replace matching characters in
        `replacement` - the characters to append to the result string in place of each matching character in `sequence`
      Returns:
        the new string

    - #### trimFrom

          @CheckReturnValue
          public java.lang.String trimFrom(java.lang.CharSequence sequence)

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

      ... returns `"cat"`.

      Note that:

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

      ... is equivalent to `String.trim()`.

    - #### trimLeadingFrom

          @CheckReturnValue
          public java.lang.String trimLeadingFrom(java.lang.CharSequence sequence)

      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 `"catbab"`.

    - #### trimTrailingFrom

          @CheckReturnValue
          public java.lang.String trimTrailingFrom(java.lang.CharSequence sequence)

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

      ... returns `"abacat"`.

    - #### collapseFrom

          @CheckReturnValue
          public java.lang.String collapseFrom(java.lang.CharSequence sequence,
                                                       char replacement)

      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", '-')

      ... returns `"b-p-r"`.

      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.

      Parameters:
        `sequence` - the character sequence to replace matching groups of characters in
        `replacement` - the character to append to the result string in place of each group of matching characters in `sequence`
      Returns:
        the new string

    - #### trimAndCollapseFrom

          @CheckReturnValue
          public java.lang.String trimAndCollapseFrom(java.lang.CharSequence sequence,
                                                              char replacement)

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

    - #### apply

          @Deprecated
          public boolean apply(java.lang.Character character)

      Deprecated. Provided only to satisfy the `Predicate` interface; use `matches(char)` instead.
      Description copied from interface: `Predicate`
      Returns the result of applying this predicate to `input`. This method is generally expected, but not absolutely required, to have the following properties:
      - Its execution does not cause any observable side effects.
      - The computation is consistent with equals; that is, `Objects.equal``(a, b)` implies that `predicate.apply(a) == predicate.apply(b))`.
      Specified by:
        `apply` in interface `Predicate<java.lang.Character>`

    - #### toString

          public java.lang.String toString()

      Returns a string representation of this `CharMatcher`, such as `CharMatcher.or(WHITESPACE, JAVA_DIGIT)`.
      Overrides:
        `toString` in class `java.lang.Object`