The Java TM Tutorial

| Start of Tutorial > Start of Trail | Search

Trail: Essential Java Classes

## Lesson: The String and StringBuffer Classes

> The `java.lang` package contains two string classes: `String` and `StringBuffer`. You've already seen the `String` class on several occasions in this tutorial. You use the `String` class when you are working with strings that cannot change. `StringBuffer`, on the other hand, is used when you want to manipulate the contents of the string on the fly.

> The `reverseIt` method in the following code uses both the `String` and `StringBuffer` classes to reverse the characters of a string. If you have a list of words, you can use this method in conjunction with a sort program to create a list of rhyming words (a list of words sorted by ending syllables). Just reverse all the strings in the list, sort the list, and reverse the strings again. You can see the `reverseIt` method producing rhyming words in the example in How to Use Pipe Streams that shows you how to use piped streams.

> >     public class ReverseString {
> >         public static String reverseIt(String source) {
> >             int i, len = source.length();
> >             StringBuffer dest = new StringBuffer(len);

> >             for (i = (len - 1); i >= 0; i--)
> >                 dest.append(source.charAt(i));
> >             return dest.toString();
> >         }
> >     }

> The `reverseIt` method accepts an argument of type `String` called `source` that contains the string data to be reversed. The method creates a `StringBuffer`, `dest`, the same size as `source`. It then loops backwards over all the characters in `source` and appends them to `dest`, thereby reversing the string. Finally, the method converts `dest`, a `StringBuffer`, to a `String`.

> In addition to highlighting the differences between `String`s and `StringBuffer`s, this lesson illustrates several features of the `String` and `StringBuffer` classes: creating `String`s and `StringBuffer`s, using accessor methods to get information about a `String` or `StringBuffer`, modifying a `StringBuffer`, and converting one type of string to another.

> > Note to C and C++ Programmers: Java strings are first-class objects, unlike C and C++ strings, which are simply null-terminated arrays of 8-bit characters.

### Why Two String Classes?

> The Java development environment provides two classes that store and manipulate character data: `String`, for constant strings, and `StringBuffer`, for strings that can change.

### Creating `Strings` and `StringBuffer`s

> The following statement taken from the `reverseIt` method creates a new `StringBuffer` in three steps: declaration, instantiation, and initialization.

> >     StringBuffer dest = new StringBuffer(len);

> These are the same steps for creating an object of any type.

### Accessor Methods

> The `reverseIt` method uses two accessor methods to obtain information about the `source` string: `charAt` and `length`. Both `String` and `StringBuffer` provide a number of other accessor methods, including some for inspecting substrings and getting the positions of a specific character.

### Modifying `StringBuffer`s

> The `reverseIt` method uses `StringBuffer`'s `append` method to add characters to `dest`. In addition to `append`, `StringBuffer` provides methods to insert characters into the buffer, modify a character at a specific location within the buffer, and so on.

### Converting Objects to Strings

> `reverseIt` converts the resulting `StringBuffer` to a `String` and returns the string. You can convert several different data types to `String`s using `String`'s `valueOf` method.

### Converting `String`s to Numbers

> You can also use methods from the `Integer`, `Float`, `Double`, and `Long` classes to convert the contents of a `String` to a number.

### Strings and the Java Compiler

> The Java compiler uses `String`s and `StringBuffer`s behind the scenes to handle literal strings and concatenation.

### Other Interesting Features

> `String` and `StringBuffer` provide several other useful ways to manipulate string data, including concatenation, comparison, substitution, and conversion to upper and lower case. `java.lang.String` and `java.lang.StringBuffer` summarize and list all of the methods and variables supported by these two classes.

| Start of Tutorial > Start of Trail | Search