Lecture Outline
11.1 Introduction
11.2 Fundamentals of Characters and Strings
11.3 Class String
11.3.1 String Constructors
11.3.2 String Methods length, charAt and getChars
11.3.3 Comparing Strings
11.3.4 Locating Characters and Substrings in Strings
11.3.5 Extracting Substrings from Strings
11.3.6 Concatenating Strings
11.3.7 Miscellaneous String Methods
11.4 Class StringBuffer
11.4.1 StringBuffer Constructors
11.4.2 StringBuffer Methods length, capacity, setLength and ensureCapacity
11.4.4 StringBuffer append Methods
11.1 Introduction
• String and character processing
– Class java.lang.String
– Class java.lang.StringBuffer
– Class java.lang.Character
11.2 Fundamentals of Characters and Strings
• Characters
– “Building blocks” of Java source programs
• String
– Series of characters treated as single unit
– May include letters, digits, etc.
– Object of class String
11.3.1 String Constructors
• Class String
– Provides six constructors
1 // Fig. 11.1: StringConstructors.java
2 // String class constructors.
3 import javax.swing.*;
4
5 public class StringConstructors {
6
7 public static void main( String args[ ] )
8 {
9 char charArray[ ] = { 'b', 'i', 'r', 't', 'h', ' ', 'd', 'a', 'y' };
10 byte byteArray[ ] = { ( byte ) 'n', ( byte ) 'e', ( byte ) 'w', ( byte ) ' ', ( byte ) 'y', ( byte ) 'e', ( byte ) 'a', ( byte ) 'r' };
11
12
13
14 String s = new String( "hello" );
15
16 // use String constructors
17 String s1 = new String();
18 String s2 = new String( s );
19 String s3 = new String( charArray );
20 String s4 = new String( charArray, 6, 3 );
21 String s5 = new String( byteArray, 4, 4 );
22 String s6 = new String( byteArray );
23
24 // append Strings to output
25 String output = "s1 = " + s1 + "\ns2 = " + s2 + "\ns3 = " + s3 +
26 "\ns4 = " + s4 + "\ns5 = " + s5 + "\ns6 = " + s6;
27
28 JOptionPane.showMessageDialog( null, output,
29 "String Class Constructors", JOptionPane.INFORMATION_MESSAGE );
30
31 System.exit( 0 );
32 }
33
34 } // end class StringConstructors
11.3.2 String Methods length, charAt and getChars
• Method length
– Determine String length
• Like arrays, Strings always “know” their size
• Method charAt
– Get character at specific location in String
• Method getChars
– Get entire set of characters in String
1 // Fig. 11.2: StringMiscellaneous.java
2 // This program demonstrates the length, charAt and getChars
3 // methods of the String class.
4 import javax.swing.*;
5
6 public class StringMiscellaneous {
7
8 public static void main( String args[ ] )
9 {
10 String s1 = "hello there";
11 char charArray[ ] = new char[ 5 ];
12
13 String output = "s1: " + s1;
14
15 // test length method
16 output += "\nLength of s1: " + s1.length();
17
18 // loop through characters in s1 and display reversed
19 output += "\nThe string reversed is: ";
20
21 for ( int count = s1.length() - 1; count >= 0; count-- )
22 output += s1.charAt( count ) + " ";
23
24 // copy characters from string into charArray
25 s1.getChars( 0, 5, charArray, 0 );
26 output += "\nThe character array is: ";
27
28 for ( int count = 0; count < charArray.length; count++ )
29 output += charArray[ count ];
30
31 JOptionPane.showMessageDialog( null, output, "String class character manipulation methods",
32 JOptionPane.INFORMATION_MESSAGE );
33
34
35 System.exit( 0 );
36 }
37
38 } // end class StringMiscellaneous
Line 16 Determine number of characters in String s1
Line 21 Append s1’s characters in reverse order to String output
Line 25 Copy (some of) s1’s characters to charArray
11.3.3 Comparing Strings
• Comparing String objects
– Method equals
– Method equalsIgnoreCase
– Method compareTo
– Method regionMatches
1 // Fig. 11.3: StringCompare.java
2 // String methods equals, equalsIgnoreCase, compareTo and regionMatches.
3 import javax.swing.JOptionPane;
4
5 public class StringCompare {
6
7 public static void main( String args[ ] )
8 {
9 String s1 = new String( "hello" ); // s1 is a copy of "hello"
10 String s2 = "goodbye";
11 String s3 = "Happy Birthday";
12 String s4 = "happy birthday";
13
14 String output = "s1 = " + s1 + "\ns2 = " + s2 + "\ns3 = " + s3 + "\ns4 = " + s4 + "\n\n";
15
16
17 // test for equality
18 if ( s1.equals( "hello" ) ) // true
19 output += "s1 equals \"hello\"\n";
20 else
21 output += "s1 does not equal \"hello\"\n";
22
23 // test for equality with ==
24 if ( s1 == "hello" ) // false; they are not the same object
25 output += "s1 equals \"hello\"\n";
26 else
27 output += "s1 does not equal \"hello\"\n";
28
29 // test for equality (ignore case)
30 if ( s3.equalsIgnoreCase( s4 ) ) // true
31 output += "s3 equals s4\n";
32 else
33 output += "s3 does not equal s4\n";
34
35 // test compareTo
36 output += "\ns1.compareTo( s2 ) is " + s1.compareTo( s2 ) +
37 "\ns2.compareTo( s1 ) is " + s2.compareTo( s1 ) + "\ns1.compareTo( s1 ) is " + s1.compareTo( s1 ) +
38 "\ns3.compareTo( s4 ) is " + s3.compareTo( s4 ) + "\ns4.compareTo( s3 ) is " + s4.compareTo( s3 ) + "\n\n";
39
40
41
42 // test regionMatches (case sensitive)
43 if ( s3.regionMatches( 0, s4, 0, 5 ) )
44 output += "First 5 characters of s3 and s4 match\n";
45 else
46 output += "First 5 characters of s3 and s4 do not match\n";
47
48 // test regionMatches (ignore case)
49 if ( s3.regionMatches( true, 0, s4, 0, 5 ) )
50 output += "First 5 characters of s3 and s4 match";
51 else
52 output += "First 5 characters of s3 and s4 do not match";
53
54 JOptionPane.showMessageDialog( null, output,
55 "String comparisons", JOptionPane.INFORMATION_MESSAGE );
56
57 System.exit( 0 );
58 }
59
60 } // end class StringCompare
Line 18 Method equals tests two objects for equality using lexicographical comparison
Line 24 Equality operator (==) tests if both references refer to same object in memory
Line 30 Test two objects for equality, but ignore case of letters in Strings
Lines 36-40 Method compareTo compares String objects
Line 43 and 49 Method regionMatches compares portions of two String objects for equality
1 // Fig. 11.4: StringStartEnd.java
2 // String methods startsWith and endsWith.
3 import javax.swing.*;
4
5 public class StringStartEnd {
6
7 public static void main( String args[ ] )
8 {
9 String strings[ ] = { "started", "starting", "ended", "ending" };
10 String output = "";
11
12 // test method startsWith
13 for ( int count = 0; count < strings.length; count++ )
14
15 if ( strings[ count ].startsWith( "st" ) )
16 output += "\"" + strings[ count ] + "\" starts with \"st\"\n";
17
18 output += "\n";
19
20 // test method startsWith starting from position
21 // 2 of the string
22 for ( int count = 0; count < strings.length; count++ )
23
24 if ( strings[ count ].startsWith( "art", 2 ) )
25 output += "\"" + strings[ count ] + "\" starts with \"art\" at position 2\n";
26
27
28 output += "\n";
29
30 // test method endsWith
31 for ( int count = 0; count < strings.length; count++ )
32
33 if ( strings[ count ].endsWith( "ed" ) )
34 output += "\"" + strings[ count ] + "\" ends with \"ed\"\n";
35
36 JOptionPane.showMessageDialog( null, output,
37 "String Class Comparisons", JOptionPane.INFORMATION_MESSAGE );
38
39 System.exit( 0 );
40 }
41
42 } // end class StringStartEnd
Line 15 Method startsWith determines if String starts with specified characters
Line 24 Method startsWith determines if String starts with specified characters
Line 33 Method endsWith determines if String ends with specified characters
11.3.4 Locating Characters and Substrings in Strings
• Search for characters in String
– Method indexOf
stringname.indexOf(“string”,[startposition])
– Method lastIndexOf
stringname.lastIndexOf(“string”,[lengthstring])
1 // Fig. 11.5: StringIndexMethods.java
2 // String searching methods indexOf and lastIndexOf.
3 import javax.swing.*;
4
5 public class StringIndexMethods {
6
7 public static void main( String args[] )
8 {
9 String letters = "abcdefghijklmabcdefghijklm";
10
11 // test indexOf to locate a character in a string
12 String output = "'c' is located at index " + letters.indexOf( 'c' );
13
14 output += "\n'a' is located at index " + letters.indexOf( 'a', 1 );
15
16 output += "\n'$' is located at index " + letters.indexOf( '$' );
17
18 // test lastIndexOf to find a character in a string
19 output += "\n\nLast 'c' is located at index " + letters.lastIndexOf( 'c' );
20
21
22 output += "\nLast 'a' is located at index " + letters.lastIndexOf( 'a', 25 );
23
24
25 output += "\nLast '$' is located at index " + letters.lastIndexOf( '$' );
26
27
28 // test indexOf to locate a substring in a string
29 output += "\n\n\"def\" is located at index " + letters.indexOf( "def" );
30
31
32 output += "\n\"def\" is located at index " + letters.indexOf( "def", 7 );
33
34
35 output += "\n\"hello\" is located at index " + letters.indexOf( "hello" );
36
37
38 // test lastIndexOf to find a substring in a string
39 output += "\n\nLast \"def\" is located at index " + letters.lastIndexOf( "def" );
40
41
42 output += "\nLast \"def\" is located at index " + letters.lastIndexOf( "def", 25 );
43
44
45 output += "\nLast \"hello\" is located at index " + letters.lastIndexOf( "hello" );
46
47
48 JOptionPane.showMessageDialog( null, output,
49 "String searching methods", JOptionPane.INFORMATION_MESSAGE );
50
51 System.exit( 0 );
52 }
53
54 } // end class StringIndexMethods
Lines 12-16 Method indexOf finds first occurrence of character in String
Lines 19-26 Method lastIndexOf finds last occurrence of character in String
Lines 29-46 Methods indexOf and lastIndexOf can also find occurrences of substrings
11.3.5 Extracting Substrings from Strings
• Create Strings from other Strings
– Method substring
stringname.substring(startingfrom,numbercaracters)
1 // Fig. 11.6: SubString.java
2 // String class substring methods.
3 import javax.swing.*;
4
5 public class SubString {
6
7 public static void main( String args[ ] )
8 {
9 String letters = "abcdefghijklmabcdefghijklm";
10
11 // test substring methods
12 String output = "Substring from index 20 to end is " + "\"" + letters.substring( 20 ) + "\"\n";
13
14
15 output += "Substring from index 3 up to 6 is " + "\"" + letters.substring( 3, 6 ) + "\"";
16
17
18 JOptionPane.showMessageDialog( null, output,
19 "String substring methods", JOptionPane.INFORMATION_MESSAGE );
20
21 System.exit( 0 );
22 }
23
24 } // end class SubString
Line 13 Beginning at index 20, extract characters from String letters
Line 16 Extract characters from index 3 to 6 from String letters
11.3.6 Concatenating Strings
• Method concat
– Concatenate two String objects
1 // Fig. 11.7: StringConcatenation.java
2 // String concat method.
3 import javax.swing.*;
4
5 public class StringConcatenation {
6
7 public static void main( String args[ ] )
8 {
9 String s1 = new String( "Happy " );
10 String s2 = new String( "Birthday" );
11
12 String output = "s1 = " + s1 + "\ns2 = " + s2;
13
14 output += "\n\nResult of s1.concat( s2 ) = " + s1.concat( s2 );
15 output += "\ns1 after concatenation = " + s1;
16
17 JOptionPane.showMessageDialog( null, output,
18 "String method concat", JOptionPane.INFORMATION_MESSAGE );
19
20 System.exit( 0 );
21 }
22
23 } // end class StringConcatenation
Line 14 Concatenate String s2 to String s1
Line 15 However, String s1 is not modified by method concat
11.3.7 Miscellaneous String Methods
• Miscellaneous String methods
– Return modified copies of String
– Return character array
1 // Fig. 11.8: StringMiscellaneous2.java
2 // String methods replace, toLowerCase, toUpperCase, trim and toCharArray.
3 import javax.swing.*;
4
5 public class StringMiscellaneous2 {
6
7 public static void main( String args[] )
8 {
9 String s1 = new String( "hello" );
10 String s2 = new String( "GOODBYE" );
11 String s3 = new String( " spaces " );
12
13 String output = "s1 = " + s1 + "\ns2 = " + s2 + "\ns3 = " + s3;
14
15 // test method replace
16 output += "\n\nReplace 'l' with 'L' in s1: " + s1.replace( 'l', 'L' );
17
18
19 // test toLowerCase and toUpperCase
20 output += "\n\ns1.toUpperCase() = " + s1.toUpperCase() + "\ns2.toLowerCase() = " + s2.toLowerCase();
21
22
23 // test trim method
24 output += "\n\ns3 after trim = \"" + s3.trim() + "\"";
25
26 // test toCharArray method
27 char charArray[] = s1.toCharArray();
28 output += "\n\ns1 as a character array = ";
29
30 for ( int count = 0; count < charArray.length; ++count )
31 output += charArray[ count ];
32
33 JOptionPane.showMessageDialog( null, output,
34 "Additional String methods", JOptionPane.INFORMATION_MESSAGE );
35
36 System.exit( 0 );
37 }
38
39 } // end class StringMiscellaneous2
Line 17 Use method replace to return s1 copy in which every occurrence of ‘l’ is replaced with ‘L’
Line 20 Use method toUpperCase to return s1 copy in which every character is uppercase
Line 21 Use method toLowerCase to return s2 copy in which every character is uppercase
Line 24 Use method trim to return s3 copy in which whitespace is eliminated
Line 27 Use method toCharArray to return character array of s1
11.4 Class StringBuffer
• Class StringBuffer
– When String object is created, its contents cannot change
– StringBuffer: used for creating and manipulating dynamic string data
• i.e., modifiable Strings
• Can store characters based on capacity
– Capacity expands dynamically to handle additional characters
• Uses operators + and += for String concatenation
11.4.1 StringBuffer Constructors
• Three StringBuffer constructors
– Default creates StringBuffer with no characters
• Capacity of 16 characters
1 // Fig. 11.10: StringBufferConstructors.java
2 // StringBuffer constructors.
3 import javax.swing.*;
4
5 public class StringBufferConstructors {
6
7 public static void main( String args[ ] )
8 {
9 StringBuffer buffer1 = new StringBuffer();
10 StringBuffer buffer2 = new StringBuffer( 10 );
11 StringBuffer buffer3 = new StringBuffer( "hello" );
12
13 String output = "buffer1 = \"" + buffer1.toString() + "\"" +
14 "\nbuffer2 = \"" + buffer2.toString() + "\"" + "\nbuffer3 = \"" + buffer3.toString() + "\"";
15
16
17 JOptionPane.showMessageDialog( null, output,
18 "StringBuffer constructors", JOptionPane.INFORMATION_MESSAGE );
19
20 System.exit( 0 );
21 }
22
23 } // end class StringBufferConstructors
Line 9 Default constructor creates empty StringBuffer with capacity of 16 characters
Line 10 Second constructor creates empty StringBuffer with capacity of specified (10) characters
Line 11 Third constructor creates StringBuffer with String “hello” and capacity of 16 characters
Lines 13-15 Method toString returns String representation of StringBuffer
11.4.2 StringBuffer Methods length, capacity, setLength and ensureCapacity
• Method length
– Return StringBuffer length
• Method capacity
– Return StringBuffer capacity
• Method setLength
– Increase or decrease StringBuffer length
• Method ensureCapacity
– Set StringBuffer capacity
– Guarantee that StringBuffer has minimum capacity
1 // Fig. 11.11: StringBufferCapLen.java
2 // StringBuffer length, setLength, capacity and ensureCapacity methods.
3 import javax.swing.*;
4
5 public class StringBufferCapLen {
6
7 public static void main( String args[ ] )
8 {
9 StringBuffer buffer = new StringBuffer( "Hello, how are you?" );
10
11 String output = "buffer = " + buffer.toString() + "\nlength = " +
12 buffer.length() + "\ncapacity = " + buffer.capacity();
13
14 buffer.ensureCapacity( 75 );
15 output += "\n\nNew capacity = " + buffer.capacity();
16
17 buffer.setLength( 10 );
18 output += "\n\nNew length = " + buffer.length() + "\nbuf = " + buffer.toString();
19
20
21 JOptionPane.showMessageDialog( null, output,
22 "StringBuffer length and capacity Methods", JOptionPane.INFORMATION_MESSAGE );
23
24
25 System.exit( 0 );
26 }
27
28 } // end class StringBufferCapLen
Line 12 Method length returns StringBuffer length
Line 12 Method capacity returns StringBuffer capacity
Line 14 Use method ensureCapacity to set capacity to 75
Line 17 Use method setLength to set length to 10
Only 10 characters from StringBuffer are printed
11.4.3 StringBuffer append Methods
• Method append
– Allow data values to be added to StringBuffer
1 // Fig. 11.13: StringBufferAppend.java
2 // StringBuffer append methods.
3 import javax.swing.*;
4
5 public class StringBufferAppend {
6
7 public static void main( String args[ ] )
8 {
9 Object objectRef = "hello";
10 String string = "goodbye";
11 char charArray[ ] = { 'a', 'b', 'c', 'd', 'e', 'f' };
12 boolean booleanValue = true;
13 char characterValue = 'Z';
14 int integerValue = 7;
15 long longValue = 10000000;
16 float floatValue = 2.5f; // f suffix indicates 2.5 is a float
17 double doubleValue = 33.333;
18 StringBuffer lastBuffer = new StringBuffer( "last StringBuffer" );
19 StringBuffer buffer = new StringBuffer();
20
21 buffer.append( objectRef );
22 buffer.append( " " ); // each of these contains two spaces
23 buffer.append( string );
24 buffer.append( " " );
25 buffer.append( charArray );
26 buffer.append( " " );
27 buffer.append( charArray, 0, 3 );
28 buffer.append( " " );
29 buffer.append( booleanValue );
30 buffer.append( " " );
31 buffer.append( characterValue );
32 buffer.append( " " );
33 buffer.append( integerValue );
34 buffer.append( " " );
35 buffer.append( longValue );
36 buffer.append( " " );
37 buffer.append( floatValue );
38 buffer.append( " " );
39 buffer.append( doubleValue );
40 buffer.append( " " );
41 buffer.append( lastBuffer );
42
43 JOptionPane.showMessageDialog( null,
44 "buffer = " + buffer.toString(), "StringBuffer append Methods", JOptionPane.INFORMATION_MESSAGE );
45
46
47 System.exit( 0 );
48 }
49
50 } // end StringBufferAppend
Line 21 Append String “hello” to StringBuffer
Line 23 Append String “goodbye”
Line 25 Append “a b c d e f”
Line 27 Append “a b c”
Line 29-39 Append boolean, char, int, long, float and double
11.4.4 StringBuffer Insertion and Deletion Methods
• Method insert
– Allow data-type values to be inserted into StringBuffer
• Methods delete and deleteCharAt
– Allow characters to be removed from StringBuffer
1 // Fig. 11.14: StringBufferInsert.java
2 // StringBuffer methods insert and delete.
3 import javax.swing.*;
4
5 public class StringBufferInsert {
6
7 public static void main( String args[ ] )
8 {
9 Object objectRef = "hello";
10 String string = "goodbye";
11 char charArray[ ] = { 'a', 'b', 'c', 'd', 'e', 'f' };
12 boolean booleanValue = true;
13 char characterValue = 'K';
14 int integerValue = 7;
15 long longValue = 10000000;
16 float floatValue = 2.5f; // f suffix indicates that 2.5 is a float
17 double doubleValue = 33.333;
18 StringBuffer buffer = new StringBuffer();
19
20 buffer.insert( 0, objectRef );
21 buffer.insert( 0, " " ); // each of these contains two spaces
22 buffer.insert( 0, string );
23 buffer.insert( 0, " " );
24 buffer.insert( 0, charArray );
25 buffer.insert( 0, " " );
26 buffer.insert( 0, charArray, 3, 3 );
27 buffer.insert( 0, " " );
28 buffer.insert( 0, booleanValue );
29 buffer.insert( 0, " " );
30 buffer.insert( 0, characterValue );
31 buffer.insert( 0, " " );
32 buffer.insert( 0, integerValue );
33 buffer.insert( 0, " " );
34 buffer.insert( 0, longValue );
35 buffer.insert( 0, " " );
36 buffer.insert( 0, floatValue );
37 buffer.insert( 0, " " );
38 buffer.insert( 0, doubleValue );
39
40 String output = "buffer after inserts:\n" + buffer.toString();
41
42 buffer.deleteCharAt( 10 ); // delete 5 in 2.5
43 buffer.delete( 2, 6 ); // delete .333 in 33.333
44
45 output += "\n\nbuffer after deletes:\n" + buffer.toString();
46
47 JOptionPane.showMessageDialog( null, output,
48 "StringBuffer insert/delete", JOptionPane.INFORMATION_MESSAGE );
49
50 System.exit( 0 );
51 }
52
53 } // end class StringBufferInsert
Lines 20-26 Use method insert to insert data in beginning of StringBuffer
Lines 27-38 Use method insert to insert data in beginning of StringBuffer
Line 42 Use method deleteCharAt to remove character from index 10 in StringBuffer
Line 43 Remove characters from indices 2 through 5 (inclusive)
