Chapter 9 Strings

1
 Motivations

Often you encounter the problems that involve string processing and file
input and output. Suppose you need to write a program to replace all
occurrences of a word with a new word in a file. How do you solve this
problem? This chapter introduces strings and text files, which will enable
you to solve this problem.

2
 Objectives
 To use the String class to process fixed strings (§9.2).
 To construct strings (§9.2.1).
 To understand that strings are immutable and to create an interned string (§9.2.2).
 To compare strings (§9.2.3).
 To get string length and characters, and combine strings (§9.2.4).
 To obtain substrings (§9.2.5).
 To convert, replace, and split strings (§9.2.6).
 To match, replace, and split strings by patterns (§9.2.7).
 To search for a character or substring in a string (§9.2.8).
 To convert between a string and an array (§9.2.9).
 To convert characters and numbers into a string (§9.2.10).
 To obtain a formatted string (§9.2.11).
 To check whether a string is a palindrome (§9.3).
 To convert hexadecimal numbers to decimal numbers (§9.4).
 To use the Character class to process a single character (§9.5).
 To use the StringBuilder and StringBuffer classes to process flexible strings (§9.6).
 To distinguish among the String, StringBuilder, and StringBuffer classes (§9.2–9.6).
 To learn how to pass arguments to the main method from the command line (§9.7).

3
 The String Class
• Constructing a String:
– String message = "Welcome to Java“;
– String message = new String("Welcome to Java“);
– String s = new String();
• Obtaining String length and Retrieving Individual Characters in a string
• String Concatenation (concat)
• Substrings (substring(index), substring(start, end))
• Comparisons (equals, compareTo)
• String Conversions
• Finding a Character or a Substring in a String
• Conversions between Strings and Arrays
• Converting Characters and Numeric Values to Strings

4
 Chapter 9 : Strings
Objectives
 To use the String class to process fixed strings
 To construct strings
 To understand that strings are immutable and to create an interned string
 To compare strings
 To get string length and characters, and combine strings
 To obtain substrings
 To convert, replace, and split strings

5
 Constructing Strings
A String can be constructed by either:
1- via the "new" operator and constructor, similar to any other classes. However, this is not commonly-used
and is not recommended.
2- directly assigning a string literal to a String reference - just like a primitive

For example:
1. String newString = new String(stringLiteral);
String message = new String("Welcome to Java"); // Explicit construction via new

2. Since strings are used frequently, Java provides a shorthand initializer for
creating a string:
String message = "Welcome to Java"; // Implicit construction via string literal

7
 Strings Are Immutable
A String object is immutable; its contents s: ref String Object:
cannot be changed. Does the following code
Solution: Java
?change the contents
If the contents of have
of a String the string
to be modified frequently, use the StringBuffer
String Object:
or StringBuilder
;"String s = "Java class instead. HTML
;"s = "HTML String Object:
Hello123456
Because String is immutable, it is not efficient to use String if you need to modify your
String Object:
string frequently (that would create many new Strings occupying new storage areas).
Hello12345
For example,

String Object:
str: ref String Object:

Hello1234 Hello
String Object:
String Object: String Object:

Hello123 Hello12 Hello1

8
 Trace Code
;"String s = "Java
;"s = "HTML

After executing String s = "Java"; After executing s = "HTML";

s : String s : String This string object

is now
String object for "Java" String object for "Java" unreferenced

Contents cannot be changed : String

String object for "HTML"

9
 String Literal vs. String Object

Interned Strings
As mentioned, there are two ways to construct a string: implicit construction by assigning
Since strings
a string literalare
orimmutable and area frequently
explicitly creating used,
String object via to
theimprove efficiency
new operator andand save memory,
constructor.
the
For JVM uses a unique instance for string literals with the same character sequence. Such an
example,
instance is called interned.
interned object
String s1 = "Hello"; // String literal
String s2 = new String("Hello"); // String
object
ref
String s3 = "Hello"; // String literal s2 s4 ref

String s4 = new String("Hello"); // String s1 ref

object s3 ref
String s5 = s1 // same reference
s1 == s1; // true, same pointer s5 ref
s1 == s3; // true, s1 and s3 share storage in common pool
s1 == s5; // true, s5 is assigned same pointer as s1 "Hello S2:String S4:String
s1 == s4; // false, different pointers "
“Hello” “Hello”
s1.equals(s4); // true, same contents
s1.equals(s3); // true, same contents
s2 == s4; // false, different pointers in heap
Common Pool for String Literals Heap
s2.equals(s4);
10
// true, same contents
 Examples
String s1 = "Welcome to Java"; s1
: String
s3
String s2 = new String("Welcome to Java"); Interned string object
for "Welcome to Java"
String s3 = "Welcome to Java";

System.out.println("s1 == s2 is " + (s1 == s2)); s2 : String

System.out.println("s1 == s3 is " + (s1 == s3));
A string object for
"Welcome to Java"

Display A new object is created if you use the new

operator.
s1 == s2 is false
If you use the string initializer, no new object is
s1 == s3 is true created if the interned object is already created.

11
 String Comparisons
java.lang.String
+equals(s1: Object): boolean Returns true if this string is equal to string s1.
+equalsIgnoreCase(s1: String): Returns true if this string is equal to string s1 case-
boolean insensitive.
+compareTo(s1: String): int Returns an integer greater than 0, equal to 0, or less than 0
to indicate whether this string is greater than, equal to, or
less than s1.
+compareToIgnoreCase(s1: String): Same as compareTo except that the comparison is case-
int insensitive.
+regionMatches(toffset: int, s1: String, Returns true if the specified subregion of this string exactly
offset: int, len: int): boolean matches the specified subregion in string s1.
+regionMatches(ignoreCase: boolean, Same as the preceding method except that you can specify
toffset: int, s1: String, offset: int, whether the match is case-sensitive.
len: int): boolean
+startsWith(prefix: String): boolean Returns true if this string starts with the specified prefix.
+endsWith(suffix: String): boolean Returns true if this string ends with the specified suffix.
12
 String Comparisons
• equals if
(s1.equalsIgnoreCase(s2))
String s1 = new String("Welcome");
String s2 = "welcome";
if (s1.equals(s2)){
// s1 and s2 have the same contents
}
if (s1 == s2) {
// s1 and s2 have the same reference
}

13
 String Comparisons, cont.
• compareTo(Object object)
if (s1.compareToIgnoreCase(s2)>0)
String s1 = new String("Welcome");
String s2 = "welcome";
if (s1.compareTo(s2) > 0) {
// s1 is greater than s2
}
else if (s1.compareTo(s2) == 0) {
// s1 and s2 have the same contents
}
else
// s1 is less than s2
}
14
import java.util.Scanner;
public class StringComp {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String string1, string2;
System.out.print("Enter a String: ");
string1 = sc.next();
System.out.print("Enter another String: ");
string2 = sc.next();
int comparison = string1.compareTo(string2);
// check comparison
if (comparison < 0)
System.out.println(string1 + "comes before" + string2 + " in the
alphabet");
else if (comparison > 0)
System.out.println(string1 + " comes after " + string2 + " in the
alphabet");
}
}
Enter a String: hello

Enter another String: goodbye

hello comes after goodbye in the alphabet

RUN
 String Length, Characters, and
Combining Strings
java.lang.String
+length(): int Returns the number of characters in this string.
+charAt(index: int): char Returns the character at the specified index from this string.
+concat(s1: String): String Returns a new string that concatenate this string with string s1.
string.

17
 Finding String Length
Finding string length using the length() method:
String message = "Welcome";
int size= message.length(); // (returns 7)

18
 Retrieving Individual Characters in a String
String message = "Welcome to Java";
To get the first character from this string:
Do not use message[0]
Use message.charAt(index)
Index starts from 0

Indices 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14

message W e l c o m e t o J a v a

message.charAt(0) message.length() is 15 message.charAt(14)

19
 String Concatenation
String s3 = s1.concat(s2);

String s3 = s1 + s2;

s1 + s2 + s3 + s4 + s5 same as
(((s1.concat(s2)).concat(s3)).concat(s4)).concat(s5);

20
 Extracting Substrings
java.lang.String
+substring(beginIndex: int): Returns this string’s substring that begins with the character at
String the specified beginIndex and extends to the end of the string,
as shown in Figure 9.6.
+substring(beginIndex: int, Returns this string’s substring that begins at the specified
endIndex: int): String beginIndex and extends to the character at index endIndex –
1, as shown in Figure 9.6. Note that the character at endIndex
is not part of the substring.

21
 Extracting Substrings
You can extract a single character from a string using the charAt method.
You can also extract a substring from a string using the substring method in
the String class.

String message = "Welcome to Java";

String s2 = message.substring(0, 11) + "HTML";

Indices 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14

message W e l c o m e t o J a v a

message.substring(0, 11) message.substring(11)

Figure 9.6 The substring method obtains a substring from a string.

22
 Converting, Replacing, and Splitting
Strings
java.lang.String
+toLowerCase(): String Returns a new string with all characters converted to lowercase.
+toUpperCase(): String Returns a new string with all characters converted to uppercase.
+trim(): String Returns a new string with blank characters trimmed on both sides.
+replace(oldChar: char, Returns a new string that replaces all matching character in this
newChar: char): String string with the new character.
+replaceFirst(oldString: String, Returns a new string that replaces the first matching substring in
newString: String): String this string with the new substring.
+replaceAll(oldString: String, Returns a new string that replace all matching substrings in this
newString: String): String string with the new substring.
+split(delimiter: String): Returns an array of strings consisting of the substrings split by the
String[] delimiter.

23
 Examples
"Welcome".toLowerCase() returns a new string, welcome.
"Welcome".toUpperCase() returns a new string, WELCOME.
" Welcome ".trim() returns a new string, Welcome.
"Welcome".replace('e', 'A') returns a new string, WAlcomA.
"Welcome".replaceFirst("e", "AB") returns a new string, WABlcome.
"Welcome".replaceAll("e", "AB") returns a new string, WABlcomAB.
"Welcome".replaceAll("el", "AB") returns a new string, WABcome.

24
 Splitting a String
String[] tokens = "Java#HTML#Perl".split("#");
for (int i = 0; i < tokens.length; i++)
System.out.print(tokens[i] + " ");

tokens: ref Java tokens[0]

displays
HTML tokens[1]
Java HTML Perl Perl tokens[2]

25
import java.util.*;
public class StringTest{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String str = new String();
System.out.print("Enter a string: ");
str = sc.next();
System.out.println("The length of the string is " + str.length() );
System.out.println("The character at position 3 is " +
str.charAt(2) );
System.out.println("Characters 2 to 4 are " + str.substring(1,4) );
System.out.println( str.concat(" was the string entered") );
System.out.println("This is upper case: " + str.toUpperCase() );
System.out.println("This is lower case: " + str.toLowerCase() );
}
}
Enter a string: Europe

The length of the string is 6

The character at position 3 is r
Characters 2 to 4 are uro
Europe was the string entered
This is upper case: EUROPE
This is lower case: europe

RUN
Exercise:
Define a method static String repeatEnd(String str, int n)
Given a string str and an int n, return a string made of n repetitions of the last n
characters of the string str. You may assume that n is between 0 and the length of the
string, inclusive.
repeatEnd("Hello", 3) → "llollollo"
repeatEnd("Hello", 2) → "lolo“
repeatEnd("Hello", 1) → "o"

28
 Thank You for Watching

29
Chapter 9- Part2 : Strings

- Matching, Replacing and Splitting by Patterns

- Finding a Character or a Substring in a String
- Problem: Finding Palindromes

30
 Matching, Replacing and Splitting by Patterns
You can match, replace, or split a string by specifying a pattern. This is an
extremely useful and powerful feature, commonly known as regular
expression
. A regular expression (abbreviated regex) is a string that describes
a pattern for matching a set of strings
• . Regular expression is complex to beginning students. For this
reason, two simple patterns are used in this section. Please refer to
Supplement III.F, “Regular Expressions,” for further studies.

"Java".matches("Java");
"Java".equals("Java");
"Java is fun".matches("Java.*");
"Java is cool".matches("Java.*");
31
 Regular Expression Syntax
Regular Expression Matches Example

x a specified character x Java matches Java

. any single character Java matches J..a
(ab|cd) a, b, or c ten matches t(en|im]
[abc] a, b, or c Java matches Ja[uvwx]a
[^abc] any character except Java matches Ja[^ars]a
a, b, or c
[a-z] a through z Java matches [A-M]av[a-d]
[^a-z] any character except Java matches Jav[^b-d]
a through z
[a-e[m-p]] a through e or Java matches
m through p [A-G[I-M]]av[a-d]
[a-e&&[c-p]] intersection of a-e Java matches
with c-p [A-P&&[I-M]]av[a-d]

\d a digit, same as [1-9] Java2 matches "Java[\\d]"

\D a non-digit $Java matches "[\\D][\\D]ava"
\w a word character Java matches "[\\w]ava"
\W a non-word character $Java matches "[\\W][\\w]ava"
\s a whitespace character "Java 2" matches "Java\\s2"
\S a non-whitespace char Java matches "[\\S]ava"

p* zero or more Java matches "[\\w]*"

occurrences of pattern p
p+ one or more Java matches "[\\w]+"
occurrences of pattern p
p? zero or one Java matches "[\\w]?Java"
occurrence of pattern p Java matches "[\\w]?ava"
p{n} exactly n Java matches "[\\w]{4}"
occurrences of pattern p
p{n,} at least n Java matches "[\\w]{3,}"
occurrences of pattern p
p{n,m} between n and m Java matches "[\\w]{1,9}"
occurrences (inclusive)

32
 Matching, Replacing and Splitting by Patterns

The following statement evaluates to true.

"440-02-4534".matches("\\d{3}-\\d{2}-\\d{4}" )

Here \\d represents a single digit, and \\d{3} represents three digits.

33
 Matching, Replacing and Splitting by Patterns
The replaceAll, replaceFirst, and split methods can be used with a regular expression.
For example, the following statement returns a new string that replaces $, +, or # in
"a+b$#c" by the string NNN.

String s = "a+b$#c".replaceAll("[$+#]", "NNN");

System.out.println(s);

Here the regular expression [$+#] specifies a pattern that matches $, +, or #. So,
the output is aNNNbNNNNNNc.

34
 Matching, Replacing and Splitting by Patterns
The following statement splits the string into an array of strings
delimited by some punctuation marks.

String[] tokens = "Java,C?C#,C+

+".split("[.,:;?]");

for (int i = 0; i < tokens.length; i++)

System.out.println(tokens[i]);

The string is split into:

Java, C, C#, and C++ which are stored in array tokens.

35
 Finding a Character or a Substring in a
String
java.lang.String
+indexOf(ch: char): int Returns the index of the first occurrence of ch in the string.
Returns -1 if not matched.
+indexOf(ch: char, fromIndex: Returns the index of the first occurrence of ch after fromIndex in
int): int the string. Returns -1 if not matched.
+indexOf(s: String): int Returns the index of the first occurrence of string s in this string.
Returns -1 if not matched.
+indexOf(s: String, fromIndex: Returns the index of the first occurrence of string s in this string
int): int after fromIndex. Returns -1 if not matched.
+lastIndexOf(ch: int): int Returns the index of the last occurrence of ch in the string.
Returns -1 if not matched.
+lastIndexOf(ch: int, Returns the index of the last occurrence of ch before fromIndex
fromIndex: int): int in this string. Returns -1 if not matched.
+lastIndexOf(s: String): int Returns the index of the last occurrence of string s. Returns -1 if
not matched.
+lastIndexOf(s: String, Returns the index of the last occurrence of string s before
fromIndex: int): int fromIndex. Returns -1 if not matched.

36
 Finding a Character or a
Substring in a String

"Welcome to Java".indexOf('W') returns 0.

"Welcome to Java".indexOf('x') returns -1.
"Welcome to Java".indexOf('o', 5) returns 9.
"Welcome to Java".indexOf("come") returns 3.
"Welcome to Java".indexOf("Java", 5) returns 11.
"Welcome to Java".indexOf("java", 5) returns -1.
"Welcome to Java".lastIndexOf('a') returns 14.

37
 Convert Character and Numbers
to Strings
The String class provides several static valueOf methods for
converting a character, an array of characters, and numeric values
to strings.
These methods have the same name valueOf with different
argument types char, char[], double, long, int, and float.
For example:
to convert a double value to a string, use String.valueOf(5.44).
The return value is string consists of characters “5.44”
38
 Problem: Finding Palindromes
• Objective: Checking whether a string is a
palindrome: a string that reads the same forward
and backward.

39
import java.util.Scanner;
public class CheckPalindrome { Example to find Palindromes
/** Main method */
public static void main(String[] args) {
// Create a Scanner
Scanner input = new Scanner(System.in); 0 1 2 3 4
// Prompt the user to enter a string m a d a m
System.out.print("Enter a string: ");
String s = input.nextLine();
if (isPalindrome(s))
System.out.println(s + " is a palindrome");
else
System.out.println(s + " is not a palindrome");
}
/** Check if a string is a palindrome */
public static boolean isPalindrome(String s) {
// The index of the first character in the string
int low = 0;
// The index of the last character in the string
int high = s.length() - 1;
0 1 2 3 4
while (low < high) { m a d a m
if (s.charAt(low) != s.charAt(high))
return false; // Not a palindromelow high
low++;
high--;
}
return true; // The string is a palindrome
} }
 Thank You for Watching

42
 Java.lang.Character Class in Java

Java provides a wrapper class Character in java.lang package. An object of type

Character contains a single field, whose type is char.

Creating a Character object :

Character ch = new Character('a');

The above statement creates a Character object which contain 'a' of type char.
There is only one constructor in Character class which expect an argument of char data
type.

43
 The Character Class

java.lang.Character

+Character(value: char) Constructs a character object with char value

+charValue(): char Returns the char value from this object
+compareTo(anotherCharacter: Character): int Compares this character with another
+equals(anotherCharacter: Character): boolean Returns true if this character equals to another
+isDigit(ch: char): boolean Returns true if the specified character is a digit
+isLetter(ch: char): boolean Returns true if the specified character is a letter
+isLetterOrDigit(ch: char): boolean Returns true if the character is a letter or a digit
+isLowerCase(ch: char): boolean Returns true if the character is a lowercase letter
+isUpperCase(ch: char): boolean Returns true if the character is an uppercase letter
+toLowerCase(ch: char): char Returns the lowercase of the specified character
+toUpperCase(ch: char): char Returns the uppercase of the specified character
44
 Examples
Character charObject = new Character('b');

charObject.compareTo(new Character('a')) //returns 1

charObject.compareTo(new Character('b')) //returns 0
charObject.compareTo(new Character('c')) //returns -1
charObject.compareTo(new Character('d') ///returns –2
charObject.equals(new Character('b')) //returns true
charObject.equals(new Character('d')) //returns false

45
boolean isLetter(char ch) : This method is used to determine whether the specified
char value(ch) is a letter or not. The method will return true if it is letter([A-Z],[a-
z]), otherwise return false. In place of character, we can also pass ASCII value as an
argument as char to int is implicitly typecasted in java.

public class Test {

public static void main(String[] args) {

System.out.println(Character.isLetter('A'));

System.out.println(Character.isLetter('0'));
}
}

true
false

46
boolean isDigit(char ch) : This method is used to determine whether the specified
char value(ch) is a digit or not. Here also we can pass ASCII value as an argument.
public class Test{
public static void main(String[] args) {

// print false as A is character

System.out.println(Character.isDigit('A'));

System.out.println(Character.isDigit('0'));

}
}

false
true

47
boolean isWhitespace(char ch) : It determines whether the specified char
value(ch) is white space. A whitespace includes space, tab, or new line.
public class Test{

public static void main(String[] args) {

System.out.println(Character.isWhitespace('A'));
System.out.println(Character.isWhitespace(' '));
System.out.println(Character.isWhitespace('\n'));
System.out.println(Character.isWhitespace('\t'));

//ASCII value of tab

System.out.println(Character.isWhitespace(9));
Output:
false
System.out.println(Character.isWhitespace('9'));
} true
} true
true
true
false
48
char toUpperCase(char ch) : It returns the uppercase of the specified char
value(ch). If an ASCII value is passed, then the ASCII value of it’s uppercase will be
returned.
public class Test{

public static void main(String[] args) {

System.out.println(Character.toUpperCase('a'));
System.out.println(Character.toUpperCase(97));
System.out.println(Character.toUpperCase(48)); }
}

Output:
A
65
48

49
 Problem: Counting Each Letter in
a String
This example gives a program that counts the number of
occurrence of each letter in a string. Assume the letters
are not case-sensitive.

50
import java.util.Scanner;
Example of Counting Each Letter in a String
public class CountEachLetter {
/** Main method */
public static void main(String[] args) {
// Create a Scanner
Scanner input = new Scanner(System.in);
// Prompt the user to enter a string
System.out.print("Enter a string: ");
String s = input.nextLine();
// Invoke the countLetters method to count each letter
int[] counts = countLetters(s.toLowerCase());
// Display results
for (int i = 0; i < counts.length; i++) {
if (counts[i] != 0)
System.out.println((char)('a' + i) + " appears " +
counts[i] + ((counts[i] == 1) ? " time" : " times")); } }
 Counts[0] 2
0
1
Counts[1] 3
2
0
1
/** Count each letter in the string */ Counts[2] 0
1
Counts[3] 1
0
public static int[] countLetters(String s) { Counts[4] 0
int[] counts = new int[26]; Counts[5] 0
Counts[6] 0
for (int i = 0; i < s.length(); i++) { Counts[7] 0
Counts[8] 0
if (Character.isLetter(s.charAt(i)))
Counts[9] 0
counts[s.charAt(i) - 'a']++; Assume s is Counts[10] 0
Counts[11] 0
} “adba2bzbc” Counts[12] 0
0
return counts; Counts[13]
Counts[14] 0
} Counts[15] 0
Counts[16] 0
0 1 2 3 4 5 6 7 8 Counts[17] 0
Counts[18] 0
a d b a 2 b z b c Counts[19] 0
Counts[20] 0
Counts[21] 0
0
i Counts[22]
0
Counts[23]
Counts[24] 0
Counts[25] 01
 Thank You for Watching

53
 StringBuilder and StringBuffer
The StringBuilder/StringBuffer class is
an alternative to the String class. In general, a
StringBuilder/StringBuffer can be used wherever a
string is used. StringBuilder/StringBuffer is more
flexible than String. You can add, insert, or
append new contents into a string buffer, whereas
the value of a String object is fixed once the string
is created.

54
 StringBuilder Constructors
java.lang.StringBuilder

+StringBuilder() Constructs an empty string builder with capacity 16.

+StringBuilder(capacity: int) Constructs a string builder with the specified capacity.
+StringBuilder(s: String) Constructs a string builder with the specified string.

55
 Modifying Strings in the Builder
java.lang.StringBuilder

+append(data: char[]): StringBuilder Appends a char array into this string builder.
+append(data: char[], offset: int, len: int): Appends a subarray in data into this string builder.
StringBuilder
+append(v: aPrimitiveType): StringBuilder Appends a primitive type value as a string to this
builder.
+append(s: String): StringBuilder Appends a string to this string builder.
+delete(startIndex: int, endIndex: int): Deletes characters from startIndex to endIndex.
StringBuilder
+deleteCharAt(index: int): StringBuilder Deletes a character at the specified index.
+insert(index: int, data: char[], offset: int, Inserts a subarray of the data in the array to the builder
len: int): StringBuilder at the specified index.
+insert(offset: int, data: char[]): Inserts data into this builder at the position offset.
StringBuilder
+insert(offset: int, b: aPrimitiveType): Inserts a value converted to a string into this builder.
StringBuilder
+insert(offset: int, s: String): StringBuilder Inserts a string into this builder at the position offset.
+replace(startIndex: int, endIndex: int, s: Replaces the characters in this builder from startIndex
String): StringBuilder to endIndex with the specified string.
+reverse(): StringBuilder Reverses the characters in the builder.
+setCharAt(index: int, ch: char): void Sets a new character at the specified index in this
builder.

56
 Examples
stringBuilder.append("Java");
stringBuilder.insert(11, "HTML and ");
stringBuilder.delete(8, 11) changes the builder to Welcome Java.
stringBuilder.deleteCharAt(8) changes the builder to Welcome o Java.
stringBuilder.reverse() changes the builder to avaJ ot emocleW.
stringBuilder.replace(11, 15, "HTML")
changes the builder to Welcome to HTML.
stringBuilder.setCharAt(0, 'w') sets the builder to welcome to Java.

57
 The toString, capacity, length,
setLength, and charAt Methods
java.lang.StringBuilder

+toString(): String Returns a string object from the string builder.

+capacity(): int Returns the capacity of this string builder.
+charAt(index: int): char Returns the character at the specified index.
+length(): int Returns the number of characters in this builder.
+setLength(newLength: int): void Sets a new length in this builder.
+substring(startIndex: int): String Returns a substring starting at startIndex.
+substring(startIndex: int, endIndex: int): Returns a substring from startIndex to endIndex-1.
String
+trimToSize(): void Reduces the storage size used for the string builder.

58
 Problem: Checking Palindromes
Ignoring Non-alphanumeric Characters

This example gives a program that counts the

number of occurrence of each letter in a
string. Assume the letters are not case-
sensitive.

59
 Example of Checking Palindromes Ignoring Non-
alphanumeric Characters
1 import java.util.Scanner;
2
3 public class PalindromeIgnoreNonAlphanumeric {
4 /** Main method */
5 public static void main(String[] args) {
6 // Create a Scanner
7 Scanner input = new Scanner(System.in);
8
9 // Prompt the user to enter a string
10 System.out.print("Enter a string: ");
11 String s = input.nextLine();
12
13 // Display result
14 System.out.println("Ignoring non-alphanumeric characters, \nis "
15 + s + " a palindrome? " + isPalindrome(s));
16 }

60
 17
18 /** Return true if a string is a palindrome */
19 public static boolean isPalindrome(String s) {
20 // Create a new string by eliminating non-alphanumeric chars
21 String s1 = filter(s);
22
23 // Create a new string that is the reversal of s1
24 String s2 = reverse(s1);
25
26 // Compare if the reversal is the same as the original string
27 return s2.equals(s1);
28 }

61
 29
30 /** Create a new string by eliminating non-alphanumeric chars */
31 public static String filter(String s) {
32 // Create a string builder
33 StringBuilder stringBuilder = new StringBuilder();
34
35 // Examine each char in the string to skip alphanumeric char
36 for (int i = 0; i < s.length(); i++) {
37 if (Character.isLetterOrDigit(s.charAt(i))) {
38 stringBuilder.append(s.charAt(i));
39 }
40 }
41
42 // Return a new filtered string
43 return stringBuilder.toString();
44 }
45
46 /** Create a new string by reversing a specified string */
47 public static String reverse(String s) {
48 StringBuilder stringBuilder = new StringBuilder(s);
49 stringBuilder.reverse(); // Invoke reverse in StringBuilder
50 return stringBuilder.toString();
51 }}
62
 Main Method Is Just a Regular Method

You can call a regular method by passing actual

parameters. Can you pass arguments to main? Of
course, yes. For example, the main method in
class B is invoked by a method in A, as shown
below:
public class A { class B {
public static void main(String[] args) { public static void main(String[] args) {
String[] strings = {"New York", for (int i = 0; i < args.length; i++)
"Boston", "Atlanta"}; System.out.println(args[i]);
B.main(strings); }
} }
}

63
 Command-Line Parameters

class TestMain {
public static void main(String[] args) {
...
}
}

java TestMain arg0 arg1 arg2 ... argn

64
 Processing
Command-Line Parameters
In the main method, get the arguments from
args[0], args[1], ..., args[n], which
corresponds to arg0, arg1, ..., argn in
the command line.

65
 Problem: Calculator

• Objective: Write a program that will perform

binary operations on integers. The program
receives three parameters: an operator and
two integers.

java Calculator "2 + 3"

java Calculator "2 - 3"
java Calculator "2 / 3"
java Calculator "2 * 3"
66
 Example of Calculator
1 public class Calculator {
2 /** Main method */
3 public static void main(String[] args) {
4 // Check number of strings passed
5 if (args.length != 1) {
6 System.out.println(
7 "Usage: java Calculator \"operand1 operator operand2\"");
8 System.exit(0);
9 }
10
11 // The result of the operation
12 int result = 0;
13
14 // The result of the operation
15 String[] tokens = args[0].split(" ");

67
 16
17 // Determine the operator
18 switch (tokens[1].charAt(0)) {
19 case '+': result = Integer.parseInt(tokens[0]) + Integer.parseInt(tokens[2]); break;
20 case '-': result = Integer.parseInt(tokens[0]) – Integer.parseInt(tokens[2]); break;
21 case '*': result = Integer.parseInt(tokens[0]) * Integer.parseInt(tokens[2]); break;
22 case '/': result = Integer.parseInt(tokens[0]) / Integer.parseInt(tokens[2]);
23 }
24
25 // Display result
26 System.out.println(tokens[0] + ' ' + tokens[1] + ' '
27 + tokens[2] + " = " + result);
28 }
29 }

68
 Regular Expression Syntax
Regular Expression Matches Example

x a specified character x Java matches Java

. any single character Java matches J..a
(ab|cd) a, b, or c ten matches t(en|im]
[abc] a, b, or c Java matches Ja[uvwx]a
[^abc] any character except Java matches Ja[^ars]a
a, b, or c
[a-z] a through z Java matches [A-M]av[a-d]
[^a-z] any character except Java matches Jav[^b-d]
a through z
[a-e[m-p]] a through e or Java matches
m through p [A-G[I-M]]av[a-d]
[a-e&&[c-p]] intersection of a-e Java matches
with c-p [A-P&&[I-M]]av[a-d]

\d a digit, same as [1-9] Java2 matches "Java[\\d]"

\D a non-digit $Java matches "[\\D][\\D]ava"
\w a word character Java matches "[\\w]ava"
\W a non-word character $Java matches "[\\W][\\w]ava"
\s a whitespace character "Java 2" matches "Java\\s2"
\S a non-whitespace char Java matches "[\\S]ava"

p* zero or more Java matches "[\\w]*"

occurrences of pattern p
p+ one or more Java matches "[\\w]+"
occurrences of pattern p
p? zero or one Java matches "[\\w]?Java"
occurrence of pattern p Java matches "[\\w]?ava"
p{n} exactly n Java matches "[\\w]{4}"
occurrences of pattern p
p{n,} at least n Java matches "[\\w]{3,}"
occurrences of pattern p
p{n,m} between n and m Java matches "[\\w]{1,9}"
occurrences (inclusive)

69