/**@class java.lang.String implements java.io.Serializable implements java.lang.Comparable implements java.lang.CharSequence @extends java.lang.Object An immutable sequence of UTF-16 {@code char}s. See {@link java.lang.Character} for details about the relationship between {@code char} and Unicode code points. @see StringBuffer @see StringBuilder @see Charset @since 1.0 */ var String = { /** Compares strings using {@link #compareToIgnoreCase}. This is not suitable for case-insensitive string comparison for all locales. Use a {@link java.text.Collator} instead. */ CASE_INSENSITIVE_ORDER : "null", /**Returns the {@code char} at {@code index}. @throws IndexOutOfBoundsException if {@code index < 0} or {@code index >= length()}. */ charAt : function( ) {}, /**Compares this string to the given string. <p>The strings are compared one {@code char} at a time. In the discussion of the return value below, note that {@code char} does not mean code point, though this should only be visible for surrogate pairs. <p>If there is an index at which the two strings differ, the result is the difference between the two {@code char}s at the lowest such index. If not, but the lengths of the strings differ, the result is the difference between the two strings' lengths. If the strings are the same length and every {@code char} is the same, the result is 0. @throws NullPointerException if {@code string} is {@code null}. */ compareTo : function( ) {}, /**Compares this string to the given string, ignoring case differences. <p>The strings are compared one {@code char} at a time. This is not suitable for case-insensitive string comparison for all locales. Use a {@link java.text.Collator} instead. <p>If there is an index at which the two strings differ, the result is the difference between the two {@code char}s at the lowest such index. If not, but the lengths of the strings differ, the result is the difference between the two strings' lengths. If the strings are the same length and every {@code char} is the same, the result is 0. @throws NullPointerException if {@code string} is {@code null}. */ compareToIgnoreCase : function( ) {}, /**Concatenates this string and the specified string. @param {String} string the string to concatenate @return {String} a new string which is the concatenation of this string and the specified string. */ concat : function( ) {}, /**Creates a new string by copying the given {@code char[]}. Modifying the array after creating the string has no effect on the string. @throws NullPointerException if {@code data} is {@code null}. */ copyValueOf : function( ) {}, /**Creates a new string by copying the given subsequence of the given {@code char[]}. Modifying the array after creating the string has no effect on the string. @throws NullPointerException if {@code data} is {@code null}. @throws IndexOutOfBoundsException if {@code length < 0, start < 0} or {@code start + length > data.length}. */ copyValueOf : function( ) {}, /**Compares the specified string to this string to determine if the specified string is a suffix. @throws NullPointerException if {@code suffix} is {@code null}. */ endsWith : function( ) {}, /**Compares the given object to this string and returns true if they are equal. The object must be an instance of {@code String} with the same length, where for every index, {@code charAt} on each string returns the same value. */ equals : function( ) {}, /**Compares the given string to this string ignoring case. <p>The strings are compared one {@code char} at a time. This is not suitable for case-insensitive string comparison for all locales. Use a {@link java.text.Collator} instead. */ equalsIgnoreCase : function( ) {}, /**Mangles a subsequence of this string into a byte array by stripping the high order bits from each {@code char}. Use {@link #getBytes}() or {@link #getBytes}(String) instead. @param {Number} start the start offset in this string. @param {Number} end the end+1 offset in this string. @param {Object {byte[]}} data the destination byte array. @param {Number} index the start offset in the destination byte array. @throws NullPointerException if {@code data} is {@code null}. @throws IndexOutOfBoundsException if {@code start < 0}, {@code end > length()}, {@code index < 0} or {@code end - start > data.length - index}. @deprecated Use {@link #getBytes()} or {@link #getBytes(String)} */ getBytes : function( ) {}, /**Returns a new byte array containing the code points in this string encoded using the system's {@link java.nio.charset.Charset#defaultCharset default charset}. <p>The behavior when this string cannot be represented in the system's default charset is unspecified. In practice, when the default charset is UTF-8 (as it is on Android), all strings can be encoded. */ getBytes : function( ) {}, /**Returns a new byte array containing the code points of this string encoded using the named charset. <p>The behavior when this string cannot be represented in the named charset is unspecified. Use {@link java.nio.charset.CharsetEncoder} for more control. @throws UnsupportedEncodingException if the charset is not supported */ getBytes : function( ) {}, /**Returns a new byte array containing the code points of this string encoded using the given charset. <p>The behavior when this string cannot be represented in the given charset is to replace malformed input and unmappable code points with the charset's default replacement byte array. Use {@link java.nio.charset.CharsetEncoder} for more control. @since 1.6 */ getBytes : function( ) {}, /**Copies the given subsequence of this string to the given array starting at the given offset. @param {Number} start the start offset in this string. @param {Number} end the end+1 offset in this string. @param {Object {char[]}} buffer the destination array. @param {Number} index the start offset in the destination array. @throws NullPointerException if {@code buffer} is {@code null}. @throws IndexOutOfBoundsException if {@code start < 0}, {@code end > length()}, {@code start > end}, {@code index < 0}, {@code end - start > buffer.length - index} */ getChars : function( ) {}, /** */ hashCode : function( ) {}, /**Returns the first index of the given code point, or -1. The search starts at the beginning and moves towards the end of this string. */ indexOf : function( ) {}, /**Returns the next index of the given code point, or -1. The search starts at the given offset and moves towards the end of this string. */ indexOf : function( ) {}, /**Returns the first index of the given string, or -1. The search starts at the beginning and moves towards the end of this string. @throws NullPointerException if {@code string} is {@code null}. */ indexOf : function( ) {}, /**Returns the next index of the given string in this string, or -1. The search for the string starts at the given offset and moves towards the end of this string. @throws NullPointerException if {@code subString} is {@code null}. */ indexOf : function( ) {}, /**Returns an interned string equal to this string. The VM maintains an internal set of unique strings. All string literals found in loaded classes' constant pools are automatically interned. Manually-interned strings are only weakly referenced, so calling {@code intern} won't lead to unwanted retention. <p>Interning is typically used because it guarantees that for interned strings {@code a} and {@code b}, {@code a.equals(b)} can be simplified to {@code a == b}. (This is not true of non-interned strings.) <p>Many applications find it simpler and more convenient to use an explicit {@link java.util.HashMap} to implement their own pools. */ intern : function( ) {}, /**Returns true if the length of this string is 0. @since 1.6 */ isEmpty : function( ) {}, /**Returns the last index of the code point {@code c}, or -1. The search starts at the end and moves towards the beginning of this string. */ lastIndexOf : function( ) {}, /**Returns the last index of the code point {@code c}, or -1. The search starts at offset {@code start} and moves towards the beginning of this string. */ lastIndexOf : function( ) {}, /**Returns the index of the start of the last match for the given string in this string, or -1. The search for the string starts at the end and moves towards the beginning of this string. @throws NullPointerException if {@code string} is {@code null}. */ lastIndexOf : function( ) {}, /**Returns the index of the start of the previous match for the given string in this string, or -1. The search for the string starts at the given index and moves towards the beginning of this string. @throws NullPointerException if {@code subString} is {@code null}. */ lastIndexOf : function( ) {}, /**Returns the number of {@code char}s in this string. If this string contains surrogate pairs, this is not the same as the number of code points. */ length : function( ) {}, /**Returns true if the given subsequence of the given string matches this string starting at the given offset. @param {Number} thisStart the start offset in this string. @param {String} string the other string. @param {Number} start the start offset in {@code string}. @param {Number} length the number of {@code char}s to compare. @throws NullPointerException if {@code string} is {@code null}. */ regionMatches : function( ) {}, /**Returns true if the given subsequence of the given string matches this string starting at the given offset. <p>If ignoreCase is true, case is ignored during the comparison. The strings are compared one {@code char} at a time. This is not suitable for case-insensitive string comparison for all locales. Use a {@link java.text.Collator} instead. @param {Boolean} ignoreCase specifies if case should be ignored (use {@link java.text.Collator} instead for non-ASCII case insensitivity). @param {Number} thisStart the start offset in this string. @param {String} string the other string. @param {Number} start the start offset in {@code string}. @param {Number} length the number of {@code char}s to compare. @throws NullPointerException if {@code string} is {@code null}. */ regionMatches : function( ) {}, /**Returns a copy of this string after replacing occurrences of the given {@code char} with another. */ replace : function( ) {}, /**Returns a copy of this string after replacing occurrences of {@code target} replaced with {@code replacement}. The string is processed from the beginning to the end. @throws NullPointerException if {@code target} or {@code replacement} is {@code null}. */ replace : function( ) {}, /**Compares the specified string to this string to determine if the specified string is a prefix. @param {String} prefix the string to look for. @return {Boolean} {@code true} if the specified string is a prefix of this string, {@code false} otherwise @throws NullPointerException if {@code prefix} is {@code null}. */ startsWith : function( ) {}, /**Compares the specified string to this string, starting at the specified offset, to determine if the specified string is a prefix. @param {String} prefix the string to look for. @param {Number} start the starting offset. @return {Boolean} {@code true} if the specified string occurs in this string at the specified offset, {@code false} otherwise. @throws NullPointerException if {@code prefix} is {@code null}. */ startsWith : function( ) {}, /**Returns a string containing a suffix of this string starting at {@code start}. The returned string shares this string's <a href="#backing_array">backing array</a>. @throws IndexOutOfBoundsException if {@code start < 0} or {@code start > length()}. */ substring : function( ) {}, /**Returns a string containing the given subsequence of this string. The returned string shares this string's <a href="#backing_array">backing array</a>. @param {Number} start the start offset. @param {Number} end the end+1 offset. @throws IndexOutOfBoundsException if {@code start < 0}, {@code start > end} or {@code end > length()}. */ substring : function( ) {}, /**Returns a new {@code char} array containing a copy of the {@code char}s in this string. This is expensive and rarely useful. If you just want to iterate over the {@code char}s in the string, use {@link #charAt} instead. */ toCharArray : function( ) {}, /**Converts this string to lower case, using the rules of the user's default locale. See "<a href="../util/Locale.html#default_locale">Be wary of the default locale</a>". @return {String} a new lower case string, or {@code this} if it's already all lower case. */ toLowerCase : function( ) {}, /**Converts this string to lower case, using the rules of {@code locale}. <p>Most case mappings are unaffected by the language of a {@code Locale}. Exceptions include dotted and dotless I in Azeri and Turkish locales, and dotted and dotless I and J in Lithuanian locales. On the other hand, it isn't necessary to provide a Greek locale to get correct case mapping of Greek characters: any locale will do. <p>See <a href="http://www.unicode.org/Public/UNIDATA/SpecialCasing.txt">http://www.unicode.org/Public/UNIDATA/SpecialCasing.txt</a> for full details of context- and language-specific special cases. @return {String} a new lower case string, or {@code this} if it's already all lower case. */ toLowerCase : function( ) {}, /**Returns this string. */ toString : function( ) {}, /**Converts this this string to upper case, using the rules of the user's default locale. See "<a href="../util/Locale.html#default_locale">Be wary of the default locale</a>". @return {String} a new upper case string, or {@code this} if it's already all upper case. */ toUpperCase : function( ) {}, /**Converts this this string to upper case, using the rules of {@code locale}. <p>Most case mappings are unaffected by the language of a {@code Locale}. Exceptions include dotted and dotless I in Azeri and Turkish locales, and dotted and dotless I and J in Lithuanian locales. On the other hand, it isn't necessary to provide a Greek locale to get correct case mapping of Greek characters: any locale will do. <p>See <a href="http://www.unicode.org/Public/UNIDATA/SpecialCasing.txt">http://www.unicode.org/Public/UNIDATA/SpecialCasing.txt</a> for full details of context- and language-specific special cases. @return {String} a new upper case string, or {@code this} if it's already all upper case. */ toUpperCase : function( ) {}, /**Returns a string with no code points <code><= \\u0020</code> at the beginning or end. */ trim : function( ) {}, /**Returns a new string containing the same {@code char}s as the given array. Modifying the array after creating the string has no effect on the string. @throws NullPointerException if {@code data} is {@code null}. */ valueOf : function( ) {}, /**Returns a new string containing the same {@code char}s as the given subset of the given array. Modifying the array after creating the string has no effect on the string. @throws IndexOutOfBoundsException if {@code length < 0}, {@code start < 0} or {@code start + length > data.length} @throws NullPointerException if {@code data} is {@code null}. */ valueOf : function( ) {}, /**Returns a new string of just the given {@code char}. */ valueOf : function( ) {}, /**Returns the string representation of the given double. */ valueOf : function( ) {}, /**Returns the string representation of the given float. */ valueOf : function( ) {}, /**Returns the string representation of the given int. */ valueOf : function( ) {}, /**Returns the string representation of the given long. */ valueOf : function( ) {}, /**Converts the specified object to its string representation. If the object is null return the string {@code "null"}, otherwise use {@code toString()} to get the string representation. @param {Object {Object}} value the object. @return {String} the object converted to a string, or the string {@code "null"}. */ valueOf : function( ) {}, /**Converts the specified boolean to its string representation. When the boolean is {@code true} return {@code "true"}, otherwise return {@code "false"}. @param {Boolean} value the boolean. @return {String} the boolean converted to a string. */ valueOf : function( ) {}, /**Returns true if the {@code char}s in the given {@code StringBuffer} are the same as those in this string. @throws NullPointerException if {@code sb} is {@code null}. @since 1.4 */ contentEquals : function( ) {}, /**Returns true if the {@code char}s in the given {@code CharSequence} are the same as those in this string. @since 1.5 */ contentEquals : function( ) {}, /**Tests whether this string matches the given {@code regularExpression}. This method returns true only if the regular expression matches the <i>entire</i> input string. A common mistake is to assume that this method behaves like {@link #contains}; if you want to match anywhere within the input string, you need to add {@code .*} to the beginning and end of your regular expression. See {@link Pattern#matches}. <p>If the same regular expression is to be used for multiple operations, it may be more efficient to reuse a compiled {@code Pattern}. @throws PatternSyntaxException if the syntax of the supplied regular expression is not valid. @throws NullPointerException if {@code regularExpression == null} @since 1.4 */ matches : function( ) {}, /**Replaces all matches for {@code regularExpression} within this string with the given {@code replacement}. See {@link Pattern} for regular expression syntax. <p>If the same regular expression is to be used for multiple operations, it may be more efficient to reuse a compiled {@code Pattern}. @throws PatternSyntaxException if the syntax of the supplied regular expression is not valid. @throws NullPointerException if {@code regularExpression == null} @see Pattern @since 1.4 */ replaceAll : function( ) {}, /**Replaces the first match for {@code regularExpression} within this string with the given {@code replacement}. See {@link Pattern} for regular expression syntax. <p>If the same regular expression is to be used for multiple operations, it may be more efficient to reuse a compiled {@code Pattern}. @throws PatternSyntaxException if the syntax of the supplied regular expression is not valid. @throws NullPointerException if {@code regularExpression == null} @see Pattern @since 1.4 */ replaceFirst : function( ) {}, /**Splits this string using the supplied {@code regularExpression}. Equivalent to {@code split(regularExpression, 0)}. See {@link Pattern#split(CharSequence, int)} for an explanation of {@code limit}. See {@link Pattern} for regular expression syntax. <p>If the same regular expression is to be used for multiple operations, it may be more efficient to reuse a compiled {@code Pattern}. @throws NullPointerException if {@code regularExpression == null} @throws PatternSyntaxException if the syntax of the supplied regular expression is not valid. @see Pattern @since 1.4 */ split : function( ) {}, /**Splits this string using the supplied {@code regularExpression}. See {@link Pattern#split(CharSequence, int)} for an explanation of {@code limit}. See {@link Pattern} for regular expression syntax. <p>If the same regular expression is to be used for multiple operations, it may be more efficient to reuse a compiled {@code Pattern}. @throws NullPointerException if {@code regularExpression == null} @throws PatternSyntaxException if the syntax of the supplied regular expression is not valid. @since 1.4 */ split : function( ) {}, /**Equivalent to {@link #substring(int, int)} but needed to implement {@code CharSequence}. @throws IndexOutOfBoundsException if {@code start < 0}, {@code end < 0}, {@code start > end} or {@code end > length()}. @see java.lang.CharSequence#subSequence(int, int) @since 1.4 */ subSequence : function( ) {}, /**Returns the Unicode code point at the given {@code index}. @throws IndexOutOfBoundsException if {@code index < 0 || index >= length()} @see Character#codePointAt(char[], int, int) @since 1.5 */ codePointAt : function( ) {}, /**Returns the Unicode code point that precedes the given {@code index}. @throws IndexOutOfBoundsException if {@code index < 1 || index > length()} @see Character#codePointBefore(char[], int, int) @since 1.5 */ codePointBefore : function( ) {}, /**Calculates the number of Unicode code points between {@code start} and {@code end}. @param {Number} start the inclusive beginning index of the subsequence. @param {Number} end the exclusive end index of the subsequence. @return {Number} the number of Unicode code points in the subsequence. @throws IndexOutOfBoundsException if {@code start < 0 || end > length() || start > end} @see Character#codePointCount(CharSequence, int, int) @since 1.5 */ codePointCount : function( ) {}, /**Returns true if this string contains the {@code chars}s from the given {@code CharSequence}. @since 1.5 */ contains : function( ) {}, /**Returns the index within this object that is offset from {@code index} by {@code codePointOffset} code points. @param {Number} index the index within this object to calculate the offset from. @param {Number} codePointOffset the number of code points to count. @return {Number} the index within this object that is the offset. @throws IndexOutOfBoundsException if {@code index} is negative or greater than {@code length()} or if there aren't enough code points before or after {@code index} to match {@code codePointOffset}. @since 1.5 */ offsetByCodePoints : function( ) {}, /**Returns a localized formatted string, using the supplied format and arguments, using the user's default locale. <p>If you're formatting a string other than for human consumption, you should use the {@code format(Locale, String, Object...)} overload and supply {@code Locale.US}. See "<a href="../util/Locale.html#default_locale">Be wary of the default locale</a>". @param {String} format the format string (see {@link java.util.Formatter#format}) @param {Object {java.lang.Object[]}} args the list of arguments passed to the formatter. If there are more arguments than required by {@code format}, additional arguments are ignored. @return {String} the formatted string. @throws NullPointerException if {@code format == null} @throws java.util.IllegalFormatException if the format is invalid. @since 1.5 */ format : function( ) {}, /**Returns a formatted string, using the supplied format and arguments, localized to the given locale. @param {Object {Locale}} locale the locale to apply; {@code null} value means no localization. @param {String} format the format string (see {@link java.util.Formatter#format}) @param {Object {java.lang.Object[]}} args the list of arguments passed to the formatter. If there are more arguments than required by {@code format}, additional arguments are ignored. @return {String} the formatted string. @throws NullPointerException if {@code format == null} @throws java.util.IllegalFormatException if the format is invalid. @since 1.5 */ format : function( ) {}, };