/**@class java.lang.Character implements java.io.Serializable implements java.lang.Comparable @extends java.lang.Object The wrapper for the primitive type {@code char}. This class also provides a number of utility methods for working with characters. <p>Character data is kept up to date as Unicode evolves. See the <a href="../util/Locale.html#locale_data">Locale data</a> section of the {@code Locale} documentation for details of the Unicode versions implemented by current and historical Android releases. <p>The Unicode specification, character tables, and other information are available at <a href="http://www.unicode.org/">http://www.unicode.org/</a>. <p>Unicode characters are referred to as <i>code points</i>. The range of valid code points is U+0000 to U+10FFFF. The <i>Basic Multilingual Plane (BMP)</i> is the code point range U+0000 to U+FFFF. Characters above the BMP are referred to as <i>Supplementary Characters</i>. On the Java platform, UTF-16 encoding and {@code char} pairs are used to represent code points in the supplementary range. A pair of {@code char} values that represent a supplementary character are made up of a <i>high surrogate</i> with a value range of 0xD800 to 0xDBFF and a <i>low surrogate</i> with a value range of 0xDC00 to 0xDFFF. <p> On the Java platform a {@code char} value represents either a single BMP code point or a UTF-16 unit that's part of a surrogate pair. The {@code int} type is used to represent all Unicode code points. <a name="unicode_categories"></a><h3>Unicode categories</h3> <p>Here's a list of the Unicode character categories and the corresponding Java constant, grouped semantically to provide a convenient overview. This table is also useful in conjunction with {@code \p} and {@code \P} in {@link java.util.regex.Pattern regular expressions}. <span class="datatable"> <style type="text/css"> .datatable td { padding-right: 20px; } </style> <p><table> <tr> <td> Cn </td> <td> Unassigned </td> <td>{@link #UNASSIGNED}</td> </tr> <tr> <td> Cc </td> <td> Control </td> <td>{@link #CONTROL}</td> </tr> <tr> <td> Cf </td> <td> Format </td> <td>{@link #FORMAT}</td> </tr> <tr> <td> Co </td> <td> Private use </td> <td>{@link #PRIVATE_USE}</td> </tr> <tr> <td> Cs </td> <td> Surrogate </td> <td>{@link #SURROGATE}</td> </tr> <tr> <td><br></td> </tr> <tr> <td> Lu </td> <td> Uppercase letter </td> <td>{@link #UPPERCASE_LETTER}</td> </tr> <tr> <td> Ll </td> <td> Lowercase letter </td> <td>{@link #LOWERCASE_LETTER}</td> </tr> <tr> <td> Lt </td> <td> Titlecase letter </td> <td>{@link #TITLECASE_LETTER}</td> </tr> <tr> <td> Lm </td> <td> Modifier letter </td> <td>{@link #MODIFIER_LETTER}</td> </tr> <tr> <td> Lo </td> <td> Other letter </td> <td>{@link #OTHER_LETTER}</td> </tr> <tr> <td><br></td> </tr> <tr> <td> Mn </td> <td> Non-spacing mark </td> <td>{@link #NON_SPACING_MARK}</td> </tr> <tr> <td> Me </td> <td> Enclosing mark </td> <td>{@link #ENCLOSING_MARK}</td> </tr> <tr> <td> Mc </td> <td> Combining spacing mark </td> <td>{@link #COMBINING_SPACING_MARK}</td> </tr> <tr> <td><br></td> </tr> <tr> <td> Nd </td> <td> Decimal digit number </td> <td>{@link #DECIMAL_DIGIT_NUMBER}</td> </tr> <tr> <td> Nl </td> <td> Letter number </td> <td>{@link #LETTER_NUMBER}</td> </tr> <tr> <td> No </td> <td> Other number </td> <td>{@link #OTHER_NUMBER}</td> </tr> <tr> <td><br></td> </tr> <tr> <td> Pd </td> <td> Dash punctuation </td> <td>{@link #DASH_PUNCTUATION}</td> </tr> <tr> <td> Ps </td> <td> Start punctuation </td> <td>{@link #START_PUNCTUATION}</td> </tr> <tr> <td> Pe </td> <td> End punctuation </td> <td>{@link #END_PUNCTUATION}</td> </tr> <tr> <td> Pc </td> <td> Connector punctuation </td> <td>{@link #CONNECTOR_PUNCTUATION}</td> </tr> <tr> <td> Pi </td> <td> Initial quote punctuation </td> <td>{@link #INITIAL_QUOTE_PUNCTUATION}</td> </tr> <tr> <td> Pf </td> <td> Final quote punctuation </td> <td>{@link #FINAL_QUOTE_PUNCTUATION}</td> </tr> <tr> <td> Po </td> <td> Other punctuation </td> <td>{@link #OTHER_PUNCTUATION}</td> </tr> <tr> <td><br></td> </tr> <tr> <td> Sm </td> <td> Math symbol </td> <td>{@link #MATH_SYMBOL}</td> </tr> <tr> <td> Sc </td> <td> Currency symbol </td> <td>{@link #CURRENCY_SYMBOL}</td> </tr> <tr> <td> Sk </td> <td> Modifier symbol </td> <td>{@link #MODIFIER_SYMBOL}</td> </tr> <tr> <td> So </td> <td> Other symbol </td> <td>{@link #OTHER_SYMBOL}</td> </tr> <tr> <td><br></td> </tr> <tr> <td> Zs </td> <td> Space separator </td> <td>{@link #SPACE_SEPARATOR}</td> </tr> <tr> <td> Zl </td> <td> Line separator </td> <td>{@link #LINE_SEPARATOR}</td> </tr> <tr> <td> Zp </td> <td> Paragraph separator </td> <td>{@link #PARAGRAPH_SEPARATOR}</td> </tr> </table> </span> @since 1.0 */ var Character = { /** The minimum {@code Character} value. */ MIN_VALUE : "0", /** The maximum {@code Character} value. */ MAX_VALUE : "65535", /** The minimum radix used for conversions between characters and integers. */ MIN_RADIX : "2", /** The maximum radix used for conversions between characters and integers. */ MAX_RADIX : "36", /** The {@link java.lang.Class} object that represents the primitive type {@code char}. */ TYPE : "null", /** Unicode category constant Cn. */ UNASSIGNED : "0", /** Unicode category constant Lu. */ UPPERCASE_LETTER : "1", /** Unicode category constant Ll. */ LOWERCASE_LETTER : "2", /** Unicode category constant Lt. */ TITLECASE_LETTER : "3", /** Unicode category constant Lm. */ MODIFIER_LETTER : "4", /** Unicode category constant Lo. */ OTHER_LETTER : "5", /** Unicode category constant Mn. */ NON_SPACING_MARK : "6", /** Unicode category constant Me. */ ENCLOSING_MARK : "7", /** Unicode category constant Mc. */ COMBINING_SPACING_MARK : "8", /** Unicode category constant Nd. */ DECIMAL_DIGIT_NUMBER : "9", /** Unicode category constant Nl. */ LETTER_NUMBER : "10", /** Unicode category constant No. */ OTHER_NUMBER : "11", /** Unicode category constant Zs. */ SPACE_SEPARATOR : "12", /** Unicode category constant Zl. */ LINE_SEPARATOR : "13", /** Unicode category constant Zp. */ PARAGRAPH_SEPARATOR : "14", /** Unicode category constant Cc. */ CONTROL : "15", /** Unicode category constant Cf. */ FORMAT : "16", /** Unicode category constant Co. */ PRIVATE_USE : "18", /** Unicode category constant Cs. */ SURROGATE : "19", /** Unicode category constant Pd. */ DASH_PUNCTUATION : "20", /** Unicode category constant Ps. */ START_PUNCTUATION : "21", /** Unicode category constant Pe. */ END_PUNCTUATION : "22", /** Unicode category constant Pc. */ CONNECTOR_PUNCTUATION : "23", /** Unicode category constant Po. */ OTHER_PUNCTUATION : "24", /** Unicode category constant Sm. */ MATH_SYMBOL : "25", /** Unicode category constant Sc. */ CURRENCY_SYMBOL : "26", /** Unicode category constant Sk. */ MODIFIER_SYMBOL : "27", /** Unicode category constant So. */ OTHER_SYMBOL : "28", /** Unicode category constant Pi. @since 1.4 */ INITIAL_QUOTE_PUNCTUATION : "29", /** Unicode category constant Pf. @since 1.4 */ FINAL_QUOTE_PUNCTUATION : "30", /** Unicode bidirectional constant. @since 1.4 */ DIRECTIONALITY_UNDEFINED : "-1", /** Unicode bidirectional constant L. @since 1.4 */ DIRECTIONALITY_LEFT_TO_RIGHT : "0", /** Unicode bidirectional constant R. @since 1.4 */ DIRECTIONALITY_RIGHT_TO_LEFT : "1", /** Unicode bidirectional constant AL. @since 1.4 */ DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC : "2", /** Unicode bidirectional constant EN. @since 1.4 */ DIRECTIONALITY_EUROPEAN_NUMBER : "3", /** Unicode bidirectional constant ES. @since 1.4 */ DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR : "4", /** Unicode bidirectional constant ET. @since 1.4 */ DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR : "5", /** Unicode bidirectional constant AN. @since 1.4 */ DIRECTIONALITY_ARABIC_NUMBER : "6", /** Unicode bidirectional constant CS. @since 1.4 */ DIRECTIONALITY_COMMON_NUMBER_SEPARATOR : "7", /** Unicode bidirectional constant NSM. @since 1.4 */ DIRECTIONALITY_NONSPACING_MARK : "8", /** Unicode bidirectional constant BN. @since 1.4 */ DIRECTIONALITY_BOUNDARY_NEUTRAL : "9", /** Unicode bidirectional constant B. @since 1.4 */ DIRECTIONALITY_PARAGRAPH_SEPARATOR : "10", /** Unicode bidirectional constant S. @since 1.4 */ DIRECTIONALITY_SEGMENT_SEPARATOR : "11", /** Unicode bidirectional constant WS. @since 1.4 */ DIRECTIONALITY_WHITESPACE : "12", /** Unicode bidirectional constant ON. @since 1.4 */ DIRECTIONALITY_OTHER_NEUTRALS : "13", /** Unicode bidirectional constant LRE. @since 1.4 */ DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING : "14", /** Unicode bidirectional constant LRO. @since 1.4 */ DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE : "15", /** Unicode bidirectional constant RLE. @since 1.4 */ DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING : "16", /** Unicode bidirectional constant RLO. @since 1.4 */ DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE : "17", /** Unicode bidirectional constant PDF. @since 1.4 */ DIRECTIONALITY_POP_DIRECTIONAL_FORMAT : "18", /** The minimum value of a high surrogate or leading surrogate unit in UTF-16 encoding, {@code '?'}. @since 1.5 */ MIN_HIGH_SURROGATE : "55296", /** The maximum value of a high surrogate or leading surrogate unit in UTF-16 encoding, {@code '?'}. @since 1.5 */ MAX_HIGH_SURROGATE : "56319", /** The minimum value of a low surrogate or trailing surrogate unit in UTF-16 encoding, {@code '?'}. @since 1.5 */ MIN_LOW_SURROGATE : "56320", /** The maximum value of a low surrogate or trailing surrogate unit in UTF-16 encoding, {@code '?'}. @since 1.5 */ MAX_LOW_SURROGATE : "57343", /** The minimum value of a surrogate unit in UTF-16 encoding, {@code '?'}. @since 1.5 */ MIN_SURROGATE : "55296", /** The maximum value of a surrogate unit in UTF-16 encoding, {@code '?'}. @since 1.5 */ MAX_SURROGATE : "57343", /** The minimum value of a supplementary code point, {@code U+010000}. @since 1.5 */ MIN_SUPPLEMENTARY_CODE_POINT : "65536", /** The minimum code point value, {@code U+0000}. @since 1.5 */ MIN_CODE_POINT : "0", /** The maximum code point value, {@code U+10FFFF}. @since 1.5 */ MAX_CODE_POINT : "1114111", /** The number of bits required to represent a {@code Character} value unsigned form. @since 1.5 */ SIZE : "16", /**Gets the primitive value of this character. @return {String} this object's primitive value. */ charValue : function( ) {}, /**Compares this object to the specified character object to determine their relative order. @param {Object {Character}} c the character object to compare this object to. @return {Number} {@code 0} if the value of this character and the value of {@code c} are equal; a positive value if the value of this character is greater than the value of {@code c}; a negative value if the value of this character is less than the value of {@code c}. @see java.lang.Comparable @since 1.2 */ compareTo : function( ) {}, /**Compares two {@code char} values. @return {Number} 0 if lhs = rhs, less than 0 if lhs < rhs, and greater than 0 if lhs > rhs. @since 1.7 */ compare : function( ) {}, /**Returns a {@code Character} instance for the {@code char} value passed. <p> If it is not necessary to get a new {@code Character} instance, it is recommended to use this method instead of the constructor, since it maintains a cache of instances which may result in better performance. @param {String} c the char value for which to get a {@code Character} instance. @return {Object {java.lang.Character}} the {@code Character} instance for {@code c}. @since 1.5 */ valueOf : function( ) {}, /**Indicates whether {@code codePoint} is a valid Unicode code point. @param {Number} codePoint the code point to test. @return {Boolean} {@code true} if {@code codePoint} is a valid Unicode code point; {@code false} otherwise. @since 1.5 */ isValidCodePoint : function( ) {}, /**Indicates whether {@code codePoint} is within the supplementary code point range. @param {Number} codePoint the code point to test. @return {Boolean} {@code true} if {@code codePoint} is within the supplementary code point range; {@code false} otherwise. @since 1.5 */ isSupplementaryCodePoint : function( ) {}, /**Indicates whether {@code ch} is a high- (or leading-) surrogate code unit that is used for representing supplementary characters in UTF-16 encoding. @param {String} ch the character to test. @return {Boolean} {@code true} if {@code ch} is a high-surrogate code unit; {@code false} otherwise. @see #isLowSurrogate(char) @since 1.5 */ isHighSurrogate : function( ) {}, /**Indicates whether {@code ch} is a low- (or trailing-) surrogate code unit that is used for representing supplementary characters in UTF-16 encoding. @param {String} ch the character to test. @return {Boolean} {@code true} if {@code ch} is a low-surrogate code unit; {@code false} otherwise. @see #isHighSurrogate(char) @since 1.5 */ isLowSurrogate : function( ) {}, /**Returns true if the given character is a high or low surrogate. @since 1.7 */ isSurrogate : function( ) {}, /**Indicates whether the specified character pair is a valid surrogate pair. @param {String} high the high surrogate unit to test. @param {String} low the low surrogate unit to test. @return {Boolean} {@code true} if {@code high} is a high-surrogate code unit and {@code low} is a low-surrogate code unit; {@code false} otherwise. @see #isHighSurrogate(char) @see #isLowSurrogate(char) @since 1.5 */ isSurrogatePair : function( ) {}, /**Calculates the number of {@code char} values required to represent the specified Unicode code point. This method checks if the {@code codePoint} is greater than or equal to {@code 0x10000}, in which case {@code 2} is returned, otherwise {@code 1}. To test if the code point is valid, use the {@link #isValidCodePoint}(int) method. @param {Number} codePoint the code point for which to calculate the number of required chars. @return {Number} {@code 2} if {@code codePoint >= 0x10000}; {@code 1} otherwise. @see #isValidCodePoint(int) @see #isSupplementaryCodePoint(int) @since 1.5 */ charCount : function( ) {}, /**Converts a surrogate pair into a Unicode code point. This method assumes that the pair are valid surrogates. If the pair are <i>not</i> valid surrogates, then the result is indeterminate. The {@link #isSurrogatePair(char, char)} method should be used prior to this method to validate the pair. @param {String} high the high surrogate unit. @param {String} low the low surrogate unit. @return {Number} the Unicode code point corresponding to the surrogate unit pair. @see #isSurrogatePair(char, char) @since 1.5 */ toCodePoint : function( ) {}, /**Returns the code point at {@code index} in the specified sequence of character units. If the unit at {@code index} is a high-surrogate unit, {@code index + 1} is less than the length of the sequence and the unit at {@code index + 1} is a low-surrogate unit, then the supplementary code point represented by the pair is returned; otherwise the {@code char} value at {@code index} is returned. @param {Object {CharSequence}} seq the source sequence of {@code char} units. @param {Number} index the position in {@code seq} from which to retrieve the code point. @return {Number} the Unicode code point or {@code char} value at {@code index} in {@code seq}. @throws NullPointerException if {@code seq} is {@code null}. @throws IndexOutOfBoundsException if the {@code index} is negative or greater than or equal to the length of {@code seq}. @since 1.5 */ codePointAt : function( ) {}, /**Returns the code point at {@code index} in the specified array of character units. If the unit at {@code index} is a high-surrogate unit, {@code index + 1} is less than the length of the array and the unit at {@code index + 1} is a low-surrogate unit, then the supplementary code point represented by the pair is returned; otherwise the {@code char} value at {@code index} is returned. @param {Object {char[]}} seq the source array of {@code char} units. @param {Number} index the position in {@code seq} from which to retrieve the code point. @return {Number} the Unicode code point or {@code char} value at {@code index} in {@code seq}. @throws NullPointerException if {@code seq} is {@code null}. @throws IndexOutOfBoundsException if the {@code index} is negative or greater than or equal to the length of {@code seq}. @since 1.5 */ codePointAt : function( ) {}, /**Returns the code point at {@code index} in the specified array of character units, where {@code index} has to be less than {@code limit}. If the unit at {@code index} is a high-surrogate unit, {@code index + 1} is less than {@code limit} and the unit at {@code index + 1} is a low-surrogate unit, then the supplementary code point represented by the pair is returned; otherwise the {@code char} value at {@code index} is returned. @param {Object {char[]}} seq the source array of {@code char} units. @param {Number} index the position in {@code seq} from which to get the code point. @param {Number} limit the index after the last unit in {@code seq} that can be used. @return {Number} the Unicode code point or {@code char} value at {@code index} in {@code seq}. @throws NullPointerException if {@code seq} is {@code null}. @throws IndexOutOfBoundsException if {@code index < 0}, {@code index >= limit}, {@code limit < 0} or if {@code limit} is greater than the length of {@code seq}. @since 1.5 */ codePointAt : function( ) {}, /**Returns the code point that precedes {@code index} in the specified sequence of character units. If the unit at {@code index - 1} is a low-surrogate unit, {@code index - 2} is not negative and the unit at {@code index - 2} is a high-surrogate unit, then the supplementary code point represented by the pair is returned; otherwise the {@code char} value at {@code index - 1} is returned. @param {Object {CharSequence}} seq the source sequence of {@code char} units. @param {Number} index the position in {@code seq} following the code point that should be returned. @return {Number} the Unicode code point or {@code char} value before {@code index} in {@code seq}. @throws NullPointerException if {@code seq} is {@code null}. @throws IndexOutOfBoundsException if the {@code index} is less than 1 or greater than the length of {@code seq}. @since 1.5 */ codePointBefore : function( ) {}, /**Returns the code point that precedes {@code index} in the specified array of character units. If the unit at {@code index - 1} is a low-surrogate unit, {@code index - 2} is not negative and the unit at {@code index - 2} is a high-surrogate unit, then the supplementary code point represented by the pair is returned; otherwise the {@code char} value at {@code index - 1} is returned. @param {Object {char[]}} seq the source array of {@code char} units. @param {Number} index the position in {@code seq} following the code point that should be returned. @return {Number} the Unicode code point or {@code char} value before {@code index} in {@code seq}. @throws NullPointerException if {@code seq} is {@code null}. @throws IndexOutOfBoundsException if the {@code index} is less than 1 or greater than the length of {@code seq}. @since 1.5 */ codePointBefore : function( ) {}, /**Returns the code point that precedes the {@code index} in the specified array of character units and is not less than {@code start}. If the unit at {@code index - 1} is a low-surrogate unit, {@code index - 2} is not less than {@code start} and the unit at {@code index - 2} is a high-surrogate unit, then the supplementary code point represented by the pair is returned; otherwise the {@code char} value at {@code index - 1} is returned. @param {Object {char[]}} seq the source array of {@code char} units. @param {Number} index the position in {@code seq} following the code point that should be returned. @param {Number} start the index of the first element in {@code seq}. @return {Number} the Unicode code point or {@code char} value before {@code index} in {@code seq}. @throws NullPointerException if {@code seq} is {@code null}. @throws IndexOutOfBoundsException if the {@code index <= start}, {@code start < 0}, {@code index} is greater than the length of {@code seq}, or if {@code start} is equal or greater than the length of {@code seq}. @since 1.5 */ codePointBefore : function( ) {}, /**Converts the specified Unicode code point into a UTF-16 encoded sequence and copies the value(s) into the char array {@code dst}, starting at index {@code dstIndex}. @param {Number} codePoint the Unicode code point to encode. @param {Object {char[]}} dst the destination array to copy the encoded value into. @param {Number} dstIndex the index in {@code dst} from where to start copying. @return {Number} the number of {@code char} value units copied into {@code dst}. @throws IllegalArgumentException if {@code codePoint} is not a valid code point. @throws NullPointerException if {@code dst} is {@code null}. @throws IndexOutOfBoundsException if {@code dstIndex} is negative, greater than or equal to {@code dst.length} or equals {@code dst.length - 1} when {@code codePoint} is a {@link #isSupplementaryCodePoint(int) supplementary code point}. @since 1.5 */ toChars : function( ) {}, /**Converts the specified Unicode code point into a UTF-16 encoded sequence and returns it as a char array. @param {Number} codePoint the Unicode code point to encode. @return {String} the UTF-16 encoded char sequence. If {@code codePoint} is a {@link #isSupplementaryCodePoint(int) supplementary code point}, then the returned array contains two characters, otherwise it contains just one character. @throws IllegalArgumentException if {@code codePoint} is not a valid code point. @since 1.5 */ toChars : function( ) {}, /**Counts the number of Unicode code points in the subsequence of the specified character sequence, as delineated by {@code beginIndex} and {@code endIndex}. Any surrogate values with missing pair values will be counted as one code point. @param {Object {CharSequence}} seq the {@code CharSequence} to look through. @param {Number} beginIndex the inclusive index to begin counting at. @param {Number} endIndex the exclusive index to stop counting at. @return {Number} the number of Unicode code points. @throws NullPointerException if {@code seq} is {@code null}. @throws IndexOutOfBoundsException if {@code beginIndex < 0}, {@code beginIndex > endIndex} or if {@code endIndex} is greater than the length of {@code seq}. @since 1.5 */ codePointCount : function( ) {}, /**Counts the number of Unicode code points in the subsequence of the specified char array, as delineated by {@code offset} and {@code count}. Any surrogate values with missing pair values will be counted as one code point. @param {Object {char[]}} seq the char array to look through @param {Number} offset the inclusive index to begin counting at. @param {Number} count the number of {@code char} values to look through in {@code seq}. @return {Number} the number of Unicode code points. @throws NullPointerException if {@code seq} is {@code null}. @throws IndexOutOfBoundsException if {@code offset < 0}, {@code count < 0} or if {@code offset + count} is greater than the length of {@code seq}. @since 1.5 */ codePointCount : function( ) {}, /**Determines the index in the specified character sequence that is offset {@code codePointOffset} code points from {@code index}. @param {Object {CharSequence}} seq the character sequence to find the index in. @param {Number} index the start index in {@code seq}. @param {Number} codePointOffset the number of code points to look backwards or forwards; may be a negative or positive value. @return {Number} the index in {@code seq} that is {@code codePointOffset} code points away from {@code index}. @throws NullPointerException if {@code seq} is {@code null}. @throws IndexOutOfBoundsException if {@code index < 0}, {@code index} is greater than the length of {@code seq}, or if there are not enough values in {@code seq} to skip {@code codePointOffset} code points forwards or backwards (if {@code codePointOffset} is negative) from {@code index}. @since 1.5 */ offsetByCodePoints : function( ) {}, /**Determines the index in a subsequence of the specified character array that is offset {@code codePointOffset} code points from {@code index}. The subsequence is delineated by {@code start} and {@code count}. @param {Object {char[]}} seq the character array to find the index in. @param {Number} start the inclusive index that marks the beginning of the subsequence. @param {Number} count the number of {@code char} values to include within the subsequence. @param {Number} index the start index in the subsequence of the char array. @param {Number} codePointOffset the number of code points to look backwards or forwards; may be a negative or positive value. @return {Number} the index in {@code seq} that is {@code codePointOffset} code points away from {@code index}. @throws NullPointerException if {@code seq} is {@code null}. @throws IndexOutOfBoundsException if {@code start < 0}, {@code count < 0}, {@code index < start}, {@code index > start + count}, {@code start + count} is greater than the length of {@code seq}, or if there are not enough values in {@code seq} to skip {@code codePointOffset} code points forward or backward (if {@code codePointOffset} is negative) from {@code index}. @since 1.5 */ offsetByCodePoints : function( ) {}, /**Convenience method to determine the value of the specified character {@code c} in the supplied radix. The value of {@code radix} must be between MIN_RADIX and MAX_RADIX. @param {String} c the character to determine the value of. @param {Number} radix the radix. @return {Number} the value of {@code c} in {@code radix} if {@code radix} lies between {@link #MIN_RADIX} and {@link #MAX_RADIX}; -1 otherwise. */ digit : function( ) {}, /**Convenience method to determine the value of the character {@code codePoint} in the supplied radix. The value of {@code radix} must be between MIN_RADIX and MAX_RADIX. @param {Number} codePoint the character, including supplementary characters. @param {Number} radix the radix. @return {Number} if {@code radix} lies between {@link #MIN_RADIX} and {@link #MAX_RADIX} then the value of the character in the radix; -1 otherwise. */ digit : function( ) {}, /**Compares this object with the specified object and indicates if they are equal. In order to be equal, {@code object} must be an instance of {@code Character} and have the same char value as this object. @param {Object {Object}} object the object to compare this double with. @return {Boolean} {@code true} if the specified object is equal to this {@code Character}; {@code false} otherwise. */ equals : function( ) {}, /**Returns the character which represents the specified digit in the specified radix. The {@code radix} must be between {@code MIN_RADIX} and {@code MAX_RADIX} inclusive; {@code digit} must not be negative and smaller than {@code radix}. If any of these conditions does not hold, 0 is returned. @param {Number} digit the integer value. @param {Number} radix the radix. @return {String} the character which represents the {@code digit} in the {@code radix}. */ forDigit : function( ) {}, /**Returns a human-readable name for the given code point, or null if the code point is unassigned. <p>As a fallback mechanism this method returns strings consisting of the Unicode block name (with underscores replaced by spaces), a single space, and the uppercase hex value of the code point, using as few digits as necessary. <p>Examples: <ul> <li>{@code Character.getName(0)} returns "NULL". <li>{@code Character.getName('e')} returns "LATIN SMALL LETTER E". <li>{@code Character.getName('٦')} returns "ARABIC-INDIC DIGIT SIX". <li>{@code Character.getName(0xe000)} returns "PRIVATE USE AREA E000". </ul> <p>Note that the exact strings returned will vary from release to release. @throws IllegalArgumentException if {@code codePoint} is not a valid code point. @since 1.7 */ getName : function( ) {}, /**Returns the numeric value of the specified Unicode character. See {@link #getNumericValue}(int). @param {String} c the character @return {Number} a non-negative numeric integer value if a numeric value for {@code c} exists, -1 if there is no numeric value for {@code c}, -2 if the numeric value can not be represented as an integer. */ getNumericValue : function( ) {}, /**Gets the numeric value of the specified Unicode code point. For example, the code point 'Ⅻ' stands for the Roman number XII, which has the numeric value 12. <p>There are two points of divergence between this method and the Unicode specification. This method treats the letters a-z (in both upper and lower cases, and their full-width variants) as numbers from 10 to 35. The Unicode specification also supports the idea of code points with non-integer numeric values; this method does not (except to the extent of returning -2 for such code points). @param {Number} codePoint the code point @return {Number} a non-negative numeric integer value if a numeric value for {@code codePoint} exists, -1 if there is no numeric value for {@code codePoint}, -2 if the numeric value can not be represented with an integer. */ getNumericValue : function( ) {}, /**Gets the general Unicode category of the specified character. @param {String} c the character to get the category of. @return {Number} the Unicode category of {@code c}. */ getType : function( ) {}, /**Gets the general Unicode category of the specified code point. @param {Number} codePoint the Unicode code point to get the category of. @return {Number} the Unicode category of {@code codePoint}. */ getType : function( ) {}, /**Gets the Unicode directionality of the specified character. @param {String} c the character to get the directionality of. @return {Number} the Unicode directionality of {@code c}. */ getDirectionality : function( ) {}, /**Returns the Unicode directionality of the given code point. This will be one of the {@code DIRECTIONALITY_} constants. For characters whose directionality is undefined, or whose directionality has no appropriate constant in this class, {@code DIRECTIONALITY_UNDEFINED} is returned. */ getDirectionality : function( ) {}, /** @hide - internal use only. */ getIcuDirectionality : function( ) {}, /**Indicates whether the specified character is mirrored. @param {String} c the character to check. @return {Boolean} {@code true} if {@code c} is mirrored; {@code false} otherwise. */ isMirrored : function( ) {}, /**Indicates whether the specified code point is mirrored. @param {Number} codePoint the code point to check. @return {Boolean} {@code true} if {@code codePoint} is mirrored, {@code false} otherwise. */ isMirrored : function( ) {}, /** */ hashCode : function( ) {}, /**Returns the high surrogate for the given code point. The result is meaningless if the given code point is not a supplementary character. @since 1.7 */ highSurrogate : function( ) {}, /**Returns the low surrogate for the given code point. The result is meaningless if the given code point is not a supplementary character. @since 1.7 */ lowSurrogate : function( ) {}, /**Returns true if the given code point is alphabetic. That is, if it is in any of the Lu, Ll, Lt, Lm, Lo, Nl, or Other_Alphabetic categories. @since 1.7 */ isAlphabetic : function( ) {}, /**Returns true if the given code point is in the Basic Multilingual Plane (BMP). Such code points can be represented by a single {@code char}. @since 1.7 */ isBmpCodePoint : function( ) {}, /**Indicates whether the specified character is defined in the Unicode specification. @param {String} c the character to check. @return {Boolean} {@code true} if the general Unicode category of the character is not {@code UNASSIGNED}; {@code false} otherwise. */ isDefined : function( ) {}, /**Indicates whether the specified code point is defined in the Unicode specification. @param {Number} codePoint the code point to check. @return {Boolean} {@code true} if the general Unicode category of the code point is not {@code UNASSIGNED}; {@code false} otherwise. */ isDefined : function( ) {}, /**Indicates whether the specified character is a digit. @param {String} c the character to check. @return {Boolean} {@code true} if {@code c} is a digit; {@code false} otherwise. */ isDigit : function( ) {}, /**Indicates whether the specified code point is a digit. @param {Number} codePoint the code point to check. @return {Boolean} {@code true} if {@code codePoint} is a digit; {@code false} otherwise. */ isDigit : function( ) {}, /**Indicates whether the specified character is ignorable in a Java or Unicode identifier. @param {String} c the character to check. @return {Boolean} {@code true} if {@code c} is ignorable; {@code false} otherwise. */ isIdentifierIgnorable : function( ) {}, /**Returns true if the given code point is a CJKV ideographic character. @since 1.7 */ isIdeographic : function( ) {}, /**Indicates whether the specified code point is ignorable in a Java or Unicode identifier. @param {Number} codePoint the code point to check. @return {Boolean} {@code true} if {@code codePoint} is ignorable; {@code false} otherwise. */ isIdentifierIgnorable : function( ) {}, /**Indicates whether the specified character is an ISO control character. @param {String} c the character to check. @return {Boolean} {@code true} if {@code c} is an ISO control character; {@code false} otherwise. */ isISOControl : function( ) {}, /**Indicates whether the specified code point is an ISO control character. @param {Number} c the code point to check. @return {Boolean} {@code true} if {@code c} is an ISO control character; {@code false} otherwise. */ isISOControl : function( ) {}, /**Indicates whether the specified character is a valid part of a Java identifier other than the first character. @param {String} c the character to check. @return {Boolean} {@code true} if {@code c} is valid as part of a Java identifier; {@code false} otherwise. */ isJavaIdentifierPart : function( ) {}, /**Indicates whether the specified code point is a valid part of a Java identifier other than the first character. @param {Number} codePoint the code point to check. @return {Boolean} {@code true} if {@code c} is valid as part of a Java identifier; {@code false} otherwise. */ isJavaIdentifierPart : function( ) {}, /**Indicates whether the specified character is a valid first character for a Java identifier. @param {String} c the character to check. @return {Boolean} {@code true} if {@code c} is a valid first character of a Java identifier; {@code false} otherwise. */ isJavaIdentifierStart : function( ) {}, /**Indicates whether the specified code point is a valid first character for a Java identifier. @param {Number} codePoint the code point to check. @return {Boolean} {@code true} if {@code codePoint} is a valid start of a Java identifier; {@code false} otherwise. */ isJavaIdentifierStart : function( ) {}, /**Indicates whether the specified character is a Java letter. @param {String} c the character to check. @return {Boolean} {@code true} if {@code c} is a Java letter; {@code false} otherwise. @deprecated Use {@link #isJavaIdentifierStart(char)} instead. */ isJavaLetter : function( ) {}, /**Indicates whether the specified character is a Java letter or digit character. @param {String} c the character to check. @return {Boolean} {@code true} if {@code c} is a Java letter or digit; {@code false} otherwise. @deprecated Use {@link #isJavaIdentifierPart(char)} instead. */ isJavaLetterOrDigit : function( ) {}, /**Indicates whether the specified character is a letter. @param {String} c the character to check. @return {Boolean} {@code true} if {@code c} is a letter; {@code false} otherwise. */ isLetter : function( ) {}, /**Indicates whether the specified code point is a letter. @param {Number} codePoint the code point to check. @return {Boolean} {@code true} if {@code codePoint} is a letter; {@code false} otherwise. */ isLetter : function( ) {}, /**Indicates whether the specified character is a letter or a digit. @param {String} c the character to check. @return {Boolean} {@code true} if {@code c} is a letter or a digit; {@code false} otherwise. */ isLetterOrDigit : function( ) {}, /**Indicates whether the specified code point is a letter or a digit. @param {Number} codePoint the code point to check. @return {Boolean} {@code true} if {@code codePoint} is a letter or a digit; {@code false} otherwise. */ isLetterOrDigit : function( ) {}, /**Indicates whether the specified character is a lower case letter. @param {String} c the character to check. @return {Boolean} {@code true} if {@code c} is a lower case letter; {@code false} otherwise. */ isLowerCase : function( ) {}, /**Indicates whether the specified code point is a lower case letter. @param {Number} codePoint the code point to check. @return {Boolean} {@code true} if {@code codePoint} is a lower case letter; {@code false} otherwise. */ isLowerCase : function( ) {}, /**Use {@link #isWhitespace}(char) instead. @deprecated Use {@link #isWhitespace(char)} instead. */ isSpace : function( ) {}, /**See {@link #isSpaceChar}(int). */ isSpaceChar : function( ) {}, /**Returns true if the given code point is a Unicode space character. The exact set of characters considered as whitespace varies with Unicode version. Note that non-breaking spaces are considered whitespace. Note also that line separators are not considered whitespace; see {@link #isWhitespace} for an alternative. */ isSpaceChar : function( ) {}, /**Indicates whether the specified character is a titlecase character. @param {String} c the character to check. @return {Boolean} {@code true} if {@code c} is a titlecase character, {@code false} otherwise. */ isTitleCase : function( ) {}, /**Indicates whether the specified code point is a titlecase character. @param {Number} codePoint the code point to check. @return {Boolean} {@code true} if {@code codePoint} is a titlecase character, {@code false} otherwise. */ isTitleCase : function( ) {}, /**Indicates whether the specified character is valid as part of a Unicode identifier other than the first character. @param {String} c the character to check. @return {Boolean} {@code true} if {@code c} is valid as part of a Unicode identifier; {@code false} otherwise. */ isUnicodeIdentifierPart : function( ) {}, /**Indicates whether the specified code point is valid as part of a Unicode identifier other than the first character. @param {Number} codePoint the code point to check. @return {Boolean} {@code true} if {@code codePoint} is valid as part of a Unicode identifier; {@code false} otherwise. */ isUnicodeIdentifierPart : function( ) {}, /**Indicates whether the specified character is a valid initial character for a Unicode identifier. @param {String} c the character to check. @return {Boolean} {@code true} if {@code c} is a valid first character for a Unicode identifier; {@code false} otherwise. */ isUnicodeIdentifierStart : function( ) {}, /**Indicates whether the specified code point is a valid initial character for a Unicode identifier. @param {Number} codePoint the code point to check. @return {Boolean} {@code true} if {@code codePoint} is a valid first character for a Unicode identifier; {@code false} otherwise. */ isUnicodeIdentifierStart : function( ) {}, /**Indicates whether the specified character is an upper case letter. @param {String} c the character to check. @return {Boolean} {@code true} if {@code c} is a upper case letter; {@code false} otherwise. */ isUpperCase : function( ) {}, /**Indicates whether the specified code point is an upper case letter. @param {Number} codePoint the code point to check. @return {Boolean} {@code true} if {@code codePoint} is a upper case letter; {@code false} otherwise. */ isUpperCase : function( ) {}, /**See {@link #isWhitespace}(int). */ isWhitespace : function( ) {}, /**Returns true if the given code point is a Unicode whitespace character. The exact set of characters considered as whitespace varies with Unicode version. Note that non-breaking spaces are not considered whitespace. Note also that line separators are considered whitespace; see {@link #isSpaceChar} for an alternative. */ isWhitespace : function( ) {}, /**Reverses the order of the first and second byte in the specified character. @param {String} c the character to reverse. @return {String} the character with reordered bytes. */ reverseBytes : function( ) {}, /**Returns the lower case equivalent for the specified character if the character is an upper case letter. Otherwise, the specified character is returned unchanged. @param {String} c the character @return {String} if {@code c} is an upper case character then its lower case counterpart, otherwise just {@code c}. */ toLowerCase : function( ) {}, /**Returns the lower case equivalent for the specified code point if it is an upper case letter. Otherwise, the specified code point is returned unchanged. @param {Number} codePoint the code point to check. @return {Number} if {@code codePoint} is an upper case character then its lower case counterpart, otherwise just {@code codePoint}. */ toLowerCase : function( ) {}, /** */ toString : function( ) {}, /**Converts the specified character to its string representation. @param {String} value the character to convert. @return {String} the character converted to a string. */ toString : function( ) {}, /**Returns the title case equivalent for the specified character if it exists. Otherwise, the specified character is returned unchanged. @param {String} c the character to convert. @return {String} the title case equivalent of {@code c} if it exists, otherwise {@code c}. */ toTitleCase : function( ) {}, /**Returns the title case equivalent for the specified code point if it exists. Otherwise, the specified code point is returned unchanged. @param {Number} codePoint the code point to convert. @return {Number} the title case equivalent of {@code codePoint} if it exists, otherwise {@code codePoint}. */ toTitleCase : function( ) {}, /**Returns the upper case equivalent for the specified character if the character is a lower case letter. Otherwise, the specified character is returned unchanged. @param {String} c the character to convert. @return {String} if {@code c} is a lower case character then its upper case counterpart, otherwise just {@code c}. */ toUpperCase : function( ) {}, /**Returns the upper case equivalent for the specified code point if the code point is a lower case letter. Otherwise, the specified code point is returned unchanged. @param {Number} codePoint the code point to convert. @return {Number} if {@code codePoint} is a lower case character then its upper case counterpart, otherwise just {@code codePoint}. */ toUpperCase : function( ) {}, };