The Java TM Tutorial

| Start of Tutorial > Start of Trail > Start of Lesson | Search

Trail: Essential Java Classes
Lesson: The String and StringBuffer Classes

## More Accessor Methods

### For the `String` Class

> In addition to the `length` and `charAt` accessors you saw on the previous page, the `String` class provides two accessors that return the position within the string of a specific character or string: `indexOf` and `lastIndexOf`. The `indexOf` method searches forward from the beginning of the string, and `lastIndexOf` searches backward from the end of the string.

> The `indexOf` and `lastIndexOf` methods are frequently used with `substring`, which returns a substring of the string. The following class illustrates the use of `lastIndexOf` and `substring` to isolate different parts of a filename.

> > Note: The methods in the following `Filename` class don't do any error checking and assume that their argument contains a full directory path and a filename with an extension. If these methods were production code they would verify that their arguments were properly constructed.

> >     // This class assumes that the string used to initialize
> >     // fullPath has a directory path, filename, and extension.
> >     // The methods won't work if it doesn't.
> >     public class Filename {
> >         private String fullPath;
> >         private char pathSeparator, extensionSeparator;

> >         public Filename(String str, char sep, char ext) {
> >             fullPath = str;
> >             pathSeparator = sep;
> >             extensionSeparator = ext;
> >         }

> >         public String extension() {
> >             int dot = fullPath.lastIndexOf(extensionSeparator);
> >             return fullPath.substring(dot + 1);
> >         }

> >         public String filename() {
> >             int dot = fullPath.lastIndexOf(extensionSeparator);
> >             int sep = fullPath.lastIndexOf(pathSeparator);
> >             return fullPath.substring(sep + 1, dot);
> >         }

> >         public String path() {
> >             int sep = fullPath.lastIndexOf(pathSeparator);
> >             return fullPath.substring(0, sep);
> >         }
> >     }

> Here's a small program that constructs a `Filename` object and calls all of its methods:

> >     public class FilenameTest {
> >         public static void main(String[] args) {
> >             Filename myHomePage = new Filename("/home/mem/index.html",
> >                                                '/', '.');
> >             System.out.println("Extension = " + myHomePage.extension());
> >             System.out.println("Filename = " + myHomePage.filename());
> >             System.out.println("Path = " + myHomePage.path());
> >         }
> >     }

> And here's the output from the program:

> >     Extension = html
> >     Filename = index
> >     Path = /home/mem

> The `extension` method uses `lastIndexOf` to locate the last occurrence of the period (.) in the filename. Then `substring` uses the return value of `lastIndexOf` to extract the filename extension--that is, the substring from the period to the end of the string. This code assumes that the filename actually has a period in it; if the filename does not have a period , then `lastIndexOf` returns -1, and the `substring` method throws a `StringIndexOutOfBoundsException`.

> Also, notice that `extension` uses `dot + 1` as the argument to `substring`. If the period character is the last character of the string, then `dot + 1` is equal to the length of the string which is one larger than the largest index into the string (because indices start at 0). However, `substring` accepts an index equal to but not greater than the length of the string and interprets it to mean "the end of the string."

> > Try this: Inspect the other methods in the `Filename` class and notice how the `lastIndexOf` and `substring` methods work together to isolate different parts of a filename.

> While the methods in the example above use only one version of the `lastIndexOf` method, the `String` class actually supports four different versions of both the `indexOf` and `lastIndexOf` methods. The four versions work as follows:

> `indexOf(int character)`
> `lastIndexOf(int character)`
>   Return the index of the first (last) occurrence of the specified character.
> `indexOf(int character, int from)`
> `lastIndexOf(int character, int from)`
>   Return the index of the first (last) occurrence of the specified character, searching forward (backward) from the specified index.
> `indexOf(String string)`
> `lastIndexOf(String string)`
>   Return the index of the first (last) occurrence of the specified String.
> `indexOf(String string, int from)`
> `lastIndexOf(String string, int from)`
>   Return the index of the first (last) occurrence of the specified String, searching forward (backward) from the specified index.

### For the `StringBuffer` Class

> Like `String`, `StringBuffer` provides `length` and `charAt` accessor methods. In addition to these two accessors, `StringBuffer` also has a method called `capacity`. The `capacity` method differs from `length` in that it returns the amount of space currently allocated for the `StringBuffer`, rather than the amount of space used. For example, the capacity of the `StringBuffer` in the `reverseIt` method shown here never changes, while the length of the `StringBuffer` increases by one for each iteration of the loop:

> >     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();
> >         }
> >     }

| Start of Tutorial > Start of Trail > Start of Lesson | Search