The document discusses the String class in Java. It covers string literals, immutability of strings, common string methods like length(), charAt(), substring(), and concatenation. It also discusses converting between strings and numbers, formatting strings, and the StringBuffer mutable string class. The Character class is described as having useful methods for classifying characters.
1 of 31
Download to read offline
More Related Content
String Method.pptx
1. Strings
"Chapter 10"
Copyright 息 2011 by Maria Litvin, Gary Litvin, and Skylight Publishing. All rights reserved.
Java Methods
Object-Oriented Programming
and Data Structures
Maria Litvin Gary Litvin
2nd AP edition with GridWorld
2. 10-2
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
3. 10-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).
4. 10-4
Literal Strings
Literal strings are anonymous constant
objects of the String class that are defined as
text in double quotes.
Literal strings dont have to be constructed:
they are just there.
5. 10-5
Literal Strings (contd)
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)) ...
6. 10-6
Literal Strings (contd)
The string text may include escape
characters (described in Section 6.5).
For example:
stands for
n stands for newline
String s1 = "Biology;
String s2 = "C:jdk1.4docs";
String s3 = "Hellon";
7. 10-7
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 without the
others being aware of the change.
8. 10-8
Immutability (contd)
Advantage: more efficient, no need to copy.
String s1 = "Sun";
String s2 = s1;
String s1 = "Sun";
String s2 = new String(s1);
s1
s2
s1
s2
OK Less efficient:
wastes memory
"Sun"
"Sun"
"Sun"
9. 10-9
Immutability (contd)
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"
10. 10-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();
private String errorMsg; errorMsg
is null
Empty strings
11. 10-11
Constructors
Strings no-args and copy constructors are
not used much.
Other constructors convert arrays
(Chapter 12) into strings
String s1 = new String ();
String s2 = new String (s1);
String s1 = "";
String s2 = s1;
12. 10-12
Methods length, charAt
int length ();
char charAt (k);
Returns the number of
characters in the string
Returns the k-th char
6
'n'
Flower".length();
Wind".charAt (2);
Returns:
Character positions in strings
are numbered starting from 0
13. 10-13
Methods substring
String s2 = s.substring (i, j);
returns the substring of chars in
positions from i to j-1
String s2 = s.substring (i);
returns the substring from the i-th
char to the end
"raw"
"happy"
"" (empty string)
strawberry".substring (2,5);
"unhappy".substring (2);
"emptiness".substring (9);
Returns:
strawberry
i j
strawberry
i
14. 10-14
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
16. 10-16
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
17. 10-17
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
18. 10-18
Replacements (contd)
Example: how to convert s1 to upper case
A common bug:
s1 = s1.toUpperCase();
s1.toUpperCase();
s1 remains
unchanged
19. 10-19
Numbers to Strings
Three ways to convert a number into a
string:
1.
String s = "" + n;
2.
String s = Integer.toString (n);
String s = Double.toString (x);
3.
String s = String.valueOf (n);
Integer and Double
are wrapper classes
from java.lang that
represent numbers as
objects. They also
provide useful static
methods.
20. 10-20
Numbers to Strings (contd)
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;
...
String s = money.format (amt);
56.7381
"56.74"
21. 10-21
Numbers to Strings (contd)
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.2fn", m, d, y, amt);
String s = String. format(
"Date: %02d/%02d/%d Amount = %7.2fn", m, d, y, amt);
Displays,
sets s to:
"Date: 05/19/2007 Amount 123.50"
22. 10-22
Numbers from Strings
These methods throw a
NumberFormatException if s does not
represent a valid number (integer, real
number, respectively).
String s1 = "-123", s2 = "123.45";
int n = Integer.parseInt(s1);
double x = Double.parseDouble(s2);
23. 10-23
Numbers from Strings (contd)
A safer way:
int n;
do {
try
{
n = Integer.parseInt(s);
}
catch (NumberFormatException ex)
{
System.out.println("Invalid input, reenter");
}
} while (...);
24. 10-24
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.
25. 10-25
Character Methods (contd)
if (Character.isDigit (ch)) ...
.isLetter...
.isLetterOrDigit...
.isUpperCase...
.isLowerCase...
.isWhitespace...
return true if ch belongs to the corresponding
category
Whitespace is
space, tab,
newline, etc.
26. 10-26
Character methods (contd)
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
27. 10-27
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
28. 10-28
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?
29. 10-29
Review (contd):
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 doesnt have a setCharAt
method?
Is s1 += s2 the same as s1 = s1 + s2 for
strings?
30. 10-30
Review (contd):
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?
31. 10-31
Review (contd):
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?