Java Methods

Object-Oriented Programming
and Data Structures
3rd AP edition

Maria Litvin ● Gary Litvin

"Chapter 8"

Strings

Copyright © 2015 by Maria Litvin, Gary Litvin, and Skylight Publishing. All rights reserved.
Objectives:
• Learn about literal strings
• Learn about String constructors and
commonly used methods
• 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
8-2
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).

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

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

8-5
Literal Strings (cont’d)
• The string text may include “escape”
characters (described in Section 5.5).
For example:
 \\ stands for \
 \n stands for newline

String s1 = "Biology”;
String s2 = "C:\\jdk1.4\\docs";
String s3 = "Hello\n";

8-6
Immutability
• Once created, a string cannot be changed:
none of its methods can change 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 leaving the
others unaware of the change.

8-7
Immutability (cont’d)
• Advantage: more efficient, no need to copy.

String s1 = "Sun"; String s1 = "Sun";

String s2 = s1; String s2 = new String(s1);

s1 s1 "Sun"
"Sun"
s2 s2 "Sun"

OK Less efficient:
wastes memory
8-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.toUpperCase(s.charAt (0));
s = ch + s.substring (1);

s "sun"

"Sun"

8-9
Empty Strings
• An empty string has no characters; its
length is 0.
String s1 = ""; Empty strings
String s2 = new String();

• Not to be confused with an uninitialized

string:

private String errorMsg; errorMsg

is null

8-10
Constructors
• String’s no-args and copy constructors are
not used much.

String s1 = new String (); String s1 = "";

String s2 = new String (s1); String s2 = s1;

• Other constructors convert arrays

(Chapter 9) into strings

8-11
Methods — length, charAt
int length (); • Returns the number of
characters in the string
char charAt (k); • Returns the k-th char

Character positions in strings

are numbered starting from 0

Returns:
”Flower".length(); 6
”Wind".charAt (2); 'n'

8-12
Methods — substring
String s2 = s.substring (i, j);
strawberry
returns the substring of chars in
positions from i to j-1
i j
String s2 = s.substring (i); strawberry
returns the substring from the i-th
char to the end i

Returns:
”strawberry".substring (2,5); "raw"
"unhappy".substring (2); "happy"
"emptiness".substring (9); "" (empty string)

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

8-14
Methods — Find (indexOf)
0 8 11 15

String date ="July 5, 2012 1:28:19 PM";

Returns:
date.indexOf ('J'); 0
date.indexOf ('2'); 8
date.indexOf ("2012"); 8
date.indexOf ('2', 9); 11 (starts searching
at position 9)

date.indexOf ("2020"); -1 (not found)

date.lastIndexOf ('2'); 15
8-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

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

8-17
Replacements (cont’d)
• Example: how to convert s1 to upper case
s1 = s1.toUpperCase();

• A common bug:
s1 remains
s1.toUpperCase();
unchanged

8-18
Numbers to Strings
• Three ways to convert a number into a
string:
1.
Integer and Double
String s = "" + n; are “wrapper” classes
2. from java.lang that
String s = Integer.toString (n); represent numbers as
objects. They also
String s = Double.toString (x); provide useful static
3. methods.

String s = String.valueOf (n);

8-19
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 = 56.7381; 56.7381
...
String s = money.format (amt); "56.74"

8-20
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);

Displays,
sets s to:
"Date: 05/19/2007 Amount 123.50"

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

8-22
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 (...);
8-23
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.

8-24
Character Methods (cont’d)
if (Character.isDigit (ch)) ...
.isLetter...
.isLetterOrDigit... Whitespace is
.isUpperCase... space, tab,
.isLowerCase... newline, etc.
.isWhitespace...
return true if ch belongs to the corresponding
category

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

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

8-27
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?

8-28
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?
8-29
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?

8-30
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?

8-31