Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   /*
    * Copyright 1994-2006 Sun Microsystems, Inc.  All Rights Reserved.
    * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    *
    * This code is free software; you can redistribute it and/or modify it
    * under the terms of the GNU General Public License version 2 only, as
    * published by the Free Software Foundation.  Sun designates this
    * particular file as subject to the "Classpath" exception as provided
    * by Sun in the LICENSE file that accompanied this code.
   *
   * This code is distributed in the hope that it will be useful, but WITHOUT
   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   * version 2 for more details (a copy is included in the LICENSE file that
   * accompanied this code).
   *
   * You should have received a copy of the GNU General Public License version
   * 2 along with this work; if not, write to the Free Software Foundation,
   * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   *
   * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
   * CA 95054 USA or visit www.sun.com if you need additional information or
   * have any questions.
   */
  
  package java.lang;
  
  import java.util.Arrays;
  import java.util.Locale;
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 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 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(s):
Lee Boynton
Arthur van Hoff
Since:
JDK1.0
See also:
Object.toString()
StringBuffer
StringBuilder
java.nio.charset.Charset
 
 
 public final class String
 {
    
The value is used for character storage.
 
     private final char value[];

    
The offset is the first index of the storage that is used.
 
     private final int offset;

    
The count is the number of characters in the String.
 
     private final int count;

    
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 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. = 0;
         this. = 0;
         this. = new char[0];
     }

    
Initializes a newly created 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 original is needed, use of this constructor is unnecessary since Strings are immutable.

Parameters:
original A String
 
     public String(String original) {
         int size = original.count;
         char[] originalValue = original.value;
         char[] v;
         if (originalValue.length > size) {
             // The array representing the String is bigger than the new
             // String itself.  Perhaps this constructor is being called
             // in order to trim the baggage, so make a copy of the array.
             int off = original.offset;
             v = Arrays.copyOfRange(originalValueoffoff+size);
         } else {
             // The array representing the String is the same
             // size as the String, so no point in making a copy.
             v = originalValue;
         }
         this. = 0;
         this. = size;
         this. = v;
     }

    
Allocates a new 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.

Parameters:
value The initial value of the string
 
     public String(char value[]) {
         int size = value.length;
         this. = 0;
         this. = size;
         this. = Arrays.copyOf(valuesize);
     }

    
Allocates a new String that contains characters from a subarray of the character array argument. The offset argument is the index of the first character of the subarray and the count argument specifies the length of the subarray. The contents of the subarray are copied; subsequent modification of the character array does not affect the newly created string.

Parameters:
value Array that is the source of characters
offset The initial offset
count The length
Throws:
IndexOutOfBoundsException If the offset and count arguments index characters outside the bounds of the value array
 
     public String(char value[], int offsetint 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. = 0;
         this. = count;
         this. = Arrays.copyOfRange(valueoffsetoffset+count);
     }

    
Allocates a new String that contains characters from a subarray of the Unicode code point array argument. The offset argument is the index of the first code point of the subarray and the count argument specifies the length of the subarray. The contents of the subarray are converted to chars; subsequent modification of the int array does not affect the newly created string.

Parameters:
codePoints Array that is the source of Unicode code points
offset The initial offset
count The length
Throws:
IllegalArgumentException If any invalid Unicode code point is found in codePoints
IndexOutOfBoundsException If the offset and count arguments index characters outside the bounds of the codePoints array
Since:
1.5
 
     public String(int[] codePointsint offsetint 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);
         }
 
         // Pass 1: Compute precise size of char[]
         int n = 0;
         for (int i = offseti < offset + counti++) {
             int c = codePoints[i];
             if (c >= . &&
                 c <  .)
                 n += 1;
             else if (Character.isSupplementaryCodePoint(c))
                 n += 2;
             else throw new IllegalArgumentException(Integer.toString(c));
         }
 
         // Pass 2: Allocate and fill in char[]
         char[] v = new char[n];
         for (int i = offsetj = 0; i < offset + counti++) {
             int c = codePoints[i];
             if (c < .) {
                 v[j++] = (charc;
             } else {
                 Character.toSurrogates(cvj);
                 j += 2;
             }
         }
 
         this.  = v;
         this.  = v.length;
         this. = 0;
     }

    
Allocates a new String constructed from a subarray of an array of 8-bit integer values.

The offset argument is the index of the first byte of the subarray, and the count argument specifies the length of the subarray.

Each byte in the subarray is converted to a 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 String constructors that take a java.nio.charset.Charset, charset name, or that use the platform's default charset.
Parameters:
ascii The bytes to be converted to characters
hibyte The top 8 bits of each 16-bit Unicode code unit
offset The initial offset
count The length
Throws:
IndexOutOfBoundsException If the offset or count argument is invalid
See also:
String(byte[],int)
String(byte[],int,int,java.lang.String)
String(byte[],int,int,java.nio.charset.Charset)
String(byte[],int,int)
String(byte[],java.lang.String)
String(byte[],java.nio.charset.Charset)
String(byte[])
 
     @Deprecated
     public String(byte ascii[], int hibyteint offsetint count) {
         checkBounds(asciioffsetcount);
         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. = 0;
         this. = count;
         this. = value;
     }

    
Allocates a new 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 String constructors that take a java.nio.charset.Charset, charset name, or that use the platform's default charset.
Parameters:
ascii The bytes to be converted to characters
hibyte The top 8 bits of each 16-bit Unicode code unit
See also:
String(byte[],int,int,java.lang.String)
String(byte[],int,int,java.nio.charset.Charset)
String(byte[],int,int)
String(byte[],java.lang.String)
String(byte[],java.nio.charset.Charset)
String(byte[])
 
     @Deprecated
     public String(byte ascii[], int hibyte) {
         this(asciihibyte, 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[] bytesint offsetint 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 String by decoding the specified subarray of bytes using the specified charset. The length of the new 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 java.nio.charset.CharsetDecoder class should be used when more control over the decoding process is required.

Parameters:
bytes The bytes to be decoded into characters
offset The index of the first byte to decode
length The number of bytes to decode
charsetName The name of a supported charset
Throws:
java.io.UnsupportedEncodingException If the named charset is not supported
IndexOutOfBoundsException If the offset and length arguments index characters outside the bounds of the bytes array
Since:
JDK1.1
 
     public String(byte bytes[], int offsetint lengthString charsetName)
         throws UnsupportedEncodingException
     {
         if (charsetName == null)
             throw new NullPointerException("charsetName");
         checkBounds(bytesoffsetlength);
         char[] v = StringCoding.decode(charsetNamebytesoffsetlength);
         this. = 0;
         this. = v.length;
         this. = v;
     }

    
Constructs a new String by decoding the specified subarray of bytes using the specified charset. The length of the new 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 java.nio.charset.CharsetDecoder class should be used when more control over the decoding process is required.

Parameters:
bytes The bytes to be decoded into characters
offset The index of the first byte to decode
length The number of bytes to decode
charset The charset to be used to decode the bytes
Throws:
IndexOutOfBoundsException If the offset and length arguments index characters outside the bounds of the bytes array
Since:
1.6
 
     public String(byte bytes[], int offsetint lengthCharset charset) {
         if (charset == null)
             throw new NullPointerException("charset");
         checkBounds(bytesoffsetlength);
         char[] v = StringCoding.decode(charsetbytesoffsetlength);
         this. = 0;
         this. = v.length;
         this. = v;
     }

    
Constructs a new String by decoding the specified array of bytes using the specified charset. The length of the new 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 java.nio.charset.CharsetDecoder class should be used when more control over the decoding process is required.

Parameters:
bytes The bytes to be decoded into characters
charsetName The name of a supported charset
Throws:
java.io.UnsupportedEncodingException If the named charset is not supported
Since:
JDK1.1
 
     public String(byte bytes[], String charsetName)
         throws UnsupportedEncodingException
     {
         this(bytes, 0, bytes.lengthcharsetName);
     }

    
Constructs a new String by decoding the specified array of bytes using the specified charset. The length of the new 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 java.nio.charset.CharsetDecoder class should be used when more control over the decoding process is required.

Parameters:
bytes The bytes to be decoded into characters
charset The charset to be used to decode the bytes
Since:
1.6
 
     public String(byte bytes[], Charset charset) {
         this(bytes, 0, bytes.lengthcharset);
     }

    
Constructs a new String by decoding the specified subarray of bytes using the platform's default charset. The length of the new 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 java.nio.charset.CharsetDecoder class should be used when more control over the decoding process is required.

Parameters:
bytes The bytes to be decoded into characters
offset The index of the first byte to decode
length The number of bytes to decode
Throws:
IndexOutOfBoundsException If the offset and the length arguments index characters outside the bounds of the bytes array
Since:
JDK1.1
 
     public String(byte bytes[], int offsetint length) {
         checkBounds(bytesoffsetlength);
         char[] v  = StringCoding.decode(bytesoffsetlength);
         this. = 0;
         this. = v.length;
         this. = v;
     }

    
Constructs a new String by decoding the specified array of bytes using the platform's default charset. The length of the new 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 java.nio.charset.CharsetDecoder class should be used when more control over the decoding process is required.

Parameters:
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.

Parameters:
buffer A StringBuffer
 
     public String(StringBuffer buffer) {
         String result = buffer.toString();
         this. = result.value;
         this. = result.count;
         this. = result.offset;
     }

    
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 StringBuilder. Obtaining a string from a string builder via the toString method is likely to run faster and is generally preferred.

Parameters:
builder A StringBuilder
Since:
1.5
 
     public String(StringBuilder builder) {
         String result = builder.toString();
         this. = result.value;
         this. = result.count;
         this. = result.offset;
     }
 
 
     // Package private constructor which shares value array for speed.
     String(int offsetint countchar value[]) {
         this. = value;
         this. = offset;
         this. = count;
     }

    
Returns the length of this string. The length is equal to the number of Unicode code units in the string.

Returns:
the length of the sequence of characters represented by this object.
 
     public int length() {
         return ;
     }

    
Returns true if, and only if, length() is 0.

Returns:
true if length() is 0, otherwise false
Since:
1.6
 
     public boolean isEmpty() {
         return  == 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.

Parameters:
index the index of the char value.
Returns:
the char value at the specified index of this string. The first char value is at index 0.
Throws:
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 >= )) {
             throw new StringIndexOutOfBoundsException(index);
         }
         return [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 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.

Parameters:
index the index to the char values
Returns:
the code point value of the character at the index
Throws:
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 >= )) {
             throw new StringIndexOutOfBoundsException(index);
         }
         return Character.codePointAtImpl( + index + );
     }

    
Returns the character (Unicode code point) before the specified index. The index refers to char values (Unicode code units) and ranges from 1 to CharSequence.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.

Parameters:
index the index following the code point that should be returned
Returns:
the Unicode code point value before the given index.
Throws:
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 >= )) {
             throw new StringIndexOutOfBoundsException(index);
         }
         return Character.codePointBeforeImpl( + index);
     }

    
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.

Parameters:
beginIndex the index to the first char of the text range.
endIndex the index after the last char of the text range.
Returns:
the number of Unicode code points in the specified text range
Throws:
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 beginIndexint endIndex) {
         if (beginIndex < 0 || endIndex >  || beginIndex > endIndex) {
             throw new IndexOutOfBoundsException();
         }
         return Character.codePointCountImpl(+beginIndexendIndex-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.

Parameters:
index the index to be offset
codePointOffset the offset in code points
Returns:
the index within this String
Throws:
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 indexint codePointOffset) {
         if (index < 0 || index > ) {
             throw new IndexOutOfBoundsException();
         }
         return Character.offsetByCodePointsImpl(,
                                                 +indexcodePointOffset) - ;
     }

    
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(dstdstBegin);
     }

    
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
 

Parameters:
srcBegin index of the first character in the string to copy.
srcEnd index after the last character in the string to copy.
dst the destination array.
dstBegin the start offset in the destination array.
Throws:
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 srcBeginint srcEndchar dst[], int dstBegin) {
         if (srcBegin < 0) {
             throw new StringIndexOutOfBoundsException(srcBegin);
         }
         if (srcEnd > ) {
             throw new StringIndexOutOfBoundsException(srcEnd);
         }
         if (srcBegin > srcEnd) {
             throw new StringIndexOutOfBoundsException(srcEnd - srcBegin);
         }
         System.arraycopy( + srcBegindstdstBegin,
              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 srcBegin; the last character to be copied is at index srcEnd-1. The total number of characters to be copied is srcEnd-srcBegin. The characters, converted to bytes, are copied into the subarray of dst starting at index 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 getBytes() method, which uses the platform's default charset.
Parameters:
srcBegin Index of the first character in the string to copy
srcEnd Index after the last character in the string to copy
dst The destination array
dstBegin The start offset in the destination array
Throws:
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
 
     @Deprecated
     public void getBytes(int srcBeginint srcEndbyte dst[], int dstBegin) {
         if (srcBegin < 0) {
             throw new StringIndexOutOfBoundsException(srcBegin);
         }
         if (srcEnd > ) {
             throw new StringIndexOutOfBoundsException(srcEnd);
         }
         if (srcBegin > srcEnd) {
             throw new StringIndexOutOfBoundsException(srcEnd - srcBegin);
         }
         int j = dstBegin;
         int n =  + srcEnd;
         int i =  + srcBegin;
         char[] val = ;   /* avoid getfield opcode */
 
         while (i < n) {
             dst[j++] = (byte)val[i++];
         }
     }

    
Encodes this 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 java.nio.charset.CharsetEncoder class should be used when more control over the encoding process is required.

Parameters:
charsetName The name of a supported charset
Returns:
The resultant byte array
Throws:
java.io.UnsupportedEncodingException If the named charset is not supported
Since:
JDK1.1
 
     public byte[] getBytes(String charsetName)
         throws UnsupportedEncodingException
     {
         if (charsetName == nullthrow new NullPointerException();
         return StringCoding.encode(charsetName);
     }

    
Encodes this String into a sequence of bytes using the given 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 java.nio.charset.CharsetEncoder class should be used when more control over the encoding process is required.

Parameters:
charset The java.nio.charset.Charset to be used to encode the String
Returns:
The resultant byte array
Since:
1.6
 
     public byte[] getBytes(Charset charset) {
         if (charset == nullthrow new NullPointerException();
         return StringCoding.encode(charset);
     }

    
Encodes this 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 java.nio.charset.CharsetEncoder class should be used when more control over the encoding process is required.

Returns:
The resultant byte array
Since:
JDK1.1
 
     public byte[] getBytes() {
         return StringCoding.encode();
     }

    
Compares this string to the specified object. The result is true if and only if the argument is not null and is a String object that represents the same sequence of characters as this object.

Parameters:
anObject The object to compare this String against
Returns:
true if the given object represents a String equivalent to this string, false otherwise
See also:
compareTo(java.lang.String)
equalsIgnoreCase(java.lang.String)
    public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = ;
            if (n == anotherString.count) {
                char v1[] = ;
                char v2[] = anotherString.value;
                int i = ;
                int j = anotherString.offset;
                while (n-- != 0) {
                    if (v1[i++] != v2[j++])
                        return false;
                }
                return true;
            }
        }
        return false;
    }

    
Compares this string to the specified StringBuffer. The result is true if and only if this String represents the same sequence of characters as the specified StringBuffer.

Parameters:
sb The StringBuffer to compare this String against
Returns:
true if this String represents the same sequence of characters as the specified StringBuffer, false otherwise
Since:
1.4
    public boolean contentEquals(StringBuffer sb) {
        synchronized(sb) {
            return contentEquals((CharSequence)sb);
        }
    }

    
Compares this string to the specified CharSequence. The result is true if and only if this String represents the same sequence of char values as the specified sequence.

Parameters:
cs The sequence to compare this String against
Returns:
true if this String represents the same sequence of char values as the specified sequence, false otherwise
Since:
1.5
    public boolean contentEquals(CharSequence cs) {
        if ( != cs.length())
            return false;
        // Argument is a StringBuffer, StringBuilder
        if (cs instanceof AbstractStringBuilder) {
            char v1[] = ;
            char v2[] = ((AbstractStringBuilder)cs).getValue();
            int i = ;
            int j = 0;
            int n = ;
            while (n-- != 0) {
                if (v1[i++] != v2[j++])
                    return false;
            }
            return true;
        }
        // Argument is a String
        if (cs.equals(this))
            return true;
        // Argument is a generic CharSequence
        char v1[] = ;
        int i = ;
        int j = 0;
        int n = ;
        while (n-- != 0) {
            if (v1[i++] != cs.charAt(j++))
                return false;
        }
        return true;
    }

    
Compares this String to another 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 c1 and c2 are considered the same ignoring case if at least one of the following is true:

Parameters:
anotherString The String to compare this String against
Returns:
true if the argument is not null and it represents an equivalent String ignoring case; false otherwise
See also:
equals(java.lang.Object)
    public boolean equalsIgnoreCase(String anotherString) {
        return (this == anotherString) ? true :
               (anotherString != null) && (anotherString.count == ) &&
               regionMatches(true, 0, anotherString, 0, );
    }

    
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 equals(java.lang.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()
 

Parameters:
anotherString the String to be compared.
Returns:
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 = ;
        int len2 = anotherString.count;
        int n = Math.min(len1len2);
        char v1[] = ;
        char v2[] = anotherString.value;
        int i = ;
        int j = anotherString.offset;
        if (i == j) {
            int k = i;
            int lim = n + i;
            while (k < lim) {
                char c1 = v1[k];
                char c2 = v2[k];
                if (c1 != c2) {
                    return c1 - c2;
                }
                k++;
            }
        } else {
            while (n-- != 0) {
                char c1 = v1[i++];
                char c2 = v2[j++];
                if (c1 != c2) {
                    return c1 - c2;
                }
            }
        }
        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.

    public static final Comparator<StringCASE_INSENSITIVE_ORDER
                                         = new CaseInsensitiveComparator();
    private static class CaseInsensitiveComparator
                         implements Comparator<String>, java.io.Serializable {
        // use serialVersionUID from JDK 1.2.2 for interoperability
        private static final long serialVersionUID = 8575799808933029326L;
        public int compare(String s1String s2) {
            int n1 = s1.length();
            int n2 = s2.length();
            int min = Math.min(n1n2);
            for (int i = 0; i < mini++) {
                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.

Parameters:
str the String to be compared.
Returns:
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.
Since:
1.2
See also:
java.text.Collator.compare(java.lang.String,java.lang.String)
    public int compareToIgnoreCase(String str) {
        return .compare(thisstr);
    }

    
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)

Parameters:
toffset the starting offset of the subregion in this string.
other the string argument.
ooffset the starting offset of the subregion in the string argument.
len the number of characters to compare.
Returns:
true if the specified subregion of this string exactly matches the specified subregion of the string argument; false otherwise.
    public boolean regionMatches(int toffsetString otherint ooffset,
                                 int len) {
        char ta[] = ;
        int to =  + toffset;
        char pa[] = other.value;
        int po = other.offset + ooffset;
        // Note: toffset, ooffset, or len might be near -1>>>1.
        if ((ooffset < 0) || (toffset < 0) || (toffset > (long) - len)
            || (ooffset > (long)other.count - 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))
     

Parameters:
ignoreCase if true, ignore case when comparing characters.
toffset the starting offset of the subregion in this string.
other the string argument.
ooffset the starting offset of the subregion in the string argument.
len the number of characters to compare.
Returns:
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 ignoreCaseint toffset,
                           String otherint ooffsetint len) {
        char ta[] = ;
        int to =  + toffset;
        char pa[] = other.value;
        int po = other.offset + ooffset;
        // Note: toffset, ooffset, or len might be near -1>>>1.
        if ((ooffset < 0) || (toffset < 0) || (toffset > (long) - len) ||
                (ooffset > (long)other.count - 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.

Parameters:
prefix the prefix.
toffset where to begin looking in this string.
Returns:
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 prefixint toffset) {
        char ta[] = ;
        int to =  + toffset;
        char pa[] = prefix.value;
        int po = prefix.offset;
        int pc = prefix.count;
        // Note: toffset might be near -1>>>1.
        if ((toffset < 0) || (toffset >  - pc)) {
            return false;
        }
        while (--pc >= 0) {
            if (ta[to++] != pa[po++]) {
                return false;
            }
        }
        return true;
    }

    
Tests if this string starts with the specified prefix.

Parameters:
prefix the prefix.
Returns:
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 equals(java.lang.Object) method.
Since:
1. 0
    public boolean startsWith(String prefix) {
        return startsWith(prefix, 0);
    }

    
Tests if this string ends with the specified suffix.

Parameters:
suffix the suffix.
Returns:
true if the character sequence represented by the argument is a suffix of the character sequence represented by this object; false otherwise. Note that the result will be true if the argument is the empty string or is equal to this String object as determined by the equals(java.lang.Object) method.
    public boolean endsWith(String suffix) {
        return startsWith(suffix - suffix.count);
    }

    
Returns a hash code for this string. The hash code for a String object is computed as
 s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]
 
using int arithmetic, where s[i] is the ith character of the string, n is the length of the string, and ^ indicates exponentiation. (The hash value of the empty string is zero.)

Returns:
a hash code value for this object.
    public int hashCode() {
        int h = ;
        if (h == 0) {
            int off = ;
            char val[] = ;
            int len = ;
            for (int i = 0; i < leni++) {
                h = 31*h + val[off++];
            }
             = h;
        }
        return h;
    }

    
Returns the index within this string of the first occurrence of the specified character. If a character with value ch occurs in the character sequence represented by this String object, then the index (in Unicode code units) of the first such occurrence is returned. For values of ch in the range from 0 to 0xFFFF (inclusive), this is the smallest value k such that:
 this.charAt(k) == ch
 
is true. For other values of ch, it is the smallest value k such that:
 this.codePointAt(k) == ch
 
is true. In either case, if no such character occurs in this string, then -1 is returned.

Parameters:
ch a character (Unicode code point).
Returns:
the index of the first occurrence of the character in the character sequence represented by this object, or -1 if the character does not occur.
    public int indexOf(int ch) {
        return indexOf(ch, 0);
    }

    
Returns the index within this string of the first occurrence of the specified character, starting the search at the specified index.

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

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

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

All indices are specified in char values (Unicode code units).

Parameters:
ch a character (Unicode code point).
fromIndex the index to start the search from.
Returns:
the index of the first occurrence of the character in the character sequence represented by this object that is greater than or equal to fromIndex, or -1 if the character does not occur.
    public int indexOf(int chint fromIndex) {
        int max =  + ;
        char v[] = ;
        if (fromIndex < 0) {
            fromIndex = 0;
        } else if (fromIndex >= ) {
            // Note: fromIndex might be near -1>>>1.
            return -1;
        }
        int i =  + fromIndex;
        if (ch < .) {
            // handle most cases here (ch is a BMP code point or a
            // negative value (invalid code point))
            for (; i < max ; i++) {
                if (v[i] == ch) {
                    return i - ;
                }
            }
            return -1;
        }
        if (ch <= .) {
            // handle supplementary characters here
            char[] surrogates = Character.toChars(ch);
            for (; i < maxi++) {
                if (v[i] == surrogates[0]) {
                    if (i + 1 == max) {
                        break;
                    }
                    if (v[i+1] == surrogates[1]) {
                        return i - ;
                    }
                }
            }
        }
        return -1;
    }

    
Returns the index within this string of the last occurrence of the specified character. For values of ch in the range from 0 to 0xFFFF (inclusive), the index (in Unicode code units) returned is the largest value k such that:
 this.charAt(k) == ch
 
is true. For other values of ch, it is the largest value k such that:
 this.codePointAt(k) == ch
 
is true. In either case, if no such character occurs in this string, then -1 is returned. The String is searched backwards starting at the last character.

Parameters:
ch a character (Unicode code point).
Returns:
the index of the last occurrence of the character in the character sequence represented by this object, or -1 if the character does not occur.
    public int lastIndexOf(int ch) {
        return lastIndexOf(ch - 1);
    }

    
Returns the index within this string of the last occurrence of the specified character, searching backward starting at the specified index. For values of ch in the range from 0 to 0xFFFF (inclusive), the index returned is the largest value k such that:
 (this.charAt(k) == ch) && (k <= fromIndex)
 
is true. For other values of ch, it is the largest value k such that:
 (this.codePointAt(k) == ch) && (k <= fromIndex)
 
is true. In either case, if no such character occurs in this string at or before position fromIndex, then -1 is returned.

All indices are specified in char values (Unicode code units).

Parameters:
ch a character (Unicode code point).
fromIndex the index to start the search from. There is no restriction on the value of fromIndex. If it is greater than or equal to the length of this string, it has the same effect as if it were equal to one less than the length of this string: this entire string may be searched. If it is negative, it has the same effect as if it were -1: -1 is returned.
Returns:
the index of the last occurrence of the character in the character sequence represented by this object that is less than or equal to fromIndex, or -1 if the character does not occur before that point.
    public int lastIndexOf(int chint fromIndex) {
        int min = ;
        char v[] = ;
        int i =  + ((fromIndex >= ) ?  - 1 : fromIndex);
        if (ch < .) {
            // handle most cases here (ch is a BMP code point or a
            // negative value (invalid code point))
            for (; i >= min ; i--) {
                if (v[i] == ch) {
                    return i - ;
                }
            }
            return -1;
        }
        int max =  + ;
        if (ch <= .) {
            // handle supplementary characters here
            char[] surrogates = Character.toChars(ch);
            for (; i >= mini--) {
                if (v[i] == surrogates[0]) {
                    if (i + 1 == max) {
                        break;
                    }
                    if (v[i+1] == surrogates[1]) {
                        return i - ;
                    }
                }
            }
        }
        return -1;
    }

    
Returns the index within this string of the first occurrence of the specified substring. The integer returned is the smallest value k such that:
 this.startsWith(str, k)
 
is true.

Parameters:
str any string.
Returns:
if the string argument occurs as a substring within this object, then the index of the first character of the first such substring is returned; if it does not occur as a substring, -1 is returned.
    public int indexOf(String str) {
        return indexOf(str, 0);
    }

    
Returns the index within this string of the first occurrence of the specified substring, starting at the specified index. The integer returned is the smallest value k for which:
     k >= Math.min(fromIndex, this.length()) && this.startsWith(str, k)
 
If no such value of k exists, then -1 is returned.

Parameters:
str the substring for which to search.
fromIndex the index from which to start the search.
Returns:
the index within this string of the first occurrence of the specified substring, starting at the specified index.
    public int indexOf(String strint fromIndex) {
        return indexOf(,
                       str.valuestr.offsetstr.countfromIndex);
    }

    
Code shared by String and StringBuffer to do searches. The source is the character array being searched, and the target is the string being searched for.

Parameters:
source the characters being searched.
sourceOffset offset of the source string.
sourceCount count of the source string.
target the characters being searched for.
targetOffset offset of the target string.
targetCount count of the target string.
fromIndex the index to begin searching from.
    static int indexOf(char[] sourceint sourceOffsetint sourceCount,
                       char[] targetint targetOffsetint targetCount,
                       int fromIndex) {
        if (fromIndex >= sourceCount) {
            return (targetCount == 0 ? sourceCount : -1);
        }
        if (fromIndex < 0) {
            fromIndex = 0;
        }
        if (targetCount == 0) {
            return fromIndex;
        }
        char first  = target[targetOffset];
        int max = sourceOffset + (sourceCount - targetCount);
        for (int i = sourceOffset + fromIndexi <= maxi++) {
            /* Look for first character. */
            if (source[i] != first) {
                while (++i <= max && source[i] != first);
            }
            /* Found first character, now look at the rest of v2 */
            if (i <= max) {
                int j = i + 1;
                int end = j + targetCount - 1;
                for (int k = targetOffset + 1; j < end && source[j] ==
                         target[k]; j++, k++);
                if (j == end) {
                    /* Found whole string. */
                    return i - sourceOffset;
                }
            }
        }
        return -1;
    }

    
Returns the index within this string of the rightmost occurrence of the specified substring. The rightmost empty string "" is considered to occur at the index value this.length(). The returned index is the largest value k such that
 this.startsWith(str, k)
 
is true.

Parameters:
str the substring to search for.
Returns:
if the string argument occurs one or more times as a substring within this object, then the index of the first character of the last such substring is returned. If it does not occur as a substring, -1 is returned.
    public int lastIndexOf(String str) {
        return lastIndexOf(str);
    }

    
Returns the index within this string of the last occurrence of the specified substring, searching backward starting at the specified index. The integer returned is the largest value k such that:
     k <= Math.min(fromIndex, this.length()) && this.startsWith(str, k)
 
If no such value of k exists, then -1 is returned.

Parameters:
str the substring to search for.
fromIndex the index to start the search from.
Returns:
the index within this string of the last occurrence of the specified substring.
    public int lastIndexOf(String strint fromIndex) {
        return lastIndexOf(,
                           str.valuestr.offsetstr.countfromIndex);
    }

    
Code shared by String and StringBuffer to do searches. The source is the character array being searched, and the target is the string being searched for.

Parameters:
source the characters being searched.
sourceOffset offset of the source string.
sourceCount count of the source string.
target the characters being searched for.
targetOffset offset of the target string.
targetCount count of the target string.
fromIndex the index to begin searching from.
    static int lastIndexOf(char[] sourceint sourceOffsetint sourceCount,
                           char[] targetint targetOffsetint targetCount,
                           int fromIndex) {
        /*
         * Check arguments; return immediately where possible. For
         * consistency, don't check for null str.
         */
        int rightIndex = sourceCount - targetCount;
        if (fromIndex < 0) {
            return -1;
        }
        if (fromIndex > rightIndex) {
            fromIndex = rightIndex;
        }
        /* Empty string always matches. */
        if (targetCount == 0) {
            return fromIndex;
        }
        int strLastIndex = targetOffset + targetCount - 1;
        char strLastChar = target[strLastIndex];
        int min = sourceOffset + targetCount - 1;
        int i = min + fromIndex;
    startSearchForLastChar:
        while (true) {
            while (i >= min && source[i] != strLastChar) {
                i--;
            }
            if (i < min) {
                return -1;
            }
            int j = i - 1;
            int start = j - (targetCount - 1);
            int k = strLastIndex - 1;
            while (j > start) {
                if (source[j--] != target[k--]) {
                    i--;
                    continue startSearchForLastChar;
                }
            }
            return start - sourceOffset + 1;
        }
    }

    
Returns a new string that is a substring of this string. The substring begins with the character at the specified index and extends to the end of this string.

Examples:

 "unhappy".substring(2) returns "happy"
 "Harbison".substring(3) returns "bison"
 "emptiness".substring(9) returns "" (an empty string)
 

Parameters:
beginIndex the beginning index, inclusive.
Returns:
the specified substring.
Throws:
IndexOutOfBoundsException if beginIndex is negative or larger than the length of this String object.
    public String substring(int beginIndex) {
        return substring(beginIndex);
    }

    
Returns a new string that is a substring of this string. The substring begins at the specified beginIndex and extends to the character at index endIndex - 1. Thus the length of the substring is endIndex-beginIndex.

Examples:

 "hamburger".substring(4, 8) returns "urge"
 "smiles".substring(1, 5) returns "mile"
 

Parameters:
beginIndex the beginning index, inclusive.
endIndex the ending index, exclusive.
Returns:
the specified substring.
Throws:
IndexOutOfBoundsException if the beginIndex is negative, or endIndex is larger than the length of this String object, or beginIndex is larger than endIndex.
    public String substring(int beginIndexint endIndex) {
        if (beginIndex < 0) {
            throw new StringIndexOutOfBoundsException(beginIndex);
        }
        if (endIndex > ) {
            throw new StringIndexOutOfBoundsException(endIndex);
        }
        if (beginIndex > endIndex) {
            throw new StringIndexOutOfBoundsException(endIndex - beginIndex);
        }
        return ((beginIndex == 0) && (endIndex == )) ? this :
            new String( + beginIndexendIndex - beginIndex);
    }

    
Returns a new character sequence that is a subsequence of this sequence.

An invocation of this method of the form

 str.subSequence(begin, end)
behaves in exactly the same way as the invocation
 str.substring(begin, end)
This method is defined so that the String class can implement the CharSequence interface.

Parameters:
beginIndex the begin index, inclusive.
endIndex the end index, exclusive.
Returns:
the specified subsequence.
Throws:
IndexOutOfBoundsException if beginIndex or endIndex are negative, if endIndex is greater than length(), or if beginIndex is greater than startIndex
Since:
1.4
Spec:
JSR-51
    public CharSequence subSequence(int beginIndexint endIndex) {
        return this.substring(beginIndexendIndex);
    }

    
Concatenates the specified string to the end of this string.

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

Examples:

 "cares".concat("s") returns "caress"
 "to".concat("get").concat("her") returns "together"
 

Parameters:
str the String that is concatenated to the end of this String.
Returns:
a string that represents the concatenation of this object's characters followed by the string argument's characters.
    public String concat(String str) {
        int otherLen = str.length();
        if (otherLen == 0) {
            return this;
        }
        char buf[] = new char[ + otherLen];
        getChars(0, buf, 0);
        str.getChars(0, otherLenbuf);
        return new String(0,  + otherLenbuf);
    }

    
Returns a new string resulting from replacing all occurrences of oldChar in this string with newChar.

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

Examples:

 "mesquite in your cellar".replace('e', 'o')
         returns "mosquito in your collar"
 "the war of baronets".replace('r', 'y')
         returns "the way of bayonets"
 "sparring with a purple porpoise".replace('p', 't')
         returns "starring with a turtle tortoise"
 "JonL".replace('q', 'x') returns "JonL" (no change)
 

Parameters:
oldChar the old character.
newChar the new character.
Returns:
a string derived from this string by replacing every occurrence of oldChar with newChar.
    public String replace(char oldCharchar newChar) {
        if (oldChar != newChar) {
            int len = ;
            int i = -1;
            char[] val = /* avoid getfield opcode */
            int off = ;   /* avoid getfield opcode */
            while (++i < len) {
                if (val[off + i] == oldChar) {
                    break;
                }
            }
            if (i < len) {
                char buf[] = new char[len];
                for (int j = 0 ; j < i ; j++) {
                    buf[j] = val[off+j];
                }
                while (i < len) {
                    char c = val[off + i];
                    buf[i] = (c == oldChar) ? newChar : c;
                    i++;
                }
                return new String(0, lenbuf);
            }
        }
        return this;
    }

    
Tells whether or not this string matches the given regular expression.

An invocation of this method of the form str.matches(regex) yields exactly the same result as the expression

java.util.regex.Pattern.java.util.regex.Pattern.matches(java.lang.String,java.lang.CharSequence)(regex, str)

Parameters:
regex the regular expression to which this string is to be matched
Returns:
true if, and only if, this string matches the given regular expression
Throws:
java.util.regex.PatternSyntaxException if the regular expression's syntax is invalid
Since:
1.4
See also:
java.util.regex.Pattern
Spec:
JSR-51
    public boolean matches(String regex) {
        return Pattern.matches(regexthis);
    }

    
Returns true if and only if this string contains the specified sequence of char values.

Parameters:
s the sequence to search for
Returns:
true if this string contains s, false otherwise
Throws:
NullPointerException if s is null
Since:
1.5
    public boolean contains(CharSequence s) {
        return indexOf(s.toString()) > -1;
    }

    
Replaces the first substring of this string that matches the given regular expression with the given replacement.

An invocation of this method of the form str.replaceFirst(regex, repl) yields exactly the same result as the expression

java.util.regex.Pattern. compile(regex).java.util.regex.Pattern.matcher(java.lang.CharSequence)(str). replaceFirst(repl)

Note that backslashes (\) and dollar signs ($) in the replacement string may cause the results to be different than if it were being treated as a literal replacement string; see java.util.regex.Matcher.replaceFirst(java.lang.String). Use java.util.regex.Matcher.quoteReplacement(java.lang.String) to suppress the special meaning of these characters, if desired.

Parameters:
regex the regular expression to which this string is to be matched
replacement the string to be substituted for the first match
Returns:
The resulting String
Throws:
java.util.regex.PatternSyntaxException if the regular expression's syntax is invalid
Since:
1.4
See also:
java.util.regex.Pattern
Spec:
JSR-51
    public String replaceFirst(String regexString replacement) {
        return Pattern.compile(regex).matcher(this).replaceFirst(replacement);
    }

    
Replaces each substring of this string that matches the given regular expression with the given replacement.

An invocation of this method of the form str.replaceAll(regex, repl) yields exactly the same result as the expression

java.util.regex.Pattern. compile(regex).java.util.regex.Pattern.matcher(java.lang.CharSequence)(str). replaceAll(repl)

Note that backslashes (\) and dollar signs ($) in the replacement string may cause the results to be different than if it were being treated as a literal replacement string; see Matcher.replaceAll. Use java.util.regex.Matcher.quoteReplacement(java.lang.String) to suppress the special meaning of these characters, if desired.

Parameters:
regex the regular expression to which this string is to be matched
replacement the string to be substituted for each match
Returns:
The resulting String
Throws:
java.util.regex.PatternSyntaxException if the regular expression's syntax is invalid
Since:
1.4
See also:
java.util.regex.Pattern
Spec:
JSR-51
    public String replaceAll(String regexString replacement) {
        return Pattern.compile(regex).matcher(this).replaceAll(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".

Parameters:
target The sequence of char values to be replaced
replacement The replacement sequence of char values
Returns:
The resulting string
Throws:
NullPointerException if target or replacement is null.
Since:
1.5
    public String replace(CharSequence targetCharSequence replacement) {
        return Pattern.compile(target.toString(), .).matcher(
            this).replaceAll(Matcher.quoteReplacement(replacement.toString()));
    }

    
Splits this string around matches of the given regular expression.

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.

The limit parameter controls the number of times the pattern is applied and therefore affects the length of the resulting array. If the limit n is greater than zero then the pattern will be applied at most n - 1 times, the array's length will be no greater than n, and the array's last entry will contain all input beyond the last matched delimiter. If n is non-positive then the pattern will be applied as many times as possible and the array can have any length. If n 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.

The string "boo:and:foo", for example, yields the following results with these parameters:

RegexLimitResult
:2{ "boo", "and:foo" }
:5{ "boo", "and", "foo" }
:-2{ "boo", "and", "foo" }
o5{ "b", "", ":and:f", "", "" }
o-2{ "b", "", ":and:f", "", "" }
o0{ "b", "", ":and:f" }

An invocation of this method of the form str.split(regex, n) yields the same result as the expression

java.util.regex.Pattern. compile(regex).java.util.regex.Pattern.split(java.lang.CharSequence,int)(str, n)

Parameters:
regex the delimiting regular expression
limit the result threshold, as described above
Returns:
the array of strings computed by splitting this string around matches of the given regular expression
Throws:
java.util.regex.PatternSyntaxException if the regular expression's syntax is invalid
Since:
1.4
See also:
java.util.regex.Pattern
Spec:
JSR-51
    public String[] split(String regexint limit) {
        return Pattern.compile(regex).split(thislimit);
    }

    
Splits this string around matches of the given regular expression.

This method works as if by invoking the two-argument split(java.lang.String,int) method with the given expression and a limit argument of zero. Trailing empty strings are therefore not included in the resulting array.

The string "boo:and:foo", for example, yields the following results with these expressions:

RegexResult
:{ "boo", "and", "foo" }
o{ "b", "", ":and:f" }

Parameters:
regex the delimiting regular expression
Returns:
the array of strings computed by splitting this string around matches of the given regular expression
Throws:
java.util.regex.PatternSyntaxException if the regular expression's syntax is invalid
Since:
1.4
See also:
java.util.regex.Pattern
Spec:
JSR-51
    public String[] split(String regex) {
        return split(regex, 0);
    }

    
Converts all of the characters in this String to lower case using the rules of the given Locale. Case mapping is based on the Unicode Standard version specified by the Character class. Since case mappings are not always 1:1 char mappings, the resulting String may be a different length than the original String.

Examples of lowercase mappings are in the following table:

Language Code of LocaleUpper CaseLower CaseDescription
tr (Turkish)\u0130\u0069capital letter I with dot above -> small letter i
tr (Turkish)\u0049\u0131capital letter I -> small letter dotless i
(all)French Friesfrench frieslowercased all chars in String
(all) lowercased all chars in String

Parameters:
locale use the case transformation rules for this locale
Returns:
the String, converted to lowercase.
Since:
1.1
See also:
toLowerCase()
toUpperCase()
toUpperCase(java.util.Locale)
    public String toLowerCase(Locale locale) {
        if (locale == null) {
            throw new NullPointerException();
        }
        int     firstUpper;
        /* Now check if there are any characters that need to be changed. */
        scan: {
            for (firstUpper = 0 ; firstUpper < ; ) {
                char c = [+firstUpper];
                if ((c >= .) &&
                    (c <= .)) {
                    int supplChar = codePointAt(firstUpper);
                    if (supplChar != Character.toLowerCase(supplChar)) {
                        break scan;
                    }
                    firstUpper += Character.charCount(supplChar);
                } else {
                    if (c != Character.toLowerCase(c)) {
                        break scan;
                    }
                    firstUpper++;
                }
            }
            return this;
        }
        char[]  result = new char[];
        int     resultOffset = 0;  /* result may grow, so i+resultOffset
                                    * is the write location in result */
        /* Just copy the first few lowerCase characters. */
        System.arraycopy(result, 0, firstUpper);
        String lang = locale.getLanguage();
        boolean localeDependent =
            (lang == "tr" || lang == "az" || lang == "lt");
        char[] lowerCharArray;
        int lowerChar;
        int srcChar;
        int srcCount;
        for (int i = firstUpperi < i += srcCount) {
            srcChar = (int)[+i];
            if ((char)srcChar >= . &&
                (char)srcChar <= .) {
                srcChar = codePointAt(i);
                srcCount = Character.charCount(srcChar);
            } else {
                srcCount = 1;
            }
            if (localeDependent || srcChar == '\u03A3') { // GREEK CAPITAL LETTER SIGMA
                lowerChar = ConditionalSpecialCasing.toLowerCaseEx(thisilocale);
            } else {
                lowerChar = Character.toLowerCase(srcChar);
            }
            if ((lowerChar == .) ||
                (lowerChar >= .)) {
                if (lowerChar == .) {
                    lowerCharArray =
                        ConditionalSpecialCasing.toLowerCaseCharArray(thisilocale);
                } else if (srcCount == 2) {
                    resultOffset += Character.toChars(lowerCharresulti + resultOffset) - srcCount;
                    continue;
                } else {
                    lowerCharArray = Character.toChars(lowerChar);
                }
                /* Grow result if needed */
                int mapLen = lowerCharArray.length;
                if (mapLen > srcCount) {
                    char[] result2 = new char[result.length + mapLen - srcCount];
                    System.arraycopy(result, 0, result2, 0,
                        i + resultOffset);
                    result = result2;
                }
                for (int x=0; x<mapLen; ++x) {
                    result[i+resultOffset+x] = lowerCharArray[x];
                }
                resultOffset += (mapLen - srcCount);
            } else {
                result[i+resultOffset] = (char)lowerChar;
            }
        }
        return new String(0, +resultOffsetresult);
    }

    
Converts all of the characters in this String to lower case using the rules of the default locale. This is equivalent to calling toLowerCase(Locale.getDefault()).

Note: 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, "TITLE".toLowerCase() in a Turkish locale returns "t\u0131tle", where '\u0131' is the LATIN SMALL LETTER DOTLESS I character. To obtain correct results for locale insensitive strings, use toLowerCase(Locale.ENGLISH).

Returns:
the String, converted to lowercase.
See also:
toLowerCase(java.util.Locale)
    public String toLowerCase() {
        return toLowerCase(Locale.getDefault());
    }