Date post: | 19-May-2015 |
Category: |
Technology |
Upload: | mbruggen |
View: | 727 times |
Download: | 0 times |
1
String and StringBuilder
Part I: String
2
About Strings Strings are objects, but there is a special syntax for writing
String literals:"Hello"
Strings, unlike most other objects, have a defined operation (as opposed to a method):
" This " + "is String " + "concatenation"" Strings can contain any character, but some of them must be
“escaped” in order to write them in a literal– \" stands for the double-quote (") character– \n stands for the newline character– \\ stands for the backslash (\)character– Each of these is written as a two-character sequence, but represents a
single character in the string
3
Useful String methods I
char charAt(int index)– Returns the character at the given index position (0-
based)
boolean startsWith(String prefix)– Tests if this String starts with the prefix String
boolean endsWith(String suffix)– Tests if this String ends with the suffix String
4
Useful String methods II
boolean equals(Object obj)– Tests if this String is the same as the obj (which may
be any type; false if it’s not a String)
boolean equalsIgnoreCase(String other)– Tests if this String is equal to the other String, where
case does not matter
int length()– Returns the length of this string; note that this is a
method, not an instance variable
5
Useful String methods III int indexOf(char ch)
– Returns the position of the first occurrence of ch in this String, or -1 if it does not occur
int indexOf(char ch, int fromIndex)– Returns the position of the first occurrence of ch, starting at (not
after) the position fromIndex
There are two similar methods that take a String instead of a char as their first argument
6
Useful String methods IV
int lastIndexOf(char ch)– Returns the position of the last occurrence of ch in this
String, or -1 if it does not occur
int lastIndexOf(char ch, int fromIndex)– Returns the position of the last occurrence of ch,
searching backward starting at position fromIndex
There are two similar methods that take a String instead of a char as their first argument
7
Useful String methods V
String substring(int beginIndex)– Returns a new string that is a substring of this string,
beginning with the character at the specified index and extending to the end of this string.
String substring(int beginIndex, int endIndex)
– Returns a new string that is a substring of this string, beginning at the specified beginIndex and extending to the character at index endIndex - 1. Thus the length of the substring is endIndex-beginIndex
8
Understanding “index” With charAt(index), indexOf(x), and lastIndexOf(x),
just count characters (starting from zero)
With substring(from) and substring(from, to), it works better to count positions between characters
So, for example, substring(4, 8) is "said", andsubstring(8, 12) is ", \"H"
"She said, \"Hi\"" 0 1 2 3 4 5 6 7 8 9 10 11 12 13
"She said, \"Hi\""0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
If indexOf(',') is 8, then substring(0, indexOf(',')) is "She said"and substring(indexOf(',') + 1) is " \"Hi\""
9
Useful String methods VI String toUpperCase()
– Returns a new String similar to this String, in which all letters are uppercase
String toLowerCase()– Returns a new String similar to this String, in which all
letters are lowercase
String trim()– Returns a new String similar to this String, but with
whitespace removed from both ends
10
Useful String methods VII String[] split(String regex)
– Breaks the string up into an array of strings– The parameter is a regular expression that defines what
separates the strings– For example,
String s = "one, two, three"; String[] ss = s.split(", ");
This assigns the array {"one", "two", "three"} to ss– Regular expressions are complex expressions that
assign meanings to many common punctuation marks, such as +, *, period, and [
Hence, regular expressions are powerful, but can be treacherous if you aren’t very familiar with them
11
Finally, a useless String method String toString()
– Returns this String
Why do we have this method?– Consistency--Every Object has a toString() method
12
Strings are immutable A String, once created, cannot be changed None of the preceding methods modify the
String, although several create a new String Statements like this create new Strings:
myString = myString + anotherCharacter; Creating a few extra Strings in a program is
no big deal Creating a lot of Strings can be very costly
13
More about equals If you write
String s = "abc"; String t = "abc";the compiler only creates the string "abc" once, and makes s and t both refer to this one string
– It can do this because strings are immutable– Hence, the test s == t will be true
However, if you now write String u = "a" + "bc";the test s == u will be false
– This is because they are different strings Moral: Use equals for strings, not ==
14
Still more about equals Suppose you want to test whether a variable
name has the value "Dave"– Here’s the obvious way to do it:
if (name.equals("Dave")) { ... }– But you could also do it this way:
if ("Dave".equals(name)) { ... } It turns out that the second way is usually
better Why?
– If name == null, the first way will cause a NullPointerException, but the second way will just return false
15
Strings, Etc.
Part II: StringBuilder
16
About StringBuilders A StringBuilder has a capacity (the number of characters
it can hold) and a length (the number of characters it is currently holding)
If the capacity is exceeded, the StringBuilder is copied to a new location with more room
StringBuilder is a reimplementation of StringBuffer– The API (collection of methods) is the same– StringBuffers are threadsafe, but StringBuilders are more efficient
StringBuilders are used to implement String concatenation
– Whenever you say String s = "ab" + "cd", Java creates a StringBuffer containing the characters a and b, appends the characters c and d to it, and converts the result back to a String
– As you might guess, this isn’t terribly efficient, but it’s fine if you don’t overdo it
17
StringBuilder constructors
StringBuilder()– Constructs a StringBuilder with a capacity of 16
characters
StringBuilder(int capacity)– Constructs a StringBuilder with the requested capacity
StringBuilder(String str)– Constructs a StringBuilder containing the String str
18
Useful StringBuilder methods I StringBuilder append(X)
– Appends X to the end of this StringBuilder; also (as a convenience) returns this StringBuilder
The append method is so heavily overloaded that it will work with any argument; if the argument is an object, its toString() method is used
19
Useful StringBuilder methods II int length()
– Returns the number of characters in this StringBuilder
void setLength(int newLength)– Sets the number of characters in this StringBuilder;
this may result in truncation of characters at the end, or addition of null characters
20
Useful StringBuilder methods III char charAt(int index)
– Returns the character at the location index
void setCharAt(int index, char ch)– Sets the character at location index to ch
StringBuilder reverse()– The sequence of characters in this StringBuilder is
replaced by the reverse of this sequence, and also returned as the value of the method
21
Useful StringBuilder methods IV StringBuilder insert(int offset, X)
– Insert X starting at the location offset in this StringBuilder, and also return this StringBuilder as the value of the method. Like append, this method is heavily overloaded
StringBuilder deleteCharAt(int index)– Deletes the character at location index
StringBuilder delete(int start, int end)– Deletes chars at locations start through end-1
22
Useful StringBuilder methods V
String substring(int start)– Returns a new String of characters from this
StringBuilder, beginning with the character at the specified index and extending to the end of this string.
String substring(int start, int end)– Returns a new String of characters from this
StringBuilder, beginning at location start and extending to the character at index end-1. Thus the length of the substring is end-begin
String toString()– Returns the characters of this StringBuilder as a String
23
When to use StringBuilders If you make a lot (thousands) of changes or
additions to a String, it is much more efficient to use a StringBuilder
If you are simply examining the contents of a String, then a String is at least as efficient as a StringBuilder
For incidental use (such as creating output lines), use Strings; they are more convenient
24
Strings, etc.
Part III: Characters
25
The Character class char is a primitive type, not an object,
therefore… …there are no methods you can call on a
char This is why we need a Character class!
There are a lot of methods in the Character class
– They are all static– Do you see why?
26
Some Character methods static boolean isDigit(char ch) static boolean isLetter(char ch) static boolean isLetterOrDigit(char ch) static boolean isLowerCase(char ch) static boolean isUpperCase(char ch) static boolean isWhitespace(char ch) static char toLowerCase(char ch) static char toUpperCase(char ch) For more methods, see java.lang.Character
27
Exceptions
28
Errors and Exceptions An error is a bug in your program
– dividing by zero– going outside the bounds of an array– trying to use a null reference
An exception is a problem whose cause is outside your program
– trying to open a file that isn’t there– running out of memory
29
What to do about errors and exceptions
An error is a bug in your program– It should be fixed
An exception is a problem that your program may encounter
– The source of the problem is outside your program– An exception is not the “normal” case, but...– ...your program must be prepared to deal with it
This is not a formal distinction–it isn’t always clear whether something should be an error or an exception
30
Dealing with exceptions Most exceptions arise when you are handling
files– A needed file may be missing– You may not have permission to write a file– A file may be the wrong type
Exceptions may also arise when you use someone else’s classes (or they use yours)
– You might use a class incorrectly– Incorrect use should result in an exception
31
The problem with exceptions Here’s what you might like to do:
– open a file– read a line from the file
But here’s what you might have to do:– open a file– if the file doesn’t exist, inform the user– if you don’t have permission to use the file, inform the user– if the file isn’t a text file, inform the user– read a line from the file– if you couldn’t read a line, inform the user– etc., etc.
All this error checking really gets in the way of understanding the code
32
Three approaches to error checking
1. Ignore all but the most important errors The code is cleaner, but the program will misbehave when it
encounters an unusual error
2. Do something appropriate for every error The code is cluttered, but the program works better You might still forget some error conditions
3. Do the normal processing in one place, handle the errors in another (this is the Java way) The code is at least reasonably uncluttered Java tries to ensure that you handle every error
33
The try statement Java provides a new control structure, the try
statement (also called the try-catch statement) to separate “normal” code from error handling: try {
do the “normal” code, ignoring possible exceptions}
catch (some exception) { handle the exception}
catch (some other exception) { handle the exception}
34
Exception handling is not optional
As in other languages, errors usually just cause your program to crash
Other languages leave it up to you whether you want to handle exceptions
– There are a lot of sloppy programs in the world– It’s normal for human beings to be lazy
Java tries to force you to handle exceptions– This is sometimes a pain in the neck, but...– the result is almost always a better program
35
Error and Exception are Objects
In Java, an error doesn’t necessarily cause your program to crash
When an error occurs, Java throws an Error object for you to use
– You can catch this object to try to recover– You can ignore the error (the program will crash)
When an exception occurs, Java throws an Exception object for you to use
– You cannot ignore an Exception; you must catch it– You get a syntax error if you forget to take care of any possible
Exception
36
The exception hierarchy Throwable: the superclass of
“throwable” objects– Error: Usually should not be caught (instead, the
bug that caused it should be fixed)– Exception: A problem that must be caught
RuntimeException: A special subclass of Exception that does not need to be caught
Hence, it is the Exceptions that are most important to us (since we have to do something about them)
37
The Exception hierarchy II
Throwable
Error Exception
RuntimeExceptionMust be caughtNeed not
be caught
38
A few kinds of Exceptions
IOException: a problem doing input/output– FileNotFoundException: no such file– EOFException: tried to read past the End Of File
NullPointerException: tried to use a object that was actually null (this is a RuntimeException)
NumberFormatException: tried to convert a non-numeric String to a number (this is a RuntimeException)
OutOfMemoryError: the program has used all available memory (this is an Error)
There are about 200 predefined Exception types
39
What to do about Exceptions You have two choices:
– You can “catch” the exception and deal with it For Java’s exceptions, this is usually the better choice
– You can “pass the buck” and let some other part of the program deal with it
This is often better for exceptions that you create and throw
Exceptions should be handled by the part of the program that is best equipped to do the right thing about them
40
What to do about Exceptions II You can catch exceptions with a try statement
– When you catch an exception, you can try to repair the problem, or you can just print out information about what happened
You can “pass the buck” by stating that the method in which the exception occurs “throws” the exception
– Example: void openFile(String fileName) throws IOException { ... }
Which of these you do depends on whose responsibility it is to do something about the exception
– If the method “knows” what to do, it should do it– If it should really be up to the user (the method caller) to decide
what to do, then “pass the buck”
41
How to use the try statement
Put try {...} around any code that might throw an exception
– This is a syntax requirement you cannot ignore
For each Exception object that might be thrown, you must provide a catch phrase: catch (exception_type name) {...}– You can have as many catch phrases as you need– name is a formal parameter that holds the exception object– You can send messages to this object and access its fields
42
finally After all the catch phrases, you can have an
optional finally phrase try { ... }
catch (AnExceptionType e) { ... }catch (AnotherExceptionType e) { ... }finally { ... }
Whatever happens in try and catch, even if it does a return statement, the finally code will be executed
– If no exception occurs, the finally will be executed after the try code
– In an exception does occur, the finally will be executed after the appropriate catch code
43
How the try statement works The code in the try {...} part is executed
If there are no problems, the catch phrases are skipped
If an exception occurs, the program jumps immediately to the first catch clause that can handle that exception
Whether or not an exception occurred, the finally code is executed
44
Ordering the catch phrases A try can be followed by many catches
– The first one that can catch the exception is the one that will catch the exception
Bad: catch(Exception e) { ... }
catch(IOException e) { ... } This is bad because IOException is a
subclass of Exception, so any IOException will be handled by the first catch
– The second catch phrase can never be used
45
Using the exception
When you say catch(IOException e), e is a formal parameter of type IOException
– A catch phrase is almost like a miniature method– e is an instance (object) of class IOException– Exception objects have methods you can use
Here’s an especially useful method that is defined for every exception type:e.printStackTrace();– This prints out what the exception was, and how you got
to the statement that caused it
46
printStackTrace() printStackTrace() does not print on
System.out, but on another stream, System.err– From BlueJ: If it doesn’t show up in the output window, look
in the DOS window that BlueJ opens– From the command line: both System.out and System.err
are sent to the terminal window printStackTrace(stream) prints on the given
stream– printStackTrace(System.out) prints on System.out, and
this output is printed along with the “normal” output
47
Throwing an Exception If your method uses code that might throw
an exception, and you don’t want to handle the exception in this method, you can say that the method “throws” the exception
Example: String myGetLine( ) throws IOException { ... }
If you do this, then the method that calls this method must handle the exception
48
Constructing an Exception Exceptions are classes; you can create your
own Exception with new– Exception types have two constructors: one with no
parameters, and one with a String parameter
You can subclass Exception to create your own exception type
– But first, you should look through the predefined exceptions to see if there is already one that’s appropriate
49
Throwing an Exception
Once you create an Exception, you can throw it– throw new UserException("Bad data");
You don’t have to throw an Exception; here’s another thing you can do with one:– new UserException("Bad
data").printStackTrace();
50
Why create an Exception? If you are writing methods for someone else
to use, you want to do something reasonable if they use your methods incorrectly
Just doing the wrong thing isn’t very friendly Remember, error messages are a good thing
—much better than not having a clue what went wrong
– Exceptions are even better than error messages, because they allow the user of your class to decide what to do
51