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.
• Since every object inherits the Object class, all objects should have the capability to be converted to a string (note, it's up to the programmer of the object to write a toString method.

 

• A java.lang.String object is a sequence of characters plus a collection of methods for manipulating strings.
  • Strings are objects!
• 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).
• Also strings can be used in assignment statements
• 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.
• Whenever an object (any object) no longer has a variable referencing it, then it can no longer be used withing the program. Java will automatically get rid of it. This is called automatic garabage collection.
• A StringBuffer object may be used instead of a string for any task that involves modifying a string.

Constructing Strings

• String Constructors :
• public String();               // Creates an empty string
• public String(String initial_value);   // Creates a copy of a string

 

• Creating strings

• String name = new String();    // create an empty string




 

• When literals are assigned to String variables Java makes those variables serve as references to the literals.
• New String objects are created whenever the String constructors are used.
• In the following example, JAVA does not make new string objects for name1, name2, name3, and name6, instead, they just reference existing string objects.
• Examples:

String name1 = "";          // Reference to the empty string
String name2 = "Socrates";   // References to "Socrates"
String name3 = "Socrates";
String name4 = new String(); // Creates an object
String name5 = new String("Socrates");
String name6 = name4;

 

String Conconcatenation

• 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. In each case, a new string is created.
String lastName = "Onassis";
String jackie = new String("Jacqueline " + "Kennedy " + lastName);
String fred = "Fred" + " Flintstone";   // note a new string is created here
• Primitive types are automatically promoted to strings when mixed with concatenation operators.
System.out.println("The square root of 25 = " + 5); // the number 5 is converted to a string for this operation

Indexing Strings

• The number of characters in a string is its length.
• The method length(), will return this value
• E.g.
String name= "fred";
System.out.println("name is " + name.length() + " characters long");

name is 4 characters long.

• Strings are indexed starting at 0, the first character in the string is at position 0. The last index is at position length() - 1.
• The method charAt(n) (where n is the index) can be used to retrieve a single character from a string.
• E.g.

String name = "Socrates";
char c = name.charAt(3);   // in this case the variable c now has an "r" in it.




• the subString() method can be used to retrieve part of a string
• examples:
String str = "HelloWorld";
str.substring(5)            ==> "World"
str.substring(3)            ==> "loWorld";
str.substring(5,7)          ==> "Wo"
str.substring(0,5)          ==> "Hello";
str.substring(5, str.length())   ==> "World"
 

Converting Data to Strings and vice versa

• the String.valueof() method can be used to convert primitive data types to strings.
static public String valueOf( primitive type  );
• since value of is a static method, you do not need to create a String object in order to use it.
• examples:

String number = new String (String.valueOf(128));  // Creates "128"
String truth = new String (String.valueOf(true));  // Creates "true"
String bee = new String (String.valueOf('B'));     // Creates "B"
String pi = new String(String.valueOf(Math.PI));   // Creates "3.14159"

• when converting floats and doubles to strings it is often desirable to control the number of digits after the decimal point, and to insert commas to make the number easier to read. 
  • The DecimalFormat object allows you to do this.  More on this in chapter 9.
• To convert strings to numbers, (int, float, double, long) you need to use the parse methods belonging to each numeric object type.
• You'll do this when you read data from text files or accept data that the user types into text boxes on forms.

• For example, to convert "123" to 123 you would use:
int j = Integer.parseInt("123");
• Similarly for floats, doubles, and longs.
• Examples:

float f = Float.parseFloat("123.456");
double d = Double.parseDouble("444.44");
long l  = Long.parseLong("22222");

• if a bad character is found in the string, then an NumberFormatException will be thrown. Chapter 11 details how to catch and process exceptions.
• You should always use the try/catch convention when converting strings to numbers.

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. They can take on the following forms:

public int indexOf(int character);
public int indexOf(int character, int startingIndex);
public int indexOf(String string);
public int indexOf(String string, int startingIndex);

public int lastIndexOf(int character);
public int lastIndexOf(int character, int startingIndex);
public int lastIndexOf(String string);
public int lastIndexOf(String string, int startingIndex);

• 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.
• The indexOf methods return the index of the first matching character or string within the searched string. If the character or string is not found, then a -1 is returned.
• The lastIndexOf methods return the index of the last matching character or string within the searched string. If the character or string is not found, then a -1 is returned.

• Character examples:
String string1 = "";
String string2 = "Hello";
String string3 = "World";
String string4 = string2 + " " + string3;

string1.indexOf('o')  ==> -1 string1.lastIndexOf('o')  ==> -1
string2.indexOf('o')  ==> 4  string2.lastIndexOf('o')  ==> 4
string3.indexOf('o')  ==> 1  string3.lastIndexOf('o')  ==> 1
string4.indexOf('o')  ==> 4  string4.lastIndexOf('o')  ==> 7

• Substring examples:
String string1 = "";
String string2 = "Hello";
String string3 = "World";
String string4 = string2 + " " + string3;

string1.indexOf("or")  ==> -1  string1.lastIndexOf("or") ==> -1
string2.indexOf("or")  ==> -1  string2.lastIndexOf("or") ==> -1
string3.indexOf("or")  ==> 1  string3.lastIndexOf("or") ==> 1
string4.indexOf("or")  ==> 7  string4.lastIndexOf("or") ==> 7

• Example, 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
  */
public String keywordSearch(String s, String keyword) {
        String resultStr = "";
        int count = 0;
        int ptr = s.indexOf(keyword);
        while (ptr != -1) {
            ++count;
            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()

Miscellaneous String Methods

• The String class contains additional useful string manipulation methods, including the following:

• Note that methods such as toUpperCase(), toLowerCase(), and trim() produce a new String object because Strings cannot be modified.

Comparing Strings

• Strings are compared according to their lexicographic order.
• Def:  For strings s1 and s2, s1 precedes s2 in lexicographic order (see ASCII or UNICODE tables) 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"

• Methods for comparing strings:

public boolean equals(Object anObject);  // Overrides Object.equals()
public boolean equalsIgnoreCase(String anotherString)
public int compareTo(String anotherString)
public int compareToIgnoreCase(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. That is, they are refering to the same string object. Don't use ==, <, > etc when comparing strings, use the equals() and compareTo() methods instead.

• The compareTo and compareToIgnoreCast methods return:
  • the value 0 if the argument is a string lexicographically equal to this string;
  • a value less than 0 if the argument is a string lexicographically greater than this string;
  • a value greater than 0 if the argument is a string lexicographically less than this string.
• Examples:
String s1 = "fred";
String s2 = "fred";
String s3 = "barney";
boolean result;
int iresult;

result = s1.equals(s2); // result = true;
result = s3.equals(s1); // retult = false;

iresult = s1.compareTo(s2);  // iresult = 0
iresult = s1.compareTo(s3); // iresult  will be a number greater than 0.

StringTokenizer

• StringTokenizer is an object that can help break up a string into its tokens -- e.g., breaking up a name and password pair in boyd:14irXp.

• A token is any sequence of characters that falls between two delimiters.
• A delimiter is one or more programmer defined characters that denote the end of one token and the start of another.
  • Common characters used for delimiters include space, period, tab, end-of-line, semicolon.

 

• When you read data in from text files it is often the case that each line of the file represents one record, with many fields. You can read the line into a string, then use StringTokenizer to break the line up into it component fields. Once you have all the fields broken up, then you can convert them to floats, ints, doubles as needed.

• Example:
StringTokenizer sTokenizer   = new StringTokenizer("http://troy.trincoll.edu/~jjj/index.html”, ":/");
• the string "http://troy.trincoll.edu/~jjj/index.html" is used to create a StringTokenizer object that has colon and backslash as the delimiter characters.
• the resulting tokens are:

http
troy.trincoll.edu
~jjj
index.html

• The following methods can be used to retrive and count the tokens

public int countTokens();  // Tells how many tokens are in the string

public boolean hasMoreTokens(); // tells whether or not there are any more tokens (use this to control a while loop)

public String nextToken(); // retrieves the next token.

• Example:
StringTokenizer sTokenizer   = new StringTokenizer("http://troy.trincoll.edu/~jjj/index.html", ":/");

System.out.println("there are " + sTokenizer.countTokens() + " tokens in the URL");
System.out.println("here they are:");

while(sTokenizer.hasMoreTokens()) {
    System.out.println(sTokenizer.nextToken());
}

produces the following output:

there are 4 tokens in the URL
here they are:
http
troy.trincoll.edu
~jjj
index.html

Summary

Key terms :  delimiter, equal strings, identical strings,lexicographic order,  string literal, token

Suggested Exercises :  1, 2, 3, 4, 5, 14, 16, 21