1. String Class

2. Objectives and Goals Identify 2 types of Strings: Literal & Symbolic.
Learn about String constructors and commonly used methods
Learn several useful methods of the Character class
Understand immutability of strings
Learn to format numbers into strings and extract numbers from strings
Learn about the StringBuffer class

3. String Class java.lang package Two types of String
Literal String – characters in double quotes
Symbolic String – variable that represents a String

4. 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.
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 “words” in double quotes Literals act as an object
Literal Strings have access to all the methods of String class as a String object does.

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

7. Literal Strings (cont’d)
can be assigned to String variables.
can be passed to methods and constructors as parameters.
have methods you can call:
String fileName = "fish.dat";
button = new JButton("Next slide");
if ("Start".equals(cmd)) ...
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 NullPointerException.

8. Literal Strings (cont’d)
The string text may include “escape” characters (described in Section 6.5). For example:
\\ stands for \
\n stands for the newline character
String s1 = "Biology”;
String s2 = "C:\\jdk1.4\\docs";
String s3 = "Hello\n";
\" stands for the double quote character.

9. Creating a String Object
String name;
Null String Reference
Has no length
Calling a null String object will cause a NullPointerException Error
String name = “”;
Empty String
Has a size of 0
String name = new String();
Creates an empty String
String name = new String(“Bob”);
Creates an object that has the name Bob
Its length is 3.

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

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

12. 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.
You can create a new String objects that have the new version of the original string’s value.
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.

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

14. 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"

15. String Assignment heLlO hello
9/11/2018 8:37 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>

16. Reference
When you create a symbolic variable that represents a String, it doesn’t contain the string object, it contains the reference (address) of the memory location of the string object.

17. Examples of referencing String Objects
String s1 = “Bob”;
s1  “Bob”
s2 = s1;
s1 & s2  “bob” points to the same memory location.
s2 = new String(s1);
s2  “Bob” two different memory locations.

18. Size and character location of a String
Size is the number of characters a String has including and blank spaces in the String.
Character positions in strings are counted starting from 0.
Location  The first letter in the String is in location 0 and the second letter is in the position 1 and so on.
Always make sure that when you refer to the positions of characters in strings, they fall in the range from 0 to string’s length – 1.

19. Methods length() charAt(int); substring(int); substring(int, int);
concat(str);
compareTo(str);
compareToIgnoreCase(str);
equals(str);
equalsIgnoreCase(str);
indexOf(char);
indexOf(char, int);
indexOf(str);
indexOf(str, int);

20. Methods Continued lastIndexOf(char); lastindexOf(char, int);
lastIndexOf(str);
lastIndexOf(str, int);
trim();
replace(oldChar, newChar);
toUpperCase();
toLowerCase();

21. AP String Methods compareTo(str); equals(str); indexOf(str); length();
substring(int, int);
substring(int);

22. Method Overloading
When you have more than one method with the same name.
The parameter list are different and the computer determine which method to pick by the parameter list.
Example:
substring(int);
substring(int, int);

23. Comparing Characters
In Unicode, the digit characters (0-9) are contiguous and in order
Likewise, the uppercase letters (A-Z) and lowercase letters (a-z) are contiguous and in order
Characters
Unicode Values
0 – 9
48 through 57
A – Z
65 through 90
a – z
97 through 122

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

25. Comparing Strings
Remember that in Java a character string is an object
The equals method can be called with strings to determine if two strings contain exactly the same characters in the same order
The equals method returns a boolean result
if (name1.equals(name2))
System.out.println ("Same name");

26. Comparing Strings
We cannot use the relational operators to compare strings
The String class contains a method called compareTo to determine if one string comes before another
A call to name1.compareTo(name2)
returns zero if name1 and name2 are equal (contain the same characters)
returns a negative value if name1 is less than name2
returns a positive value if name1 is greater than name2

27. Comparing Strings
if (name1.compareTo(name2) < 0)
System.out.println (name1 + "comes first");
else
if (name1.compareTo(name2) == 0)
System.out.println ("Same name");
System.out.println (name2 + "comes first");
Because comparing characters and strings is based on a character set, it is called a lexicographic ordering

28. Lexicographic Ordering
Lexicographic ordering is not strictly alphabetical when uppercase and lowercase characters are mixed
For example, the string "Great" comes before the string "fantastic" because all of the uppercase letters come before all of the lowercase letters in Unicode
Also, short strings come before longer strings with the same prefix (lexicographically)
Therefore "book" comes before "bookcase"

29. Comparing Objects
The == operator can be applied to objects – it returns true if the two references are aliases of each other
The equals method is defined for all objects, but unless we redefine it when we write a class, it has the same semantics as the == operator
It has been redefined in the String class to compare the characters in the two strings
When you write a class, you can redefine the equals method to return true under whatever conditions are appropriate

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

31. 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:
”strawberry".substring (2,5);
"unhappy".substring (2);
"emptiness".substring (9);
"raw"
"happy"
"" (empty string)

32. 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".

33. 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)

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

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

36. Replacements (cont’d)
Example: how to convert s1 to upper case
A common bug:
S1 is not assigned to a memory location that holds the change.
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.

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

38. 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"

39. 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 "

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

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

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

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

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

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

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

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

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

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