Skip to main content

Computational Problem Solving with Java and Interactive Object Graphics

Mark F. Russo, PhD

Section 3.3 The String Class

Another way that we benefit from encapsulation is unique to object oriented programming. That is to encapsulate both state (data) and behavior (methods) in a larger structure called an object. The way that we create an instance of an object is by using the code we write when declaring a class. In fact, an object is often referred to as an instance of a class, and creating a new object as instantiating a class. We won’t be writing new custom classes to be instantiated until a bit later. Fortunately, The JDK ships with a huge number of prewritten and debugged classes that we can use directly. The first class we will investigate is the String class.

Subsection 3.3.1 Instantiating a String Object

It may surprise you to learn that String is a class because it also has a handy literal notation that allows us to create String objects directly using double-quotes (""). In fact, there is a second way to instantiate a new String, which is the way we instantiate any object in Java. That is, by using the new keyword to invoke the class constructor. In the following program we create two String objects: one using literal notation and the other by invoking the String constructor using the new keyword. Both result in a new String object.
// Strings.java
public class Strings {
    public static void main(String[] args) {// Start execution here

        String name1, name2;                // Declare variables
        name1 = "Athos";                    // Assign String literal
        name2 = new String("Porthos");      // Invoke String constructor

        System.out.println(name1 + " and " + name2);
    }
}
Listing 3.3.1. Two ways to create String objects.
Once we know the name of the class we want to create and the parameters expected by its constructor, we use the new keyword to invoke the constructor using the following pattern of invocation. The result is a new object, an instance of the class, which we save by assigning to a variable declared with the class type. The following figure demonstrates constructor invocation and assignment of the created object.
Figure 3.3.2. Instantiating a String object

Subsection 3.3.2 String Methods

As we’ve discussed, the idea of encapsulation in object oriented programming implies that objects (and classes) may implement their own state and behavior. The state of an object is captured by its internal variables that it declares, and its behavior by the methods it implements. Often, an object’s methods manipulate and manage its internal data, which is consist with encapsulation.
To access variables and methods declared within an object, we must gain access to its inner scope. We do this using what’s know as the dot operator (.). If we follow an object with a dot, we are effectively peering into the inner scope of the object. We are able to access anything within the object that the object exposes. To demonstrate, let’s have a look at what objects of type String implement.
As you know, the data held and managed by a String object is a sequence of characters. A String object implements several methods that allow us to interrogate and manipulate these internal data.
For example, one of the String object methods is named toUpperCase(). As the method name implies, it converts all characters in a String to uppercase and returns a new String composed of all uppercase letters. Recall in Section 2.6 we learned that a String object is immutable. All String methods that seemingly modify internal character data, actually return a new String object.
Let’s return to JShell for a moment to explore methods of the String class. In the following JShell session, we create a new String object and then invoke its toUpperCase() method which returns a new String made up of uppercase characters only.
jshell> String name2 = new String("Porthos");  // Create a new String object
name2 ==> "Porthos"
|  created variable name2 : String

jshell> String name3 = name2.toUpperCase();    // Produce an uppercase version
name3 ==> "PORTHOS"
|  created variable name3 : String

jshell>
The variable name3 now references an object of type String with the value "PORTHOS".
Here is something interesting to try. JShell is able to look up all the items within the scope of an object and print out a list of their names. Enter the variable name of one of your String objects into JShell followed by the dot-operator, for example, name3. and then press the TAB key. JShell will give you a list of all accessible names, like in the following JShell session. In the case of String everything accessible is a method, hence each item in the list is followed by one or two parentheses.
jshell> name3.         // Press the TAB key
charAt(                chars()                codePointAt(
codePointBefore(       codePointCount(        codePoints()
compareTo(             compareToIgnoreCase(   concat(
contains(              contentEquals(         describeConstable()
endsWith(              equals(                equalsIgnoreCase(
formatted(             getBytes(              getChars(
getClass()             hashCode()             indent(
indexOf(               intern()               isBlank()
isEmpty()              lastIndexOf(           length()
lines()                matches(               notify()
notifyAll()            offsetByCodePoints(    regionMatches(
repeat(                replace(               replaceAll(
replaceFirst(          resolveConstantDesc(   split(
startsWith(            strip()                stripIndent()
stripLeading()         stripTrailing()        subSequence(
substring(             toCharArray()          toLowerCase(
toString()             toUpperCase(           transform(
translateEscapes()     trim()                 wait(
As you can see by the list above, Java provides a rich set of methods and functionalities in the String class, making it powerful and versatile for working with text and String manipulation. Here are some commonly used methods and functionalities of the String class:
Table 3.3.3. Common String methods
Retrieving String length: int length = myStr.length();
Comparing Strings: boolean isEqual = myStr1.equals(myStr2);
Concatenating Strings: char concat = myStr1.concatenate(myStr2);
Accessing characters: char firstChar = myStr.charAt(idx);
Extracting substrings: String substring = myStr.substring(startIdx, endIdx);
Finding substring: int index = myStr.indexOf(subStr);
Converting case: String lowercase = myStr.toLowerCase();
Converting case: String uppercase = myStr.toUpperCase();
Replacing substrings: String replaced = myStr.replace(oldValue, newValue);
Removing whitespace: String trimmed = myStr.trim(response);
To compare the content of two Strings, you should use the equals() method instead of the == operator. The equals() method compares the two Strings character-by-character, while the == operator checks if the two Strings reference the same memory location. Using == to compare Strings is rarely what you want to do. Use it only if you understand the difference. Otherwise, .equals() is the better choice.

Subsection 3.3.3 String Examples

The following program demonstrates several String methods.
// StringExample.java
public class StringExample {
    public static void main(String[] args) {

        String part1 = new String("Anti");          // String constructor
        String part2 = "disestablishmentarianism";  // String literal
        String word  = part1.concat(part2);         // Concat Strings

        // Get word length
        int len = word.length();
        System.out.println(word + " has " + len + " characters");

        // Get character at an index (starts at 0)
        char first = word.charAt(0);
        char last  = word.charAt( word.length() - 1 );
        System.out.println("The first character is " + first);
        System.out.println("The last character is " + last);

        // Find a substring
        int idx = word.indexOf("dis");
        System.out.println("The substring 'dis' starts at index " + idx);

        // Replace substrings
        String newWord = word.replace("Anti", "Pro");
        System.out.println("The new word is " + newWord);
    }
}
Compile and run the program.
javac StringExample.java
java StringExample
Antidisestablishmentarianism has 28 characters
The first character is A
The last character is m
The substring 'dis' starts at index 4
The new word is Prodisestablishmentarianism
Some things to note.
  • The concate() method of String does the same job as the + operator with String operands. You may nest concat() invocations.
  • The index of the first character is 0. Passing 0 to the charAt(0) method returns 'A'. To get the last character, we must pass an index equal to length() - 1. If the first index is 0, then the last index must be 1 less than the length. This is a general rule in Java. All indexes start at 0.

Rule: All Indexes Start at 0.

Whenever using an element index for sequential data in Java, the first index is always 0. This implies that the last index is always the length of the sequence minus 1.
<Prev^TopNext>