You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@groovy.apache.org by su...@apache.org on 2018/10/06 14:59:31 UTC
groovy git commit: GROOVY-8831: Add instance methods from `String` to
`GString`(closes #806)
Repository: groovy
Updated Branches:
refs/heads/master 3aec80673 -> 9e0ebf3af
GROOVY-8831: Add instance methods from `String` to `GString`(closes #806)
Project: http://git-wip-us.apache.org/repos/asf/groovy/repo
Commit: http://git-wip-us.apache.org/repos/asf/groovy/commit/9e0ebf3a
Tree: http://git-wip-us.apache.org/repos/asf/groovy/tree/9e0ebf3a
Diff: http://git-wip-us.apache.org/repos/asf/groovy/diff/9e0ebf3a
Branch: refs/heads/master
Commit: 9e0ebf3af3a5e1e65b9071fcff474948eb701db9
Parents: 3aec806
Author: Daniel Sun <su...@apache.org>
Authored: Sat Oct 6 22:57:30 2018 +0800
Committer: Daniel Sun <su...@apache.org>
Committed: Sat Oct 6 22:59:25 2018 +0800
----------------------------------------------------------------------
src/main/groovy/groovy/lang/GString.java | 1412 +++++++++++++++++++++++++
1 file changed, 1412 insertions(+)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/groovy/blob/9e0ebf3a/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 d2b1d5b..a3b337f 100644
--- a/src/main/groovy/groovy/lang/GString.java
+++ b/src/main/groovy/groovy/lang/GString.java
@@ -27,7 +27,13 @@ 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
@@ -237,21 +243,102 @@ 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)>0 && y.compareTo(z)>0)</tt> implies
+ * <tt>x.compareTo(z)>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);
@@ -273,4 +360,1329 @@ 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 < 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> >= 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> >= 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> <= 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> <= 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> >= 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> - 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 ,} <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>, <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>\u0130</td>
+ * <td>\u0069</td>
+ * <td>capital letter I with dot above -> small letter i</td>
+ * </tr>
+ * <tr>
+ * <td>tr (Turkish)</td>
+ * <td>\u0049</td>
+ * <td>\u0131</td>
+ * <td>capital letter I -> 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>\u0069</td>
+ * <td>\u0130</td>
+ * <td>small letter i -> capital letter I with dot above</td>
+ * </tr>
+ * <tr>
+ * <td>tr (Turkish)</td>
+ * <td>\u0131</td>
+ * <td>\u0049</td>
+ * <td>small letter dotless i -> capital letter I</td>
+ * </tr>
+ * <tr>
+ * <td>(all)</td>
+ * <td>\u00df</td>
+ * <td>\u0053 \u0053</td>
+ * <td>small letter sharp s -> two letters: SS</td>
+ * </tr>
+ * <tr>
+ * <td>(all)</td>
+ * <td>Fahrvergnügen</td>
+ * <td>FAHRVERGNÜ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™ 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();
+ }
+
}