package java.lang; import java.io.UnsupportedEncodingException; import java.util.Comparator; import ej.annotation.Nullable; public final class String implements java.io.Serializable, Comparable, CharSequence { /** * A Comparator that orders String objects as by compareToIgnoreCase. This * comparator is serializable. */ public static final Comparator CASE_INSENSITIVE_ORDER = new Comparator() { @Override public int compare(@Nullable String o1, @Nullable String o2) { throw new RuntimeException(); } }; /** * Initializes a newly created {@code String} object so that it represents an empty character * sequence. Note that use of this constructor is unnecessary since Strings are immutable. */ public String() { throw new RuntimeException(); } /** * Constructs a new {@code String} by decoding the specified array of bytes using the platform's * default charset. The length of the new {@code String} is a function of the charset, and hence may * not be equal to the length of the byte array. * * @param bytes * The bytes to be decoded into characters */ public String(byte[] bytes) { throw new RuntimeException(); } /** * Constructs a new {@code String} by decoding the specified subarray of bytes using the platform's * default charset. The length of the new {@code String} is a function of the charset, and hence may * not be equal to the length of the subarray. * * @param bytes * The bytes to be decoded into characters * * @param offset * The index of the first byte to decode * * @param length * The number of bytes to decode * * @throws IndexOutOfBoundsException * If the {@code offset} and the {@code length} arguments index characters outside the * bounds of the {@code bytes} array */ public String(byte[] bytes, int offset, int length) { throw new RuntimeException(); } /** * Constructs a new {@code String} by decoding the specified subarray of bytes using the specified * charset. The length of the new {@code String} is a function of the charset, and hence may not be * equal to the length of the subarray. * * @param bytes * The bytes to be decoded into characters * * @param offset * The index of the first byte to decode * * @param length * The number of bytes to decode * * @param charsetName * The name of a supported charset * * @throws UnsupportedEncodingException * If the named charset is not supported * * @throws IndexOutOfBoundsException * If the {@code offset} and {@code length} arguments index characters outside the bounds of * the {@code bytes} array */ public String(byte[] bytes, int offset, int length, String charsetName) throws UnsupportedEncodingException { throw new RuntimeException(); } /** * Constructs a new {@code String} by decoding the specified array of bytes using the specified * charset. The length of the new {@code String} is a function of the charset, and hence may not be * equal to the length of the byte array. * * @param bytes * The bytes to be decoded into characters * * @param charsetName * The name of a supported charset * * @throws UnsupportedEncodingException * If the named charset is not supported */ public String(byte[] bytes, String charsetName) throws UnsupportedEncodingException { throw new RuntimeException(); } /** * Allocates a new {@code String} so that it represents the sequence of characters currently * contained in the character array argument. The contents of the character array are copied; * subsequent modification of the character array does not affect the newly created string. * * @param value * The initial value of the string */ public String(char[] value) { throw new RuntimeException(); } /** * Allocates a new {@code String} that contains characters from a subarray of the character array * argument. The {@code offset} argument is the index of the first character of the subarray and the * {@code count} argument specifies the length of the subarray. The contents of the subarray are * copied; subsequent modification of the character array does not affect the newly created string. * * @param value * Array that is the source of characters * * @param offset * The initial offset * * @param count * The length * * @throws IndexOutOfBoundsException * If the {@code offset} and {@code count} arguments index characters outside the bounds of * the {@code value} array */ public String(char[] value, int offset, int count) { throw new RuntimeException(); } /** * Initializes a newly created {@code String} object so that it represents the same sequence of * characters as the argument; in other words, the newly created string is a copy of the argument * string. Unless an explicit copy of {@code original} is needed, use of this constructor is * unnecessary since Strings are immutable. * * @param original * A {@code String} */ public String(String original) { throw new RuntimeException(); } /** * Allocates a new string that contains the sequence of characters currently contained in the string * buffer argument. The contents of the string buffer are copied; subsequent modification of the * string buffer does not affect the newly created string. * * @param buffer * A {@code StringBuffer} */ public String(StringBuffer buffer) { throw new RuntimeException(); } /** * Allocates a new string that contains the sequence of characters currently contained in the string * builder argument. The contents of the string builder are copied; subsequent modification of the * string builder does not affect the newly created string. * *

* This constructor is provided to ease migration to {@code StringBuilder}. Obtaining a string from * a string builder via the {@code toString} method is likely to run faster and is generally * preferred. * * @param builder * A {@code StringBuilder} */ public String(StringBuilder builder) { throw new RuntimeException(); } /** * Returns a String that represents the character sequence in the array specified. * * @param data * the character array. * @return a String that contains the characters of the character array. */ public static String copyValueOf(char[] data) { throw new RuntimeException(); } /** * Returns a String that represents the character sequence in the array specified. * * @param data * the character array. * @param offset * initial offset of the subarray. * @param count * length of the subarray. * @return a String that contains the characters of the specified subarray of the * character array. */ public static String copyValueOf(char[] data, int offset, int count) { throw new RuntimeException(); } /** * Returns the string representation of the boolean argument. * * @param b * a boolean. * @return if the argument is true, a string equal to "true" is returned; * otherwise, a string equal to "false" is returned. */ public static String valueOf(boolean b) { throw new RuntimeException(); } /** * Returns the string representation of the char argument. * * @param c * a char. * @return a string of length 1 containing as its single character the argument * c. */ public static String valueOf(char c) { throw new RuntimeException(); } /** * Returns the string representation of the char array argument. The contents of the * character array are copied; subsequent modification of the character array does not affect the * newly created string. * * @param data * a char array. * @return a newly allocated string representing the same sequence of characters contained in the * character array argument. */ public static String valueOf(char[] data) { throw new RuntimeException(); } /** * Returns the string representation of a specific subarray of the char array argument. *

* The offset argument is the index of the first character of the subarray. The * count argument specifies the length of the subarray. The contents of the subarray * are copied; subsequent modification of the character array does not affect the newly created * string. * * @param data * the character array. * @param offset * the initial offset into the value of the String. * @param count * the length of the value of the String. * @return a string representing the sequence of characters contained in the subarray of the * character array argument. * @exception IndexOutOfBoundsException * if offset is negative, or count is negative, or * offset+count is larger than data.length. */ public static String valueOf(char[] data, int offset, int count) { throw new RuntimeException(); } /** * Returns the string representation of the double argument. *

* The representation is exactly the one returned by the Double.toString method of one * argument. * * @param d * a double. * @return a string representation of the double argument. * @see java.lang.Double#toString(double) */ public static String valueOf(double d) { throw new RuntimeException(); } /** * Returns the string representation of the float argument. *

* The representation is exactly the one returned by the Float.toString method of one * argument. * * @param f * a float. * @return a string representation of the float argument. * @see java.lang.Float#toString(float) */ public static String valueOf(float f) { throw new RuntimeException(); } /** * Returns the string representation of the int argument. *

* The representation is exactly the one returned by the Integer.toString method of one * argument. * * @param i * an int. * @return a string representation of the int argument. * @see java.lang.Integer#toString(int, int) */ public static String valueOf(int i) { throw new RuntimeException(); } /** * Returns the string representation of the long argument. *

* The representation is exactly the one returned by the Long.toString method of one * argument. * * @param l * a long. * @return a string representation of the long argument. * @see java.lang.Long#toString(long) */ public static String valueOf(long l) { throw new RuntimeException(); } /** * Returns the string representation of the Object argument. * * @param obj * an Object. * @return if the argument is null, then a string equal to "null"; * otherwise, the value of obj.toString() is returned. * @see java.lang.Object#toString() */ public static String valueOf(@Nullable Object obj) { throw new RuntimeException(); } /** * Returns the char value at the specified index. An index ranges from 0 * to length() - 1. The first char value of the sequence is at index * 0, the next at index 1, and so on, as for array indexing. * * @param index * the index of the char value. * @return the char value at the specified index of this string. The first * char value is at index 0. * @exception IndexOutOfBoundsException * if the index argument is negative or not less than the length of this * string. */ @Override public char charAt(int index) { throw new RuntimeException(); } /** * Compares two strings lexicographically. The comparison is based on the Unicode value of each * character in the strings. The character sequence represented by this String object * is compared lexicographically to the character sequence represented by the argument string. The * result is a negative integer if this String object lexicographically precedes the * argument string. The result is a positive integer if this String object * lexicographically follows the argument string. The result is zero if the strings are equal; * compareTo returns 0 exactly when the {@link #equals(Object)} method * would return true. *

* This is the definition of lexicographic ordering. If two strings are different, then either they * have different characters at some index that is a valid index for both strings, or their lengths * are different, or both. If they have different characters at one or more index positions, let * k be the smallest such index; then the string whose character at position k has the * smaller value, as determined by using the < operator, lexicographically precedes the other * string. In this case, compareTo returns the difference of the two character values * at position k in the two string -- that is, the value:

* * 
     * this.charAt(k) - anotherString.charAt(k)
     *
* *
If there is no index position at which they differ, then the shorter string * lexicographically precedes the longer string. In this case, compareTo returns the * difference of the lengths of the strings -- that is, the value:
* * 
     * this.length() - anotherString.length()
     *
* *
* * @param anotherString * the String to be compared. * @return the value 0 if the argument string is equal to this string; a value less * than 0 if this string is lexicographically less than the string argument; * and a value greater than 0 if this string is lexicographically greater than * the string argument. */ @Override public int compareTo(String anotherString) { throw new RuntimeException(); } /** * Compares two strings lexicographically, ignoring case differences. This method returns an integer * whose sign is that of calling compareTo with normalized versions of the strings * where case differences have been eliminated by calling * Character.toLowerCase(Character.toUpperCase(character)) on each character. *

* Note that this method does not take locale into account, and will result in an * unsatisfactory ordering for certain locales. The java.text package provides collators to * allow locale-sensitive ordering. * * @param str * the String to be compared. * @return a negative integer, zero, or a positive integer as the specified String is greater than, * equal to, or less than this String, ignoring case considerations. */ public int compareToIgnoreCase(String str) { throw new RuntimeException(); } /** * Concatenates the specified string to the end of this string. *

* If the length of the argument string is 0, then this String object is * returned. Otherwise, a new String object is created, representing a character * sequence that is the concatenation of the character sequence represented by this * String object and the character sequence represented by the argument string. *

* Examples:

* * 
     * "cares".concat("s") returns "caress"
     * "to".concat("get").concat("her") returns "together"
     *
* *
* * @param str * the String that is concatenated to the end of this String. * @return a string that represents the concatenation of this object's characters followed by the * string argument's characters. */ public String concat(String str) { throw new RuntimeException(); } /** * Returns true if and only if this string contains the specified sequence of char values. * * @param s * the sequence to search for * @return true if this string contains s, false otherwise * @throws NullPointerException * if s is null */ public boolean contains(CharSequence s) { throw new RuntimeException(); } /** * Compares this string to the specified {@code CharSequence}. The result is {@code true} if and * only if this {@code String} represents the same sequence of char values as the specified * sequence. * * @param cs * The sequence to compare this {@code String} against * * @return {@code true} if this {@code String} represents the same sequence of char values as the * specified sequence, {@code false} otherwise */ public boolean contentEquals(CharSequence cs) { throw new RuntimeException(); } /** * Compares this string to the specified {@code StringBuffer}. The result is {@code true} if and * only if this {@code String} represents the same sequence of characters as the specified * {@code StringBuffer}. * * @param sb * The {@code StringBuffer} to compare this {@code String} against * * @return {@code true} if this {@code String} represents the same sequence of characters as the * specified {@code StringBuffer}, {@code false} otherwise */ public boolean contentEquals(StringBuffer sb) { throw new RuntimeException(); } /** * Tests if this string ends with the specified suffix. * * @param suffix * the suffix. * @return true if the character sequence represented by the argument is a suffix of * the character sequence represented by this object; false otherwise. Note * that the result will be true if the argument is the empty string or is equal * to this String object as determined by the {@link #equals(Object)} method. */ public boolean endsWith(String suffix) { throw new RuntimeException(); } /** * Compares this string to the specified object. The result is {@code true} if and only if the * argument is not {@code null} and is a {@code String} object that represents the same sequence of * characters as this object. * * @param anObject * The object to compare this {@code String} against * * @return {@code true} if the given object represents a {@code String} equivalent to this string, * {@code false} otherwise * * @see #compareTo(String) * @see #equalsIgnoreCase(String) */ @Override public boolean equals(@Nullable Object anObject) { throw new RuntimeException(); } /** * Compares this {@code String} to another {@code String}, ignoring case considerations. Two strings * are considered equal ignoring case if they are of the same length and corresponding characters in * the two strings are equal ignoring case. * *

* Two characters {@code c1} and {@code c2} are considered the same ignoring case if at least one of * the following is true: *

    *
  • The two characters are the same (as compared by the {@code ==} operator) *
  • Applying the method {@link java.lang.Character#toUpperCase(char)} to each character produces * the same result *
  • Applying the method {@link java.lang.Character#toLowerCase(char)} to each character produces * the same result *
* * @param anotherString * The {@code String} to compare this {@code String} against * * @return {@code true} if the argument is not {@code null} and it represents an equivalent * {@code String} ignoring case; {@code false} otherwise * * @see #equals(Object) */ public boolean equalsIgnoreCase(String anotherString) { throw new RuntimeException(); } /** * Encodes this {@code String} into a sequence of bytes using the platform's default charset, * storing the result into a new byte array. * * @return The resultant byte array */ public byte[] getBytes() { throw new RuntimeException(); } /** * Encodes this {@code String} into a sequence of bytes using the named charset, storing the result * into a new byte array. * * @param charsetName * The name of a supported charset * * @return The resultant byte array * * @throws UnsupportedEncodingException * If the named charset is not supported */ public byte[] getBytes(String charsetName) throws UnsupportedEncodingException { throw new RuntimeException(); } /** * Copies characters from this string into the destination character array. *

* The first character to be copied is at index srcBegin; the last character to be * copied is at index srcEnd-1 (thus the total number of characters to be copied is * srcEnd-srcBegin). The characters are copied into the subarray of dst * starting at index dstBegin and ending at index: *

* * 
     * dstbegin + (srcEnd - srcBegin) - 1
     *
* *
* * @param srcBegin * index of the first character in the string to copy. * @param srcEnd * index after the last character in the string to copy. * @param dst * the destination array. * @param dstBegin * the start offset in the destination array. * @exception IndexOutOfBoundsException * If any of the following is true: *
    *
  • srcBegin is negative. *
  • srcBegin is greater than srcEnd *
  • srcEnd is greater than the length of this string *
  • dstBegin is negative *
  • dstBegin+(srcEnd-srcBegin) * is larger than dst.length *
*/ public void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) { throw new RuntimeException(); } /** * Returns a hash code for this string. The hash code for a String object is computed * as
* * 
     * s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]
     *
* *
using int arithmetic, where s[i] is the ith * character of the string, n is the length of the string, and ^ indicates * exponentiation. (The hash value of the empty string is zero.) * * @return a hash code value for this object. */ @Override public int hashCode() { throw new RuntimeException(); } /** * Returns the index within this string of the first occurrence of the specified character. If a * character with value ch occurs in the character sequence represented by this * String object, then the index (in Unicode code units) of the first such occurrence * is returned. For values of ch in the range from 0 to 0xFFFF (inclusive), this is the * smallest value k such that:
* * 
     * this.charAt(k) == ch
     *
* *
is true. For other values of ch, it is the smallest value k * such that:
* * 
     * this.codePointAt(k) == ch
     *
* *
is true. In either case, if no such character occurs in this string, then * -1 is returned. * * @param ch * a character (Unicode code point). * @return the index of the first occurrence of the character in the character sequence represented * by this object, or -1 if the character does not occur. */ public int indexOf(int ch) { throw new RuntimeException(); } /** * Returns the index within this string of the first occurrence of the specified character, starting * the search at the specified index. *

* If a character with value ch occurs in the character sequence represented by this * String object at an index no smaller than fromIndex, then the index of * the first such occurrence is returned. For values of ch in the range from 0 to * 0xFFFF (inclusive), this is the smallest value k such that:

* * 
     * (this.charAt(k) == ch) && (k >= fromIndex)
     *
* *
is true. For other values of ch, it is the smallest value k * such that:
* * 
     * (this.codePointAt(k) == ch) && (k >= fromIndex)
     *
* *
is true. In either case, if no such character occurs in this string at or after * position fromIndex, then -1 is returned. * *

* There is no restriction on the value of fromIndex. If it is negative, it has the * same effect as if it were zero: this entire string may be searched. If it is greater than the * length of this string, it has the same effect as if it were equal to the length of this string: * -1 is returned. * *

* All indices are specified in char values (Unicode code units). * * @param ch * a character (Unicode code point). * @param fromIndex * the index to start the search from. * @return the index of the first occurrence of the character in the character sequence represented * by this object that is greater than or equal to fromIndex, or * -1 if the character does not occur. */ public int indexOf(int ch, int fromIndex) { throw new RuntimeException(); } /** * Returns the index within this string of the first occurrence of the specified substring. * *

* The returned index is the smallest value k for which:

* * 
     * this.startsWith(str, k)
     *
* *
If no such value of k exists, then {@code -1} is returned. * * @param str * the substring to search for. * @return the index of the first occurrence of the specified substring, or {@code -1} if there is * no such occurrence. */ public int indexOf(String str) { throw new RuntimeException(); } /** * Returns the index within this string of the first occurrence of the specified substring, starting * at the specified index. * *

* The returned index is the smallest value k for which:

* * 
     * k >= fromIndex && this.startsWith(str, k)
     *
* *
If no such value of k exists, then {@code -1} is returned. * * @param str * the substring to search for. * @param fromIndex * the index from which to start the search. * @return the index of the first occurrence of the specified substring, starting at the specified * index, or {@code -1} if there is no such occurrence. */ public int indexOf(String str, int fromIndex) { throw new RuntimeException(); } /** * Returns a canonical representation for the string object. *

* A pool of strings, initially empty, is maintained privately by the class String. *

* When the intern method is invoked, if the pool already contains a string equal to this * String object as determined by the {@link #equals(Object)} method, then the string * from the pool is returned. Otherwise, this String object is added to the pool and a * reference to this String object is returned. *

* It follows that for any two strings s and t, * s.intern() == t.intern() is true if and only if * s.equals(t) is true. *

* All literal strings and string-valued constant expressions are interned. String literals are * defined in section 3.10.5 of the The Java™ Language Specification. * * @return a string that has the same contents as this string, but is guaranteed to be from a pool * of unique strings. */ public String intern() { throw new RuntimeException(); } /** * Returns true if, and only if, {@link #length()} is 0. * * @return true if {@link #length()} is 0, otherwise false */ public boolean isEmpty() { throw new RuntimeException(); } /** * Returns the index within this string of the last occurrence of the specified character. For * values of ch in the range from 0 to 0xFFFF (inclusive), the index (in Unicode code * units) returned is the largest value k such that:

* * 
     * this.charAt(k) == ch
     *
* *
is true. For other values of ch, it is the largest value k such * that:
* * 
     * this.codePointAt(k) == ch
     *
* *
is true. In either case, if no such character occurs in this string, then * -1 is returned. The String is searched backwards starting at the last * character. * * @param ch * a character (Unicode code point). * @return the index of the last occurrence of the character in the character sequence represented * by this object, or -1 if the character does not occur. */ public int lastIndexOf(int ch) { throw new RuntimeException(); } /** * Returns the index within this string of the last occurrence of the specified character, searching * backward starting at the specified index. For values of ch in the range from 0 to * 0xFFFF (inclusive), the index returned is the largest value k such that:
* * 
     * (this.charAt(k) == ch) && (k <= fromIndex)
     *
* *
is true. For other values of ch, it is the largest value k such * that:
* * 
     * (this.codePointAt(k) == ch) && (k <= fromIndex)
     *
* *
is true. In either case, if no such character occurs in this string at or before * position fromIndex, then -1 is returned. * *

* All indices are specified in char values (Unicode code units). * * @param ch * a character (Unicode code point). * @param fromIndex * the index to start the search from. There is no restriction on the value of * fromIndex. If it is greater than or equal to the length of this string, it * has the same effect as if it were equal to one less than the length of this string: this * entire string may be searched. If it is negative, it has the same effect as if it were -1: * -1 is returned. * @return the index of the last occurrence of the character in the character sequence represented * by this object that is less than or equal to fromIndex, or -1 * if the character does not occur before that point. */ public int lastIndexOf(int ch, int fromIndex) { throw new RuntimeException(); } /** * Returns the index within this string of the last occurrence of the specified substring. The last * occurrence of the empty string "" is considered to occur at the index value * {@code this.length()}. * *

* The returned index is the largest value k for which:

* * 
     * this.startsWith(str, k)
     *
* *
If no such value of k exists, then {@code -1} is returned. * * @param str * the substring to search for. * @return the index of the last occurrence of the specified substring, or {@code -1} if there is no * such occurrence. */ public int lastIndexOf(String str) { throw new RuntimeException(); } /** * Returns the index within this string of the last occurrence of the specified substring, searching * backward starting at the specified index. * *

* The returned index is the largest value k for which:

* * 
     * k <= fromIndex && this.startsWith(str, k)
     *
* *
If no such value of k exists, then {@code -1} is returned. * * @param str * the substring to search for. * @param fromIndex * the index to start the search from. * @return the index of the last occurrence of the specified substring, searching backward from the * specified index, or {@code -1} if there is no such occurrence. */ public int lastIndexOf(String str, int fromIndex) { throw new RuntimeException(); } /** * Returns the length of this string. The length is equal to the number of * Unicode code units in the string. * * @return the length of the sequence of characters represented by this object. */ @Override public int length() { throw new RuntimeException(); } /** * Tests if two string regions are equal. *

* A substring of this String object is compared to a substring of the argument * other. The result is true if these substrings represent character sequences * that are the same, ignoring case if and only if ignoreCase is true. The substring of * this String object to be compared begins at index toffset and has length * len. The substring of other to be compared begins at index ooffset and * has length len. The result is false if and only if at least one of the * following is true: *

    *
  • toffset is negative. *
  • ooffset is negative. *
  • toffset+len is greater than the length of this String object. *
  • ooffset+len is greater than the length of the other argument. *
  • ignoreCase is false and there is some nonnegative integer k less * than len such that:
    * * 
         * this.charAt(toffset + k) != other.charAt(ooffset + k)
     *
    * *
    *
  • ignoreCase is true and there is some nonnegative integer k less than * len such that:
    * * 
         * Character.toLowerCase(this.charAt(toffset + k)) != Character.toLowerCase(other.charAt(ooffset + k))
     *
    * *
    and:
    * * 
         * Character.toUpperCase(this.charAt(toffset + k)) != Character.toUpperCase(other.charAt(ooffset + k))
     *
    * *
    *
* * @param ignoreCase * if true, ignore case when comparing characters. * @param toffset * the starting offset of the subregion in this string. * @param other * the string argument. * @param ooffset * the starting offset of the subregion in the string argument. * @param len * the number of characters to compare. * @return true if the specified subregion of this string matches the specified * subregion of the string argument; false otherwise. Whether the matching is * exact or case insensitive depends on the ignoreCase argument. */ public boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len) { throw new RuntimeException(); } /** * Tests if two string regions are equal. *

* A substring of this String object is compared to a substring of the argument other. The * result is true if these substrings represent identical character sequences. The substring of this * String object to be compared begins at index toffset and has length * len. The substring of other to be compared begins at index ooffset and has * length len. The result is false if and only if at least one of the following is * true: *

    *
  • toffset is negative. *
  • ooffset is negative. *
  • toffset+len is greater than the length of this String object. *
  • ooffset+len is greater than the length of the other argument. *
  • There is some nonnegative integer k less than len such that: * this.charAt(toffset+k) != other.charAt(ooffset+k) *
* * @param toffset * the starting offset of the subregion in this string. * @param other * the string argument. * @param ooffset * the starting offset of the subregion in the string argument. * @param len * the number of characters to compare. * @return true if the specified subregion of this string exactly matches the specified * subregion of the string argument; false otherwise. */ public boolean regionMatches(int toffset, String other, int ooffset, int len) { throw new RuntimeException(); } /** * Returns a new string resulting from replacing all occurrences of oldChar in this * string with newChar. *

* If the character oldChar does not occur in the character sequence represented by * this String object, then a reference to this String object is returned. * Otherwise, a new String object is created that represents a character sequence * identical to the character sequence represented by this String object, except that * every occurrence of oldChar is replaced by an occurrence of newChar. *

* Examples:

* * 
     * "mesquite in your cellar".replace('e', 'o')
     *         returns "mosquito in your collar"
     * "the war of baronets".replace('r', 'y')
     *         returns "the way of bayonets"
     * "sparring with a purple porpoise".replace('p', 't')
     *         returns "starring with a turtle tortoise"
     * "JonL".replace('q', 'x') returns "JonL" (no change)
     *
* *
* * @param oldChar * the old character. * @param newChar * the new character. * @return a string derived from this string by replacing every occurrence of oldChar * with newChar. */ public String replace(char oldChar, char newChar) { throw new RuntimeException(); } /** * Replaces each substring of this string that matches the literal target sequence with the * specified literal replacement sequence. The replacement proceeds from the beginning of the string * to the end, for example, replacing "aa" with "b" in the string "aaa" will result in "ba" rather * than "ab". * * @param target * The sequence of char values to be replaced * @param replacement * The replacement sequence of char values * @return The resulting string * @throws NullPointerException * if target or replacement is null. */ public String replace(CharSequence target, CharSequence replacement) { throw new RuntimeException(); } /** * Tests if this string starts with the specified prefix. * * @param prefix * the prefix. * @return true if the character sequence represented by the argument is a prefix of * the character sequence represented by this string; false otherwise. Note * also that true will be returned if the argument is an empty string or is * equal to this String object as determined by the {@link #equals(Object)} * method. */ public boolean startsWith(String prefix) { throw new RuntimeException(); } /** * Tests if the substring of this string beginning at the specified index starts with the specified * prefix. * * @param prefix * the prefix. * @param toffset * where to begin looking in this string. * @return true if the character sequence represented by the argument is a prefix of * the substring of this object starting at index toffset; false * otherwise. The result is false if toffset is negative or * greater than the length of this String object; otherwise the result is the * same as the result of the expression * * 
     *         this.substring(toffset).startsWith(prefix)
     *
*/ public boolean startsWith(String prefix, int toffset) { throw new RuntimeException(); } /** * Returns a new character sequence that is a subsequence of this sequence. * *

* An invocation of this method of the form * *

* * 
     * str.subSequence(begin, end)
     *
* *
* * behaves in exactly the same way as the invocation * *
* * 
     * str.substring(begin, end)
     *
* *
* * This method is defined so that the String class can implement the {@link CharSequence} * interface. * * @param beginIndex * the begin index, inclusive. * @param endIndex * the end index, exclusive. * @return the specified subsequence. * * @throws IndexOutOfBoundsException * if beginIndex or endIndex are negative, if endIndex is greater * than length(), or if beginIndex is greater than startIndex */ @Override public CharSequence subSequence(int beginIndex, int endIndex) { throw new RuntimeException(); } /** * Returns a new string that is a substring of this string. The substring begins with the character * at the specified index and extends to the end of this string. *

* Examples:

* * 
     * "unhappy".substring(2) returns "happy"
     * "Harbison".substring(3) returns "bison"
     * "emptiness".substring(9) returns "" (an empty string)
     *
* *
* * @param beginIndex * the beginning index, inclusive. * @return the specified substring. * @exception IndexOutOfBoundsException * if beginIndex is negative or larger than the length of this * String object. */ public String substring(int beginIndex) { throw new RuntimeException(); } /** * Returns a new string that is a substring of this string. The substring begins at the specified * beginIndex and extends to the character at index endIndex - 1. Thus the * length of the substring is endIndex-beginIndex. *

* Examples:

* * 
     * "hamburger".substring(4, 8) returns "urge"
     * "smiles".substring(1, 5) returns "mile"
     *
* *
* * @param beginIndex * the beginning index, inclusive. * @param endIndex * the ending index, exclusive. * @return the specified substring. * @exception IndexOutOfBoundsException * if the beginIndex is negative, or endIndex is larger than * the length of this String object, or beginIndex is larger * than endIndex. */ public String substring(int beginIndex, int endIndex) { throw new RuntimeException(); } /** * Converts this string to a new character array. * * @return a newly allocated character array whose length is the length of this string and whose * contents are initialized to contain the character sequence represented by this string. */ public char[] toCharArray() { throw new RuntimeException(); } /** * Converts all of the characters in this String to lower case using the rules of the * default locale. This is equivalent to calling toLowerCase(Locale.getDefault()). * * @return the String, converted to lowercase. */ public String toLowerCase() { throw new RuntimeException(); } /** * This object (which is already a string!) is itself returned. * * @return the string itself. */ @Override public String toString() { throw new RuntimeException(); } /** * Converts all of the characters in this String to upper case using the rules of the * default locale. This method is equivalent to toUpperCase(Locale.getDefault()). * * @return the String, converted to uppercase. */ public String toUpperCase() { throw new RuntimeException(); } /** * Returns a copy of the string, with leading and trailing whitespace omitted. *

* If this String object represents an empty character sequence, or the first and last * characters of character sequence represented by this String object both have codes * greater than '\u0020' (the space character), then a reference to this * String object is returned. *

* Otherwise, if there is no character with a code greater than '\u0020' in the * string, then a new String object representing an empty string is created and * returned. *

* Otherwise, let k be the index of the first character in the string whose code is greater * than '\u0020', and let m be the index of the last character in the string * whose code is greater than '\u0020'. A new String object is * created, representing the substring of this string that begins with the character at index * k and ends with the character at index m-that is, the result of * this.substring(k, m+1). *

* This method may be used to trim whitespace (as defined above) from the beginning and end of a * string. * * @return A copy of this string with leading and trailing white space removed, or this string if it * has no leading or trailing white space. */ public String trim() { throw new RuntimeException(); } } /** * The String class represents character strings. All string literals in Java programs, * such as "abc", are implemented as instances of this class. *

* Strings are constant; their values cannot be changed after they are created. String buffers * support mutable strings. Because String objects are immutable they can be shared. For example: *

* * 
 * String str = "abc";
 *
* *
*

* is equivalent to: *

* * 
 * char[] data = { 'a', 'b', 'c' };
 * String str = new String(data);
 *
* *
*

* Here are some more examples of how strings can be used: *

* * 
 * System.out.println("abc");
 * String cde = "cde";
 * System.out.println("abc" + cde);
 * String c = "abc".substring(2, 3);
 * String d = cde.substring(1, 2);
 *
* *
*

* The class String includes methods for examining individual characters of the * sequence, for comparing strings, for searching strings, for extracting substrings, and for * creating a copy of a string with all characters translated to uppercase or to lowercase. Case * mapping is based on the Unicode Standard version specified by the {@link java.lang.Character * Character} class. *

* The Java language provides special support for the string concatenation operator ( + ), * and for conversion of other objects to strings. String concatenation is implemented through the * StringBuilder(or StringBuffer) class and its append * method. String conversions are implemented through the method toString, defined by * Object and inherited by all classes in Java. For additional information on string * concatenation and conversion, see Gosling, Joy, and Steele, The Java Language * Specification. * *

* Unless otherwise noted, passing a null argument to a constructor or method in this class * will cause a {@link NullPointerException} to be thrown. */