As with most programming languages, strings are used extensively throughout
Java, so the Java API has quite a bit of functionality to help you manipulate
strings. This chapter describes the following classes:

The java.lang.String class represents all textual strings in Java. A String
object is immutable; once you create a String
object, there is no way to change the sequence of characters it represents
or the length of the string.

The java.lang.StringBuffer
class represents a variable-length, mutable sequence of characters.
With a StringBuffer object,
you can insert characters anywhere in the sequence and add characters to
the end of the sequence.

The java.util.StringTokenizer
class provides support for parsing a string into a sequence of words,
or tokens.

You can create a String object
in Java simply by assigning a string literal to a String
variable:

String quote = "To be or not to be";

All string literals are compiled into String
objects. Although the Java compiler does not generally treat
expressions involving object references as compile-time constants,
references to String objects created from string
literals are treated as compile-time constants.

Of course, there are many other ways to create a String
object. The String class has
a number of constructors that let you create a String
from an array of bytes, an array of characters, another String
object, or a StringBuffer object.

If you are a C or C++ programmer, you may be wondering if String
objects are null-terminated. The answer is no, and, in fact, the question
is irrelevant. The String class
actually uses a character array internally. Since arrays in Java are actual
objects that know their own length, a String
object also knows its length and does not require a special terminator.
Use the length() method to
get the length of a String
object.

Although String objects are
immutable, the String class
does provide a number of useful methods for working with strings. Any operation
that would otherwise change the characters or the length of the string
returns a new String object
that copies the necessary portions of the original String.

The following methods access the contents of a String
object:

substring() creates
a new String object that contains
a sub-sequence of the sequence of characters represented by a String
object.

charAt() returns
the character at a given position in a String
object.

getChars() and getBytes()
return a range of characters in a char
array or a byte array.

toCharArray() returns
the entire contents of a String
object as a char array.

You can compare the contents of String
objects with the following methods:

equals() returns
true if two String
objects have the exact same contents, while equalsIgnoreCase()
returns true if two objects
have the same contents ignoring differences between upper- and lowercase
versions of the same character.

regionMatches()
determines if two sub-strings contain the same sequence of characters.

startsWith() and
endsWith() determine if a String
object begins or ends with a particular sequence of characters.

compareTo() determines
if the contents of one String
object are less than, equal to, or greater than the contents of another
String object.

Use the following methods to search for characters in a string:

indexOf() searches
forward through a string for a given character or string.

lastIndexOf()
searches backwards through a string for a given character or string.

The following methods manipulate the contents of a string and return a
new, related string:

concat() returns
a new String object that is
the concatenation of two String
objects.

replace() returns
a new String object that contains
the same sequence of characters as the original string, but with a given
character replaced by another given character.

toLowerCase() and toUpperCase()
return new String objects that
contain the same sequence of characters as the original string, but converted
to lower- or uppercase.

trim() returns a new String
object that contains the same character sequence as the original string,
but with leading and trailing white space and control characters removed.

The String class also defines
a number of static methods
named valueOf() that return
string representations of primitive Java data types and objects. The Object
class defines a toString()
method, and, since Object is
the ultimate superclass of every other class, every class inherits a basic
toString() method. Any class
that has a string representation should override the toString()
method to produce the appropriate string.