references: 'The Java Certification Study Guide', Heller&Roberts, The JDK 1.2.2 documentation

String and StringBuffer encapsulate strings of characters. In java these are sets of 16-bit
Unicode characters. The String class represents an immutable string. This means once an
instance is created they are constant and can't be changed. StringBuffer class on the other
hand allows the creation of a changeable or mutable, character string. The most common
ways to create a String object is via the constructor or by assigning a string literal.

1) a  constructor

String s1 = new String( "common constructor");

2) assigning a string literal

String s2 = "a string literal";
 

Deep and Shallow Comparisons

When reference types are compared via the = = operator, the addresses stored in by the
references are compared. This is called a shallow comparison. If the equals( ) method
is used, the contents pointed to by the address stored in the reference is compared. This
is a deep comparison.

The java environment maintains a pool of string literals. Each string literal is represented in
the pool. Identical string literals are only represented once in the pool. If an identical literal is
used twice in a program, it is only represented once in the literal pool. When deep and shallow
comparison are made on the two references representing the same string literal value the result
is that consistent with the idea that the reference both refer to the same value and the references
also point to the same address.

For example

String xx = "X";
String xy = "X";
if (xx.equals(xy))            // a 'deep' comparison ( of values stored ) resolves to true
if (xx = = xy)                 // the second 'shallow' comparison also resolves to true

The second "shallow" comparison compares the addresses used to store the string literals
and in the of identical string literals it is the same for both references.

On the other hand, when a reference is created via the constructor housing a literal, first the
literal is recorded in the literal pool and then a new string is created, copied from the one in
the literal pool. This copy is stored at a different location so will not share the same address
as the one in the literal pool.

String yy = "X";
String yx = new String("X");
if (yy.equals(yx))      // a 'deep' comparison (of stored values) resolves to true
// however
if (yy = = yx)          // will resolve to false
 

Some code to demonstate the above class sTz{ public static void main(String[]args){   String xx = "X";   String xy = "X";    if (xx.equals(xy))      System.out.println      ("\n"+"A deep comparison tests true for comparison on literal assignmnents");    if (xx == xy)       System.out.println      ("A shallow test yields true indicating one value is stored at one address \n");    String yy = "X";   String yx = new String("X");     if (yy.equals(yx))         System.out.println        ("Values are the same when assigned by literal or by literal-supplied constructor");      if (yy == yx)      ;     else     System.out.println    ("Shallow tests false showing the two values are stored at different addresses");     }   } .

Here is another constructor for String class that shows the creation of a string from an array
of char values.       // String(byte[] bytes)

Example from the jdk documentation

String str = "abc";     // is equivalent to:

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

String Class                // for reference

Constructor Summary

Here are 9 String constructors that show String instances can be created from an empty character
sequence, a provided String object (where in fact a copy is created and encapsulated in the new
instance), a  StringBuffer instance, and arrays. (or parts of arrays), of byte and char type, with or
without specified character encodings.
 

String( )	Initializes a newly created String object so that it represents an empty character sequence.
String(byte[] bytes)	Construct a new String by converting the specified array of bytes using the platform's default character encoding.
String (byte[] bytes, int offset, int length)	Construct a new String by converting the specified subarray of bytes using the platform's default character encoding.
String(byte[] bytes, int offset, int length, String enc)	Construct a new String by converting the specified subarray of bytes using the specified character encoding.
String(byte[] bytes, String enc)	Construct a new String by converting the specified array of bytes using the specified character encoding.
String(char[] value)	Allocates a new String so that it represents the sequence of characters currently contained in the character array argument.
String (char[] value, int offset, int count)	Allocates a new String that contains characters from a subarray of the character array argument.
String(String value)	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.
String(StringBuffer buffer)	Allocates a new string that contains the sequence of characters currently contained in the string buffer argument.

   //  constructors deprecated because they didn't work properly are left out

 Method Summary       // the short summary from the JDK API documentation
 

char charAt(int index)	Returns the character at the specified index. //An index ranges from 0  to length() - 1. // The first character of the sequence is at index 0
int compareTo(Object o)	Compares this String to another Object.
int compareTo(String anotherString)	Compares two strings lexicographically. // returns a negative int if string is less than argument, 0 if the same, and a positive int if greater than See API for details
int compareToIgnoreCase(String str)	Compares two strings lexicographically, ignoring case considerations.
String concat(String str)	Concatenates the specified string to the end of this string.
static String copyValueOf(char[] data)	Returns a String that is equivalent to the specified character array.
static String copyValueOf (char[] data, int offset, int count)	Returns a String that is equivalent to the specified character array.
boolean endsWith(String suffix)	Tests if this string ends with the specified suffix.
boolean equals(Object anObject)	Compares this string to the specified object.
boolean equalsIgnoreCase (String anotherString)	Compares this String to another String, ignoring case considerations.
byte[] getBytes( )	Convert this String into bytes according to the platform's default  character encoding, storing the result into a new byte array.
byte[] getBytes(String enc)	Convert this String into bytes according to the specified character encoding, storing the result into a new byte array.
void getChars(int srcBegin, int srcEnd,  char[] dst, int dstBegin)	Copies characters from this string into the destination character array.
int hashCode( )	Returns a hashcode for this string.
int indexOf(int ch)	Returns the index within this string of the first occurrence of the specified character.
int indexOf(int ch, int fromIndex)	Returns the index within this string of the first occurrence of the specified character, starting the search at the specified index.
int indexOf(String str)	Returns the index within this string of the first occurrence of the specified substring.
int indexOf(String str, int fromIndex)	Returns the index within this string of the first occurrence of the specified substring, starting at the specified index.
String intern( )	Returns a canonical representation for the string object.
int lastIndexOf(int ch)	Returns the index within this string of the last occurrence of the specified character.
int lastIndexOf(int ch, int fromIndex)	Returns the index within this string of the last occurrence of the specified character, searching backward starting at the specified index.
int lastIndexOf(String str)	Returns the index within this string of the rightmost occurrence of the specified substring.
int lastIndexOf(String str, int fromIndex)	Returns the index within this string of the last occurrence of the specified substring.
int length( )	Returns the length of this string.
boolean regionMatches(boolean ignoreCase,  int toffset, String other,  int ooffset, int len)	Tests if two string regions are equal.
boolean regionMatches(int toffset, String other, int ooffset, int len)	Tests if two string regions are equal.
String  replace(char oldChar, char newChar)	Returns a new string resulting from replacing all occurrences of oldChar in this string with newChar.
boolean startsWith(String prefix)	Tests if this string starts with the specified prefix.
boolean startsWith(String prefix, int toffset)	Tests if this string starts with the specified prefix beginning a specified index.
String substring(int beginIndex)	Returns a new string that is a substring of this string.
String substring (int beginIndex, int endIndex)	Returns a new string that is a substring of this string.
char[] toCharArray()	Converts this string to a new character array.
String toLowerCase( )	Converts all of the characters in this String to lower case using the rules of the default locale, which is returned by Locale.getDefault.
String toLowerCase(Locale locale)	Converts all of the characters in this String to lower case using the rules of the given Locale.
String toString()	This object (which is already a string!) is itself returned.
String toUpperCase()	Converts all of the characters in this String to upper case using the rules of the default locale, which is returned by Locale.getDefault.
String toUpperCase(Locale locale)	Converts all of the characters in this String to upper case using the rules of the given locale.
String trim()	Removes white space from both ends of this string.
static String valueOf(boolean b)	Returns the string representation of the boolean argument.
static String valueOf(char c)	Returns the string representation of the char argument.
static String valueOf(char[] data)	Returns the string representation of the char array argument.
static String valueOf (char[] data, int offset, int count)	Returns the string representation of a specific subarray of the char array argument.
static String valueOf(double d)	Returns the string representation of the double argument.
static String valueOf(float f)	Returns the string representation of the float argument.
static String valueOf(int i)	Returns the string representation of the int argument.
static String valueOf(long l)	Returns the string representation of the long argument.
static String valueOf(Object obj)	Returns the string representation of the Object argument.

 String Class Code Example
 
 

A class demonstrating several String class methods import java.io.*; class StringT{ public static void main(String[] args){   char[] sa = {'S', 't', 'r', 'i', 'n','g'};    String string = new String(sa);                                      // one of String's constructors   System.out.println("\n 1. string has the value " +string );   String sb = "string";   int i = string.compareTo(sb);                                                                 // compareTo( )   System.out.println(" 2. The lexigraphical comparison yields " + i );   String cat=string.concat(sb);                                                                           // concat( );   System.out.println(" 3. sb concatenated to string is " + cat + "\n"); try{   byte[] b= new byte[string.length( )];   System.out.println(" 4. string length is " +string.length( )+"\n");   for(int k=0;k<b.length;k++){       b = string.getBytes("8859_1");  //  getBytes("8859_1") with character encoding        System.out.println(b[k]);       }     }     catch(UnsupportedEncodingException uee){  // have to catch unsupported encoding     System.out.println("Unsupported Encoding");     } int j = string.indexOf("St");                                                                                  // indexOf( ) System.out.println("\n 5. The first occurence of ring is at index " + j );                          // This reports index 0 so think of the index like an offset starting at zero int z = (int)'T';                                                                            // casting a char type to an int System.out.println(" 6. The char literal T cast to an int is "+ z); System.out.println(" 7. before and after trim() \n");                                                   // trim( ) System.out.println("    before length: " + "   xyz   ".length());  // calling on string literals System.out.println("    after length: " + "   xyz   ".trim().length()); String string2=string.valueOf(sa);                                       // valueOf used on a char array  System.out.println("\n 8. This is sa array returned as a string " + string2);  } }