AhmadLang / Java, How To Program, 2004

It is not necessary to copy an existing String object. String objects are immutabletheir character contents cannot be changed after they are created, because class String does not provide any methods that allow the contents of a String object to be modified.

[Page 1353]

Line 14 instantiates a new String object and assigns its reference to s3 using class String's constructor that takes a char array as an argument. The new String object contains a copy of the characters in the array.

Line 15 instantiates a new String object and assigns its reference to s4 using class String's constructor that takes a char array and two integers as arguments. The second argument specifies the starting position (the offset) from which characters in the array are accessed. Remember that the first character is at position 0. The third argument specifies the number of characters (the count) to access in the array. The new String object contains a string formed from the accessed characters. If the offset or the count specified as an argument results in accessing an element outside the bounds of the character array, a String-IndexOutOfBoundsException is thrown. We discussed exceptions in detail in Chapter 13.

Common Programming Error 29.1

Attempting to access a character that is outside the bounds of a string (i.e., an index less than 0 or an index greater than or equal to the string's length) results in a StringIndexOutOfBounds-Exception.

29.3.2. String Methods length, charAt and getChars

String methods length, charAt and getChars return the length of a string, obtain the character at a specific location in a string and retrieve a set of characters from a string as a char array, respectively. The application in Fig. 29.2 demonstrates each of these methods.

5public class StringMiscellaneous

6{

7public static void main( String args[] )

8{

9String s1 = "hello there";

10char charArray[] = new char[ 5 ];

12System.out.printf( "s1: %s", s1 );

14// test length method

15System.out.printf( "\nLength of s1: %d", s1.length() );

17// loop through characters in s1 with charAt and display reversed

18System.out.print( "\nThe string reversed is: " );

4public class StringCompare

5{

9String s2 = "goodbye";

10String s3 = "Happy Birthday";

11String s4 = "happy birthday";

16// test for equality

17if ( s1 equals( "hello" ) ) // true

18System.out.println( "s1 equals \"hello\"" );

19else

20System.out.println( "s1 does not equal \"hello\"" );

22// test for equality with ==

23 if ( s1 == "hello" ) // false; they are not the same object

24System.out.println( "s1 is the same object as \"hello\"" );

25else

26System.out.println( "s1 is not the same object as \"hello\"" );

28// test for equality (ignore case)

29if ( s3.equalsIgnoreCase( s4 ) ) // true

30System.out.printf( "%s equals %s with case ignored\n", s3, s4 );

31else

32System.out.println( "s3 does not equal s4" );

33

34// test compareTo

35System.out.printf(

36"\ns1.compareTo( s2 ) is %d", s1.compareTo( s2 ) );

37System.out.printf(

38"\ns2.compareTo( s1 ) is %d", s2.compareTo( s1 ) );

39System.out.printf(

40"\ns1.compareTo( s1 ) is %d", s1.compareTo( s1 ) );

41System.out.printf(

42"\ns3.compareTo( s4 ) is %d", s3.compareTo( s4 ) );

43System.out.printf(

44"\ns4.compareTo( s3 ) is %d\n\n", s4.compareTo( s3 ) );

46// test regionMatches (case sensitive)

47if ( s3.regionMatches( 0, s4, 0, 5 ) )

48System.out.println( "First 5 characters of s3 and s4 match" );

49else

50System.out.println(

53// test regionMatches (ignore case)

54if ( s3. regionMatches( true, 0, s4, 0, 5 ) )

55System.out.println( "First 5 characters of s3 and s4 match" );

56else

57System.out.println(

59} // end main

60} // end class StringCompare

The condition at line 17 uses method equals to compare string s1 and the string literal "hello" for equality. Method equals (a method of class Object overridden in String) tests any two objects for equalitythe strings contained in the two objects are identical. The method returns true if the contents of the objects are equal, and false otherwise. The preceding condition is TRue because string s1 was initialized with the string literal "hello". Method equals uses a lexicographical comparisonit compares the integer Unicode values (see Appendix F, Unicode, for more information) that represent each character in each string. Thus, if the string "hello" is compared with the string "HELLO", the result is false, because the integer representation of a lowercase letter is different from that of the corresponding uppercase letter.

The condition at line 23 uses the equality operator == to compare string s1 for equality with the string literal "hello". Operator == has different functionality when it is used to compare references than when it is used to compare values of primitive types. When primitive-type values are compared with ==, the result is true if both values are identical. When references are compared with ==, the result is true if both references refer to the same object in memory. To compare the actual contents (or state information) of objects for equality, a method must be invoked. In the case of Strings, that method is equals. The preceding condition evaluates to false at line 23 because the reference s1 was initialized with the statement

s1 = new String( "hello" );

[Page 1357]

which creates a new String object with a copy of string literal "hello" and assigns the new object to variable s1. If s1 had been initialized with the statement

s1 = "hello";

which directly assigns the string literal "hello" to variable s1, the condition would be TRue. Remember that Java treats all string literal objects with the same contents as one String object to which there can be many references. Thus, lines 8, 17 and 23 all refer to the same String object "hello" in memory.

Common Programming Error 29.2

Comparing references with == can lead to logic errors, because == compares the references to determine whether they refer to the same object, not whether two objects have the same contents. When two identical (but separate) objects are compared with ==, the result will be false. When comparing objects to determine whether they have the same contents, use method equals.

If you are sorting Strings, you may compare them for equality with method equals-IgnoreCase, which ignores whether the letters in each string are uppercase or lowercase when performing the comparison. Thus, the string "hello" and the string "HELLO" compare as equal. Line 29 uses String method

equalsIgnoreCase to compare string s3Happy Birthdayfor equality with string s4happy birthday. The result of this comparison is true because the comparison ignores case sensitivity.

Lines 3544 use method compareTo to compare strings. Method compareTo is declared in the Comparable interface and implemented in the String class. Line 36 compares string s1 to string s2. Method compareTo returns 0 if the strings are equal, a negative number if the string that invokes compareTo is less than the string that is passed as an argument and a positive number if the string that invokes compareTo is greater than the string that is passed as an argument. Method compareTo uses a lexicographical comparisonit compares the numeric values of corresponding characters in each string. (For more information on the exact value returned by the compareTo method, see java.sun.com/j2se/5.0/docs/api/java/lang/String.html.)

[Page 1358]

The condition at line 47 uses String method regionMatches to compare portions of two strings for equality. The first argument is the starting index in the string that invokes the method. The second argument is a comparison string. The third argument is the starting index in the comparison string. The last argument is the number of characters to compare between the two strings. The method returns TRue only if the specified number of characters are lexicographically equal.

Finally, the condition at line 54 uses a five-argument version of String method regionMatches to compare portions of two strings for equality. When the first argument is true, the method ignores the case of the characters being compared. The remaining arguments are identical to those described for the fourargument regionMatches method.

The second example in this section (Fig. 29.4) demonstrates String methods startsWith and endsWith. Method main creates array strings containing the strings "started", "starting", "ended" and "ending". The remainder of method main consists of three for statements that test the elements of the array to determine whether they start with or end with a particular set of characters.

Figure 29.4. String class startsWith and endsWith methods.

(This item is displayed on page 1359 in the print version)

1// Fig. 29.4: StringStartEnd.java

2// String methods startsWith and endsWith.

4public class StringStartEnd

10// test method startsWith

11for ( String string : strings )

12{

13if ( string.startsWith( "st" ) )

19// test method startsWith starting from position 2 of string

20for ( String string : strings )

21{

22if ( string.startsWith( "art", 2 ) )

29// test method endsWith

30for ( String string : strings )

31{

32if ( string.endsWith( "ed" ) )

34} // end for

35} // end main

36} // end class StringStartEnd

"started" starts with "st" "starting" starts with "st"

"started" starts with "art" at position 2 "starting" starts with "art" at position 2

"started" ends with "ed" "ended" ends with "ed"

The first for statement (lines 1115) uses the version of method startsWith that takes a String argument. The condition in the if statement (line 13) determines whether each String in the array starts with the characters "st". If so, the method returns true and the application prints that String. Otherwise, the method returns false and nothing happens.

The second for statement (lines 2025) uses the startsWith method that takes a String and an integer as arguments. The integer specifies the index at which the comparison should begin in the string. The condition in the if statement (line 22) determines whether each String in the array has the characters "art" beginning with the third character in each string. If so, the method returns true and the application prints the String.

The third for statement (lines 3034) uses method endsWith, which takes a String argument. The condition at line 32 determines whether each String in the array ends with the characters "ed". If so, the method returns true and the application prints the String.

29.3.4. Locating Characters and Substrings in Strings

Often it is useful to search for a character or set of characters in a string. For example, if you are creating your own word processor, you might want to provide a capability for searching through documents. Figure 29.5 demonstrates the many versions of String methods indexOf and lastIndexOf that search for a specified character or substring in a string. All the searches in this example are performed on the string letters (initialized with "abcdefghijklmabcdefghijklm") in method main. Lines 1116 use method indexOf to locate the first occurrence of a character in a string. If method indexOf finds the character, it returns the character's index in the stringotherwise, indexOf returns 1. There are two versions of indexOf that search for characters in a string. The expression in line 12 uses the version of method indexOf that takes an integer representation of the character to find. The expression at line 14 uses another version of method indexOf, which takes two integer argumentsthe character and the starting index at which the search of the string should begin.

[Page 1359]

Figure 29.5. String class searching methods.

(This item is displayed on pages 1360 - 1361 in the print version)

4public class StringIndexMethods

5{

6 public static void main( String args[] )

7{

8String letters = "abcdefghijklmabcdefghijklm";

10// test indexOf to locate a character in a string

11System.out.printf(

12"'c' is located at index %d\n", letters.indexOf( 'c' ) );

13System.out.printf(

18// test lastIndexOf to find a character in a string

19System.out.printf( "Last 'c' is located at index %d\n",

20letters.lastIndexOf( 'c' ) );

21System.out.printf( "Last 'a' is located at index %d\n",

22letters.lastIndexOf( 'a', 25 ) );

23System.out.printf( "Last '$' is located at index %d\n\n",

24letters.lastIndexOf( '$' ) );

25

26// test indexOf to locate a substring in a string

27System.out.printf( "\"def\" is located at index %d\n",

28letters.indexOf( "def" ) );

29System.out.printf( "\"def\" is located at index %d\n",

30letters.indexOf( "def",7 ) );

31System.out.printf( "\"hello\" is located at index %d\n\n",

32letters.indexOf( "hello" ) );

33

34// test lastIndexOf to find a substring in a string

35System.out.printf( "Last \"def\" is located at index %d\n",

36letters.lastIndexOf( "def" ) );

37System.out.printf( "Last \"def\" is located at index %d\n",

38letters.lastIndexOf( "def", 25 ) );

39System.out.printf( "Last \"hello\" is located at index %d\n",

40letters.lastIndexOf( "hello" ) );

41} // end main

42} // end class StringIndexMethods

'c' is located at index 2 'a' is located at index 13 '$' is located at index -1

Last 'c' is located at index 15

Last 'a' is located at index 13

Last '$' is located at index -1

"def" is located at index 3 "def" is located at index 16 "hello" is located at index -1

Last "def" is located at index 16

Last "def" is located at index 16

Last "hello" is located at index -1

The statements at lines 1924 use method lastIndexOf to locate the last occurrence of a character in a string. Method lastIndexOf performs the search from the end of the string toward the beginning of the string. If method lastIndexOf finds the character, it returns the index of the character in the stringotherwise, lastIndexOf returns 1. There are two versions of lastIndexOf that search for characters in a string. The expression at line 20 uses the version of method lastIndexOf that takes the integer representation of the character. The expression at line 22 uses the version of method lastIndexOf that takes two integer argumentsthe integer representation of the character and the index from which to begin searching backward.

[Page 1360]

[Page 1361]

Lines 2740 demonstrate versions of methods indexOf and lastIndexOf that each take a String as the first argument. These versions of the methods perform identically to those described earlier except that they search for sequences of characters (or substrings) that are specified by their String arguments. If the substring is found, these methods return the index in the string of the first character in the substring.

1// Fig. 29.7: StringConcatenation.java

2// String concat method.

3

4public class StringConcatenation

5{

10

11System.out.printf( "s1 = %s\ns2 = %s\n\n", s1, s2 );

12System.out.printf(

14System.out.printf( "s1 after concatenation = %s\n", s1 );

15} // end main

16} // end class StringConcatenation

s1 = Happy

s2 = Birthday

Result of s1.concat( s2 ) = Happy Birthday s1 after concatenation = Happy

29.3.7. Miscellaneous String Methods

Class String provides several methods that return modified copies of strings or that return character arrays. These methods are demonstrated in the application in Fig. 29.8.

Figure 29.8. String methods replace, toLowerCase, toUpperCase, trim

and toCharArray.

(This item is displayed on page 1363 in the print version)

4public class StringMiscellaneous2

5{

14// test method replace

15System.out.printf(

18// test toLowerCase and toUpperCase

19System.out.printf( "s1.toUpperCase() = %s\n", s1.toUpperCase() );

20System.out.printf( "s2.toLowerCase() = %s\n\n", s2.toLowerCase() );

22// test trim method

23System.out.printf( "s3 after trim = \"%s\"\n\n", s3.trim() );

25// test toCharArray method

26char charArray[] = s1.toCharArray();

27System.out.print( "s1 as a character array = " );