groovy-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sun...@apache.org
Subject groovy git commit: Revert "GROOVY-8831: Add instance methods from `String` to `GString`(closes #806)"
Date Sun, 07 Oct 2018 03:53:37 GMT
Repository: groovy
Updated Branches:
  refs/heads/master 9e0ebf3af -> 5ff63b1cd


Revert "GROOVY-8831: Add instance methods from `String` to `GString`(closes #806)"

This reverts commit 9e0ebf3


Project: http://git-wip-us.apache.org/repos/asf/groovy/repo
Commit: http://git-wip-us.apache.org/repos/asf/groovy/commit/5ff63b1c
Tree: http://git-wip-us.apache.org/repos/asf/groovy/tree/5ff63b1c
Diff: http://git-wip-us.apache.org/repos/asf/groovy/diff/5ff63b1c

Branch: refs/heads/master
Commit: 5ff63b1cdad87450893c5809f82b962c87688e23
Parents: 9e0ebf3
Author: Daniel Sun <sunlan@apache.org>
Authored: Sun Oct 7 11:53:08 2018 +0800
Committer: Daniel Sun <sunlan@apache.org>
Committed: Sun Oct 7 11:53:08 2018 +0800

----------------------------------------------------------------------
 src/main/groovy/groovy/lang/GString.java | 1412 -------------------------
 1 file changed, 1412 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/groovy/blob/5ff63b1c/src/main/groovy/groovy/lang/GString.java
----------------------------------------------------------------------
diff --git a/src/main/groovy/groovy/lang/GString.java b/src/main/groovy/groovy/lang/GString.java
index a3b337f..d2b1d5b 100644
--- a/src/main/groovy/groovy/lang/GString.java
+++ b/src/main/groovy/groovy/lang/GString.java
@@ -27,13 +27,7 @@ import java.io.IOException;
 import java.io.Serializable;
 import java.io.UnsupportedEncodingException;
 import java.io.Writer;
-import java.nio.charset.Charset;
-import java.nio.charset.CharsetEncoder;
-import java.text.Collator;
-import java.util.Locale;
-import java.util.regex.Matcher;
 import java.util.regex.Pattern;
-import java.util.regex.PatternSyntaxException;
 
 /**
  * Represents a String which contains embedded values such as "hello there
@@ -243,102 +237,21 @@ public abstract class GString extends GroovyObjectSupport implements Comparable,
         return toString().equals(that.toString());
     }
 
-    /**
-     * Compares this object with the specified object for order.  Returns a
-     * negative integer, zero, or a positive integer as this object is less
-     * than, equal to, or greater than the specified object.
-     *
-     * <p>The implementor must ensure <tt>sgn(x.compareTo(y)) ==
-     * -sgn(y.compareTo(x))</tt> for all <tt>x</tt> and <tt>y</tt>.  (This
-     * implies that <tt>x.compareTo(y)</tt> must throw an exception iff
-     * <tt>y.compareTo(x)</tt> throws an exception.)
-     *
-     * <p>The implementor must also ensure that the relation is transitive:
-     * <tt>(x.compareTo(y)&gt;0 &amp;&amp; y.compareTo(z)&gt;0)</tt> implies
-     * <tt>x.compareTo(z)&gt;0</tt>.
-     *
-     * <p>Finally, the implementor must ensure that <tt>x.compareTo(y)==0</tt>
-     * implies that <tt>sgn(x.compareTo(z)) == sgn(y.compareTo(z))</tt>, for
-     * all <tt>z</tt>.
-     *
-     * <p>It is strongly recommended, but <i>not</i> strictly required that
-     * <tt>(x.compareTo(y)==0) == (x.equals(y))</tt>.  Generally speaking, any
-     * class that implements the <tt>Comparable</tt> interface and violates
-     * this condition should clearly indicate this fact.  The recommended
-     * language is "Note: this class has a natural ordering that is
-     * inconsistent with equals."
-     *
-     * <p>In the foregoing description, the notation
-     * <tt>sgn(</tt><i>expression</i><tt>)</tt> designates the mathematical
-     * <i>signum</i> function, which is defined to return one of <tt>-1</tt>,
-     * <tt>0</tt>, or <tt>1</tt> according to whether the value of
-     * <i>expression</i> is negative, zero or positive.
-     *
-     * @param   that the object to be compared.
-     * @return  a negative integer, zero, or a positive integer as this object
-     *          is less than, equal to, or greater than the specified object.
-     *
-     * @throws NullPointerException if the specified object is null
-     * @throws ClassCastException if the specified object's type prevents it
-     *         from being compared to this object.
-     */
     @Override
     public int compareTo(Object that) {
         return toString().compareTo(that.toString());
     }
 
-    /**
-     * Returns the <code>char</code> value at the specified index.  An index ranges from zero
-     * to <tt>length() - 1</tt>.  The first <code>char</code> value of the sequence is at
-     * index zero, the next at index one, and so on, as for array
-     * indexing.
-     *
-     * <p>If the <code>char</code> value specified by the index is a
-     * <a href="{@docRoot}/java/lang/Character.html#unicode">surrogate</a>, the surrogate
-     * value is returned.
-     *
-     * @param   index   the index of the <code>char</code> value to be returned
-     *
-     * @return  the specified <code>char</code> value
-     *
-     * @throws  IndexOutOfBoundsException
-     *          if the <tt>index</tt> argument is negative or not less than
-     *          <tt>length()</tt>
-     */
     @Override
     public char charAt(int index) {
         return toString().charAt(index);
     }
 
-    /**
-     * Returns the length of this character sequence.  The length is the number
-     * of 16-bit <code>char</code>s in the sequence.
-     *
-     * @return  the number of <code>char</code>s in this sequence
-     */
     @Override
     public int length() {
         return toString().length();
     }
 
-    /**
-     * Returns a <code>CharSequence</code> that is a subsequence of this sequence.
-     * The subsequence starts with the <code>char</code> value at the specified index and
-     * ends with the <code>char</code> value at index <tt>end - 1</tt>.  The length
-     * (in <code>char</code>s) of the
-     * returned sequence is <tt>end - start</tt>, so if <tt>start == end</tt>
-     * then an empty sequence is returned.
-     *
-     * @param   start   the start index, inclusive
-     * @param   end     the end index, exclusive
-     *
-     * @return  the specified subsequence
-     *
-     * @throws  IndexOutOfBoundsException
-     *          if <tt>start</tt> or <tt>end</tt> are negative,
-     *          if <tt>end</tt> is greater than <tt>length()</tt>,
-     *          or if <tt>start</tt> is greater than <tt>end</tt>
-     */
     @Override
     public CharSequence subSequence(int start, int end) {
         return toString().subSequence(start, end);
@@ -360,1329 +273,4 @@ public abstract class GString extends GroovyObjectSupport implements Comparable,
     public byte[] getBytes(String charset) throws UnsupportedEncodingException {
        return toString().getBytes(charset);
     }
-
-    /**
-     * Returns {@code true} if, and only if, {@link #length()} is {@code 0}.
-     *
-     * @return {@code true} if {@link #length()} is {@code 0}, otherwise
-     * {@code false}
-     *
-     * @since 3.0.0
-     */
-    public boolean isEmpty() {
-        return toString().isEmpty();
-    }
-
-    /**
-     * Returns the character (Unicode code point) at the specified
-     * index. The index refers to {@code char} values
-     * (Unicode code units) and ranges from {@code 0} to
-     * {@link #length()}{@code  - 1}.
-     *
-     * <p> If the {@code char} value specified at the given index
-     * is in the high-surrogate range, the following index is less
-     * than the length of this {@code String}, and the
-     * {@code char} value at the following index is in the
-     * low-surrogate range, then the supplementary code point
-     * corresponding to this surrogate pair is returned. Otherwise,
-     * the {@code char} value at the given index is returned.
-     *
-     * @param      index the index to the {@code char} values
-     * @return the code point value of the character at the
-     *             {@code index}
-     * @exception IndexOutOfBoundsException  if the {@code index}
-     *             argument is negative or not less than the length of this
-     *             string.
-     * @since 3.0.0
-     */
-    public int codePointAt(int index) {
-        return toString().codePointAt(index);
-    }
-
-    /**
-     * Returns the character (Unicode code point) before the specified
-     * index. The index refers to {@code char} values
-     * (Unicode code units) and ranges from {@code 1} to {@link
-     * CharSequence#length() length}.
-     *
-     * <p> If the {@code char} value at {@code (index - 1)}
-     * is in the low-surrogate range, {@code (index - 2)} is not
-     * negative, and the {@code char} value at {@code (index -
-     * 2)} is in the high-surrogate range, then the
-     * supplementary code point value of the surrogate pair is
-     * returned. If the {@code char} value at {@code index -
-     * 1} is an unpaired low-surrogate or a high-surrogate, the
-     * surrogate value is returned.
-     *
-     * @param     index the index following the code point that should be returned
-     * @return the Unicode code point value before the given index.
-     * @exception IndexOutOfBoundsException if the {@code index}
-     *            argument is less than 1 or greater than the length
-     *            of this string.
-     * @since 3.0.0
-     */
-    public int codePointBefore(int index) {
-        return toString().codePointBefore(index);
-    }
-
-    /**
-     * Returns the number of Unicode code points in the specified text
-     * range of this {@code String}. The text range begins at the
-     * specified {@code beginIndex} and extends to the
-     * {@code char} at index {@code endIndex - 1}. Thus the
-     * length (in {@code char}s) of the text range is
-     * {@code endIndex-beginIndex}. Unpaired surrogates within
-     * the text range count as one code point each.
-     *
-     * @param beginIndex the index to the first {@code char} of
-     * the text range.
-     * @param endIndex the index after the last {@code char} of
-     * the text range.
-     * @return the number of Unicode code points in the specified text
-     * range
-     * @exception IndexOutOfBoundsException if the
-     * {@code beginIndex} is negative, or {@code endIndex}
-     * is larger than the length of this {@code String}, or
-     * {@code beginIndex} is larger than {@code endIndex}.
-     * @since 3.0.0
-     */
-    public int codePointCount(int beginIndex, int endIndex) {
-        return toString().codePointCount(beginIndex, endIndex);
-    }
-
-    /**
-     * Returns the index within this {@code String} that is
-     * offset from the given {@code index} by
-     * {@code codePointOffset} code points. Unpaired surrogates
-     * within the text range given by {@code index} and
-     * {@code codePointOffset} count as one code point each.
-     *
-     * @param index the index to be offset
-     * @param codePointOffset the offset in code points
-     * @return the index within this {@code String}
-     * @exception IndexOutOfBoundsException if {@code index}
-     *   is negative or larger then the length of this
-     *   {@code String}, or if {@code codePointOffset} is positive
-     *   and the substring starting with {@code index} has fewer
-     *   than {@code codePointOffset} code points,
-     *   or if {@code codePointOffset} is negative and the substring
-     *   before {@code index} has fewer than the absolute value
-     *   of {@code codePointOffset} code points.
-     * @since 3.0.0
-     */
-    public int offsetByCodePoints(int index, int codePointOffset) {
-        return toString().offsetByCodePoints(index, codePointOffset);
-    }
-
-    /**
-     * Copies characters from this string into the destination character
-     * array.
-     * <p>
-     * The first character to be copied is at index {@code srcBegin};
-     * the last character to be copied is at index {@code srcEnd-1}
-     * (thus the total number of characters to be copied is
-     * {@code srcEnd-srcBegin}). The characters are copied into the
-     * subarray of {@code dst} starting at index {@code dstBegin}
-     * and ending at index:
-     * <blockquote><pre>
-     *     dstBegin + (srcEnd-srcBegin) - 1
-     * </pre></blockquote>
-     *
-     * @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:
-     *            <ul><li>{@code srcBegin} is negative.
-     *            <li>{@code srcBegin} is greater than {@code srcEnd}
-     *            <li>{@code srcEnd} is greater than the length of this
-     *                string
-     *            <li>{@code dstBegin} is negative
-     *            <li>{@code dstBegin+(srcEnd-srcBegin)} is larger than
-     *                {@code dst.length}</ul>
-     *
-     * @since 3.0.0
-     */
-    public void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) {
-        toString().getChars(srcBegin, srcEnd, dst, dstBegin);
-    }
-
-    /**
-     * Encodes this {@code String} into a sequence of bytes using the given
-     * {@linkplain Charset charset}, storing the result into a
-     * new byte array.
-     *
-     * <p> This method always replaces malformed-input and unmappable-character
-     * sequences with this charset's default replacement byte array.  The
-     * {@link CharsetEncoder} class should be used when more
-     * control over the encoding process is required.
-     *
-     * @param  charset
-     *         The {@linkplain Charset} to be used to encode
-     *         the {@code String}
-     *
-     * @return The resultant byte array
-     *
-     * @since 3.0.0
-     */
-    public byte[] getBytes(Charset charset) {
-        return toString().getBytes(charset);
-    }
-
-    /**
-     * 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}. This method
-     * synchronizes on the {@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
-     *
-     * @since 3.0.0
-     */
-    public boolean contentEquals(StringBuffer sb) {
-        return toString().contentEquals(sb);
-    }
-
-    /**
-     * 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. Note that if the
-     * {@code CharSequence} is a {@code StringBuffer} then the method
-     * synchronizes on it.
-     *
-     * @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
-     *
-     * @since 3.0.0
-     */
-    public boolean contentEquals(CharSequence cs) {
-        return toString().contentEquals(cs);
-    }
-
-    /**
-     * 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.
-     *
-     * <p> Two characters {@code c1} and {@code c2} are considered the same
-     * ignoring case if at least one of the following is true:
-     * <ul>
-     *   <li> The two characters are the same (as compared by the
-     *        {@code ==} operator)
-     *   <li> Applying the method {@link
-     *        Character#toUpperCase(char)} to each character
-     *        produces the same result
-     *   <li> Applying the method {@link
-     *        Character#toLowerCase(char)} to each character
-     *        produces the same result
-     * </ul>
-     *
-     * @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)
-     *
-     * @since 3.0.0
-     */
-    public boolean equalsIgnoreCase(String anotherString) {
-        return toString().equalsIgnoreCase(anotherString);
-    }
-
-    /**
-     * Compares two strings lexicographically.
-     * The comparison is based on the Unicode value of each character in
-     * the strings. The character sequence represented by this
-     * {@code String} object is compared lexicographically to the
-     * character sequence represented by the argument string. The result is
-     * a negative integer if this {@code String} object
-     * lexicographically precedes the argument string. The result is a
-     * positive integer if this {@code String} object lexicographically
-     * follows the argument string. The result is zero if the strings
-     * are equal; {@code compareTo} returns {@code 0} exactly when
-     * the {@link #equals(Object)} method would return {@code true}.
-     * <p>
-     * 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 <i>k</i> be the smallest such index; then the string
-     * whose character at position <i>k</i> has the smaller value, as
-     * determined by using the &lt; operator, lexicographically precedes the
-     * other string. In this case, {@code compareTo} returns the
-     * difference of the two character values at position {@code k} in
-     * the two string -- that is, the value:
-     * <blockquote><pre>
-     * this.charAt(k)-anotherString.charAt(k)
-     * </pre></blockquote>
-     * If there is no index position at which they differ, then the shorter
-     * string lexicographically precedes the longer string. In this case,
-     * {@code compareTo} returns the difference of the lengths of the
-     * strings -- that is, the value:
-     * <blockquote><pre>
-     * this.length()-anotherString.length()
-     * </pre></blockquote>
-     *
-     * @param   anotherString   the {@code String} to be compared.
-     * @return the value {@code 0} if the argument string is equal to
-     *          this string; a value less than {@code 0} if this string
-     *          is lexicographically less than the string argument; and a
-     *          value greater than {@code 0} if this string is
-     *          lexicographically greater than the string argument.
-     *
-     * @since 3.0.0
-     */
-    public int compareTo(String anotherString) {
-        return toString().compareTo(anotherString);
-    }
-
-    /**
-     * Compares two strings lexicographically, ignoring case
-     * differences. This method returns an integer whose sign is that of
-     * calling {@code compareTo} with normalized versions of the strings
-     * where case differences have been eliminated by calling
-     * {@code Character.toLowerCase(Character.toUpperCase(character))} on
-     * each character.
-     * <p>
-     * Note that this method does <em>not</em> take locale into account,
-     * and will result in an unsatisfactory ordering for certain locales.
-     * The java.text package provides <em>collators</em> to allow
-     * locale-sensitive ordering.
-     *
-     * @param   str   the {@code 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.
-     * @see     Collator#compare(String, String)
-     * @since 3.0.0
-     */
-    public int compareToIgnoreCase(String str) {
-        return toString().compareToIgnoreCase(str);
-    }
-
-    /**
-     * Tests if two string regions are equal.
-     * <p>
-     * A substring of this {@code 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
-     * {@code String} object to be compared begins at index {@code toffset}
-     * and has length {@code len}. The substring of other to be compared
-     * begins at index {@code ooffset} and has length {@code len}. The
-     * result is {@code false} if and only if at least one of the following
-     * is true:
-     * <ul><li>{@code toffset} is negative.
-     * <li>{@code ooffset} is negative.
-     * <li>{@code toffset+len} is greater than the length of this
-     * {@code String} object.
-     * <li>{@code ooffset+len} is greater than the length of the other
-     * argument.
-     * <li>There is some nonnegative integer <i>k</i> less than {@code len}
-     * such that:
-     * {@code this.charAt(toffset + }<i>k</i>{@code ) != other.charAt(ooffset + }
-     * <i>k</i>{@code )}
-     * </ul>
-     *
-     * @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  {@code true} if the specified subregion of this string
-     *          exactly matches the specified subregion of the string argument;
-     *          {@code false} otherwise.
-     * @since 3.0.0
-     */
-    public boolean regionMatches(int toffset, String other, int ooffset, int len) {
-        return toString().regionMatches(toffset, other, ooffset, len);
-    }
-
-    /**
-     * Tests if two string regions are equal.
-     * <p>
-     * A substring of this {@code String} object is compared to a substring
-     * of the argument {@code other}. The result is {@code true} if these
-     * substrings represent character sequences that are the same, ignoring
-     * case if and only if {@code ignoreCase} is true. The substring of
-     * this {@code String} object to be compared begins at index
-     * {@code toffset} and has length {@code len}. The substring of
-     * {@code other} to be compared begins at index {@code ooffset} and
-     * has length {@code len}. The result is {@code false} if and only if
-     * at least one of the following is true:
-     * <ul><li>{@code toffset} is negative.
-     * <li>{@code ooffset} is negative.
-     * <li>{@code toffset+len} is greater than the length of this
-     * {@code String} object.
-     * <li>{@code ooffset+len} is greater than the length of the other
-     * argument.
-     * <li>{@code ignoreCase} is {@code false} and there is some nonnegative
-     * integer <i>k</i> less than {@code len} such that:
-     * <blockquote><pre>
-     * this.charAt(toffset+k) != other.charAt(ooffset+k)
-     * </pre></blockquote>
-     * <li>{@code ignoreCase} is {@code true} and there is some nonnegative
-     * integer <i>k</i> less than {@code len} such that:
-     * <blockquote><pre>
-     * Character.toLowerCase(this.charAt(toffset+k)) !=
-     Character.toLowerCase(other.charAt(ooffset+k))
-     * </pre></blockquote>
-     * and:
-     * <blockquote><pre>
-     * Character.toUpperCase(this.charAt(toffset+k)) !=
-     *         Character.toUpperCase(other.charAt(ooffset+k))
-     * </pre></blockquote>
-     * </ul>
-     *
-     * @param   ignoreCase   if {@code 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  {@code true} if the specified subregion of this string
-     *          matches the specified subregion of the string argument;
-     *          {@code false} otherwise. Whether the matching is exact
-     *          or case insensitive depends on the {@code ignoreCase}
-     *          argument.
-     *
-     * @since 3.0.0
-     */
-    public boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len) {
-        return toString().regionMatches(ignoreCase, toffset, other, ooffset, len);
-    }
-
-    /**
-     * 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  {@code true} if the character sequence represented by the
-     *          argument is a prefix of the substring of this object starting
-     *          at index {@code toffset}; {@code false} otherwise.
-     *          The result is {@code false} if {@code toffset} is
-     *          negative or greater than the length of this
-     *          {@code String} object; otherwise the result is the same
-     *          as the result of the expression
-     *          <pre>
-     *          this.substring(toffset).startsWith(prefix)
-     *          </pre>
-     *
-     * @since 3.0.0
-     */
-    public boolean startsWith(String prefix, int toffset) {
-        return toString().startsWith(prefix, toffset);
-    }
-
-    /**
-     * Tests if this string starts with the specified prefix.
-     *
-     * @param   prefix   the prefix.
-     * @return  {@code true} if the character sequence represented by the
-     *          argument is a prefix of the character sequence represented by
-     *          this string; {@code false} otherwise.
-     *          Note also that {@code true} will be returned if the
-     *          argument is an empty string or is equal to this
-     *          {@code String} object as determined by the
-     *          {@link #equals(Object)} method.
-     * @since 3.0.0
-     */
-    public boolean startsWith(String prefix) {
-        return toString().startsWith(prefix);
-    }
-
-    /**
-     * Tests if this string ends with the specified suffix.
-     *
-     * @param   suffix   the suffix.
-     * @return  {@code true} if the character sequence represented by the
-     *          argument is a suffix of the character sequence represented by
-     *          this object; {@code false} otherwise. Note that the
-     *          result will be {@code true} if the argument is the
-     *          empty string or is equal to this {@code String} object
-     *          as determined by the {@link #equals(Object)} method.
-     *
-     * @since 3.0.0
-     */
-    public boolean endsWith(String suffix) {
-        return toString().endsWith(suffix);
-    }
-
-    /**
-     * Returns the index within this string of the first occurrence of
-     * the specified character. If a character with value
-     * {@code ch} occurs in the character sequence represented by
-     * this {@code String} object, then the index (in Unicode
-     * code units) of the first such occurrence is returned. For
-     * values of {@code ch} in the range from 0 to 0xFFFF
-     * (inclusive), this is the smallest value <i>k</i> such that:
-     * <blockquote><pre>
-     * this.charAt(<i>k</i>) == ch
-     * </pre></blockquote>
-     * is true. For other values of {@code ch}, it is the
-     * smallest value <i>k</i> such that:
-     * <blockquote><pre>
-     * this.codePointAt(<i>k</i>) == ch
-     * </pre></blockquote>
-     * is true. In either case, if no such character occurs in this
-     * string, then {@code -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
-     *          {@code -1} if the character does not occur.
-     *
-     * @since 3.0.0
-     */
-    public int indexOf(int ch) {
-        return toString().indexOf(ch);
-    }
-
-    /**
-     * Returns the index within this string of the first occurrence of the
-     * specified character, starting the search at the specified index.
-     * <p>
-     * If a character with value {@code ch} occurs in the
-     * character sequence represented by this {@code String}
-     * object at an index no smaller than {@code fromIndex}, then
-     * the index of the first such occurrence is returned. For values
-     * of {@code ch} in the range from 0 to 0xFFFF (inclusive),
-     * this is the smallest value <i>k</i> such that:
-     * <blockquote><pre>
-     * (this.charAt(<i>k</i>) == ch) {@code &&} (<i>k</i> &gt;= fromIndex)
-     * </pre></blockquote>
-     * is true. For other values of {@code ch}, it is the
-     * smallest value <i>k</i> such that:
-     * <blockquote><pre>
-     * (this.codePointAt(<i>k</i>) == ch) {@code &&} (<i>k</i> &gt;= fromIndex)
-     * </pre></blockquote>
-     * is true. In either case, if no such character occurs in this
-     * string at or after position {@code fromIndex}, then
-     * {@code -1} is returned.
-     *
-     * <p>
-     * There is no restriction on the value of {@code 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: {@code -1} is returned.
-     *
-     * <p>All indices are specified in {@code 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 {@code fromIndex}, or {@code -1}
-     *          if the character does not occur.
-     *
-     * @since 3.0.0
-     */
-    public int indexOf(int ch, int fromIndex) {
-        return toString().indexOf(ch, fromIndex);
-    }
-
-    /**
-     * Returns the index within this string of the last occurrence of
-     * the specified character. For values of {@code ch} in the
-     * range from 0 to 0xFFFF (inclusive), the index (in Unicode code
-     * units) returned is the largest value <i>k</i> such that:
-     * <blockquote><pre>
-     * this.charAt(<i>k</i>) == ch
-     * </pre></blockquote>
-     * is true. For other values of {@code ch}, it is the
-     * largest value <i>k</i> such that:
-     * <blockquote><pre>
-     * this.codePointAt(<i>k</i>) == ch
-     * </pre></blockquote>
-     * is true.  In either case, if no such character occurs in this
-     * string, then {@code -1} is returned.  The
-     * {@code 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
-     *          {@code -1} if the character does not occur.
-     *
-     * @since 3.0.0
-     */
-    public int lastIndexOf(int ch) {
-        return toString().lastIndexOf(ch);
-    }
-
-    /**
-     * Returns the index within this string of the last occurrence of
-     * the specified character, searching backward starting at the
-     * specified index. For values of {@code ch} in the range
-     * from 0 to 0xFFFF (inclusive), the index returned is the largest
-     * value <i>k</i> such that:
-     * <blockquote><pre>
-     * (this.charAt(<i>k</i>) == ch) {@code &&} (<i>k</i> &lt;= fromIndex)
-     * </pre></blockquote>
-     * is true. For other values of {@code ch}, it is the
-     * largest value <i>k</i> such that:
-     * <blockquote><pre>
-     * (this.codePointAt(<i>k</i>) == ch) {@code &&} (<i>k</i> &lt;= fromIndex)
-     * </pre></blockquote>
-     * is true. In either case, if no such character occurs in this
-     * string at or before position {@code fromIndex}, then
-     * {@code -1} is returned.
-     *
-     * <p>All indices are specified in {@code 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 {@code 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 {@code fromIndex}, or {@code -1}
-     *          if the character does not occur before that point.
-     *
-     * @since 3.0.0
-     */
-    public int lastIndexOf(int ch, int fromIndex) {
-        return toString().lastIndexOf(ch, fromIndex);
-    }
-
-    /**
-     * Returns the index within this string of the first occurrence of the
-     * specified substring.
-     *
-     * <p>The returned index is the smallest value <i>k</i> for which:
-     * <blockquote><pre>
-     * this.startsWith(str, <i>k</i>)
-     * </pre></blockquote>
-     * If no such value of <i>k</i> 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.
-     *
-     * @since 3.0.0
-     */
-    public int indexOf(String str) {
-        return toString().indexOf(str);
-    }
-
-    /**
-     * Returns the index within this string of the first occurrence of the
-     * specified substring, starting at the specified index.
-     *
-     * <p>The returned index is the smallest value <i>k</i> for which:
-     * <blockquote><pre>
-     * <i>k</i> &gt;= fromIndex {@code &&} this.startsWith(str, <i>k</i>)
-     * </pre></blockquote>
-     * If no such value of <i>k</i> 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.
-     *
-     * @since 3.0.0
-     */
-    public int indexOf(String str, int fromIndex) {
-        return toString().indexOf(str, fromIndex);
-    }
-
-    /**
-     * 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()}.
-     *
-     * <p>The returned index is the largest value <i>k</i> for which:
-     * <blockquote><pre>
-     * this.startsWith(str, <i>k</i>)
-     * </pre></blockquote>
-     * If no such value of <i>k</i> 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.
-     *
-     * @since 3.0.0
-     */
-    public int lastIndexOf(String str) {
-        return toString().lastIndexOf(str);
-    }
-
-    /**
-     * Returns the index within this string of the last occurrence of the
-     * specified substring, searching backward starting at the specified index.
-     *
-     * <p>The returned index is the largest value <i>k</i> for which:
-     * <blockquote><pre>
-     * <i>k</i> {@code <=} fromIndex {@code &&} this.startsWith(str, <i>k</i>)
-     * </pre></blockquote>
-     * If no such value of <i>k</i> 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.
-     *
-     * @since 3.0.0
-     */
-    public int lastIndexOf(String str, int fromIndex) {
-        return toString().lastIndexOf(str, fromIndex);
-    }
-
-    /**
-     * Returns a 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. <p>
-     * Examples:
-     * <blockquote><pre>
-     * "unhappy".substring(2) returns "happy"
-     * "Harbison".substring(3) returns "bison"
-     * "emptiness".substring(9) returns "" (an empty string)
-     * </pre></blockquote>
-     *
-     * @param      beginIndex   the beginning index, inclusive.
-     * @return the specified substring.
-     * @exception IndexOutOfBoundsException  if
-     *             {@code beginIndex} is negative or larger than the
-     *             length of this {@code String} object.
-     *
-     * @since 3.0.0
-     */
-    public String substring(int beginIndex) {
-        return toString().substring(beginIndex);
-    }
-
-    /**
-     * Returns a string that is a substring of this string. The
-     * substring begins at the specified {@code beginIndex} and
-     * extends to the character at index {@code endIndex - 1}.
-     * Thus the length of the substring is {@code endIndex-beginIndex}.
-     * <p>
-     * Examples:
-     * <blockquote><pre>
-     * "hamburger".substring(4, 8) returns "urge"
-     * "smiles".substring(1, 5) returns "mile"
-     * </pre></blockquote>
-     *
-     * @param      beginIndex   the beginning index, inclusive.
-     * @param      endIndex     the ending index, exclusive.
-     * @return the specified substring.
-     * @exception IndexOutOfBoundsException  if the
-     *             {@code beginIndex} is negative, or
-     *             {@code endIndex} is larger than the length of
-     *             this {@code String} object, or
-     *             {@code beginIndex} is larger than
-     *             {@code endIndex}.
-     *
-     * @since 3.0.0
-     */
-    public String substring(int beginIndex, int endIndex) {
-        return toString().substring(beginIndex, endIndex);
-    }
-
-    /**
-     * Concatenates the specified string to the end of this string.
-     * <p>
-     * If the length of the argument string is {@code 0}, then this
-     * {@code String} object is returned. Otherwise, a
-     * {@code String} object is returned that represents a character
-     * sequence that is the concatenation of the character sequence
-     * represented by this {@code String} object and the character
-     * sequence represented by the argument string.<p>
-     * Examples:
-     * <blockquote><pre>
-     * "cares".concat("s") returns "caress"
-     * "to".concat("get").concat("her") returns "together"
-     * </pre></blockquote>
-     *
-     * @param   str   the {@code String} that is concatenated to the end
-     *                of this {@code String}.
-     * @return a string that represents the concatenation of this object's
-     *          characters followed by the string argument's characters.
-     *
-     * @since 3.0.0
-     */
-    public String concat(String str) {
-        return toString().concat(str);
-    }
-
-    /**
-     * Returns a string resulting from replacing all occurrences of
-     * {@code oldChar} in this string with {@code newChar}.
-     * <p>
-     * If the character {@code oldChar} does not occur in the
-     * character sequence represented by this {@code String} object,
-     * then a reference to this {@code String} object is returned.
-     * Otherwise, a {@code String} object is returned that
-     * represents a character sequence identical to the character sequence
-     * represented by this {@code String} object, except that every
-     * occurrence of {@code oldChar} is replaced by an occurrence
-     * of {@code newChar}.
-     * <p>
-     * Examples:
-     * <blockquote><pre>
-     * "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)
-     * </pre></blockquote>
-     *
-     * @param   oldChar   the old character.
-     * @param   newChar   the new character.
-     * @return a string derived from this string by replacing every
-     *          occurrence of {@code oldChar} with {@code newChar}.
-     *
-     * @since 3.0.0
-     */
-    public String replace(char oldChar, char newChar) {
-        return toString().replace(oldChar, newChar);
-    }
-
-    /**
-     * Tells whether or not this string matches the given <a
-     * href="../util/regex/Pattern.html#sum">regular expression</a>.
-     *
-     * <p> An invocation of this method of the form
-     * <i>str</i>{@code .matches(}<i>regex</i>{@code )} yields exactly the
-     * same result as the expression
-     *
-     * <blockquote>
-     * {@link Pattern}.{@link Pattern#matches(String, CharSequence)
-     * matches(<i>regex</i>, <i>str</i>)}
-     * </blockquote>
-     *
-     * @param   regex
-     *          the regular expression to which this string is to be matched
-     *
-     * @return  {@code true} if, and only if, this string matches the
-     *          given regular expression
-     *
-     * @throws  PatternSyntaxException
-     *          if the regular expression's syntax is invalid
-     *
-     * @see Pattern
-     *
-     * @since 3.0.0
-     * @spec JSR-51
-     */
-    public boolean matches(String regex) {
-        return toString().matches(regex);
-    }
-
-    /**
-     * 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 {@code s}, false otherwise
-     * @since 3.0.0
-     */
-    public boolean contains(CharSequence s) {
-        return toString().contains(s);
-    }
-
-    /**
-     * Replaces the first substring of this string that matches the given <a
-     * href="../util/regex/Pattern.html#sum">regular expression</a> with the
-     * given replacement.
-     *
-     * <p> An invocation of this method of the form
-     * <i>str</i>{@code .replaceFirst(}<i>regex</i>{@code ,} <i>repl</i>{@code )}
-     * yields exactly the same result as the expression
-     *
-     * <blockquote>
-     * <code>
-     * {@link Pattern}.{@link
-     * Pattern#compile compile}(<i>regex</i>).{@link
-     * Pattern#matcher(CharSequence) matcher}(<i>str</i>).{@link
-     * Matcher#replaceFirst replaceFirst}(<i>repl</i>)
-     * </code>
-     * </blockquote>
-     *
-     *<p>
-     * Note that backslashes ({@code \}) and dollar signs ({@code $}) in the
-     * replacement string may cause the results to be different than if it were
-     * being treated as a literal replacement string; see
-     * {@link Matcher#replaceFirst}.
-     * Use {@link Matcher#quoteReplacement} to suppress the special
-     * meaning of these characters, if desired.
-     *
-     * @param   regex
-     *          the regular expression to which this string is to be matched
-     * @param   replacement
-     *          the string to be substituted for the first match
-     *
-     * @return The resulting {@code String}
-     *
-     * @throws PatternSyntaxException
-     *          if the regular expression's syntax is invalid
-     *
-     * @see Pattern
-     *
-     * @since 3.0.0
-     * @spec JSR-51
-     */
-    public String replaceFirst(String regex, String replacement) {
-        return toString().replaceFirst(regex, replacement);
-    }
-
-    /**
-     * Replaces each substring of this string that matches the given <a
-     * href="../util/regex/Pattern.html#sum">regular expression</a> with the
-     * given replacement.
-     *
-     * <p> An invocation of this method of the form
-     * <i>str</i>{@code .replaceAll(}<i>regex</i>{@code ,} <i>repl</i>{@code )}
-     * yields exactly the same result as the expression
-     *
-     * <blockquote>
-     * <code>
-     * {@link Pattern}.{@link
-     * Pattern#compile compile}(<i>regex</i>).{@link
-     * Pattern#matcher(CharSequence) matcher}(<i>str</i>).{@link
-     * Matcher#replaceAll replaceAll}(<i>repl</i>)
-     * </code>
-     * </blockquote>
-     *
-     *<p>
-     * Note that backslashes ({@code \}) and dollar signs ({@code $}) in the
-     * replacement string may cause the results to be different than if it were
-     * being treated as a literal replacement string; see
-     * {@link Matcher#replaceAll Matcher.replaceAll}.
-     * Use {@link Matcher#quoteReplacement} to suppress the special
-     * meaning of these characters, if desired.
-     *
-     * @param   regex
-     *          the regular expression to which this string is to be matched
-     * @param   replacement
-     *          the string to be substituted for each match
-     *
-     * @return The resulting {@code String}
-     *
-     * @throws PatternSyntaxException
-     *          if the regular expression's syntax is invalid
-     *
-     * @see Pattern
-     *
-     * @since 3.0.0
-     * @spec JSR-51
-     */
-    public String replaceAll(String regex, String replacement) {
-        return toString().replaceAll(regex, replacement);
-    }
-
-    /**
-     * 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
-     * @since 3.0.0
-     */
-    public String replace(CharSequence target, CharSequence replacement) {
-        return toString().replace(target, replacement);
-    }
-
-    /**
-     * Splits this string around matches of the given
-     * <a href="../util/regex/Pattern.html#sum">regular expression</a>.
-     *
-     * <p> The array returned by this method contains each substring of this
-     * string that is terminated by another substring that matches the given
-     * expression or is terminated by the end of the string.  The substrings in
-     * the array are in the order in which they occur in this string.  If the
-     * expression does not match any part of the input then the resulting array
-     * has just one element, namely this string.
-     *
-     * <p> When there is a positive-width match at the beginning of this
-     * string then an empty leading substring is included at the beginning
-     * of the resulting array. A zero-width match at the beginning however
-     * never produces such empty leading substring.
-     *
-     * <p> The {@code limit} parameter controls the number of times the
-     * pattern is applied and therefore affects the length of the resulting
-     * array.  If the limit <i>n</i> is greater than zero then the pattern
-     * will be applied at most <i>n</i>&nbsp;-&nbsp;1 times, the array's
-     * length will be no greater than <i>n</i>, and the array's last entry
-     * will contain all input beyond the last matched delimiter.  If <i>n</i>
-     * is non-positive then the pattern will be applied as many times as
-     * possible and the array can have any length.  If <i>n</i> is zero then
-     * the pattern will be applied as many times as possible, the array can
-     * have any length, and trailing empty strings will be discarded.
-     *
-     * <p> The string {@code "boo:and:foo"}, for example, yields the
-     * following results with these parameters:
-     *
-     * <blockquote><table cellpadding=1 cellspacing=0 summary="Split example showing regex, limit, and result">
-     * <tr>
-     *     <th>Regex</th>
-     *     <th>Limit</th>
-     *     <th>Result</th>
-     * </tr>
-     * <tr><td align=center>:</td>
-     *     <td align=center>2</td>
-     *     <td>{@code { "boo", "and:foo" }}</td></tr>
-     * <tr><td align=center>:</td>
-     *     <td align=center>5</td>
-     *     <td>{@code { "boo", "and", "foo" }}</td></tr>
-     * <tr><td align=center>:</td>
-     *     <td align=center>-2</td>
-     *     <td>{@code { "boo", "and", "foo" }}</td></tr>
-     * <tr><td align=center>o</td>
-     *     <td align=center>5</td>
-     *     <td>{@code { "b", "", ":and:f", "", "" }}</td></tr>
-     * <tr><td align=center>o</td>
-     *     <td align=center>-2</td>
-     *     <td>{@code { "b", "", ":and:f", "", "" }}</td></tr>
-     * <tr><td align=center>o</td>
-     *     <td align=center>0</td>
-     *     <td>{@code { "b", "", ":and:f" }}</td></tr>
-     * </table></blockquote>
-     *
-     * <p> An invocation of this method of the form
-     * <i>str.</i>{@code split(}<i>regex</i>{@code ,}&nbsp;<i>n</i>{@code )}
-     * yields the same result as the expression
-     *
-     * <blockquote>
-     * <code>
-     * {@link Pattern}.{@link
-     * Pattern#compile compile}(<i>regex</i>).{@link
-     * Pattern#split(CharSequence, int) split}(<i>str</i>,&nbsp;<i>n</i>)
-     * </code>
-     * </blockquote>
-     *
-     *
-     * @param  regex
-     *         the delimiting regular expression
-     *
-     * @param  limit
-     *         the result threshold, as described above
-     *
-     * @return the array of strings computed by splitting this string
-     *          around matches of the given regular expression
-     *
-     * @throws PatternSyntaxException
-     *          if the regular expression's syntax is invalid
-     *
-     * @see Pattern
-     *
-     * @since 3.0.0
-     * @spec JSR-51
-     */
-    public String[] split(String regex, int limit) {
-        return toString().split(regex, limit);
-    }
-
-    /**
-     * Splits this string around matches of the given <a
-     * href="../util/regex/Pattern.html#sum">regular expression</a>.
-     *
-     * <p> This method works as if by invoking the two-argument {@link
-     * #split(String, int) split} method with the given expression and a limit
-     * argument of zero.  Trailing empty strings are therefore not included in
-     * the resulting array.
-     *
-     * <p> The string {@code "boo:and:foo"}, for example, yields the following
-     * results with these expressions:
-     *
-     * <blockquote><table cellpadding=1 cellspacing=0 summary="Split examples showing regex and result">
-     * <tr>
-     *  <th>Regex</th>
-     *  <th>Result</th>
-     * </tr>
-     * <tr><td align=center>:</td>
-     *     <td>{@code { "boo", "and", "foo" }}</td></tr>
-     * <tr><td align=center>o</td>
-     *     <td>{@code { "b", "", ":and:f" }}</td></tr>
-     * </table></blockquote>
-     *
-     *
-     * @param  regex
-     *         the delimiting regular expression
-     *
-     * @return the array of strings computed by splitting this string
-     *          around matches of the given regular expression
-     *
-     * @throws PatternSyntaxException
-     *          if the regular expression's syntax is invalid
-     *
-     * @see Pattern
-     *
-     * @since 3.0.0
-     * @spec JSR-51
-     */
-    public String[] split(String regex) {
-        return toString().split(regex);
-    }
-
-    /**
-     * Converts all of the characters in this {@code String} to lower
-     * case using the rules of the given {@code Locale}.  Case mapping is based
-     * on the Unicode Standard version specified by the {@link Character Character}
-     * class. Since case mappings are not always 1:1 char mappings, the resulting
-     * {@code String} may be a different length than the original {@code String}.
-     * <p>
-     * Examples of lowercase  mappings are in the following table:
-     * <table border="1" summary="Lowercase mapping examples showing language code of locale, upper case, lower case, and description">
-     * <tr>
-     *   <th>Language Code of Locale</th>
-     *   <th>Upper Case</th>
-     *   <th>Lower Case</th>
-     *   <th>Description</th>
-     * </tr>
-     * <tr>
-     *   <td>tr (Turkish)</td>
-     *   <td>&#92;u0130</td>
-     *   <td>&#92;u0069</td>
-     *   <td>capital letter I with dot above -&gt; small letter i</td>
-     * </tr>
-     * <tr>
-     *   <td>tr (Turkish)</td>
-     *   <td>&#92;u0049</td>
-     *   <td>&#92;u0131</td>
-     *   <td>capital letter I -&gt; small letter dotless i </td>
-     * </tr>
-     * <tr>
-     *   <td>(all)</td>
-     *   <td>French Fries</td>
-     *   <td>french fries</td>
-     *   <td>lowercased all chars in String</td>
-     * </tr>
-     * <tr>
-     *   <td>(all)</td>
-     *   <td><img src="doc-files/capiota.gif" alt="capiota"><img src="doc-files/capchi.gif" alt="capchi">
-     *       <img src="doc-files/captheta.gif" alt="captheta"><img src="doc-files/capupsil.gif" alt="capupsil">
-     *       <img src="doc-files/capsigma.gif" alt="capsigma"></td>
-     *   <td><img src="doc-files/iota.gif" alt="iota"><img src="doc-files/chi.gif" alt="chi">
-     *       <img src="doc-files/theta.gif" alt="theta"><img src="doc-files/upsilon.gif" alt="upsilon">
-     *       <img src="doc-files/sigma1.gif" alt="sigma"></td>
-     *   <td>lowercased all chars in String</td>
-     * </tr>
-     * </table>
-     *
-     * @param locale use the case transformation rules for this locale
-     * @return the {@code String}, converted to lowercase.
-     * @see     String#toLowerCase()
-     * @see     String#toUpperCase()
-     * @see     String#toUpperCase(Locale)
-     * @since 3.0.0
-     */
-    public String toLowerCase(Locale locale) {
-        return toString().toLowerCase(locale);
-    }
-
-    /**
-     * Converts all of the characters in this {@code String} to lower
-     * case using the rules of the default locale. This is equivalent to calling
-     * {@code toLowerCase(Locale.getDefault())}.
-     * <p>
-     * <b>Note:</b> This method is locale sensitive, and may produce unexpected
-     * results if used for strings that are intended to be interpreted locale
-     * independently.
-     * Examples are programming language identifiers, protocol keys, and HTML
-     * tags.
-     * For instance, {@code "TITLE".toLowerCase()} in a Turkish locale
-     * returns {@code "t\u005Cu0131tle"}, where '\u005Cu0131' is the
-     * LATIN SMALL LETTER DOTLESS I character.
-     * To obtain correct results for locale insensitive strings, use
-     * {@code toLowerCase(Locale.ROOT)}.
-     * <p>
-     * @return the {@code String}, converted to lowercase.
-     * @see     String#toLowerCase(Locale)
-     *
-     * @since 3.0.0
-     */
-    public String toLowerCase() {
-        return toString().toLowerCase();
-    }
-
-    /**
-     * Converts all of the characters in this {@code String} to upper
-     * case using the rules of the given {@code Locale}. Case mapping is based
-     * on the Unicode Standard version specified by the {@link Character Character}
-     * class. Since case mappings are not always 1:1 char mappings, the resulting
-     * {@code String} may be a different length than the original {@code String}.
-     * <p>
-     * Examples of locale-sensitive and 1:M case mappings are in the following table.
-     *
-     * <table border="1" summary="Examples of locale-sensitive and 1:M case mappings. Shows Language code of locale, lower case, upper case, and description.">
-     * <tr>
-     *   <th>Language Code of Locale</th>
-     *   <th>Lower Case</th>
-     *   <th>Upper Case</th>
-     *   <th>Description</th>
-     * </tr>
-     * <tr>
-     *   <td>tr (Turkish)</td>
-     *   <td>&#92;u0069</td>
-     *   <td>&#92;u0130</td>
-     *   <td>small letter i -&gt; capital letter I with dot above</td>
-     * </tr>
-     * <tr>
-     *   <td>tr (Turkish)</td>
-     *   <td>&#92;u0131</td>
-     *   <td>&#92;u0049</td>
-     *   <td>small letter dotless i -&gt; capital letter I</td>
-     * </tr>
-     * <tr>
-     *   <td>(all)</td>
-     *   <td>&#92;u00df</td>
-     *   <td>&#92;u0053 &#92;u0053</td>
-     *   <td>small letter sharp s -&gt; two letters: SS</td>
-     * </tr>
-     * <tr>
-     *   <td>(all)</td>
-     *   <td>Fahrvergn&uuml;gen</td>
-     *   <td>FAHRVERGN&Uuml;GEN</td>
-     *   <td></td>
-     * </tr>
-     * </table>
-     * @param locale use the case transformation rules for this locale
-     * @return the {@code String}, converted to uppercase.
-     * @see     String#toUpperCase()
-     * @see     String#toLowerCase()
-     * @see     String#toLowerCase(Locale)
-     * @since 3.0.0
-     */
-    public String toUpperCase(Locale locale) {
-        return toString().toUpperCase(locale);
-    }
-
-    /**
-     * Converts all of the characters in this {@code String} to upper
-     * case using the rules of the default locale. This method is equivalent to
-     * {@code toUpperCase(Locale.getDefault())}.
-     * <p>
-     * <b>Note:</b> This method is locale sensitive, and may produce unexpected
-     * results if used for strings that are intended to be interpreted locale
-     * independently.
-     * Examples are programming language identifiers, protocol keys, and HTML
-     * tags.
-     * For instance, {@code "title".toUpperCase()} in a Turkish locale
-     * returns {@code "T\u005Cu0130TLE"}, where '\u005Cu0130' is the
-     * LATIN CAPITAL LETTER I WITH DOT ABOVE character.
-     * To obtain correct results for locale insensitive strings, use
-     * {@code toUpperCase(Locale.ROOT)}.
-     * <p>
-     * @return the {@code String}, converted to uppercase.
-     * @see     String#toUpperCase(Locale)
-     *
-     * @since 3.0.0
-     */
-    public String toUpperCase() {
-        return toString().toUpperCase();
-    }
-
-    /**
-     * Returns a string whose value is this string, with any leading and trailing
-     * whitespace removed.
-     * <p>
-     * If this {@code String} object represents an empty character
-     * sequence, or the first and last characters of character sequence
-     * represented by this {@code String} object both have codes
-     * greater than {@code '\u005Cu0020'} (the space character), then a
-     * reference to this {@code String} object is returned.
-     * <p>
-     * Otherwise, if there is no character with a code greater than
-     * {@code '\u005Cu0020'} in the string, then a
-     * {@code String} object representing an empty string is
-     * returned.
-     * <p>
-     * Otherwise, let <i>k</i> be the index of the first character in the
-     * string whose code is greater than {@code '\u005Cu0020'}, and let
-     * <i>m</i> be the index of the last character in the string whose code
-     * is greater than {@code '\u005Cu0020'}. A {@code String}
-     * object is returned, representing the substring of this string that
-     * begins with the character at index <i>k</i> and ends with the
-     * character at index <i>m</i>-that is, the result of
-     * {@code this.substring(k, m + 1)}.
-     * <p>
-     * This method may be used to trim whitespace (as defined above) from
-     * the beginning and end of a string.
-     *
-     * @return A string whose value is this string, with any leading and trailing white
-     *          space removed, or this string if it has no leading or
-     *          trailing white space.
-     *
-     * @since 3.0.0
-     */
-    public String trim() {
-        return toString().trim();
-    }
-
-    /**
-     * 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.
-     *
-     * @since 3.0.0
-     */
-    public char[] toCharArray() {
-        return toString().toCharArray();
-    }
-
-    /**
-     * Returns a canonical representation for the string object.
-     * <p>
-     * A pool of strings, initially empty, is maintained privately by the
-     * class {@code String}.
-     * <p>
-     * When the intern method is invoked, if the pool already contains a
-     * string equal to this {@code String} object as determined by
-     * the {@link #equals(Object)} method, then the string from the pool is
-     * returned. Otherwise, this {@code String} object is added to the
-     * pool and a reference to this {@code String} object is returned.
-     * <p>
-     * It follows that for any two strings {@code s} and {@code t},
-     * {@code s.intern() == t.intern()} is {@code true}
-     * if and only if {@code s.equals(t)} is {@code true}.
-     * <p>
-     * All literal strings and string-valued constant expressions are
-     * interned. String literals are defined in section 3.10.5 of the
-     * <cite>The Java&trade; Language Specification</cite>.
-     *
-     * @return a string that has the same contents as this string, but is
-     *          guaranteed to be from a pool of unique strings.
-     *
-     * @since 3.0.0
-     */
-    public String intern() {
-        return toString().intern();
-    }
-
 }


Mime
View raw message