| 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: These methods 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.

> > >     class Filename {
> > >         String fullPath;
> > >         char pathSeparator;

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

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

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

> > >         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:

> > >     class FilenameTest {
> > >         public static void main(String[] args) {
> > >             Filename myHomePage = new Filename("/home/mem/public_html/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/public_html

> > 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:

> > >     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 String and StringBuffer Classes