Characters and Strings

The Java platform contains three classes that you can use when working with character data:

• Character[1] A class whose instances can hold a single character value. This class also defines handy methods that can manipulate or inspect single-character data.

  [1] http://java.sun.com/j2se/1.3/docs/api/java/lang/Character.html

• String[2] A class for working with immutable (unchanging) data composed of multiple characters.

  [2] http://java.sun.com/j2se/1.3/docs/api/java/lang/String.html

• StringBuffer[3] A class for storing and manipulating mutable data composed of multiple characters.

  [3] http://java.sun.com/j2se/1.3/docs/api/java/lang/StringBuffer.html

Characters

An object of Character type contains a single character value. You use a Character object instead of a primitive char variable when an object is requiredfor example, when passing a character value into a method that changes the value or when placing a character value into a data structure, such as a vector, that requires objects.

public class CharacterDemo { public static void main(String args[]) { Character a = new Character('a'); Character a2 = new Character('a'); Character b = new Character('b'); int difference = a.compareTo(b); if (difference == 0) { System.out.println("a is equal to b."); } else if (difference < 0) { System.out.println("a is less than b."); } else if (difference > 0) { System.out.println("a is greater than b."); } System.out.println("a is " + ((a.equals(a2)) ? "equal" : "not equal") + " to a2."); System.out.println("The character " + a.toString() + " is " + (Character.isUpperCase(a.charValue()) ? "upper" : "lower") + "case."); } }

The following is the output from this program:

a is less than b. a is equal to a2. The character a is lowercase.

The CharacterDemo program calls the following constructors and methods provided by the Character class:

• Character(char) The Character class's only constructor, which creates a Character object containing the value provided by the argument. Once a Character object has been created, the value it contains cannot be changed.
• compareTo(Character)[1] An instance method that compares the values held by two character objects: the object on which the method is called (a in the example) and the argument to the method (b in the example). This method returns an integer indicating whether the value in the current object is greater than, equal to, or less than the value held by the argument. A letter is greater than another letter if its numeric value is greater.

  [1] The compareTo method was added to the Character class for Java 2 SDK v. 1.2.

• equals(Object) An instance method that compares the value held by the current object with the value held by another. This method returns true if the values held by both objects are equal.
• toString() An instance method that converts the object to a string. The resulting string is one character in length and contains the value held by the character object.
• charValue() An instance method that returns the value held by the character object as a primitive char value.
• isUpperCase(char) A class method that determines whether a primitive char value is uppercase. This is one of many Character class methods that inspect or manipulate character data. Table 23 lists several other useful class methods the Character class provides.

[a] Added to the Java platform for the 1.1 release. Replaces isSpace(char), which is deprecated.

[b] Added to the Java platform for the 1.1 release.

[c] Added to the Java platform for the 1.1 release. Replaces isJavaLetter(char), which is deprecated.

[d] Added to the Java platform for the 1.1 release. Replaces isJavaLetterOrDigit(char), which is deprecated.

Strings and String Buffers

The Java platform provides two classes, String and StringBuffer, that store and manipulate stringscharacter data consisting of more than one character. The String class provides for strings whose value will not change. For example, if you write a method that requires string data and the method is not going to modify the string in any way, pass a String object into the method. The StringBuffer class provides for strings that will be modified; you use string buffers when you know that the value of the character data will change. You typically use string buffers for constructing character data dynamically: for example, when reading text data from a file. Because strings are constants, they are more efficient to use than are string buffers and can be shared. So it's important to use strings when you can.

public class StringsDemo { public static void main(String[] args) { String palindrome = "Dot saw I was Tod"; int len = palindrome.length(); StringBuffer dest = new StringBuffer(len); for (int i = (len - 1); i >= 0; i--) { dest.append(palindrome.charAt(i)); } System.out.println(dest.toString()); } }

The output from this program is:

doT saw I was toD

In addition to highlighting the differences between strings and string buffers, this section discusses several features of the String and StringBuffer classes: creating strings and string buffers, using accessor methods to get information about a string or string buffer, and modifying a string buffer.

Creating Strings and String Buffers

A string is often created from a string literala series of characters enclosed in double quotes. For example, when it encounters the following string literal, the Java platform creates a String object whose value is Gobbledygook.

"Gobbledygook"

The StringsDemo program uses this technique to create the string referred to by the palindrome variable:

String palindrome = "Dot saw I was Tod";

You can also create String objects as you would any other Java object: using the new keyword and a constructor. The String class provides several constructors that allow you to provide the initial value of the string, using different sources, such as an array of characters, an array of bytes, or a string buffer. Table 24 shows the constructors provided by the String class.

[a] The String class defines other constructors not listed in this table. Those constructors have been deprecated, and their use is not recommended.

Here's an example of creating a string from a character array:

char[] helloArray = { 'h', 'e', 'l', 'l', 'o' }; helloString = new String(helloArray); System.out.println(helloString);

The last line of this code snippet displays: hello.

You must always use new to create a string buffer. The StringBuffer class has three constructors, as described in Table 25.

The StringsDemo program creates the string buffer referred to by dest, using the constructor that sets the buffer's capacity:

String palindrome = "Dot saw I was Tod"; int len = palindrome.length(); StringBuffer dest = new StringBuffer(len);

This code creates the string buffer with an initial capacity equal to the length of the string referred to by the name palindrome. This ensures only one memory allocation for dest because it's just big enough to contain the characters that will be copied to it. By initializing the string buffer's capacity to a reasonable first guess, you minimize the number of times memory must be allocated for it. This makes your code more efficient because memory allocation is a relatively expensive operation.

Getting the Length of a String or a String Buffer

Methods used to obtain information about an object are known as accessor methods. One accessor method that you can use with both strings and string buffers is the length method, which returns the number of characters contained in the string or the string buffer. After the following two lines of code have been executed, len equals 17:

String palindrome = "Dot saw I was Tod"; int len = palindrome.length();

In addition to length, the StringBuffer class has a method called capacity, which returns the amount of space allocated for the string buffer rather than the amount of space used. For example, the capacity of the string buffer referred to by dest in the StringsDemo program never changes, although its length increases by 1 for each iteration of the loop. Figure 48 shows the capacity and the length of dest after nine characters have been appended to it.

Figure 48. A string buffer's length is the number of characters it contains; a string buffer's capacity is the number of character spaces that have been allocated.

The String class doesn't have a capacity method, because a string cannot change.

Getting Characters by Index from a String or a String Buffer

You can get the character at a particular index within a string or a string buffer by using the charAt accessor. The index of the first character is 0; the index of the last is length()-1. For example, the following code gets the character at index 9 in a string:

String anotherPalindrome = "Niagara. O roar again!"; char aChar = anotherPalindrome.charAt(9);

Indices begin at 0, so the character at index 9 is 'O', as illustrated in Figure 49:

Figure 49. Use the charAt method to get a character at a particular index.

The figure also shows that to compute the index of the last character of a string, you have to subtract 1 from the value returned by the length method.

If you want to get more than one character from a string or a string buffer, you can use the substring method. The substring method has two versions, as shown in Table 26.

[a] The substring methods were added to the StringBuffer class for Java 2 SDK 1.2.

The following code gets from the Niagara palindrome the substring that extends from index 11 to index 15, which is the word "roar":

String anotherPalindrome = "Niagara. O roar again!"; String roar = anotherPalindrome.substring(11, 15);

Remember that indices begin at 0 (Figure 50).

Figure 50. Use the substring method to get part of a string or string buffer.

Searching for a Character or a Substring within a String

The String class provides two accessor methods that return the position within the string of a specific character or substring: indexOf and lastIndexOf. The indexOf method searches forward from the beginning of the string, and lastIndexOf searches backward from the end of the string. Table 27 describes the various forms of the indexOf and the lastIndexOf methods.

The StringBuffer class does not support the indexOf or the lastIndexOf methods. If you need to use these methods on a string buffer, first convert the string buffer to a string by using the toString method.

Note

The methods in the following class don't do any error checking and assume that their argument contains a full directory path and a file name 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); } }

public class FilenameDemo { 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 FilenameDemo:

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

As shown in Figure 51, our extension method uses lastIndexOf to locate the last occurrence of the period (.) in the file name. Then substring uses the return value of lastIndexOf to extract the file name extensionthat is, the substring from the period to the end of the string. This code assumes that the file name has a period in it; if the file name does not have a period, lastIndexOf returns -1, and the substring method throws a StringIndexOutOfBoundsException.

Figure 51. The use of lastIndexOf and substring in the extension method in the Filename class.

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

Comparing Strings and Portions of Strings

The String class has several methods for comparing strings and portions of strings. Table 28 lists and describes these methods.

[a] Methods marked with * were added to the String class for Java 2 SDK 1.2.

public class RegionMatchesDemo { public static void main(String[] args) { String searchMe = "Green Eggs and Ham"; String findMe = "Eggs"; int len = findMe.length(); boolean foundIt = false; int i = 0; while (!searchMe.regionMatches(i, findMe, 0, len)) { i++; foundIt = true; } if (foundIt) { System.out.println(searchMe.substring(i, i+len)); } } }

The output from this program is Eggs.

The program steps through the string referred to by searchMe one character at a time. For each character, the program calls the regionMatches method to determine whether the substring beginning with the current character matches the string for which the program is looking.

Manipulating Strings

The String class has several methods that appear to modify a string. Of course, strings can't be modified, so what these methods really do is create and return a second string that contains the result, as indicated in Table 29.

public class BostonAccentDemo { private static void bostonAccent(String sentence) { char r = 'r'; char h = 'h'; String translatedSentence = sentence.replace(r, h); System.out.println(translatedSentence); } public static void main(String[] args) { String translateThis = "Park the car in Harvard yard."; bostonAccent(translateThis); } }

The replace method switches all the r's to h's in the sentence string so that the output of this program is:

Pahk the cah in Hahvahd yahd.

Modifying String Buffers

As you know, string buffers can change. The StringBuffer class provides various methods for modifying the data within a string buffer. Table 30 summarizes the methods used to modify a string buffer.

[a] Methods marked with * were added to the StringBuffer class for Java 2 SDK 1.2.

public class InsertDemo { public static void main(String[] args) { StringBuffer palindrome = new StringBuffer( "A man, a plan, a canal; Panama."); palindrome.insert(15, "a cat, "); System.out.println(palindrome); } }

The output from this program is still a palindrome:

A man, a plan, a cat, a canal; Panama. [2]

[2] Palindrome by Jim Saxe.

With insert, you specify the index before which you want the data inserted. In the example, 15 specifies that "a cat, " is to be inserted before the first a in a canal. To insert data at the beginning of a string buffer, use an index of 0. To add data at the end of a string buffer, use an index equal to the current length of the string buffer or use append.

If the operation that modifies a string buffer causes the size of the string buffer to grow beyond its current capacity, the string buffer allocates more memory. As mentioned previously, memory allocation is a relatively expensive operation, and you can make your code more efficient by initializing a string buffer's capacity to a reasonable first guess.

Strings and the Compiler

The compiler uses the String and the StringBuffer classes behind the scenes to handle literal strings and concatenation. As you know, you specify literal strings between double quotes:

"Hello World!"

You can use literal strings anywhere you would use a String object. For example, System.out.println accepts a string argument, so you could use a literal string there:

System.out.println("Might I add that you look lovely today.");

You can also use String methods directly from a literal string:

int len = "Goodbye Cruel World".length();

Because the compiler automatically creates a new string object for every literal string it encounters, you can use a literal string to initialize a string:

String s = "Hola Mundo";

The preceding construct is equivalent to, but more efficient than, this one, which ends up creating two identical strings:

String s = new String("Hola Mundo"); //don't do this

You can use + to concatenate strings:

String cat = "cat"; System.out.println("con" + cat + "enation");

Behind the scenes, the compiler uses string buffers to implement concatenation. The preceding example compiles to:

String cat = "cat"; System.out.println(new StringBuffer().append("con"). append(cat).append("enation").toString());

You can also use the + operator to append to a string values that are not themselves strings:

System.out.println("You're number " + 1);

The compiler implicitly converts the nonstring value (the integer 1 in the example) to a string object before performing the concatenation operation.

Summary of Characters and Strings

Use a Character object to contain a single character value, use a String object to contain a sequence of characters that won't change, and use a StringBuffer object to construct or to modify a sequence of characters dynamically. Refer to the tables listed in Table 31 for details about constructors and methods in these classes.

public class Palindrome { public static boolean isPalindrome(String stringToTest) { String workingCopy = removeJunk(stringToTest); String reversedCopy = reverse(workingCopy); return reversedCopy.equalsIgnoreCase(workingCopy); } protected static String removeJunk(String string) { int i, len = string.length(); StringBuffer dest = new StringBuffer(len); char c; for (i = (len - 1); i >= 0; i--) { c = string.charAt(i); if (Character.isLetterOrDigit(c)) { dest.append(c); } } return dest.toString(); } protected static String reverse(String string) { StringBuffer sb = new StringBuffer(string); return sb.reverse().toString(); } public static void main(String[] args) { String string = "Madam, I'm Adam."; System.out.println(); System.out.println("Testing whether the following " + "string is a palindrome:"); System.out.println(" " + string); System.out.println(); if (isPalindrome(string)) { System.out.println("It IS a palindrome!"); } else { System.out.println("It is NOT a palindrome!"); } System.out.println(); } }

The output from this program is:

Testing whether the following string is a palindrome: Madam, I'm Adam. It IS a palindrome!

Questions and Exercises: Characters and Strings

Questions

Exercises

Answers

You can find answers to these Questions and Exercises online:

http://java.sun.com/docs/books/tutorial/java/data/QandE/characters-answers.html