Finding the length of a string

One of the most basic string operations is determining the length of a string. You do that with the length method. For example:

String s = "A wonderful day for a neighbor.";
int len = s.length();

Here len is assigned a value of 31 because the string s consists of 30 characters.

Getting the length of a string usually isn’t very useful by itself, but the length method often plays an important role in other string manipulations, as you see throughout the following sections.

Making simple string modifications

Several of the methods of the String class return modified versions of the original string. toLowerCase, for example, converts a string to all-lowercase letters:

String s1 = "Oompa Loompa";
String s2 = s1.toLowerCase();

Here s2 is set to the string oompa loompa. The toUpperCase method works the same way but converts strings to all-uppercase letters.

The trim method removes white-space characters (spaces, tabs, newlines, and so on) from the start and end of a word. Here’s an example:

String s = " Oompa Loompa ";
s = s.trim();

Here the spaces before and after Oompa Loompa are removed. Thus, the resulting string is ten characters long.

Bear in mind that because strings are immutable, these methods don’t actually change the String object. Instead, they create a new String with the modified value. A common mistake — especially for programmers who are new to Java but experienced in other languages — is to forget to assign the return value from one of these methods. The following statement has no effect on s:

s.trim();

Here the trim method trims the string — but then the program discards the result. The remedy is to assign the result of this expression back to s, like this:

s = s.trim();

Extracting characters from a string

You can use the charAt method to extract a character from a specific position in a string. When you do, keep in mind that the index number for the first character in a string is 0, not 1. Also, you should check the length of the string before extracting a character. If you specify an index value that’s beyond the end of the string, the exception StringIndexOutOfBoundsException is thrown. (Fortunately, this is an unchecked exception, so you don’t have to enclose the charAt method in a try/catch statement.)

Here’s an example of a program that uses the charAt method to count the number of vowels in a string entered by the user:

import java.util.Scanner;

public class CountVowels
{

static Scanner sc = new Scanner(System.in);
public static void main(String[] args)
{
System.out.print("Enter a string: ");
String s = sc.nextLine();

int vowelCount = 0;

for (int i = 0; i < s.length(); i++)
{
char c = s.charAt(i);
if ( (c == 'A') || (c == 'a')
|| (c == 'E') || (c == 'e')
|| (c == 'I') || (c == 'i')
|| (c == 'O') || (c == 'o')
|| (c == 'U') || (c == 'u') )
vowelCount++;
}
System.out.println("That string contains "
+ vowelCount + " vowels.");
}
}

Here the for loop checks the length of the string to make sure that the index variable i doesn’t exceed the string length. Then each character is extracted and checked with an if statement to see whether it is a vowel. The condition expression in this if statement is a little complicated because it must check for five different vowels, both uppercase and lowercase.

Following is an example that shows the output created by this program if you enter a string listing all of the letters of the alphabet:

Enter a string: abcdefghijklmnopqrstuvwxyz
That string contains 5 vowels.

Extracting substrings from a string

The substring method lets you extract a portion of a string. This method has two forms. The first version accepts a single integer parameter. It returns the substring that starts at the position indicated by this parameter and extends to the rest of the string. (Remember that string positions start with 0, not 1.) Here’s an example:

String s = "Baseball";
String b = s.substring(4); // "ball"

Here b is assigned the string ball.

The second version of the substring method accepts two parameters to indicate the start and end of the substring you want to extract. Note that the substring actually ends at the character that’s immediately before the position indicated by the second parameter. So, to extract the characters at positions 2 through 5, specify 1 as the start position and 6 as the ending position. For example:

String s = "Baseball";
String b = s.substring(2, 6); // "seba"

Here b is assigned the string seba.

The following program uses substrings to replace all the vowels in a string entered by the user with asterisks:

import java.util.Scanner;

public class MarkVowels
{
static Scanner sc = new Scanner(System.in);

public static void main(String[] args)
{
System.out.print("Enter a string: ");
String s = sc.nextLine();
String originalString = s;

int vowelCount = 0;

for (int i = 0; i < s.length(); i++)
{
char c = s.charAt(i);
if ( (c == 'A') || (c == 'a')
|| (c == 'E') || (c == 'e')
|| (c == 'I') || (c == 'i')
|| (c == 'O') || (c == 'o')
|| (c == 'U') || (c == 'u') )
{
String front = s.substring(0, i);
String back = s.substring(i+1);
s = front + "*" + back;
}
}
System.out.println();
System.out.println(originalString);
System.out.println(s);
}
}

This program uses a for loop and the charAt method to extract each character from the string. Then, if the character is a vowel, a string named front is created that consists of all the characters that appear before the vowel. Next, a second string named back is created with all the characters that appear after the vowel. Finally, the s string is replaced by a new string that’s constructed from the front string, an asterisk, and the back string.

Here’s some sample console output from this program so that you can see how it works:

Enter a string: Where have all the vowels gone?

Where have all the vowels gone?
Wh*r* h*v* *ll th* v*w*ls g*n*?

Splitting a string

The split command is especially useful for splitting a string into separate strings based on a delimiter character. Suppose you have a string with the parts of an address separated by colons, like this:

1500 N. Third Street:Fresno:CA:93722

With the split method, you can easily separate this string into four strings. In the process, the colons are discarded.

Unfortunately, the use of the split method requires that you use an array, and arrays are covered in the next chapter. I’m going to plow ahead with this section anyway on a hunch that you already know a few basic things about arrays. (If not, you can always come back to this section after you read the next chapter.)

The split method carves a string into an array of strings separated by the delimiter character passed via a string parameter. Here’s a routine that splits an address into separate strings and then prints out all the strings:

String address =
"1500 N. Third Street:Fresno:CA:93722";

String[] parts = address.split(":");

for (int i = 0; i < parts.length; i++)
System.out.println(parts[i]);

If you run this code, the following lines are displayed on the console:

1500 N. Third Street
Fresno
CA
93722

The string passed to the split method is actually a special type of string used for pattern recognition, called a regular expression. You discover regular expressions in Book 5. For now, here are a few regular expressions that might be useful when you use the split method:

The last regular expression in this table, \s+, is especially useful for breaking a string into separate words. The following program accepts a string from the user, breaks it into separate words, and then displays the words on separate lines:

import java.util.Scanner;

public class ListWords
{
static Scanner sc = new Scanner(System.in);

public static void main(String[] args)
{
System.out.print("Enter a string: ");
String s = sc.nextLine();
String[] word = s.split("\s+");
for (String w : word)
System.out.println(w);
}
}

Here’s a sample of the console output for a typical execution of this program:

Enter a string: This string has several words
This
string
has
several
words

Notice that some of the words in the string entered by the user are preceded by more than one space character. The \s+ pattern used by the split method treats any consecutive white-space character as a single delimiter when splitting the words.

Replacing parts of a string

You can use the replaceFirst or replaceAll method to replace a part of a string that matches a pattern you supply with some other text. Here’s the main method of a program that gets a line of text from the user and then replaces all occurrences of the string cat with dog:

public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
System.out.print("Enter a string: ");
String s = sc.nextLine();

s = s.replaceAll("cat", "dog");

System.out.println(s);
}

And here’s the console for a typical execution of this program:

Enter a string: I love cats.
I love dogs.

As with the split methods, the first parameter of replace methods can be a regular expression that provides a complex matching string. (For more information, see Book 5, Chapter 3.)

Once again, don’t forget that strings are immutable. As a result, the replace methods don’t actually modify the String object itself. Instead, they return a new String object with the modified value.

Creating a StringBuilder object

You can’t assign string literals directly to a StringBuilder object, as you can with a String object. The StringBuilder class, however, has a constructor that accepts a String as a parameter. So to create a StringBuilder object, you use a statement such as this:

StringBuilder sb = new StringBuilder("Today is the day!");

Internally, a StringBuilder object maintains a fixed area of memory where it stores a string value. This area of memory is called the buffer. The string held in this buffer doesn’t have to use the entire buffer. As a result, a StringBuilder object has both a length and a capacity. The length represents the current length of the string maintained by the StringBuilder, and the capacity represents the size of the buffer itself. Note that the length can’t exceed the capacity.

When you create a StringBuilder object, initially the capacity is set to the length of the string plus 16. The StringBuilder class automatically increases its capacity whenever necessary, so you don’t have to worry about exceeding the capacity.

Using StringBuilder methods

Table 1-2 lists the most useful methods of the StringBuilder class. Note that the StringBuffer class uses the same methods. If you have to use StringBuffer instead of StringBuilder, just change the class name and use the same methods.

Viewing a StringBuilder example

To illustrate how the StringBuilder class works, here’s a StringBuilder version of the MarkVowels program from earlier in this chapter:

import java.util.Scanner;

public class StringBuilderApp
{
static Scanner sc = new Scanner(System.in);

public static void main(String[] args)
{
System.out.print("Enter a string: ");

String s = sc.nextLine();
StringBuilder sb = new StringBuilder(s);

int vowelCount = 0;

for (int i = 0; i < s.length(); i++)
{
char c = s.charAt(i);
if ( (c == 'A') || (c == 'a')
|| (c == 'E') || (c == 'e')
|| (c == 'I') || (c == 'i')
|| (c == 'O') || (c == 'o')
|| (c == 'U') || (c == 'u') )
{
sb.setCharAt(i, '*');
}
}
System.out.println();
System.out.println(s);
System.out.println(sb.toString());
}
}

This program uses the setCharAt method to directly replace any vowels it finds with asterisks. That’s much more efficient than concatenating substrings (which is the way the String version of this program worked).