> ### Solution for
> Programming Exercise 4.1

> THIS PAGE DISCUSSES ONE POSSIBLE SOLUTION to the following exercise from this on-line Java textbook.

> Exercise 4.1: To "capitalize" a string means to change the first letter of each word in the string to upper case (if it is not already upper case). For example, a capitalized version of "Now is the time to act!" is "Now Is The Time To Act!". Write a subroutine named `printCapitalized` that will print a capitalized version of a string to standard output. The string to be printed should be a parameter to the subroutine. Test your subroutine with a `main()` routine that gets a line of input from the user and applies the subroutine to it.

> Note that a letter is the first letter of a word if it is not immediately preceded in the string by another letter. Recall that there is a standard `boolean`-valued function `Character.isLetter(char)` that can be used to test whether its parameter is a letter. There is another standard `char`-valued function, `Character.toUpperCase(char)`, that returns a capitalized version of the single character passed to it as a parameter. That is, if the parameter is a letter, it returns the upper-case version. If the parameter is not a letter, it just returns a copy of the parameter.

> Discussion

> We are told the name of the subroutine and that it has one parameter of type `String`. The name of the parameter is not specified. I will use `str`. The return type is `void` because the subroutine does not return a value. (It displays a value to the user, but to return a value means to return it to the line in the program where the function is called. The value returned by a function is generally not displayed to the user by the function.) The first line of the subroutine definition will be:

>          static  void  printCapitalized( String str )

> The subroutine must look at each character in `str` and decide whether to capitalize it or not. An algorithm for the subroutine is

>          for each character in str:
>              if the character is the first letter of a word:
>                  Print a capitalized version of the character
>              else:
>                  Print the character
>          Print a carriage return to end the line of output

> The test as to whether a character is the first letter of a word is surprisingly complicated. A test that almost works is: "If the character is a letter and the preceding character is not a letter." The problem is that if the character is the first character is the string, then there is no preceding character. If the character is `str.charAt(i)`, then the preceding character would be `str.charAt(i-1)`, but `str.charAt(i-1)` doesn't exist if `i` is `0`. Let's look at Java code that suffers from this bug. Recall that the operator "`!`" stands for "not."

>          for ( i = 0;  i < str.length();  i++ ) {        // BUGGY CODE
>              ch = str.charAt( i );
>              if ( Character.isLetter(ch) && ! Character.isLetter(str.charAt(i-1)) )
>                  System.out.print( Character.toUpperCase(ch) );
>              else
>                  System.out.print( ch );
>          }
>          System.out.println();

> This will crash when `i` is zero. There are several ways to work around the problem, and all of them are techniques that are worth knowing. The first is to use a more complicated test in the `if` statement: "if the character is a letter and either it's the first character in the string or the previous character is not a letter". In Java, this is "`if (Character.isLetter(ch) && (i==0 || !Character.isLetter(str.charAt(i-1))))`". But it can be difficult to get such a complicated test right. Another possibility is a bit sneaky: Add an extra character onto the beginning of `str`, and then start the `for` loop with `i=1`. Any character will do, as long as it's not a letter. For example, you could say "`str = "." + str;`" Since the `for` loop starts at `i=1`, the "." is not copied to output, and the problem of `i==0` doesn't arise. The method that I will use is similar, but it doesn't require any modification of `str`. I'll use another variable to represent the preceding character in the string, except that at the beginning of the string, I'll set it to the arbitrary value, '.'. At the end of the loop, the character that we have just processed becomes the "previous character" in the next iteration of the loop. Here is the complete subroutine, using this method:

>            static void printCapitalized( String str ) {
>               char ch;       // One of the characters in str.
>               char prevCh;   // The character that comes before ch in the string.
>               int i;         // A position in str, from 0 to str.length()-1.
>               prevCh = '.';  // Prime the loop with any non-letter character.
>               for ( i = 0;  i < str.length();  i++ ) {
>                  ch = str.charAt(i);
>                  if ( Character.isLetter(ch)  &&  ! Character.isLetter(prevCh) )
>                      System.out.print( Character.toUpperCase(ch) );
>                  else
>                      System.out.print( ch );
>                  prevCh = ch;  // prevCh for next iteration is ch.
>               }
>               System.out.println();
>            }

> This doesn't exhaust the possibilities. Another idea, for example, would be to use a boolean variable to keep track of whether the previous character was a letter.

> Writing a `main()` routine to test this subroutine on a line of input is easy.

> The Solution

>         public class CapitolizeOneString {

>            /*  This program will get a line of input from the user
>                and will print a copy of the line in which the first
>                character of each word has been changed to upper case.
>                The program was written to test the printCapitalized
>                subroutine.  It depends on the non-standard TextIO class.
>            */

>            public static void main(String[] args) {
>               String line;  // Line of text entered by user.
>               TextIO.putln("Enter a line of text.");
>               line = TextIO.getln();
>               TextIO.putln();
>               TextIO.putln("Capitalized version:");
>               printCapitalized( line );
>            }  // end main()

>            static void printCapitalized( String str ) {
>                  // Print a copy of str to standard output, with the
>                  // first letter of each word in upper case.
>               char ch;       // One of the characters in str.
>               char prevCh;   // The character that comes before ch in the string.
>               int i;         // A position in str, from 0 to str.length()-1.
>               prevCh = '.';  // Prime the loop with any non-letter character.
>               for ( i = 0;  i < str.length();  i++ ) {
>                  ch = str.charAt(i);
>                  if ( Character.isLetter(ch)  &&  ! Character.isLetter(prevCh) )
>                     System.out.print( Character.toUpperCase(ch) );
>                  else
>                     System.out.print( ch );
>                  prevCh = ch;  // prevCh for next iteration is ch.
>               }
>               System.out.println();
>            }

>         }  // end class

> [ Exercises | Chapter Index | Main Index ]