1. "Chapter 9" Strings Java Methods Maria Litvin Gary LitvinTM
Maria Litvin
Gary Litvin
An Introduction
to Object-Oriented Programming
"Chapter 9"
Strings
Processing text is what computers do much of the time. Your Java compiler is one example of a program that does a lot of handling and parsing of strings. Handling strings is pretty straightforward and convenient in Java.
Copyright © 2003 by Maria Litvin, Gary Litvin, and Skylight Publishing. All rights reserved.

2. Objectives: Learn about literal strings
Learn about String constructors and commonly used methods
Understand immutability of strings
Learn to convert strings into numbers and numbers into strings
Learn several useful methods of the Character class
The char data type is not in the AP Java subset, while strings are. However, any reasonable course will teach chars. One of the reasons for excluding char from the subset was the perceived danger of confusing a char constant 'x' with a string constant "x". An unstated objective of this chapter is to get a clear understanding that char and String are two different data types. char is a primitive data type; strings are objects.

3. The String class
An object of the String class represents a string of characters.
The String class belongs to the java.lang package, which is built into Java.
Like other classes, String has constructors and methods.
Unlike other classes, String has two operators, + and += (used for concatenation).
There is no need to import java.lang.String because the java.lang package is imported automatically into all classes.
The + and += operators for strings are an exception in Java, the only example of overloaded operators for objects.

4. Literal Strings
Literal strings are anonymous constant objects of the String class that are defined as text in double quotes.
The string text may include “escape” characters, as described in Chapter 6 (p. 146); for example:
\\ stands for \
\n stands for the newline character
\" stands for the double quote character.
Like the char type, String objects internally represent characters using Unicode.
"Biology”, "C:\\jdk1.4\\docs”, "Hello\n"

5. Literal Strings (cont’d)
don’t have to be constructed: they are “just there.”
can be assigned to String variables.
can be passed to methods and constructors as arguments.
have methods you can call:
Calling a method of a literal string, as in "sometext".someMethod(...), may seem unusual to programmers who are used to other languages. "sometext".equals(str) is often used instead of str.equals("sometext") because the former version works even when str is null, while the latter would throw a null reference exception.
String fileName = "fish.dat";
button = new JButton("Next slide");
if (”Start".equals(cmd)) ...

6. Immutability
Once created, a string cannot be changed: none of its methods changes the string.
Such types of objects are called immutable.
Immutable objects are convenient because two references can point to the same object safely.
There is no danger of changing an object through one reference without the others being aware of the change.
If all the instance fields in a class are private and none of the methods can directly or indirectly set the field values, then the class’s objects are immutable. A few String methods create and return a different string, but none of them changes the string for which they were called. The Integer, Character, and Double classes, discussed later, are immutable, too.

7. Immutability (cont’d)
Advantage: more efficient, no need to copy.
String s1 = "Sun";
String s2 = s1;
String s1 = "Sun";
String s2 = new String(s1); s1 s1
"Sun"
Thus it is safe for immutable objects to copy references rather than the contents. Cloning (creating copies of objects) is not required. This may save time when Strings are stored in lists, etc.
"Sun" s2 s2
"Sun" OK
Less efficient and wasteful

8. Immutability (cont’d)
Disadvantage: less efficient — you need to create a new string and throw away the old one for every small change.
String s = "sun";
char ch = Character.toUpper(s.charAt (0));
s = ch + s.substring (1);
On the other hand, the immutability may result in tremendous inefficiency when strings are modified often, especially when a string is gradually built by appending characters or numbers to it. Programmers should use the StringBuffer class for these tasks. s
"sun"
'S' +
"un"

9. Empty Strings An empty string has no characters; its length is 0.
Not to be confused with an uninitialized string:
String s1 = "";
String s2 = new String();
Empty strings
You may need an empty string as a starting point when you plan to append items to a string.
private String errorMsg;
errorMsg is null

10. Constructors String’s no-args and copy constructors are not used much.
Other constructors convert arrays into strings (used in a lab in Chapter 10).
String s1 = new String ();
String s2 = new String (s1);
String s1 = "";
String s2 = s1;
As explained earlier, it is a good idea to avoid the copy constructor.
One useful constructor converts an array of chars into a String.

11. Methods — length, charAt
Returns the number of characters in the string
Returns the k-th char
int length ();
char charAt (k);
Character positions in strings are numbered starting from 0
Character positions in strings are counted starting from 0, so str.charAt(0) returns the first character and str.charAt(str.length() - 1) returns the last character. This is consistent with indices in arrays (Chapter 10): the index of the first element is 0.
Returns:
”Flower".length();
”Wind".charAt (2); 6
’n'

12. Methods — substring String s2 = s.substring (i, k);
returns the substring of chars in positions from i to k-1
String s2 = s.substring (i);
returns the substring from the i-th char to the end
strawberry
i k
It is actually convenient that the k-th char is excluded from the substring. The length of the substring is k ‑ i.
str.substring (i) is the same as str.substring(i, str.length()).
Returns:
”strawberry".substring (2,5);
"unhappy".substring (2);
"emptiness".substring (9);
”raw"
"happy"
"" (empty string)

13. Methods — Concatenation
String result = s1 + s2;
concatenates s1 and s2
String result = s1.concat (s2);
the same as s1 + s2
result += s3;
concatenates s3 to result
result += num;
converts num to String and concatenates it to result
It looks like the += operator for strings violates immutability. In fact the string is not changed, rather the reference is reassigned. s1 += s2 is the same as s1 = s1 + s2. So if you have
String s = "Nice ", t = s;
s += "day";
the value of t remains "Nice ".

14. Methods — Find (indexOf)
String date ="July 5, :28:19 PM";
date.indexOf ('J');
date.indexOf ('2');
date.indexOf ("2012");
date.indexOf ('2', 9);
date.indexOf ("2020");
date.lastIndexOf ('2');
Returns:
String has four overloaded versions of indexOf and four versions of lastIndexOf.
lastIndexOf(ch, fromPos) starts looking at fromPos and goes backwards towards the beginning of the string.
(starts searching at position 9)
(not found)

15. Methods — Comparisons boolean b = s1.equals(s2);
returns true if the string s1 is equal to s2
boolean b = s1.equalsIgnoreCase(s2);
returns true if the string s1 matches s2, case-blind
int diff = s1.compareTo(s2);
returns the “difference” s1 - s2
int diff = s1.compareToIgnoreCase(s2);
returns the “difference” s1 - s2, case-blind
You cannot use relational operators for comparing the contents of strings.
s1.compareTo(s2) returns an int. Basically if s1 is “smaller” than s2, the result is negative, and if s1 is “larger” the result is positive. compareTo returns 0 whenever equals returns true.
Here is how Java docs describe compareTo:
Compares two strings lexicographically. The comparison is based on the Unicode value of each character in the strings. The character sequence represented by this String object is compared lexicographically to the character sequence represented by the argument string. The result is a negative integer if this String object lexicographically precedes the argument string. The result is a positive integer if this String object lexicographically follows the argument string. The result is zero if the strings are equal; compareTo returns 0 exactly when the equals(Object) method would return true.
This is the definition of lexicographic ordering. If two strings are different, then either they have different characters at some index that is a valid index for both strings, or their lengths are different, or both. If they have different characters at one or more index positions, let k be the smallest such index; then the string whose character at position k has the smaller value, as determined by using the < operator, lexicographically precedes the other string. In this case, compareTo returns the difference of the two character values at position k in the two string — that is, the value:
this.charAt(k)-anotherString.charAt(k)
If there is no index position at which they differ, then the shorter string lexicographically precedes the longer string. In this case, compareTo returns the difference of the lengths of the strings — that is, the value:
this.length()-anotherString.length()

16. Methods — Replacements
String s2 = s1.trim ();
returns a new string formed from s1 by removing white space at both ends
String s2 = s1.replace(oldCh, newCh);
returns a new string formed from s1 by replacing all occurrences of oldCh with newCh
String s2 = s1.toUpperCase();
String s2 = s1.toLowerCase();
returns a new string formed from s1 by converting its characters to upper (lower) case
Note that these methods do not change the string s1 but create and return a new string.
trim() only removes whitespace at the ends of the string, not in the middle.

17. Replacements (cont’d)
Example: how to convert s1 to upper case
A common bug:
s1 = s1.toUpperCase();
s1 remains unchanged
s1.toUpperCase();
s1.toUpperCase();
doesn’t do anything. The correct statement is:
s1 = s1.toUpperCase();
The variable s1 is reassigned to the new string returned by s1.toUpperCase(); the old string is disposed of.

18. Methods — toString
It is customary to provide a toString method for your class.
toString converts an object into a String (for printing it out, for debugging, etc.).
is the same as
System.out.print (obj);
The Object class (and therefore any object) has a toString method that returns a cryptic description of the object. It is a good idea to override this default method and define a more suitable one for your class. As the example shows, this method is used for implicit “casting” of objects of your class into strings. It works with the print and println methods and with the + operator for strings.
System.out.print (obj.toString());

19. Numbers to Strings and Strings to Numbers
Integer and Double are “wrapper” classes from java.lang that represent numbers as objects.
Integer and Double provide useful static methods for conversions:
String s1 = Integer.toString (i);
String s2 = Double.toString (d);
int n = Integer.parseInt (s1);
double x = Double.parseDouble (s2);
A wrapper class has a constructor that takes an item of the “wrapped” type as an argument. For example, Integer is a wrapper for int:
int x = 5;
Integer obj = new Integer(x);
The wrapped type can be a class, too. The wrapper class adds run-time functionality to the wrapped object. In this case, Integer and Double just provide handy static methods for numbers.
int i;
double d;

20. Numbers to Strings Three ways to convert a number into a string: 1.
String s = "" + num; 2.
String s = Integer.toString (i);
String s = Double.toString (d); 3.
String s = String.valueOf (num);
int i;
double d;
You can also convert a char to a string by using
String s = "" + ch;
By convention, a static method valueOf in a class converts something (its arguments) into an object of this class. For example:
public class Fraction {
public static Fraction valueOf(double x) {...}
should take a double and return a corresponding Fraction.
Here String.valueOf(x) returns a string.

21. Numbers to Strings (cont’d)
The DecimalFormat class can be used for more controlled conversions of numbers into strings:
import java.text.DecimalFormat;
...
DecimalFormat money =
new DecimalFormat("0.00");
double amt = …;
String s = money.format (amt);
As usual in Java, there is a hierarchy of subclasses and rather elaborate rules for specifying different formats. For example, you can define
DecimalFormat dollars = new DecimalFormat("$#,##0.00");
Then
System.out.println (dollars.format( ));
displays
$12,345,678.99
"56.79"

22. Strings to Numbers
int n = Integer.parseInt(s);
double x = Double.parseDouble(s);
These methods throw a NumberFormatException if s does not represent a valid number.
Older versions of SDK (before 1.2) did not have Double.parseDouble; you had to use
In a real program you should use exception handling with number conversions to avoid aborting the program when the user mistypes a character:
try {
String str = input.readLine();
int x = Integer.parseInt(str);
catch (NumberFormatException e)
... // show a friendly message that
// an error has occurred and give
// a chance to reenter }
double x = Double.valueOf(s).doubleValue();

23. Character Methods
java.lang.Character is a class that represents characters as objects.
Character has several useful static methods that determine the type of a character.
Character also has methods that convert a letter to the upper or lower case.
Character is a wrapper class for char.

24. Character Methods (cont’d)
if (Character.isDigit (ch)) ...
.isLetter...
.isLetterOrDigit...
.isUpperCase...
.isLowerCase...
.isWhitespace...
return true if ch belongs to the corresponding category
Whitespace is space, tab, newline, etc.
See Java docs for the formal definition of whitespace characters.

25. Character methods (cont’d)
char ch2 = Character.toUpperCase (ch1);
.toLowerCase (ch1);
if ch1 is a letter, returns its upper (lower) case; otherwise returns ch1
int d = Character.digit (ch, radix);
returns the int value of the digit ch in the given int radix
char ch = Character.forDigit (d, radix);
returns a char that represents int d in a given int radix
For example Character.digit('7',10) returns 7 and Character.digit('A', 16) returns 10. Character.forDigit(7,10) returns '7'.

26. StringTokenizer
java.util.StringTokenizer is used to extract “tokens” from a string.
Tokens are separated by delimiters (e.g., whitespace).
A tokenizer object is constructed with a given string as an argument.
The second optional argument is a string that lists all delimiters (default is whitespace).
The StringTokenizer’s constructor takes a string, extracts all the tokens, and places them into a queue. Then the nextToken method retrieves and returns the next token from the queue.

27. StringTokenizer (cont’d)
import java.util.StringTokenizer;
...
String str = input.readLine();
StringTokenizer q =
new StringTokenizer (str);
// or:
// new StringTokenizer (str, ";+ \t, ");
int n = q.countTokens ();
while ( q.hasMoreTokens() ) {
String word = q.nextToken();
Delimiters are whitespace
All delimiters
You can either call the countTokens() method to find out how many tokens you have or call hasMoreTokens() to see if there are any tokens left in the queue.
The number of found tokens

28. EquationSolver Applet
This applet uses the same text field for input and for output. The initial version requires spaces around + and - signs. The version extended in the lab assignment can handle input with no spaces: it adds spaces around arithmetic operation signs.

29. EquationSolver (cont’d)
Uses many techniques discussed earlier:
trim, substring, and other String methods clean the input, surround operation signs with spaces
StringTokenizer extracts tokens
Character.isDigit, and other Character methods identify tokens
Integer.parseInt converts tokens to numbers
String's + operator combines strings and numbers to generate output
This lab and the end-of-chapter exercises give you a chance to get comfortable with String methods and number-to-string conversions.

30. Review: What makes the String class unusual?
How can you include a double quote character into a literal string?
Is "length".length() allowed syntax? If so, what is the returned value?
Define immutable objects.
Does immutability of Strings make Java more efficient or less efficient?
What makes the String class unusual?
+ and += operators
How can you include a double quote character into a literal string?
\"
Is "length".length() allowed syntax? If so, what is the returned value?
Yes, it is valid and returns 6
Define immutable objects.
Objects that cannot be changed by calling their methods (nor by directly manipulating their fields).
Does immutability of strings make Java more efficient or less efficient?
It depends. It may be more efficient if the code involves making many copies of strings. It is less efficient if the code involves changing characters in strings or assembling strings from separate items (chars or numbers). Actually the latter situation is more common. You should then use the StringBuffer class rather than String.

31. Review (cont’d): How do you declare an empty string?
Why are String constructors not used very often?
If the value of String city is "Boston", what is returned by city.charAt (2)?
By city.substring (2, 4)?
How come String doesn’t have a setCharAt method?
Is s1 += s2 the same as s1 = s1 + s2 for strings?
How do you declare an empty string?
String s = "";
Why are String constructors not used very often?
Because you can simply assign a literal string to a variable, so there is no need to make copies of strings.
If the value of String city is "Boston", what is returned by city.charAt(2) ?
By city.substring(2,4) ?
's' and "st", respectively.
How come String doesn’t have a setCharAt method?
To keep it immutable. StringBuffer has setCharAt(ch,pos).
Is s1 += s2 the same as s1 = s1 + s2 for strings?
Yes

32. Review (cont’d):
What do the indexOf methods do? Name a few overloaded versions.
What is more efficient for strings: == and other relational operators or equals and compareTo methods?
What does the trim method do?
What does s.toUpperCase() do to s?
What does the toString method return for a String object?
What do the indexOf methods do? Name a few overloaded versions.
Find a character or a substring in a string. indexOf(char), indexOf(String), indexOf(char, int fromPos), indexOf(String, int fromPos)
What is more efficient for strings: == and other relational operators or equals and compareTo methods?
This is not a matter of efficiency: you must use equals and compareTo to compare the contents of strings; == compares references, which are equal only if they refer to exactly the same string.
What does the trim method do?
It returns a new string which contains this string with whitespace removed at the ends.
What does s.toUpperCase() do to s?
Nothing: s is immutable.
What does the toString method return for a String object?
This string

33. Review (cont’d): Name a simple way to convert a number into a string.
Which class has a method for converting a String into an int?
Name a few Character methods that help identify the category to which a given character belongs.
What is the StringTokenizer class used for?
Name a simple way to convert a number into a string
"" + num;
Which class has a method for converting a String into an int?
Integer (the method parseInt)
Name a few Character methods that help identify the category to which a given char belongs.
isDigit, isLetter, isUpperCase, isLowerCase, isWhitespace.
What is the StringTokenizer class used for?
To extract tokens (contiguous blocks of characters) separated by delimiters.