Transcript Java, Java, Java - Penn State Berks Home Page

presentation slides for
Object-Oriented Problem Solving
JAVA, JAVA, JAVA
Second Edition
Ralph Morelli
Trinity College
Hartford, CT
published by Prentice Hall
Java, Java, Java
Object Oriented Problem Solving
Chapter 7: Strings
Objectives
• Be more familiar with the string data
structure.
• Know how to solve problems that involve
manipulating strings.
• Be able to use loops in designing string
processing algorithms.
• Have a better understanding of how
inheritance can be used in program design.
Java, Java, Java, 2E by R. Morelli
Copyright 2002. All rights reserved.
Chapter 7: Strings
Outline
•
•
•
•
•
•
•
•
•
•
•
•
•
Introduction
String Basics
Finding Things within a String
Example: Keyword Search
From the Java Library: StringBuffer
Retrieving Parts of Strings
Example: Processing Names and Passwords
Processing Each Character in a String
Case Study: Silly CyberPet String Tricks
Comparing Strings
From the Java Library: StringTokenizer
Object-Oriented Design: The abstract Cipher Class
In the Laboratory: Pig Latin Translation
Java, Java, Java, 2E by R. Morelli
Copyright 2002. All rights reserved.
Chapter 7: Strings
Introduction
• A data structure is a collection of data that
is organized (structured) in some way.
• A string is a collection of character (char)
data. Strings are important data structures in
a programming language
• Strings are used to represent a wide variety
of data.
• In Java, the Object.toString() method
represents an object as a string.
Java, Java, Java, 2E by R. Morelli
Copyright 2002. All rights reserved.
Chapter 7: Strings
String Basics
• A java.lang.String object is a sequence of
characters plus a collection of methods for
manipulating strings.
• Unlike other Java objects, Strings have certain
characteristics in common with the primitive data
types.
• For example, strings can have literals. A String
literal is a sequence of zero or more characters
contained in double quotes -- for example,
“Socrates” and “” (empty string).
Java, Java, Java, 2E by R. Morelli
Copyright 2002. All rights reserved.
Chapter 7: Strings
The String Class
Java, Java, Java, 2E by R. Morelli
Copyright 2002. All rights reserved.
Chapter 7: Strings
Constructing Strings
• String constructors:
public String();
public String(String initial_value);
// Creates an empty string
// Creates a copy of a string
• The following constructor statement creates a
String object and makes name a reference to it:
String name = new String();
String instance variables.
Java, Java, Java, 2E by R. Morelli
Copyright 2002. All rights reserved.
Chapter 7: Strings
Constructing Strings (cont)
• A literal -- e.g., “Socrates” -- is considered a
reference to a String object. All occurrences of
“Socrates” in a program refer to the same object.
Java, Java, Java, 2E by R. Morelli
Copyright 2002. All rights reserved.
Chapter 7: Strings
Constructing Strings (cont)
• When literals are assigned to String variables Java
makes those variables serve as references to the
literals.
String name1 = "";
String name2 = "Socrates";
String name3 = "Socrates";
Java, Java, Java, 2E by R. Morelli
// Reference to the empty string
// References to "Socrates"
Copyright 2002. All rights reserved.
Chapter 7: Strings
Constructing Strings (cont)
• New String objects are created whenever the String
constructors are used:
String name4 = new String();
String name5 = new String("Socrates");
String name6 = name4;
Java, Java, Java, 2E by R. Morelli
// Creates an object
Copyright 2002. All rights reserved.
Chapter 7: Strings
Concatenating Strings
• When surrounded on either side by a String, the +
symbol is used as a binary concatenation operator.
It has the effect of joining two strings together.
String lastName = "Onassis";
String jackie = new String("Jacqueline " + "Kennedy " + lastName);
“Jacqueline Kennedy Onassis”
• Primitive types are automatically promoted to
strings when mixed with concatenation operators.
System.out.println("The square root of 25 = " + 5);
Output: The square root of 25 = 5
Java, Java, Java, 2E by R. Morelli
Copyright 2002. All rights reserved.
Chapter 7: Strings
Indexing Strings
• The number of characters in a string is its length.
String
String
String
String
string1
string2
string3
string4
=
=
=
=
"";
// string1.length() ==> 0
"Hello";
// string2.length() ==> 5
"World";
// string3.length() ==> 5;
string2 + " " + string3; // string4.length() ==> 11;
• The position of a character within a string is called
its index. Strings are zero indexed -- the first
character is at index 0.
Note: Because of zero
indexing, the last
character in a string of 8
characters is at index 7.
Java, Java, Java, 2E by R. Morelli
Copyright 2002. All rights reserved.
Chapter 7: Strings
Converting Data to String
• The String.valueOf() methods are class methods
that convert primitive types into String objects.
Static public String valueOf( primitive type
String
String
String
String
number = new String (String.valueOf(128));
truth = new String (String.valueOf(true));
bee = new String (String.valueOf('B'));
pi = new String(String.valueOf(Math.PI));
//
//
//
//
Creates
Creates
Creates
Creates
"128"
"true"
"B"
"3.14159"
Note the difference
between ‘B’ and “B”
Recall that one refers to
class methods by using the
class name as the qualifier.
Java, Java, Java, 2E by R. Morelli
);
Copyright 2002. All rights reserved.
Chapter 7: Strings
Finding Things within a String
• The indexOf() and lastIndexof() methods are
instance methods that can be used to find the index
position of a character or a substring within a
String.
public
public
public
public
int
int
int
int
indexOf(int character);
indexOf(int character, int startingIndex);
indexOf(String string);
indexOf(String string, int startingIndex);
public
public
public
public
int
int
int
int
lastIndexOf(int character);
lastIndexOf(int character, int startingIndex);
lastIndexOf(String string);
lastIndexOf(String string, int startingIndex);
Java, Java, Java, 2E by R. Morelli
Copyright 2002. All rights reserved.
Chapter 7: Strings
IndexOf() and LastIndexOf()
• The indexOf() method searches from left to right
within a String for either a character or a substring.
• The lastIndexOf() method searches from right to
left for a character or substring.
String
String
String
String
string1
string2
string3
string4
=
=
=
=
"";
"Hello";
"World";
string2 + " " + string3;
string1.indexOf('o')
string2.indexOf('o')
string3.indexOf('o')
string4.indexOf('o')
==>
==>
==>
==>
-1
4
1
4
string1.lastIndexOf('o')
string2.lastIndexOf('o')
string3.lastIndexOf('o')
string4.lastIndexOf('o')
==>
==>
==>
==>
-1
4
1
7
A return value of -1 means
the character is not in the
string.
Java, Java, Java, 2E by R. Morelli
Copyright 2002. All rights reserved.
Chapter 7: Strings
IndexOf() and LastIndexOf()
• The indexOf() and lastIndexOf() methods can also
be used to find substrings, such as “or”.
String
String
String
String
string1
string2
string3
string4
=
=
=
=
"";
"Hello";
"World";
string2 + " " + string3;
string1.indexOf("or")
string2.indexOf("or")
string3.indexOf("or")
string4.indexOf("or")
==>
==>
==>
==>
-1
-1
1
7
string1.lastIndexOf("or")
string2.lastIndexOf("or")
string3.lastIndexOf("or")
string4.lastIndexOf("or")
==>
==>
==>
==>
A return value of -1 means that
“or” is not in the string.
Java, Java, Java, 2E by R. Morelli
Copyright 2002. All rights reserved.
Chapter 7: Strings
-1
-1
1
7
Example: Keyword Search
• Finding a keyword within a string is a task that
word processors and browsers must do.
• Algorithm Design: Find every occurrence of some
keyword, K, within a string, S:
Suppose S is our string and K is the keyword.
Initialize a counter variable and result string.
Set P to the indexOf() the first occurrence of K in S.
While ( P != -1 )
While loop because there may
Increment the counter
be 0 or more occurrences.
Insert P into the result string
Set P to the next location of the keyword in S
Insert the count into the result string
Return the result string as a String
When P is -1, there are no
more occurrences of K in S.
Java, Java, Java, 2E by R. Morelli
Copyright 2002. All rights reserved.
Chapter 7: Strings
Implementation: Keyword Search
/**
* Pre: s and keyword are any Strings
* Post: keywordSearch() returns a String containing the
* number of occurrences of keyword in s, followed
* by the starting location of each occurrence
Bound: When ptr is
*/
public String keywordSearch(String s, String keyword) {
-1, no more
String resultStr = "";
occurrences of s.
int count = 0;
int ptr = s.indexOf(keyword);
while (ptr != -1) {
Initializer
++count;
Updater
resultStr = resultStr + ptr + " ";
ptr = s.indexOf(keyword, ptr + 1);
// Find next occurrence
}
resultStr = count + ": " + resultStr;
// Insert the count
return resultStr;
// Return as a String
} // keywordSearch()
Test Performed
keywordSearch( "this is a test","is")
keywordSearch( "able was i ere i saw elba","a")
keywordSearch( "this is a test","taste")
Java, Java, Java, 2E by R. Morelli
Expected Result
2: 2 4
4: 0 6 18 24
0:
Copyright 2002. All rights reserved.
Test data should
test all possible
outcomes.
Chapter 7: Strings
Automatic Garbage Collection
• Immutability: Java Strings are cannot be modified.
Whenever you assign a new value to a String, Java must
create a new String object and discard the old one. In
resultStr = resultStr + ptr + “ “;
Java will create a new object (b) referenced by resultStr:
The original resultStr
object has no more
references to it so it has
to be garbage collected
which takes time.
Java, Java, Java, 2E by R. Morelli
This is the new
resultStr.
Copyright 2002. All rights reserved.
Chapter 7: Strings
Library: java.lang.StringBuffer
• Objects of java.lang.StringBuffer class are strings
that can be modified. Some of its methods are:
Java, Java, Java, 2E by R. Morelli
Copyright 2002. All rights reserved.
Chapter 7: Strings
The Revised keywordSearch()
public String keywordSearch(String s, String keyword) {
StringBuffer resultStr = new StringBuffer(); // Create StringBuffer
int count = 0;
int ptr = s.indexOf(keyword);
while (ptr != -1) {
++count;
resultStr.append(ptr + " "); // Insert letters into it
ptr = s.indexOf(keyword, ptr + 1);
The revised
}
resultStr.insert(0, count + ": ");
keywordSearch()
return resultStr.toString(); // Convert buffer back to a String
uses a local
} // keywordSearch()
StringBuffer to
build the result, but
converts it back to
String before
returning.
Java, Java, Java, 2E by R. Morelli
Copyright 2002. All rights reserved.
Chapter 7: Strings
Retrieving Parts of Strings
• The String class contains methods to retrieve
characters and substrings from a string.
Takes the
substring
from
startIndex to
endIndex
public char charAt(int index)
public String substring(int startIndex)
public String substring(int startIndex, int
endIndex)
Takes the
substring from
startIndex to the
end of string.
Note: endIndex points to index
after the last character taken.
String str = "HelloWorld";
str.substring(5)
==> "World"
str.substring(3)
==> "loWorld";
//
0123456789
String str = "HelloWorld";
str.substring(5,7)
==> "Wo"
str.substring(0,5)
==> "Hello";
str.substring(5, str.length())
==> "World"
Java, Java, Java, 2E by R. Morelli
Copyright 2002. All rights reserved.
Chapter 7: Strings
Example: Names and Passwords
• Problem: Suppose user names and passwords are
stored as delimited strings where ‘:’ is the delimiter.
Write methods to get the name and password.
• Algorithm: Use the indexOf()
smith:bg1s5xxx
mccarthy:2ffo900ssi
and substring() methods.
public String getName(String str) {
int posColon = str.indexOf(':');
// Find the delimiter
String result = str.substring(0, posColon); // Extract the name
return result;
These 3 could be a single statement:
}
return str.substring(0, str.indexOf(‘:’));
public String getPassword(String str) {
int posColon = str.indexOf(':');
// Find the delimiter
String result = str.substring(posColon + 1); // Extract the password
return result;
}
Java, Java, Java, 2E by R. Morelli
Copyright 2002. All rights reserved.
Chapter 7: Strings
Processing Each Character in a String
• For example, suppose you want to count the
number of occurrences of a certain character in a
string:
Use the string’s
length as a bound.
// countChar counts the number of ch’s in str
// Precondition: Neither str nor ch are null
// Postcondition: countchar() == the number of ch in str
public int countChar(String str, char ch) {
int counter = 0;
// Initialize a counter
for (int k = 0; k < str.length(); k++)
// For each character
if (str.charAt(k) == ch)
// If it's a ch
counter++;
//
count it
return counter;
// Return the result
}
Possible off-by-one Error: Remember that
the last character in a string is at index
length()-1.
Java, Java, Java, 2E by R. Morelli
Copyright 2002. All rights reserved.
Chapter 7: Strings
Case Study: Silly String Tricks
• Problem: Give CyberPet a bunch of string tricks, each of
which transforms a string into a different string.
• Problem Decomposition: The StringTricks class will have
a getNextTrick() method that will pick a trick from
CyberPet’s bag of tricks.
The
tricks.
Java, Java, Java, 2E by R. Morelli
Copyright 2002. All rights reserved.
Chapter 7: Strings
Method Design: getNextTrick()
• getNextTrick() uses modular arithmetic to pick a number
between 0 and nTricks -1 and calls a trick method.
/**
* Pre: s is any non null string
* Post: A trick is picked and s is transformed and returned
* The nextTrick variable is incremented modulo NTRICKS
*/
public String getNextTrick(String s) {
String result = new String();
// Stores the result
if (nextTrick == 0)
// Do the next trick
result = reverse(s);
else if (nextTrick == 1)
result = capitalize(s);
else
result = toUpperCase(s);
nextTrick = (nextTrick + 1) % NTRICKS; // Update for next time
return result;
} // getNextTrick()
nextTrick gives the
number of the next trick
to be performed.
Java, Java, Java, 2E by R. Morelli
Copyright 2002. All rights reserved.
Chapter 7: Strings
Method Design: reverse()
• reverse() reverses the letters in its String parameter.
A StringBuffer is used to
construct the reverse of s.
/**
* Pre: s is any non null string
* Post: s is returned in reverse order
*/
public String reverse(String s) {
StringBuffer result = new StringBuffer();
for (int k = s.length() -1; k >= 0; k--) {
result.append(s.charAt(k));
} //for
return result.toString();
} // reverse()
The result must be
converted back to a String.
Java, Java, Java, 2E by R. Morelli
Copyright 2002. All rights reserved.
Chapter 7: Strings
Method Design: toUpperCase()
• toUpperCase() converts its parameter into
UPPERCASE.
Check that the
character needs to be
converted.
/**
* Pre: s is any non NULL string
* Post: Each letter in s is converted to UPPERCASE
*/
public String toUpperCase(String s) {
StringBuffer result = new StringBuffer();
for (int k = 0; k < s.length(); k++) {
if ((s.charAt(k) >= 'a') && (s.charAt(k) <= 'z')) // If lowercase
result.append((char)(s.charAt(k) - 32)); // Convert
else
result.append((char)s.charAt(k));
} //for
return result.toString();
} // toUpperCase()
Subtracting 32 from the
integer representation
changes a char to uppercase.
Java, Java, Java, 2E by R. Morelli
Copyright 2002. All rights reserved.
Chapter 7: Strings
Method Design: capitalize()
• capitalize() converts its parameter into a string with
an initial capital letter (Capitalize).
Note use of
toUpperCase(char)
method.
/**
* Pre: s is any non null string
* Post: s is returned with only its first letter capitalized
*/
public String capitalize(String s) {
if (s.length() == 0)
return s;
StringBuffer result = new StringBuffer();
result.append(toUpperCase(s.charAt(0))); // Change first to UPPERCASE
for (int k = 1; k < s.length(); k++) {
// Convert every other letter
result.append(toLowerCase(s.charAt(k)));
} //for
return result.toString();
} // capitalize()
private char toUpperCase(char ch) {
if ((ch >= ‘a’) && (ch <= ‘z’))
return (char)(ch - 32);
// Explicit cast required
return ch;
}
Java, Java, Java, 2E by R. Morelli
Copyright 2002. All rights reserved.
Chapter 7: Strings
Miscellaneous String Methods
• The String class contains additional useful string
manipulation methods, including the following:
Method Signature
boolean endsWith( String suffix)
boolean startsWith(String prefix)
String toUpperCase()
String toLowerCase()
String trim()
Example
"Perfection".endsWith("tion")
"Perfection".startsWith("Per")
"Perfection".toUpperCase()
"Perfection".toLowerCase()
" Perfection ".trim()
Value
true
true
"PERFECTION"
"perfection"
"Perfection"
• Note that methods such as toUpperCase(),
toLowerCase(), and trim() produce a new String
object because Strings cannot be modified.
Java, Java, Java, 2E by R. Morelli
Copyright 2002. All rights reserved.
Chapter 7: Strings
Comparing Strings
• Strings are compared according to their
lexicographic order.
• Def: For strings s1 and s2, s1 precedes s2 in
lexicographic order if its first character precedes
the first character of s2. If their first characters are
equal, then s1 precedes s2 if its second character
precedes the second character of s2, and soon.
Finally, the empty string is handled as a special
case, preceding all other strings.
• The following strings are arranged in lexicographic
order:
" " "!" "0" "A" "Andy" "Z" "Zero" "a" "an" "and" "andy" "candy" "zero"
Java, Java, Java, 2E by R. Morelli
Copyright 2002. All rights reserved.
Chapter 7: Strings
Lexicographic Order
• A Java method that implements our
definition of lexicographic order.
public boolean precedes(String s1, String s2) {
int minlen = Math.min(s1.length(), s2.length()); // Pick shorter length
int k = 0;
// Start at the first character
while (k < minlen) {
// While more characters
if (s1.charAt(k) < s2.charAt(k))
// If kth s1 < kth in s2
return true;
//
then s1 precedes s2
else if (s2.charAt(k) < s1.charAt(k))
// If kth in s2 < kth in s1
return false;
//
s1 does not precede s2
else
// If neither case
k++;
//
go on to the next character
} // while
return s1.length() < s2.length();
// If all characters so far are equal
} // precedes()
//
s1 < s2 if it is shorter than s2
Java, Java, Java, 2E by R. Morelli
Copyright 2002. All rights reserved.
Chapter 7: Strings
String Identity vs. String Equality
• Methods for comparing strings:
public boolean equals(Object anObject); // Overrides Object.equals()
public boolean equalsIgnoreCase(String anotherString)
public int compareTo(String anotherString)
• Two strings are equal if they have the same letters
in the same order:
String s1 = "hello";
String s2 = "Hello";
s1.equals(s2)
// false
s1.equals("hello”); // true
• Error: Using == to compare two strings. For
objects, o1 == o2 means o1 and o2 are identical.
• The == operator is equivalent to Object.equal()
method: o1.equal(o2) means o1 and o2 are
identical.
Java, Java, Java, 2E by R. Morelli
Copyright 2002. All rights reserved.
Chapter 7: Strings
String Identity vs. String Equality (cont)
Given the following declarations
String s1 = new
String("hello");
String s2 = new
String("hello");
String s3 = new
String("Hello");
String s4 = s1;
// s1 ==
String s5 = "hello";
String s6 = "hello";
We get the following equality results
s1.equals(s2)
s1.equals(s3)
s1.equalsIgnoreCase(s3)
s1.equals(s4)
s1.equals(s5)
s1.equals(s6)
==>
==>
==>
==>
==>
==>
true
false
true
true
true
true
s4
And the following identity results
s5 and s6 refer
to the same
(identical)
literal object.
Java, Java, Java, 2E by R. Morelli
s1
s1
s1
s1
s5
==
==
==
==
==
s2
s3
s4
s5
s6
Copyright 2002. All rights reserved.
==>
==>
==>
==>
==>
Chapter 7: Strings
false
false
true
false
true
String Identity vs. String Equality (cont)
• In this figure, s1, s2, s4, s5, and s6 are equal.
• Strings s1 and s4 are identical, as are s5 and s6.
Java, Java, Java, 2E by R. Morelli
Copyright 2002. All rights reserved.
Chapter 7: Strings
Library: java.util.StringTokenizer
• Break up a string into its
tokens -- e.g., breaking up
a name and password pair
in boyd:14irXp.
• The StringTokenizer class
is designed for this
purpose.
Java, Java, Java, 2E by R. Morelli
Copyright 2002. All rights reserved.
Chapter 7: Strings
StringTokenizer (cont)
• A StringTokenizer breaks a string into tokens separated by
delimiters, which by default value are the whitespace
characters:
StringTokenizer sTokenizer
= new StringTokenizer("This is an English sentence.");
In this case, the period is
part of last token
Tokens
This
is
an
English
sentence.
• The delimiters can be specified as a String parameter:
StringTokenizer sTokenizer
= new StringTokenizer("http://troy.trincoll.edu/~jjj/index.html”, ":/");
Tokens
Java, Java, Java, 2E by R. Morelli
http
troy.trincoll.edu
~jjj
index.html
Copyright 2002. All rights reserved.
Chapter 7: Strings
OO Design: Abstract Cipher Class
• Problem: Create a collection of Cipher
classes, including a Caesar cipher and a
transposition cipher.
• Methods used by all ciphers -- encrypt(),
decrypt(), encode() and decode() -- should
be defined or implemented in a superclass.
Java, Java, Java, 2E by R. Morelli
Copyright 2002. All rights reserved.
Chapter 7: Strings
OO Design: Abstract Cipher Class
The Cipher class is
abstract because some of
its methods are not
implemented.
The encrypt() and decrypt()
methods are the same for every
subclass and should be
implemented in the superclass.
The encode() and decode() methods are
different for every subclass, so they
must be defined abstractly in the
superclass.
Java, Java, Java, 2E by R. Morelli
Copyright 2002. All rights reserved.
Chapter 7: Strings
Class Design: The Cipher Superclass
The encrypt() and decrypt() methods
work the same for every cipher, so
they are completely implemented.
import java.util.*;
public abstract class Cipher {
public String encrypt(String s) {
StringBuffer result = new StringBuffer("");
// Use a StringBuffer
StringTokenizer words = new StringTokenizer(s); // Break s into its words
while (words.hasMoreTokens()) {
// For each word in s
result.append(encode(words.nextToken()) + " "); //
Encode it
}
return result.toString();
// Return the result
} // encrypt()
public String decrypt(String s) {
StringBuffer result = new StringBuffer("");
// Use a StringBuffer
StringTokenizer words = new StringTokenizer(s); // Break s into words
while (words.hasMoreTokens()) {
// For each word in s
result.append(decode(words.nextToken()) + " "); // Decode it
}
return result.toString();
// Return the decryption
} // decrypt()
Polymorphism: encode()
and decode() are
implemented differently in
each cipher.
public abstract String encode(String word);
public abstract String decode(String word);
} // Cipher
Java, Java, Java, 2E by R. Morelli
An abstract method
has no body, no
implementation.
// Abstract methods
Copyright 2002. All rights reserved.
Chapter 7: Strings
Rules for Abstract Methods and Classes
• Any class containing an abstract method must be
declared an abstract class.
• An abstract class cannot be instantiated. It must be
subclassed.
• A subclass of an abstract class may be instantiated
only if it implements all of the superclass's
abstract methods. A subclass that implements only
some of the abstract methods must itself be
declared abstract.
• A class may be declared abstract even it contains
no abstract methods. It could contain instances
variables that are common to all its subclasses.
Java, Java, Java, 2E by R. Morelli
Copyright 2002. All rights reserved.
Chapter 7: Strings
Class Design: Caesar Cipher
• In a Caesar cipher, which was first used by Julius Caesar in
the Gaulic campaigns, letters of the alphabet are shifted by
three letters, wrapping around at the end of the alphabet:
PlainText:
abcdefghijklmnopqrstuvwxyz
CaesarShifted: defghijklmnopqrstuvwxyzabc
• An expression to shift a character:
ch = (char)('a' + (ch -'a'+ 3) % 26);
(char)('a' + (ch -'a'+ 3) % 26)
(char)('a' + ('y' - 'a' +3) % 26)
(char)(97 + (121 - 97 + 3) % 26)
(char)(97 + (27 % 26))
(char)(97 + 1)
(char)(98)
'b'
Java, Java, Java, 2E by R. Morelli
//
//
//
//
//
//
//
Perform Caesar shift
Perform Caesar shift
on 'y'
Map 'y' to 0..25
Shift by 3, wrapping around
Map result back to 'a' to 'z'
Convert from int to char
Copyright 2002. All rights reserved.
Chapter 7: Strings
Implementation: Caesar Class
public class Caesar extends Cipher {
Caesar inherits from Cipher, so it must
implement encode() and decode().
public String encode(String word) {
StringBuffer result = new StringBuffer();
for (int k = 0; k < word.length(); k++) {
char ch = word.charAt(k);
ch = (char)('a' + (ch -'a'+ 3) % 26);
result.append(ch);
}
return result.toString();
} // encode()
// Initialize a string buffer
// For each character in word
// Get the character
// Perform caesar shift
// Append it to new string
// Return the result as a string
public String decode(String word) {
StringBuffer result = new StringBuffer();
// Initialize a string buffer
for (int k = 0; k < word.length(); k++) {
// For each character in word
char ch = word.charAt(k);
// Get the character
ch = (char)('a' + (ch - 'a' + 23) % 26); // Perform reverse caesar shift
result.append(ch);
// Append it to new string
}
return result.toString();
// Return the result as a string
} // decode()
} // Caesar
Java, Java, Java, 2E by R. Morelli
Copyright 2002. All rights reserved.
Chapter 7: Strings
Implementation: Transpose Class
Transpose inherits from Cipher, so it
must implement encode() and decode().
public class Transpose extends Cipher {
public String encode(String word) {
StringBuffer result = new StringBuffer(word);
return result.reverse().toString();
} // encode()
public String decode(String word) {
return encode(word);
} // decode
} // Transpose
// Initialize a buffer
// Reverse and return it
// Just call encode
This version of transpose just reverses the word
using the reverse() method from StringBuffer.
Java, Java, Java, 2E by R. Morelli
Copyright 2002. All rights reserved.
Chapter 7: Strings
The TestEncrypt Class
public class TestEncrypt {
public static void main(String argv[]) {
Caesar caesar = new Caesar();
String plain = "this is the secret message";
// Here's the message
String secret = caesar.encrypt(plain);
// Encrypt the message
System.out.println(" ******** Caesar Cipher Encryption *********");
System.out.println("PlainText: " + plain);
// Display the results
System.out.println("Encrypted: " + secret);
System.out.println("Decrypted: " + caesar.decrypt(secret)); // Decrypt
Transpose transpose = new Transpose();
secret = transpose.encrypt(plain);
System.out.println("\n ******** Transpose Cipher Encryption *********");
System.out.println("PlainText: " + plain);
// Display the results
System.out.println("Encrypted: " + secret);
System.out.println("Decrypted: " + transpose.decrypt(secret));
} // main()
} // TestEncrypt
Java, Java, Java, 2E by R. Morelli
Copyright 2002. All rights reserved.
Chapter 7: Strings
The TestEncrypt Output
A Caesar cipher has different letters
from the plaintext.
********* Caesar Cipher Encryption *********
PlainText: this is the secret message
Encrypted: wklv lv wkh vhfuhw phvvdjh
Decrypted: this is the secret message
********* Transpose Cipher Encryption *********
PlainText: this is the secret message
Encrypted: siht si eht terces egassem
Decrypted: this is the secret message
A Transpose cipher has the same letters
as the plaintext, but they’re rearranged.
Java, Java, Java, 2E by R. Morelli
Copyright 2002. All rights reserved.
Chapter 7: Strings
In the Laboratory: PigLatinApplet
• Objectives:
– To introduce the String class methods.
– To give practice using simple looping constructs
• Problem Statement: Write a Java applet that translates an
English sentence or expression into Pig Latin .
• Pig Latin Rules:
– If the word begins with a consonant -- such as string,
Latin -- divide the word at the first vowel, swapping the
front and back halves and append ay to the word -ingstray, atinLay.
– If the word begins with a vowel -- such as am, are, i -append yay to the word -- amyay, areyay, iyay.
– If the word has no vowels (other than ‘y’) -- such as my
thy-- append yay to it -- myyay, thyyay.
Java, Java, Java, 2E by R. Morelli
Copyright 2002. All rights reserved.
Chapter 7: Strings
PigLatin Applet: Design
• GUI Design
• Decomposition: Classes
– PigLatinApplet: serves as the user interface.
– PigLatin: performs the translations.
Java, Java, Java, 2E by R. Morelli
Copyright 2002. All rights reserved.
Chapter 7: Strings
Design: PigLatin and PigLatinApplet
As in the
Math class,
static
methods can
be called
without
instantiating
a PigLatin
object.
Java, Java, Java, 2E by R. Morelli
Copyright 2002. All rights reserved.
Chapter 7: Strings
PigLatin: Design
Only one
public
method.
Java, Java, Java, 2E by R. Morelli
Copyright 2002. All rights reserved.
Chapter 7: Strings
Algorithm Design
• PigLatin.translate(String) algorithm
Precondition: The String parameter contains a sentence
Initialize a result string
For each word in the input string
// String tokenizer task
translate it into Pig Latin
// translateWord task
Append it to the result string // String concatenation task
Return the result string
• PigLatin.translateWord(String) algorithm
Precondition: The String parameter contains a single word
Find the first vowel in the word.
Apply the Pig Latin translation rules
• PigLatin.findFirstVowel(String) algorithm
Since the rules for handling a word that begins with a vowel and one
that has no vowel are the same, return 0 if the word contains no
vowel, otherwise return the location of the first vowel.
Java, Java, Java, 2E by R. Morelli
Copyright 2002. All rights reserved.
Chapter 7: Strings
Technical Terms
ciphertext
data structure
lexicographic order
plaintext
string literal
transposition cipher
concatenation
empty string
off-by-one error
read only
substitution cipher
unit indexed
Java, Java, Java, 2E by R. Morelli
Copyright 2002. All rights reserved.
cryptography
index
orphan object
string
token
zero indexed
Chapter 7: Strings
Summary Of Important Points
• A String literal is a sequence of 0 or more
characters enclosed within double quote marks. A
String object is a sequence of 0 or more
characters, plus a variety of class and instance
methods and variables.
• The String concatenation operator is the
overloaded + symbol; it is used to combine two
strings into a single String:
“hello” + “world” ==> “helloworld”.
• Strings are indexed starting at 0 (zero indexing).
Java, Java, Java, 2E by R. Morelli
Copyright 2002. All rights reserved.
Chapter 7: Strings
Summary Of Important Points (cont)
• The indexOf() and lastIndexOf() methods are
used for finding the first or last occurrence of a
character or substring within a String.
• The valueOf() methods are used to convert a
nonstring into a String.
• The length() method is used to determine the
number of characters in a String.
• The charAt() method is used to return the single
character at a particular index position.
• The various substring() methods are used to return
the substring at particular index positions in a
String.
Java, Java, Java, 2E by R. Morelli
Copyright 2002. All rights reserved.
Chapter 7: Strings
Summary Of Important Points (cont)
• The overloaded equals() method returns true if
two Strings contain the same exact sequence of
characters. The == operator, when used on Strings,
returns true if two references designate the same
String object.
• A StringTokenizer is an object that can be used to
break a String into a collection of tokens separated
by delimiters. The whitespace characters, -- tabs,
blanks, and newlines -- are the default delimiters.
• An abstract class is one that contains one or more
abstract methods, which are methods that lack a
method body or an implementation. An abstract
class can be subclassed but not instantiated.
Java, Java, Java, 2E by R. Morelli
Copyright 2002. All rights reserved.
Chapter 7: Strings