| (1 << LOWERCASE_LETTER)               | (1 << TITLECASE_LETTER)               | (1 << MODIFIER_LETTER)               | (1 << OTHER_LETTER)               | (1 << LETTER_NUMBER))) != 0;  }  /**   * Determines if a character can follow the first letter in   * a Unicode identifier. This includes letters, connecting punctuation,   * digits, numeric letters, combining marks, non-spacing marks, and   * isIdentifierIgnorable.   * <br>   * Unicode identifier extender =   *   [Lu]|[Ll]|[Lt]|[Lm]|[Lo]|[Nl]|[Mn]|[Mc]|[Nd]|[Pc]|[Cf]|   *   |U+0000-U+0008|U+000E-U+001B|U+007F-U+009F   *   * @param ch character to test   * @return true if ch can follow the first letter in a Unicode identifier   * @see #isIdentifierIgnorable(char)   * @see #isJavaIdentifierPart(char)   * @see #isLetterOrDigit(char)   * @see #isUnicodeIdentifierStart(char)   * @since 1.1   */  public static boolean isUnicodeIdentifierPart(char ch)  {    int category = getType(ch);    return ((1 << category)            & ((1 << UPPERCASE_LETTER)               | (1 << LOWERCASE_LETTER)               | (1 << TITLECASE_LETTER)               | (1 << MODIFIER_LETTER)               | (1 << OTHER_LETTER)               | (1 << NON_SPACING_MARK)               | (1 << COMBINING_SPACING_MARK)               | (1 << DECIMAL_DIGIT_NUMBER)               | (1 << LETTER_NUMBER)               | (1 << CONNECTOR_PUNCTUATION)               | (1 << FORMAT))) != 0      || (category == CONTROL && isIdentifierIgnorable(ch));  }  /**   * Determines if a character is ignorable in a Unicode identifier. This   * includes the non-whitespace ISO control characters (<code>'\u0000'</code>   * through <code>'\u0008'</code>, <code>'\u000E'</code> through   * <code>'\u001B'</code>, and <code>'\u007F'</code> through   * <code>'\u009F'</code>), and FORMAT characters.   * <br>   * Unicode identifier ignorable = [Cf]|U+0000-U+0008|U+000E-U+001B   *    |U+007F-U+009F   *   * @param ch character to test   * @return true if ch is ignorable in a Unicode or Java identifier   * @see #isJavaIdentifierPart(char)   * @see #isUnicodeIdentifierPart(char)   * @since 1.1   */  public static boolean isIdentifierIgnorable(char ch)  {    return (ch <= '\u009F' && (ch < '\t' || ch >= '\u007F'                               || (ch <= '\u001B' && ch >= '\u000E')))      || getType(ch) == FORMAT;  }  /**   * Converts a Unicode character into its lowercase equivalent mapping.   * If a mapping does not exist, then the character passed is returned.   * Note that isLowerCase(toLowerCase(ch)) does not always return true.   *   * @param ch character to convert to lowercase   * @return lowercase mapping of ch, or ch if lowercase mapping does   *         not exist   * @see #isLowerCase(char)   * @see #isUpperCase(char)   * @see #toTitleCase(char)   * @see #toUpperCase(char)   */  public static char toLowerCase(char ch)  {    // Signedness doesn't matter, as result is cast back to char.    return (char) (ch + lower[readChar(ch) >> 7]);  }  /**   * Converts a Unicode character into its uppercase equivalent mapping.   * If a mapping does not exist, then the character passed is returned.   * Note that isUpperCase(toUpperCase(ch)) does not always return true.   *   * @param ch character to convert to uppercase   * @return uppercase mapping of ch, or ch if uppercase mapping does   *         not exist   * @see #isLowerCase(char)   * @see #isUpperCase(char)   * @see #toLowerCase(char)   * @see #toTitleCase(char)   */  public static char toUpperCase(char ch)  {    // Signedness doesn't matter, as result is cast back to char.    return (char) (ch + upper[readChar(ch) >> 7]);  }  /**   * Converts a Unicode character into its titlecase equivalent mapping.   * If a mapping does not exist, then the character passed is returned.   * Note that isTitleCase(toTitleCase(ch)) does not always return true.   *   * @param ch character to convert to titlecase   * @return titlecase mapping of ch, or ch if titlecase mapping does   *         not exist   * @see #isTitleCase(char)   * @see #toLowerCase(char)   * @see #toUpperCase(char)   */  public static char toTitleCase(char ch)  {    // As title is short, it doesn't hurt to exhaustively iterate over it.    for (int i = title.length - 2; i >= 0; i -= 2)      if (title[i] == ch)        return title[i + 1];    return toUpperCase(ch);  }  /**   * Converts a character into a digit of the specified radix. If the radix   * exceeds MIN_RADIX or MAX_RADIX, or if the result of getNumericValue(ch)   * exceeds the radix, or if ch is not a decimal digit or in the case   * insensitive set of 'a'-'z', the result is -1.   * <br>   * character argument boundary = [Nd]|U+0041-U+005A|U+0061-U+007A   *    |U+FF21-U+FF3A|U+FF41-U+FF5A   *   * @param ch character to convert into a digit   * @param radix radix in which ch is a digit   * @return digit which ch represents in radix, or -1 not a valid digit   * @see #MIN_RADIX   * @see #MAX_RADIX   * @see #forDigit(int, int)   * @see #isDigit(char)   * @see #getNumericValue(char)   */  public static int digit(char ch, int radix)  {    if (radix < MIN_RADIX || radix > MAX_RADIX)      return -1;    char attr = readChar(ch);    if (((1 << (attr & TYPE_MASK))         & ((1 << UPPERCASE_LETTER)            | (1 << LOWERCASE_LETTER)            | (1 << DECIMAL_DIGIT_NUMBER))) != 0)      {        // Signedness doesn't matter; 0xffff vs. -1 are both rejected.        int digit = numValue[attr >> 7];        return (digit < radix) ? digit : -1;      }    return -1;  }  /**   * Returns the Unicode numeric value property of a character. For example,   * <code>'\\u216C'</code> (the Roman numeral fifty) returns 50.   *   * <p>This method also returns values for the letters A through Z, (not   * specified by Unicode), in these ranges: <code>'\u0041'</code>   * through <code>'\u005A'</code> (uppercase); <code>'\u0061'</code>   * through <code>'\u007A'</code> (lowercase); and <code>'\uFF21'</code>   * through <code>'\uFF3A'</code>, <code>'\uFF41'</code> through   * <code>'\uFF5A'</code> (full width variants).   *   * <p>If the character lacks a numeric value property, -1 is returned.   * If the character has a numeric value property which is not representable   * as a nonnegative integer, such as a fraction, -2 is returned.   *   * character argument boundary = [Nd]|[Nl]|[No]|U+0041-U+005A|U+0061-U+007A   *    |U+FF21-U+FF3A|U+FF41-U+FF5A   *   * @param ch character from which the numeric value property will   *        be retrieved   * @return the numeric value property of ch, or -1 if it does not exist, or   *         -2 if it is not representable as a nonnegative integer   * @see #forDigit(int, int)   * @see #digit(char, int)   * @see #isDigit(char)   * @since 1.1   */  public static int getNumericValue(char ch)  {    // Treat numValue as signed.    return (short) numValue[readChar(ch) >> 7];  }  /**   * Determines if a character is a ISO-LATIN-1 space. This is only the five   * characters <code>'\t'</code>, <code>'\n'</code>, <code>'\f'</code>,   * <code>'\r'</code>, and <code>' '</code>.   * <br>   * Java space = U+0020|U+0009|U+000A|U+000C|U+000D   *   * @param ch character to test   * @return true if ch is a space, else false   * @deprecated Replaced by {@link #isWhitespace(char)}   * @see #isSpaceChar(char)   * @see #isWhitespace(char)   */  public static boolean isSpace(char ch)  {    // Performing the subtraction up front alleviates need to compare longs.    return ch-- <= ' ' && ((1 << ch)                           & ((1 << (' ' - 1))                              | (1 << ('\t' - 1))                              | (1 << ('\n' - 1))                              | (1 << ('\r' - 1))                              | (1 << ('\f' - 1)))) != 0;  }  /**   * Determines if a character is a Unicode space character. This includes   * SPACE_SEPARATOR, LINE_SEPARATOR, and PARAGRAPH_SEPARATOR.   * <br>   * Unicode space = [Zs]|[Zp]|[Zl]   *   * @param ch character to test   * @return true if ch is a Unicode space, else false   * @see #isWhitespace(char)   * @since 1.1   */  public static boolean isSpaceChar(char ch)  {    return ((1 << getType(ch))            & ((1 << SPACE_SEPARATOR)               | (1 << LINE_SEPARATOR)               | (1 << PARAGRAPH_SEPARATOR))) != 0;  }  /**   * Determines if a character is Java whitespace. This includes Unicode   * space characters (SPACE_SEPARATOR, LINE_SEPARATOR, and   * PARAGRAPH_SEPARATOR) except the non-breaking spaces   * (<code>'\u00A0'</code>, <code>'\u2007'</code>, and <code>'\u202F'</code>);   * and these characters: <code>'\u0009'</code>, <code>'\u000A'</code>,   * <code>'\u000B'</code>, <code>'\u000C'</code>, <code>'\u000D'</code>,   * <code>'\u001C'</code>, <code>'\u001D'</code>, <code>'\u001E'</code>,   * and <code>'\u001F'</code>.   * <br>   * Java whitespace = ([Zs] not Nb)|[Zl]|[Zp]|U+0009-U+000D|U+001C-U+001F   *   * @param ch character to test   * @return true if ch is Java whitespace, else false   * @see #isSpaceChar(char)   * @since 1.1   */  public static boolean isWhitespace(char ch)  {    int attr = readChar(ch);    return ((((1 << (attr & TYPE_MASK))              & ((1 << SPACE_SEPARATOR)                 | (1 << LINE_SEPARATOR)                 | (1 << PARAGRAPH_SEPARATOR))) != 0)            && (attr & NO_BREAK_MASK) == 0)      || (ch <= '\u001F' && ((1 << ch)                             & ((1 << '\t')                                | (1 << '\n')                                | (1 << '\u000B')                                | (1 << '\u000C')                                | (1 << '\r')                                | (1 << '\u001C')                                | (1 << '\u001D')                                | (1 << '\u001E')                                | (1 << '\u001F'))) != 0);  }  /**   * Determines if a character has the ISO Control property.   * <br>   * ISO Control = [Cc]   *   * @param ch character to test   * @return true if ch is an ISO Control character, else false   * @see #isSpaceChar(char)   * @see #isWhitespace(char)   * @since 1.1   */  public static boolean isISOControl(char ch)  {    return getType(ch) == CONTROL;  }  /**   * Returns the Unicode general category property of a character.   *   * @param ch character from which the general category property will   *        be retrieved   * @return the character category property of ch as an integer   * @see #UNASSIGNED   * @see #UPPERCASE_LETTER   * @see #LOWERCASE_LETTER   * @see #TITLECASE_LETTER   * @see #MODIFIER_LETTER   * @see #OTHER_LETTER   * @see #NON_SPACING_MARK   * @see #ENCLOSING_MARK   * @see #COMBINING_SPACING_MARK   * @see #DECIMAL_DIGIT_NUMBER   * @see #LETTER_NUMBER   * @see #OTHER_NUMBER   * @see #SPACE_SEPARATOR   * @see #LINE_SEPARATOR   * @see #PARAGRAPH_SEPARATOR   * @see #CONTROL   * @see #FORMAT   * @see #PRIVATE_USE   * @see #SURROGATE   * @see #DASH_PUNCTUATION   * @see #START_PUNCTUATION   * @see #END_PUNCTUATION   * @see #CONNECTOR_PUNCTUATION   * @see #OTHER_PUNCTUATION   * @see #MATH_SYMBOL   * @see #CURRENCY_SYMBOL   * @see #MODIFIER_SYMBOL   * @see #INITIAL_QUOTE_PUNCTUATION   * @see #FINAL_QUOTE_PUNCTUATION   * @since 1.1   */  public static int getType(char ch)  {    return readChar(ch) & TYPE_MASK;  }  /**   * Converts a digit into a character which represents that digit   * in a specified radix. If the radix exceeds MIN_RADIX or MAX_RADIX,   * or the digit exceeds the radix, then the null character <code>'\0'</code>   * is returned.  Otherwise the return value is in '0'-'9' and 'a'-'z'.   * <br>   * return value boundary = U+0030-U+0039|U+0061-U+007A   *   * @param digit digit to be converted into a character   * @param radix radix of digit   * @return character representing digit in radix, or '\0'   * @see #MIN_RADIX   * @see #MAX_RADIX   * @see #digit(char, int)   */  public static char forDigit(int digit, int radix)  {    if (radix < MIN_RADIX || radix > MAX_RADIX        || digit < 0 || digit >= radix)      return '\0';    return Number.digits[digit];  }  /**   * Returns the Unicode directionality property of the character. This   * is used in the visual ordering of text.   *   * @param ch the character to look up   * @return the directionality constant, or DIRECTIONALITY_UNDEFINED   * @see #DIRECTIONALITY_UNDEFINED   * @see #DIRECTIONALITY_LEFT_TO_RIGHT   * @see #DIRECTIONALITY_RIGHT_TO_LEFT   * @see #DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC   * @see #DIRECTIONALITY_EUROPEAN_NUMBER   * @see #DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR   * @see #DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR   * @see #DIRECTIONALITY_ARABIC_NUMBER   * @see #DIRECTIONALITY_COMMON_NUMBER_SEPARATOR   * @see #DIRECTIONALITY_NONSPACING_MARK   * @see #DIRECTIONALITY_BOUNDARY_NEUTRAL   * @see #DIRECTIONALITY_PARAGRAPH_SEPARATOR   * @see #DIRECTIONALITY_SEGMENT_SEPARATOR   * @see #DIRECTIONALITY_WHITESPACE   * @see #DIRECTIONALITY_OTHER_NEUTRALS   * @see #DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING   * @see #DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE   * @see #DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING   * @see #DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE   * @see #DIRECTIONALITY_POP_DIRECTIONAL_FORMAT   * @since 1.4   */  public static byte getDirectionality(char ch)  {    // The result will correctly be signed.    return (byte) (direction[readChar(ch) >> 7] >> 2);  }  /**   * Determines whether the character is mirrored according to Unicode. For   * example, <code>\u0028</code> (LEFT PARENTHESIS) appears as '(' in   * left-to-right text, but ')' in right-to-left text.   *   * @param ch the character to look up   * @return true if the character is mirrored   * @since 1.4   */  public static boolean isMirrored(char ch)  {    return (readChar(ch) & MIRROR_MASK) != 0;  }  /**   * Compares another Character to this Character, numerically.   *   * @param anotherCharacter Character to compare with this Character   * @return a negative integer if this Character is less than   *         anotherCharacter, zero if this Character is equal, and   *         a positive integer if this Character is greater   * @throws NullPointerException if anotherCharacter is null   * @since 1.2   */  public int compareTo(Character anotherCharacter)  {    return value - anotherCharacter.value;  }  /**   * Compares an object to this Character.  Assuming the object is a   * Character object, this method performs the same comparison as   * compareTo(Character).   *   * @param o object to compare   * @return the comparison value   * @throws ClassCastException if o is not a Character object   * @throws NullPointerException if o is null   * @see #compareTo(Character)   * @since 1.2   */  public int compareTo(Object o)  {    return compareTo((Character) o);  }  /**   * Returns an <code>Character</code> object wrapping the value.   * In contrast to the <code>Character</code> constructor, this method   * will cache some values.  It is used by boxing conversion.   *   * @param val the value to wrap   * @return the <code>Character</code>   *    * @since 1.5   */  public static Character valueOf(char val)  {    if (val > MAX_CACHE)      return new Character(val);    synchronized (charCache)      {    if (charCache[val - MIN_VALUE] == null)      charCache[val - MIN_VALUE] = new Character(val);    return charCache[val - MIN_VALUE];      }  }  /**   * Reverse the bytes in val.   * @since 1.5   */  public static char reverseBytes(char val)  {    return (char) (((val >> 8) & 0xff) | ((val << 8) & 0xff00));  }  /**   * Converts a unicode code point to a UTF-16 representation of that   * code point.   *    * @param codePoint the unicode code point