java String源码

 /*
  * Copyright (c) 1994, 2010, Oracle and/or its affiliates. All rights reserved.
  * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
  *
  *
  *
  *
  *
  *
  *
  *
  *
  *
  *
  *
  *
  *
  *
  *
  *
  *
  *
  *
  */
 package java.lang;

 import java.io.ObjectStreamField;
 import java.io.UnsupportedEncodingException;
 import java.nio.charset.Charset;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Comparator;
 import java.util.Formatter;
 import java.util.Locale;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import java.util.regex.PatternSyntaxException;

 /**
  * The String class represents character strings. All
  * string literals in Java programs, such as "abc", are
  * implemented as instances of this class.
  *
  * Strings are constant; their values cannot be changed after they
  * are created. String buffers support mutable strings.
  * Because String objects are immutable they can be shared. For example:
  *
  *     String str = "abc";
  *
  * is equivalent to:
  *
  *     char data[] = {'a', 'b', 'c'};
  *     String str = new String(data);
  *
  * Here are some more examples of how strings can be used:
  *
  *     System.out.println("abc");
  *     String cde = "cde";
  *     System.out.println("abc" + cde);
  *     String c = "abc".substring(2,3);
  *     String d = cde.substring(1, 2);
  *
  *
  * The class String includes methods for examining
  * individual characters of the sequence, for comparing strings, for
  * searching strings, for extracting substrings, and for creating a
  * copy of a string with all characters translated to uppercase or to
  * lowercase. Case mapping is based on the Unicode Standard version
  * specified by the {@link java.lang.Character Character} class.
  *
  * The Java language provides special support for the string
  * concatenation operator ( + ), and for conversion of
  * other objects to strings. String concatenation is implemented
  * through the StringBuilder(or StringBuffer)
  * class and its append method.
  * String conversions are implemented through the method
  * toString, defined by Object and
  * inherited by all classes in Java. For additional information on
  * string concatenation and conversion, see Gosling, Joy, and Steele,
  * The Java Language Specification.
  *
  *  Unless otherwise noted, passing a null argument to a constructor
  * or method in this class will cause a {@link NullPointerException} to be
  * thrown.
  *
  * A String represents a string in the UTF-16 format
  * in which supplementary characters are represented by surrogate
  * pairs (see the section Unicode
  * Character Representations in the Character class for
  * more information).
  * Index values refer to char code units, so a supplementary
  * character uses two positions in a String.
  * The String class provides methods for dealing with
  * Unicode code points (i.e., characters), in addition to those for
  * dealing with Unicode code units (i.e., char values).
  *
  * @author  Lee Boynton
  * @author  Arthur van Hoff
  * @author  Martin Buchholz
  * @author  Ulf Zibis
  * @see     java.lang.Object#toString()
  * @see     java.lang.StringBuffer
  * @see     java.lang.StringBuilder
  * @see     java.nio.charset.Charset
  * @since   JDK1.0
  */

 public final class String
     implements java.io.Serializable, Comparable, CharSequence {
     /** The value is used for character storage. */
     private final char value[];

     /** Cache the hash code for the string */
     private int hash; // Default to 0

     /** use serialVersionUID from JDK 1.0.2 for interoperability */
     private static final long serialVersionUID = -6849794470754667710L;

     /**
      * Class String is special cased within the Serialization Stream Protocol.
      *
      * A String instance is written initially into an ObjectOutputStream in the
      * following format:
      *
      *      TC_STRING (utf String)
      *
      * The String is written by method DataOutput.writeUTF.
      * A new handle is generated to  refer to all future references to the
      * string instance within the stream.
      */
     private static final ObjectStreamField[] serialPersistentFields =
             new ObjectStreamField[0];

     /**
      * Initializes a newly created {@code String} object so that it represents
      * an empty character sequence.  Note that use of this constructor is
      * unnecessary since Strings are immutable.
      */
     public String() {
         this.value = new char[0];
     }

     /**
      * Initializes a newly created {@code String} object so that it represents
      * the same sequence of characters as the argument; in other words, the
      * newly created string is a copy of the argument string. Unless an
      * explicit copy of {@code original} is needed, use of this constructor is
      * unnecessary since Strings are immutable.
      *
      * @param  original
      *         A {@code String}
      */
     public String(String original) {
         this.value = original.value;
         this.hash = original.hash;
     }

     /**
      * Allocates a new {@code String} so that it represents the sequence of
      * characters currently contained in the character array argument. The
      * contents of the character array are copied; subsequent modification of
      * the character array does not affect the newly created string.
      *
      * @param  value
      *         The initial value of the string
      */
     public String(char value[]) {
         this.value = Arrays.copyOf(value, value.length);
     }

     /**
      * Allocates a new {@code String} that contains characters from a subarray
      * of the character array argument. The {@code offset} argument is the
      * index of the first character of the subarray and the {@code count}
      * argument specifies the length of the subarray. The contents of the
      * subarray are copied; subsequent modification of the character array does
      * not affect the newly created string.
      *
      * @param  value
      *         Array that is the source of characters
      *
      * @param  offset
      *         The initial offset
      *
      * @param  count
      *         The length
      *
      * @throws  IndexOutOfBoundsException
      *          If the {@code offset} and {@code count} arguments index
      *          characters outside the bounds of the {@code value} array
      */
     public String(char value[], int offset, int count) {
         if (offset < 0) {
             throw new StringIndexOutOfBoundsException(offset);
         }
         if (count < 0) {
             throw new StringIndexOutOfBoundsException(count);
         }
         // Note: offset or count might be near -1>>>1.
         if (offset > value.length - count) {
             throw new StringIndexOutOfBoundsException(offset + count);
         }
         this.value = Arrays.copyOfRange(value, offset, offset+count);
     }

     /**
      * Allocates a new {@code String} that contains characters from a subarray
      * of the Unicode code point array
      * argument.  The {@code offset} argument is the index of the first code
      * point of the subarray and the {@code count} argument specifies the
      * length of the subarray.  The contents of the subarray are converted to
      * {@code char}s; subsequent modification of the {@code int} array does not
      * affect the newly created string.
      *
      * @param  codePoints
      *         Array that is the source of Unicode code points
      *
      * @param  offset
      *         The initial offset
      *
      * @param  count
      *         The length
      *
      * @throws  IllegalArgumentException
      *          If any invalid Unicode code point is found in {@code
      *          codePoints}
      *
      * @throws  IndexOutOfBoundsException
      *          If the {@code offset} and {@code count} arguments index
      *          characters outside the bounds of the {@code codePoints} array
      *
      * @since  1.5
      */
     public String(int[] codePoints, int offset, int count) {
         if (offset < 0) {
             throw new StringIndexOutOfBoundsException(offset);
         }
         if (count < 0) {
             throw new StringIndexOutOfBoundsException(count);
         }
         // Note: offset or count might be near -1>>>1.
         if (offset > codePoints.length - count) {
             throw new StringIndexOutOfBoundsException(offset + count);
         }

         final int end = offset + count;

         // Pass 1: Compute precise size of char[]
         int n = count;
         for (int i = offset; i < end; i++) {
             int c = codePoints[i];
             if (Character.isBmpCodePoint(c))
                 continue;
             else if (Character.isValidCodePoint(c))
                 n++;
             else throw new IllegalArgumentException(Integer.toString(c));
         }

         // Pass 2: Allocate and fill in char[]
         final char[] v = new char[n];

         for (int i = offset, j = 0; i < end; i++, j++) {
             int c = codePoints[i];
             if (Character.isBmpCodePoint(c))
                 v[j] = (char)c;
             else
                 Character.toSurrogates(c, v, j++);
         }

         this.value = v;
     }

     /**
      * Allocates a new {@code String} constructed from a subarray of an array
      * of 8-bit integer values.
      *
      *  The {@code offset} argument is the index of the first byte of the
      * subarray, and the {@code count} argument specifies the length of the
      * subarray.
      *
      *  Each {@code byte} in the subarray is converted to a {@code char} as
      * specified in the method above.
      *
      * @deprecated This method does not properly convert bytes into characters.
      * As of JDK 1.1, the preferred way to do this is via the
      * {@code String} constructors that take a {@link
      * java.nio.charset.Charset}, charset name, or that use the platform's
      * default charset.
      *
      * @param  ascii
      *         The bytes to be converted to characters
      *
      * @param  hibyte
      *         The top 8 bits of each 16-bit Unicode code unit
      *
      * @param  offset
      *         The initial offset
      * @param  count
      *         The length
      *
      * @throws  IndexOutOfBoundsException
      *          If the {@code offset} or {@code count} argument is invalid
      *
      * @see  #String(byte[], int)
      * @see  #String(byte[], int, int, java.lang.String)
      * @see  #String(byte[], int, int, java.nio.charset.Charset)
      * @see  #String(byte[], int, int)
      * @see  #String(byte[], java.lang.String)
      * @see  #String(byte[], java.nio.charset.Charset)
      * @see  #String(byte[])
      */
     @Deprecated
     public String(byte ascii[], int hibyte, int offset, int count) {
         checkBounds(ascii, offset, count);
         char value[] = new char[count];

         if (hibyte == 0) {
             for (int i = count; i-- > 0;) {
                 value[i] = (char)(ascii[i + offset] & 0xff);
             }
         } else {
             hibyte <<= 8;
             for (int i = count; i-- > 0;) {
                 value[i] = (char)(hibyte | (ascii[i + offset] & 0xff));
             }
         }
         this.value = value;
     }

     /**
      * Allocates a new {@code String} containing characters constructed from
      * an array of 8-bit integer values. Each character cin the
      * resulting string is constructed from the corresponding component
      * b in the byte array such that:
      *
      *
      *     c == (char)(((hibyte & 0xff) << 8)
      *                         | (b & 0xff))
      *
      *
      * @deprecated  This method does not properly convert bytes into
      * characters.  As of JDK 1.1, the preferred way to do this is via the
      * {@code String} constructors that take a {@link
      * java.nio.charset.Charset}, charset name, or that use the platform's
      * default charset.
      *
      * @param  ascii
      *         The bytes to be converted to characters
      *
      * @param  hibyte
      *         The top 8 bits of each 16-bit Unicode code unit
      *
      * @see  #String(byte[], int, int, java.lang.String)
      * @see  #String(byte[], int, int, java.nio.charset.Charset)
      * @see  #String(byte[], int, int)
      * @see  #String(byte[], java.lang.String)
      * @see  #String(byte[], java.nio.charset.Charset)
      * @see  #String(byte[])
      */
     @Deprecated
     public String(byte ascii[], int hibyte) {
         this(ascii, hibyte, 0, ascii.length);
     }

     /* Common private utility method used to bounds check the byte array
      * and requested offset & length values used by the String(byte[],..)
      * constructors.
      */
     private static void checkBounds(byte[] bytes, int offset, int length) {
         if (length < 0)
             throw new StringIndexOutOfBoundsException(length);
         if (offset < 0)
             throw new StringIndexOutOfBoundsException(offset);
         if (offset > bytes.length - length)
             throw new StringIndexOutOfBoundsException(offset + length);
     }

     /**
      * Constructs a new {@code String} by decoding the specified subarray of
      * bytes using the specified charset.  The length of the new {@code String}
      * is a function of the charset, and hence may not be equal to the length
      * of the subarray.
      *
      *  The behavior of this constructor when the given bytes are not valid
      * in the given charset is unspecified.  The {@link
      * java.nio.charset.CharsetDecoder} class should be used when more control
      * over the decoding process is required.
      *
      * @param  bytes
      *         The bytes to be decoded into characters
      *
      * @param  offset
      *         The index of the first byte to decode
      *
      * @param  length
      *         The number of bytes to decode

      * @param  charsetName
      *         The name of a supported {@linkplain java.nio.charset.Charset
      *         charset}
      *
      * @throws  UnsupportedEncodingException
      *          If the named charset is not supported
      *
      * @throws  IndexOutOfBoundsException
      *          If the {@code offset} and {@code length} arguments index
      *          characters outside the bounds of the {@code bytes} array
      *
      * @since  JDK1.1
      */
     public String(byte bytes[], int offset, int length, String charsetName)
             throws UnsupportedEncodingException {
         if (charsetName == null)
             throw new NullPointerException("charsetName");
         checkBounds(bytes, offset, length);
         this.value = StringCoding.decode(charsetName, bytes, offset, length);
     }

     /**
      * Constructs a new {@code String} by decoding the specified subarray of
      * bytes using the specified {@linkplain java.nio.charset.Charset charset}.
      * The length of the new {@code String} is a function of the charset, and
      * hence may not be equal to the length of the subarray.
      *
      *  This method always replaces malformed-input and unmappable-character
      * sequences with this charset's default replacement string.  The {@link
      * java.nio.charset.CharsetDecoder} class should be used when more control
      * over the decoding process is required.
      *
      * @param  bytes
      *         The bytes to be decoded into characters
      *
      * @param  offset
      *         The index of the first byte to decode
      *
      * @param  length
      *         The number of bytes to decode
      *
      * @param  charset
      *         The {@linkplain java.nio.charset.Charset charset} to be used to
      *         decode the {@code bytes}
      *
      * @throws  IndexOutOfBoundsException
      *          If the {@code offset} and {@code length} arguments index
      *          characters outside the bounds of the {@code bytes} array
      *
      * @since  1.6
      */
     public String(byte bytes[], int offset, int length, Charset charset) {
         if (charset == null)
             throw new NullPointerException("charset");
         checkBounds(bytes, offset, length);
         this.value =  StringCoding.decode(charset, bytes, offset, length);
     }

     /**
      * Constructs a new {@code String} by decoding the specified array of bytes
      * using the specified {@linkplain java.nio.charset.Charset charset}.  The
      * length of the new {@code String} is a function of the charset, and hence
      * may not be equal to the length of the byte array.
      *
      *  The behavior of this constructor when the given bytes are not valid
      * in the given charset is unspecified.  The {@link
      * java.nio.charset.CharsetDecoder} class should be used when more control
      * over the decoding process is required.
      *
      * @param  bytes
      *         The bytes to be decoded into characters
      *
      * @param  charsetName
      *         The name of a supported {@linkplain java.nio.charset.Charset
      *         charset}
      *
      * @throws  UnsupportedEncodingException
      *          If the named charset is not supported
      *
      * @since  JDK1.1
      */
     public String(byte bytes[], String charsetName)
             throws UnsupportedEncodingException {
         this(bytes, 0, bytes.length, charsetName);
     }

     /**
      * Constructs a new {@code String} by decoding the specified array of
      * bytes using the specified {@linkplain java.nio.charset.Charset charset}.
      * The length of the new {@code String} is a function of the charset, and
      * hence may not be equal to the length of the byte array.
      *
      *  This method always replaces malformed-input and unmappable-character
      * sequences with this charset's default replacement string.  The {@link
      * java.nio.charset.CharsetDecoder} class should be used when more control
      * over the decoding process is required.
      *
      * @param  bytes
      *         The bytes to be decoded into characters
      *
      * @param  charset
      *         The {@linkplain java.nio.charset.Charset charset} to be used to
      *         decode the {@code bytes}
      *
      * @since  1.6
      */
     public String(byte bytes[], Charset charset) {
         this(bytes, 0, bytes.length, charset);
     }

     /**
      * Constructs a new {@code String} by decoding the specified subarray of
      * bytes using the platform's default charset.  The length of the new
      * {@code String} is a function of the charset, and hence may not be equal
      * to the length of the subarray.
      *
      *  The behavior of this constructor when the given bytes are not valid
      * in the default charset is unspecified.  The {@link
      * java.nio.charset.CharsetDecoder} class should be used when more control
      * over the decoding process is required.
      *
      * @param  bytes
      *         The bytes to be decoded into characters
      *
      * @param  offset
      *         The index of the first byte to decode
      *
      * @param  length
      *         The number of bytes to decode
      *
      * @throws  IndexOutOfBoundsException
      *          If the {@code offset} and the {@code length} arguments index
      *          characters outside the bounds of the {@code bytes} array
      *
      * @since  JDK1.1
      */
     public String(byte bytes[], int offset, int length) {
         checkBounds(bytes, offset, length);
         this.value = StringCoding.decode(bytes, offset, length);
     }

     /**
      * Constructs a new {@code String} by decoding the specified array of bytes
      * using the platform's default charset.  The length of the new {@code
      * String} is a function of the charset, and hence may not be equal to the
      * length of the byte array.
      *
      *  The behavior of this constructor when the given bytes are not valid
      * in the default charset is unspecified.  The {@link
      * java.nio.charset.CharsetDecoder} class should be used when more control
      * over the decoding process is required.
      *
      * @param  bytes
      *         The bytes to be decoded into characters
      *
      * @since  JDK1.1
      */
     public String(byte bytes[]) {
         this(bytes, 0, bytes.length);
     }

     /**
      * Allocates a new string that contains the sequence of characters
      * currently contained in the string buffer argument. The contents of the
      * string buffer are copied; subsequent modification of the string buffer
      * does not affect the newly created string.
      *
      * @param  buffer
      *         A {@code StringBuffer}
      */
     public String(StringBuffer buffer) {
         synchronized(buffer) {
             this.value = Arrays.copyOf(buffer.getValue(), buffer.length());
         }
     }

     /**
      * Allocates a new string that contains the sequence of characters
      * currently contained in the string builder argument. The contents of the
      * string builder are copied; subsequent modification of the string builder
      * does not affect the newly created string.
      *
      *  This constructor is provided to ease migration to {@code
      * StringBuilder}. Obtaining a string from a string builder via the {@code
      * toString} method is likely to run faster and is generally preferred.
      *
      * @param   builder
      *          A {@code StringBuilder}
      *
      * @since  1.5
      */
     public String(StringBuilder builder) {
         this.value = Arrays.copyOf(builder.getValue(), builder.length());
     }

     /*
     * Package private constructor which shares value array for speed.
     * this constructor is always expected to be called with share==true.
     * a separate constructor is needed because we already have a public
     * String(char[]) constructor that makes a copy of the given char[].
     */
     String(char[] value, boolean share) {
         // assert share : "unshared not supported";
         this.value = value;
     }

     /**
      * Package private constructor
      *
      * @deprecated Use {@link #String(char[],int,int)} instead.
      */
     @Deprecated
     String(int offset, int count, char[] value) {
         this(value, offset, count);
     }

     /**
      * Returns the length of this string.
      * The length is equal to the number of Unicode
      * code units in the string.
      *
      * @return  the length of the sequence of characters represented by this
      *          object.
      */
     public int length() {
         return value.length;
     }

     /**
      * Returns true if, and only if, {@link #length()} is 0.
      *
      * @return true if {@link #length()} is 0, otherwise
      * false
      *
      * @since 1.6
      */
     public boolean isEmpty() {
         return value.length == 0;
     }

     /**
      * Returns the char value at the
      * specified index. An index ranges from 0 to
      * length() - 1. The first char value of the sequence
      * is at index 0, the next at index 1,
      * and so on, as for array indexing.
      *
      * If the char value specified by the index is a
      * surrogate, the surrogate
      * value is returned.
      *
      * @param      index   the index of the char value.
      * @return     the char value at the specified index of this string.
      *             The first char value is at index 0.
      * @exception  IndexOutOfBoundsException  if the index
      *             argument is negative or not less than the length of this
      *             string.
      */
     public char charAt(int index) {
         if ((index < 0) || (index >= value.length)) {
             throw new StringIndexOutOfBoundsException(index);
         }
         return value[index];
     }

     /**
      * Returns the character (Unicode code point) at the specified
      * index. The index refers to char values
      * (Unicode code units) and ranges from 0 to
      * {@link #length()} - 1.
      *
      *  If the char value specified at the given index
      * is in the high-surrogate range, the following index is less
      * than the length of this String, and the
      * 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 char value at the given index is returned.
      *
      * @param      index the index to the char values
      * @return     the code point value of the character at the
      *             index
      * @exception  IndexOutOfBoundsException  if the index
      *             argument is negative or not less than the length of this
      *             string.
      * @since      1.5
      */
     public int codePointAt(int index) {
         if ((index < 0) || (index >= value.length)) {
             throw new StringIndexOutOfBoundsException(index);
         }
         return Character.codePointAtImpl(value, index, value.length);
     }

     /**
      * Returns the character (Unicode code point) before the specified
      * index. The index refers to char values
      * (Unicode code units) and ranges from 1 to {@link
      * CharSequence#length() length}.
      *
      *  If the char value at (index - 1)
      * is in the low-surrogate range, (index - 2) is not
      * negative, and the char value at (index -
      * 2) is in the high-surrogate range, then the
      * supplementary code point value of the surrogate pair is
      * returned. If the char value at 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 index
      *            argument is less than 1 or greater than the length
      *            of this string.
      * @since     1.5
      */
     public int codePointBefore(int index) {
         int i = index - 1;
         if ((i < 0) || (i >= value.length)) {
             throw new StringIndexOutOfBoundsException(index);
         }
         return Character.codePointBeforeImpl(value, index, 0);
     }

     /**
      * Returns the number of Unicode code points in the specified text
      * range of this String. The text range begins at the
      * specified beginIndex and extends to the
      * char at index endIndex - 1. Thus the
      * length (in chars) of the text range is
      * endIndex-beginIndex. Unpaired surrogates within
      * the text range count as one code point each.
      *
      * @param beginIndex the index to the first char of
      * the text range.
      * @param endIndex the index after the last char of
      * the text range.
      * @return the number of Unicode code points in the specified text
      * range
      * @exception IndexOutOfBoundsException if the
      * beginIndex is negative, or endIndex
      * is larger than the length of this String, or
      * beginIndex is larger than endIndex.
      * @since  1.5
      */
     public int codePointCount(int beginIndex, int endIndex) {
         if (beginIndex < 0 || endIndex > value.length || beginIndex > endIndex) {
             throw new IndexOutOfBoundsException();
         }
         return Character.codePointCountImpl(value, beginIndex, endIndex - beginIndex);
     }

     /**
      * Returns the index within this String that is
      * offset from the given index by
      * codePointOffset code points. Unpaired surrogates
      * within the text range given by index and
      * 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 String
      * @exception IndexOutOfBoundsException if index
      *   is negative or larger then the length of this
      *   String, or if codePointOffset is positive
      *   and the substring starting with index has fewer
      *   than codePointOffset code points,
      *   or if codePointOffset is negative and the substring
      *   before index has fewer than the absolute value
      *   of codePointOffset code points.
      * @since 1.5
      */
     public int offsetByCodePoints(int index, int codePointOffset) {
         if (index < 0 || index > value.length) {
             throw new IndexOutOfBoundsException();
         }
         return Character.offsetByCodePointsImpl(value, 0, value.length,
                 index, codePointOffset);
     }

     /**
      * Copy characters from this string into dst starting at dstBegin.
      * This method doesn't perform any range checking.
      */
     void getChars(char dst[], int dstBegin) {
         System.arraycopy(value, 0, dst, dstBegin, value.length);
     }

     /**
      * Copies characters from this string into the destination character
      * array.
      *
      * The first character to be copied is at index srcBegin;
      * the last character to be copied is at index srcEnd-1
      * (thus the total number of characters to be copied is
      * srcEnd-srcBegin). The characters are copied into the
      * subarray of dst starting at index dstBegin
      * and ending at index:
      *
      *     dstbegin + (srcEnd-srcBegin) - 1
      *
      *
      * @param      srcBegin   index of the first character in the string
      *                        to copy.
      * @param      srcEnd     index after the last character in the string
      *                        to copy.
      * @param      dst        the destination array.
      * @param      dstBegin   the start offset in the destination array.
      * @exception IndexOutOfBoundsException If any of the following
      *            is true:
      *            srcBegin is negative.  
         *            srcBegin is greater than srcEnd  
         *            srcEnd is greater than the length of this  
         *                string  
         *            dstBegin is negative  
         *            dstBegin+(srcEnd-srcBegin) is larger than  
         *                dst.length
      */
     public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) {
         if (srcBegin < 0) {
             throw new StringIndexOutOfBoundsException(srcBegin);
         }
         if (srcEnd > value.length) {
             throw new StringIndexOutOfBoundsException(srcEnd);
         }
         if (srcBegin > srcEnd) {
             throw new StringIndexOutOfBoundsException(srcEnd - srcBegin);
         }
         System.arraycopy(value, srcBegin, dst, dstBegin, srcEnd - srcBegin);
     }

     /**
      * Copies characters from this string into the destination byte array. Each
      * byte receives the 8 low-order bits of the corresponding character. The
      * eight high-order bits of each character are not copied and do not
      * participate in the transfer in any way.
      *
      *  The first character to be copied is at index {@code srcBegin}; the
      * last character to be copied is at index {@code srcEnd-1}.  The total
      * number of characters to be copied is {@code srcEnd-srcBegin}. The
      * characters, converted to bytes, are copied into the subarray of {@code
      * dst} starting at index {@code dstBegin} and ending at index:
      *
      *
      *     dstbegin + (srcEnd-srcBegin) - 1
      *
      *
      * @deprecated  This method does not properly convert characters into
      * bytes.  As of JDK 1.1, the preferred way to do this is via the
      * {@link #getBytes()} method, which uses the platform's default charset.
      *
      * @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
      *
      * @throws  IndexOutOfBoundsException
      *          If any of the following is true:
      *            
         *             {@code srcBegin} is negative  
         *             {@code srcBegin} is greater than {@code srcEnd}  
         *             {@code srcEnd} is greater than the length of this String  
         *             {@code dstBegin} is negative  
         *             {@code dstBegin+(srcEnd-srcBegin)} is larger than {@code  
         *                 dst.length}  
         *
      */
     @Deprecated
     public void getBytes(int srcBegin, int srcEnd, byte dst[], int dstBegin) {
         if (srcBegin < 0) {
             throw new StringIndexOutOfBoundsException(srcBegin);
         }
         if (srcEnd > value.length) {
             throw new StringIndexOutOfBoundsException(srcEnd);
         }
         if (srcBegin > srcEnd) {
             throw new StringIndexOutOfBoundsException(srcEnd - srcBegin);
         }
         int j = dstBegin;
         int n = srcEnd;
         int i = srcBegin;
         char[] val = value;   /* avoid getfield opcode */

         while (i < n) {
             dst[j++] = (byte)val[i++];
         }
     }

     /**
      * Encodes this {@code String} into a sequence of bytes using the named
      * charset, storing the result into a new byte array.
      *
      *  The behavior of this method when this string cannot be encoded in
      * the given charset is unspecified.  The {@link
      * java.nio.charset.CharsetEncoder} class should be used when more control
      * over the encoding process is required.
      *
      * @param  charsetName
      *         The name of a supported {@linkplain java.nio.charset.Charset
      *         charset}
      *
      * @return  The resultant byte array
      *
      * @throws  UnsupportedEncodingException
      *          If the named charset is not supported
      *
      * @since  JDK1.1
      */
     public byte[] getBytes(String charsetName)
             throws UnsupportedEncodingException {
         if (charsetName == null) throw new NullPointerException();
         return StringCoding.encode(charsetName, value, 0, value.length);
     }

     /**
      * Encodes this {@code String} into a sequence of bytes using the given
      * {@linkplain java.nio.charset.Charset charset}, storing the result into a
      * new byte array.
      *
      *  This method always replaces malformed-input and unmappable-character
      * sequences with this charset's default replacement byte array.  The
      * {@link java.nio.charset.CharsetEncoder} class should be used when more
      * control over the encoding process is required.
      *
      * @param  charset
      *         The {@linkplain java.nio.charset.Charset} to be used to encode
      *         the {@code String}
      *
      * @return  The resultant byte array
      *
      * @since  1.6
      */
     public byte[] getBytes(Charset charset) {
         if (charset == null) throw new NullPointerException();
         return StringCoding.encode(charset, value, 0, value.length);
     }

     /**
      * Encodes this {@code String} into a sequence of bytes using the
      * platform's default charset, storing the result into a new byte array.
      *
      *  The behavior of this method when this string cannot be encoded in
      * the default charset is unspecified.  The {@link
      * java.nio.charset.CharsetEncoder} class should be used when more control
      * over the encoding process is required.
      *
      * @return  The resultant byte array
      *
      * @since      JDK1.1
      */
     public byte[] getBytes() {
         return StringCoding.encode(value, 0, value.length);
     }

     /**
      * Compares this string to the specified object.  The result is {@code
      * true} if and only if the argument is not {@code null} and is a {@code
      * String} object that represents the same sequence of characters as this
      * object.
      *
      * @param  anObject
      *         The object to compare this {@code String} against
      *
      * @return  {@code true} if the given object represents a {@code String}
      *          equivalent to this string, {@code false} otherwise
      *
      * @see  #compareTo(String)
      * @see  #equalsIgnoreCase(String)
      */
     public boolean equals(Object anObject) {
         if (this == anObject) {
             return true;
         }
         if (anObject instanceof String) {
             String anotherString = (String) anObject;
             int n = value.length;
             if (n == anotherString.value.length) {
                 char v1[] = value;
                 char v2[] = anotherString.value;
                 int i = 0;
                 while (n-- != 0) {
                     if (v1[i] != v2[i])
                             return false;
                     i++;
                 }
                 return true;
             }
         }
         return false;
     }

     /**
      * Compares this string to the specified {@code StringBuffer}.  The result
      * is {@code true} if and only if this {@code String} represents the same
      * sequence of characters as the specified {@code StringBuffer}.
      *
      * @param  sb
      *         The {@code StringBuffer} to compare this {@code String} against
      *
      * @return  {@code true} if this {@code String} represents the same
      *          sequence of characters as the specified {@code StringBuffer},
      *          {@code false} otherwise
      *
      * @since  1.4
      */
     public boolean contentEquals(StringBuffer sb) {
         synchronized (sb) {
             return contentEquals((CharSequence) 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.
      *
      * @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  1.5
      */
     public boolean contentEquals(CharSequence cs) {
         if (value.length != cs.length())
             return false;
         // Argument is a StringBuffer, StringBuilder
         if (cs instanceof AbstractStringBuilder) {
             char v1[] = value;
             char v2[] = ((AbstractStringBuilder) cs).getValue();
             int i = 0;
             int n = value.length;
             while (n-- != 0) {
                 if (v1[i] != v2[i])
                     return false;
                 i++;
             }
             return true;
         }
         // Argument is a String
         if (cs.equals(this))
             return true;
         // Argument is a generic CharSequence
         char v1[] = value;
         int i = 0;
         int n = value.length;
         while (n-- != 0) {
             if (v1[i] != cs.charAt(i))
                 return false;
             i++;
         }
         return true;
     }

     /**
      * Compares this {@code String} to another {@code String}, ignoring case
      * considerations.  Two strings are considered equal ignoring case if they
      * are of the same length and corresponding characters in the two strings
      * are equal ignoring case.
      *
      *  Two characters {@code c1} and {@code c2} are considered the same
      * ignoring case if at least one of the following is true:
      *   
         *    The two characters are the same (as compared by the  
         *        {@code ==} operator)  
         *    Applying the method {@link  
         *        java.lang.Character#toUpperCase(char)} to each character  
         *        produces the same result  
         *    Applying the method {@link  
         *        java.lang.Character#toLowerCase(char)} to each character  
         *        produces the same result  
         *
      *
      * @param  anotherString
      *         The {@code String} to compare this {@code String} against
      *
      * @return  {@code true} if the argument is not {@code null} and it
      *          represents an equivalent {@code String} ignoring case; {@code
      *          false} otherwise
      *
      * @see  #equals(Object)
      */
     public boolean equalsIgnoreCase(String anotherString) {
         return (this == anotherString) ? true
                 : (anotherString != null)
                 && (anotherString.value.length == value.length)
                 && regionMatches(true, 0, anotherString, 0, value.length);
     }

     /**
      * Compares two strings lexicographically.
      * The comparison is based on the Unicode value of each character in
      * the strings. The character sequence represented by this
      * String object is compared lexicographically to the
      * character sequence represented by the argument string. The result is
      * a negative integer if this String object
      * lexicographically precedes the argument string. The result is a
      * positive integer if this String object lexicographically
      * follows the argument string. The result is zero if the strings
      * are equal; compareTo returns 0 exactly when
      * the {@link #equals(Object)} method would return true.
      *
      * This is the definition of lexicographic ordering. If two strings are
      * different, then either they have different characters at some index
      * that is a valid index for both strings, or their lengths are different,
      * or both. If they have different characters at one or more index
      * positions, let k be the smallest such index; then the string
      * whose character at position k has the smaller value, as
      * determined by using the < operator, lexicographically precedes the
      * other string. In this case, compareTo returns the
      * difference of the two character values at position k in
      * the two string -- that is, the value:
      *
      * this.charAt(k)-anotherString.charAt(k)
      *
      * If there is no index position at which they differ, then the shorter
      * string lexicographically precedes the longer string. In this case,
      * compareTo returns the difference of the lengths of the
      * strings -- that is, the value:
      *
      * this.length()-anotherString.length()
      *
      *
      * @param   anotherString   the String to be compared.
      * @return  the value 0 if the argument string is equal to
      *          this string; a value less than 0 if this string
      *          is lexicographically less than the string argument; and a
      *          value greater than 0 if this string is
      *          lexicographically greater than the string argument.
      */
     public int compareTo(String anotherString) {
         int len1 = value.length;
         int len2 = anotherString.value.length;
         int lim = Math.min(len1, len2);
         char v1[] = value;
         char v2[] = anotherString.value;

         int k = 0;
         while (k < lim) {
             char c1 = v1[k];
             char c2 = v2[k];
             if (c1 != c2) {
                 return c1 - c2;
             }
             k++;
         }
         return len1 - len2;
     }

     /**
      * A Comparator that orders String objects as by
      * compareToIgnoreCase. This comparator is serializable.
      *
      * Note that this Comparator does not take locale into account,
      * and will result in an unsatisfactory ordering for certain locales.
      * The java.text package provides Collators to allow
      * locale-sensitive ordering.
      *
      * @see     java.text.Collator#compare(String, String)
      * @since   1.2
      */
     public static final Comparator CASE_INSENSITIVE_ORDER
                                          = new CaseInsensitiveComparator();
     private static class CaseInsensitiveComparator
             implements Comparator, java.io.Serializable {
         // use serialVersionUID from JDK 1.2.2 for interoperability
         private static final long serialVersionUID = 8575799808933029326L;

         public int compare(String s1, String s2) {
             int n1 = s1.length();
             int n2 = s2.length();
             int min = Math.min(n1, n2);
             for (int i = 0; i < min; i++) {
                 char c1 = s1.charAt(i);
                 char c2 = s2.charAt(i);
                 if (c1 != c2) {
                     c1 = Character.toUpperCase(c1);
                     c2 = Character.toUpperCase(c2);
                     if (c1 != c2) {
                         c1 = Character.toLowerCase(c1);
                         c2 = Character.toLowerCase(c2);
                         if (c1 != c2) {
                             // No overflow because of numeric promotion
                             return c1 - c2;
                         }
                     }
                 }
             }
             return n1 - n2;
         }
     }

     /**
      * Compares two strings lexicographically, ignoring case
      * differences. This method returns an integer whose sign is that of
      * calling compareTo with normalized versions of the strings
      * where case differences have been eliminated by calling
      * Character.toLowerCase(Character.toUpperCase(character)) on
      * each character.
      *
      * Note that this method does not take locale into account,
      * and will result in an unsatisfactory ordering for certain locales.
      * The java.text package provides collators to allow
      * locale-sensitive ordering.
      *
      * @param   str   the String to be compared.
      * @return  a negative integer, zero, or a positive integer as the
      *          specified String is greater than, equal to, or less
      *          than this String, ignoring case considerations.
      * @see     java.text.Collator#compare(String, String)
      * @since   1.2
      */
     public int compareToIgnoreCase(String str) {
         return CASE_INSENSITIVE_ORDER.compare(this, str);
     }

     /**
      * Tests if two string regions are equal.
      *
      * A substring of this String object is compared to a substring
      * of the argument other. The result is true if these substrings
      * represent identical character sequences. The substring of this
      * String object to be compared begins at index toffset
      * and has length len. The substring of other to be compared
      * begins at index ooffset and has length len. The
      * result is false if and only if at least one of the following
      * is true:
      * toffset is negative.  
         * ooffset is negative.  
         * toffset+len is greater than the length of this  
         * String object.  
         * ooffset+len is greater than the length of the other  
         * argument.  
         * There is some nonnegative integer k less than len  
         * such that:  
         * this.charAt(toffset+k) != other.charAt(ooffset+k)  
         *
      *
      * @param   toffset   the starting offset of the subregion in this string.
      * @param   other     the string argument.
      * @param   ooffset   the starting offset of the subregion in the string
      *                    argument.
      * @param   len       the number of characters to compare.
      * @return  true if the specified subregion of this string
      *          exactly matches the specified subregion of the string argument;
      *          false otherwise.
      */
     public boolean regionMatches(int toffset, String other, int ooffset,
             int len) {
         char ta[] = value;
         int to = toffset;
         char pa[] = other.value;
         int po = ooffset;
         // Note: toffset, ooffset, or len might be near -1>>>1.
         if ((ooffset < 0) || (toffset < 0)
                 || (toffset > (long)value.length - len)
                 || (ooffset > (long)other.value.length - len)) {
             return false;
         }
         while (len-- > 0) {
             if (ta[to++] != pa[po++]) {
                 return false;
             }
         }
         return true;
     }

     /**
      * Tests if two string regions are equal.
      *
      * A substring of this String object is compared to a substring
      * of the argument other. The result is true if these
      * substrings represent character sequences that are the same, ignoring
      * case if and only if ignoreCase is true. The substring of
      * this String object to be compared begins at index
      * toffset and has length len. The substring of
      * other to be compared begins at index ooffset and
      * has length len. The result is false if and only if
      * at least one of the following is true:
      * toffset is negative.  
         * ooffset is negative.  
         * toffset+len is greater than the length of this  
         * String object.  
         * ooffset+len is greater than the length of the other  
         * argument.  
         * ignoreCase is false and there is some nonnegative  
         * integer k less than len such that:  
         *   
         * this.charAt(toffset+k) != other.charAt(ooffset+k)  
         *   
         * ignoreCase is true and there is some nonnegative  
         * integer k less than len such that:  
         *   
         * Character.toLowerCase(this.charAt(toffset+k)) !=  
         Character.toLowerCase(other.charAt(ooffset+k))  
         *   
         * and:  
         *   
         * Character.toUpperCase(this.charAt(toffset+k)) !=  
         *         Character.toUpperCase(other.charAt(ooffset+k))  
         *   
         *
      *
      * @param   ignoreCase   if true, ignore case when comparing
      *                       characters.
      * @param   toffset      the starting offset of the subregion in this
      *                       string.
      * @param   other        the string argument.
      * @param   ooffset      the starting offset of the subregion in the string
      *                       argument.
      * @param   len          the number of characters to compare.
      * @return  true if the specified subregion of this string
      *          matches the specified subregion of the string argument;
      *          false otherwise. Whether the matching is exact
      *          or case insensitive depends on the ignoreCase
      *          argument.
      */
     public boolean regionMatches(boolean ignoreCase, int toffset,
             String other, int ooffset, int len) {
         char ta[] = value;
         int to = toffset;
         char pa[] = other.value;
         int po = ooffset;
         // Note: toffset, ooffset, or len might be near -1>>>1.
         if ((ooffset < 0) || (toffset < 0)
                 || (toffset > (long)value.length - len)
                 || (ooffset > (long)other.value.length - len)) {
             return false;
         }
         while (len-- > 0) {
             char c1 = ta[to++];
             char c2 = pa[po++];
             if (c1 == c2) {
                 continue;
             }
             if (ignoreCase) {
                 // If characters don't match but case may be ignored,
                 // try converting both characters to uppercase.
                 // If the results match, then the comparison scan should
                 // continue.
                 char u1 = Character.toUpperCase(c1);
                 char u2 = Character.toUpperCase(c2);
                 if (u1 == u2) {
                     continue;
                 }
                 // Unfortunately, conversion to uppercase does not work properly
                 // for the Georgian alphabet, which has strange rules about case
                 // conversion.  So we need to make one last check before
                 // exiting.
                 if (Character.toLowerCase(u1) == Character.toLowerCase(u2)) {
                     continue;
                 }
             }
             return false;
         }
         return true;
     }

     /**
      * Tests if the substring of this string beginning at the
      * specified index starts with the specified prefix.
      *
      * @param   prefix    the prefix.
      * @param   toffset   where to begin looking in this string.
      * @return  true if the character sequence represented by the
      *          argument is a prefix of the substring of this object starting
      *          at index toffset; false otherwise.
      *          The result is false if toffset is
      *          negative or greater than the length of this
      *          String object; otherwise the result is the same
      *          as the result of the expression
      *
      *          this.substring(toffset).startsWith(prefix)
      *
      */
     public boolean startsWith(String prefix, int toffset) {
         char ta[] = value;
         int to = toffset;
         char pa[] = prefix.value;
         int po = 0;
         int pc = prefix.value.length;
         // Note: toffset might be near -1>>>1.
         if ((toffset < 0) || (toffset > value.length - pc)) {
             return false;
         }
         while (--pc >= 0) {
             if (ta[to++] != pa[po++]) {
                 return false;
             }
         }
         return true;
     }

     /**
      * Tests if this string starts with the specified prefix.
      *
      * @param   prefix   the prefix.
      * @return  true if the character sequence represented by the
      *          argument is a prefix of the character sequence represented by
      *          this string; false otherwise.
      *          Note also that true will be returned if the
      *          argument is an empty string or is equal to this
      *          String object as determined by the
      *          {@link #equals(Object)} method.
      * @since   1. 0
      */
     public boolean startsWith(String prefix) {
         return startsWith(prefix, 0);
     }

     /**
      * Tests if this string ends with the specified suffix.
      *
      * @param   suffix   the suffix.
      * @return  true if the character sequence represented by the
      *          argument is a suffix of the character sequence represented by
      *          this object; false otherwise. Note that the
      *          result will be true if the argument is the
      *          empty string or is equal&nb