This chapter illustrates different features of String and StringBuffer classes: modifying a StringBuffer,
A D V E R T I S E M E N T
creating Strings and StringBuffers,converting one type of string to another and
using of accessor methods to get information about a String or StringBuffer.
The two String Classes
Java programming environment provides two classes which stores and manipulates
character data suich as String, for immutable strings (which should not be modified),
and StringBuffer for mutable strings (which needs to be modified).
public static String reverseIt(String source)
int i, len = source.length();
StringBuffer dest = new StringBuffer(len);
for (i = (len - 1); i >= 0; i--)
The String class is provided for the constant strings; you can use Strings when you
don't want its value to be changed. Let us consider for example, if you pass the string
data into the method, and you don't want to modify the string by the method in any way,
you can use "String". Typically, Strings are used to pass character data to methods
and return character data from the methods. method reverseIt() takes an String argument
and returns back a String value.
A StringBuffer class is used for non-constant string. When we know that value of the
character data will do change we use StringBuffers. Typically StringBuffers are used
for constructing the character data like that of reverseIt() method.
Creating Strings and StringBuffers classes
The reverseIt method in the above example creates a StringBuffer called "dest" whose
initial length is equal to that of source. StringBuffer dest declares to the compiler
that dest will be used to refer to an object whose type is of String, the new operator
will allocate memory for the new object, and StringBuffer() will initialize the object.
When we create any object in a Java program, we always do use the same three steps:
declaration, instantiation, initialization.
The Accessor Methods
Methods which are used to obtain information about the object are known as accessor
methods. The method reverseIt() uses two String's accessor methods to get the
information about a source string.
First, reverseIt() uses String's length()
accessor method to obtain the length of the String source.
int len = source.length();
Second, reverseIt() uses the charAt()
accessor which returns the character at the position specified in the parameter.
Modifying a StringBuffer
To add characters to dest reverseIt() method uses StringBuffer's append() method.
In addition to append() method, StringBuffer also provides methods to insert
characters into buffer or modify the character at a specific location within buffer,
append() is the only StringBuffer's methods which allows you to append data to end of
the StringBuffer. There are different append() methods which appends data of various
types, like boolean, float, int, and even Object, to the end of the StringBuffer.
The data is first converted into string before the append could takes place.
Converting the Objects to Strings
Sometimes it becomes necessary to convert an object into String because you may need to
pass it to a method that accepts only String values. consider for example, System.out.println()
will not accept StringBuffer, so there is need to convert a StringBuffer to String before
you could print it. The reverseIt() method in the above example uses StringBuffer's
toString() method to converte StringBuffer into String object before returning the String.
many of the classes in java.lang supports toString() including all the "type
wrapper" classes such as Integer, Boolean,Character and others. Even the base
Object class has toString() method which converts an Object to String. When we
write a subclass of an Object, we can override the method toString() to perform
the more specific conversion for the subclass.
for convenience, the String class do provides the static method "valueOf()" which we can
use to convert variables of different types to the String. For example, to print the
value of the pi