1. Strings
Chapter 6

2. Goals and Objectives Write code using the String class.
Manipulate and compare strings using the String class and its methods.
Learn about literal strings
Learn about String constructors and commonly used methods
Develop code with correct and efficient use of repetitive control structures.
Apply problem solving strategies.
Understand immutability of strings
Learn to format numbers into strings and extract numbers from strings
Learn several useful methods of the Character class
Learn about the StringBuffer class

3. Part of the java.lang package
The String Class
9/11/2018 8:36 AM
Part of the java.lang package
A String object is comprised of a sequence of characters with the first character at index position 0
Methods
length()
toString()
charAt(int)
replace(oldChar, newChar)
substring(int)
substring(int,int)
toUpperCase()
toLowerCase()
concat(str)
trim()
indexOf(char)
indexOf(char, int)
indexOf(str);
indexOf(str,int)
lastIndexOf(char)
lastIndexOf(char,int)
lastIndexOf(str)
lastIndexOf(str,int)
equals(str)
equalsIgnoreCase()
compareTo(str)
compareToIgnoreCase(str)
Refer to page 138 in the text.
The String class is used for representing text. The first character of a string is at index position 0. The last character is at position length()-1.

4. The String class
An object of the String class represents a string of characters.
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.
Like the char type, String objects internally represent characters using Unicode.
The + and += operators for strings are an exception in Java, the only example of operators that work with objects.

5. Literal Strings
Literal strings are anonymous constant objects of the String class that are defined as text in double quotes.
Literal strings don’t have to be constructed: they are “just there.”
This is one of the reasons why String constructors are not used very often: instead of constructing a string you just write a literal string.

6. Literal Strings (cont’d)
The string text may include “escape” characters (\) For example:
\\ stands for \
\n stands for the newline character
\t – tab
\” – double quotes
\’ – single quote
\" stands for the double quote character.
String s1 = "Biology”;
String s2 = "C:\\jdk1.4\\docs";
String s3 = "Hello\n";

7. String Assignment heLlO hello
9/11/2018 8:36 AM
String Assignment
Strings are immutable. Assigning a new string to a String object simply changes the object reference to point to the new string in memory:
String text;
text = "heLlO";
text = text.toLowerCase();
text
heLlO
hello
Note: This slide contains animations. Press the space bar or click the mouse button to display each animation.
This slide contains three (3) animations.
Refer to page 139 in the text.
The object instantiation, String text, associates the object name text with a memory location <press space bar>
The first assignment statement points to the location in memory that stores the mixed-case string <press space bar>
The second assignment statement, moves the pointer to the location in memory that stores the lowercase string <press space bar>

8. 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

9. Null String
String name; // null string
Does not have a length.

10. Declaring a String String name = “Bob”; 0 1 2 OR OR
String name = new String(“Bob’); B o b B o b

11. new Operator String s1 = “Bob”; String s2 = s1;
String s2 = new String(“Bob”); S1
Bob S2
Bob s1
Bob s2

12. Constructors String’s no-args and copy constructors are not used much.
Other constructors convert arrays into strings
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.

13. Immutability
Once created, a string cannot be changed: none of its methods changes the string.
Such objects are called immutable.
Immutable objects are convenient because several 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.

14. 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"
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"
Less efficient: wastes memory OK

15. 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.toUpperCase(s.charAt (0));
s = ch + s.substring (1);
The immutability of strings may also 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"
"Sun"

16. 9/11/2018 8:36 AM
Comparing Strings
The String class includes several methods for comparing two strings: equals() equalsIgnoreCase() compareTo() compareToIgnoreCase() indexOf() lastIndexOf()
Refer to page 140 in the text.

17. Methods — length, charAt
int length ();
char charAt (k);
Returns the number of characters in the string
Returns the k-th char
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 12): the index of the first element is 0.
Returns:
”Flower".length();
”Wind".charAt (2); 6
’n'

18. 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
strawberry i
substring is overloaded: there are two versions.
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:
"raw"
"happy"
"" (empty string)
”strawberry".substring (2,5);
"unhappy".substring (2);
"emptiness".substring (9);

19. 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 ", while s becomes "Nice day".

20. 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 backward towards the beginning of the string.
(starts searching at position 9)
(not found)

21. Methods — Comparisons returns true if the string s1 is equal to s2
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()

22. 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.

23. 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 changed to refer to the new string returned by s1.toUpperCase(); the old string is disposed of.

24. 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);
Integer and Double are “wrapper” classes from java.lang that represent numbers as objects. They also provide useful static methods.
You can also convert a char to a string by using
String s = "" + ch; or
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.

25. Numbers to Strings (cont’d)
The DecimalFormat class can be used for formatting 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 formatting 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.74"

26. Numbers to Strings (cont’d)
Java 5.0 added printf and format methods:
int m = 5, d = 19, y = 2007;
double amt = 123.5;
System.out.printf ( "Date: %02d/%02d/%d Amount = %7.2f\n", m, d, y, amt);
String s = String. format(
"Date: %02d/%02d/%d Amount = %7.2f\n", m, d, y, amt);
printf and format are methods with variable numbers of parameters.
Besides %d and %f, the format string can have other specifiers for the output data elements. See Java API.
Displays, sets s to:
"Date: 05/19/2007 Amount "

27. Numbers from Strings
String s1 = "-123", s2 = "123.45";
int n = Integer.parseInt(s1);
double x = Double.parseDouble(s2);
These methods throw a NumberFormatException if s does not represent a valid number (integer, real number, respectively).
In a real program you should use exception handling with number conversions to avoid aborting the program when the user mistypes a character, as explained in the next slide.

28. Numbers from Strings (cont’d)
A safer way:
int n;
do {
try {
n = Integer.parseInt(s); }
catch (NumberFormatException ex)
System.out.println("Invalid input, reenter");
} while (...);
The try-catch statement is repeated until the user enters a valid string.

29. Character Methods
java.lang.Character is a “wrapper” class that represents characters as objects.
Character has several useful static methods that determine the type of a character (letter, digit, etc.).
Character also has methods that convert a letter to the upper or lower case.
Character is a wrapper class for char.

30. 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.

31. 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'.

32. The StringBuffer Class
Represents a string of characters as a mutable object
Constructors:
StringBuffer() // empty StringBuffer of the default capacity
StringBuffer(n) // empty StringBuffer of a given capacity
StringBuffer(str) // converts str into a StringBuffer
Adds setCharAt, insert, append, and delete methods
The toString method converts this StringBuffer into a String
substring and indexOF(String) methods work the same way as in String.

33. 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 and literal strings
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.

34. 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.

35. 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.

36. 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 difference between the String and StringBuffer classes?
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 difference between the String and StringBuffer classes?
StringBuffer objects are mutable; StringBuffer is more efficient for assembling a string from pieces. It has methods for inserting, appending, and deleting characters.