String handling

String Handling
Abhishek S. Rao

• Implementing strings as built-in objects allows Java to provide a full
complement of features that make string handling convenient. For
example, Java has methods to compare two strings, search for a
substring, concatenate two strings, and change the case of letters within
a string.
• Somewhat unexpectedly, when you create a String object, you are
creating a string that cannot be changed. That is, once a String object
has been created, you cannot change the characters that comprise that
string. At first, this may seem to be a serious restriction. However, such
is not the case. You can still perform all types of string operations.
• The difference is that each time you need an altered version of an
existing string, a new String object is created that contains the
modifications. The original string is left unchanged. This approach is
used because fixed, immutable strings can be implemented more
efficiently than changeable ones. For those cases in which a modifiable
string is desired, Java provides two options: StringBuffer and

• The String, StringBuffer, and StringBuilder classes are
defined in java.lang. Thus, they are available to all programs
automatically. All are declared final, which means that none of
these classes may be subclassed. This allows certain
optimizations that increase performance to take place on
common string operations.

The String Constructors
The String class supports several constructors. To create an empty
String, call the default constructor. For example, String s = new
will create an instance of String with no characters in it. Frequently,
you will want to create strings that have initial values. The String class
provides a variety of constructors to handle this. To create a String
initialized by an array of characters, use the constructor shown here:
String(char chars[ ])
Here is an example:

You can specify a subrange of a character array as an initializer
using the following constructor:
String(char chars[ ], int startIndex, int numChars)
Here, startIndex specifies the index at which the subrange begins,
and numChars specifies the number of characters to use. Here is
an example:

String Length
The length of a string is the number of characters that it contains.
To obtain this
value, call the length( ) method, shown here:
int length( )
The following fragment prints "3", since there are three
characters in the string s:

Special String Operations
Because strings are a common and important part of programming,
Java has added special support for several string operations within the
syntax of the language. These operations include the automatic creation
of new String instances from string literals, concatenation of multiple
String objects by use of the + operator, and the conversion of other
to a string representation. There are explicit methods available to
perform all of these functions, but Java does them automatically as a
convenience for the programmer and to add clarity.

String Literals
For each string literal in your program, Java automatically constructs a
String object. Thus, you can use a string literal to initialize a String
example, the following code fragment creates two equivalent strings:

String Concatenation
In general, Java does not allow operators to be applied to String
objects. The one exception to this rule is the + operator, which
concatenates two strings, producing a String object as the result.
This allows you to chain together a series of + operations. For
example, the following fragment concatenates three strings:

String Conversion and toString( )
When Java converts data into its string representation during
concatenation, it does so by calling one of the overloaded versions of the
string conversion method valueOf( ) defined by String. valueOf( ) is
overloaded for all the primitive types and for type Object.
For the primitive types, valueOf( ) returns a string that contains the
human-readable equivalent of the value with which it is called. For
objects, valueOf( ) calls the toString( ) method on the object.

Every class implements toString( ) because it is defined by Object.
However, the default implementation of toString( ) is seldom
sufficient. For most important classes that you create, you will want to
override toString( ) and provide your own string representations.
Fortunately, this is easy to do. The toString( ) method has this general
form:
String toString( )
To implement toString( ), simply return a String object that contains
the humanreadable string that appropriately describes an object of
your class.
By overriding toString( ) for classes that you create, you allow them to
be fully integrated into Java’s programming environment. For example,
they can be used in print( ) and println( ) statements and in
concatenation expressions. The following program demonstrates this
by overriding toString( ) for the Box class:

Character Extraction
The String class provides a number of ways in which characters can
be extracted from a String object. Several are examined here.
Although the characters that comprise a string within a String object
cannot be indexed as if they were a character array, many of the
String methods employ an index (or offset) into the string for their
operation. Like arrays, the string indexes begin at zero.

String Comparison
The String class includes a number of methods that compare strings
or substrings within strings.

trim( )
The trim( ) method returns a copy of the invoking string from which
which any leading and trailing whitespace has been removed. It has
has this general form:
String trim( )
Here is an example:

String handling

More Related Content

What's hot (20)

Similar to String handling (20)

Recently uploaded (20)

String handling