Lecture Notes 09: The String API, and Primitive types vs Reference types.

Objectives

By the end of this module, for simple programs, you will be able to:

• Demonstrate declaration of String variables;
• Demonstrate use of important String methods;
• Demonstrate use of String operators;
• Demonstrate char extraction from String;
• Demonstrate String manipulation;
• Identify new syntactic elements related to the above.

Before Starting

• Read Sections 9.01 to 9.03 in the Codio Course

If you do not have your Codio course ready, use any text editor or simple IDE. Some possibilities are:

• Write using Sublime; Compile and run in the Terminal
• Use IDEs like: IntelliJ, DrJava, or JGrasp

Catching Up

Before we move forward, let's catch up (complete any remaining work from the previous module)
In this case, make sure we've got:

1. Characters and ASCII, and how to concatenate with strings

The Two Main Categories of Types

As mentioned in the previous class, Strings have an API (Application Programming Interface), which describe the set of rules for using Strings in the programming of an application.

but why do we need to know the rules for using Strings?

Because Strings are different than the other types we've seen, like int, double, float, boolean, and char.

Before we move forward, let's look at how memory works in a computer and how we will imagine it for the duration of the class:

• Each box holds a "word", which is a number of bits (0's or 1's).
• The size of the word varies, but modern OSs use word sizes of 8 bits (a Byte), 16 bits, 32 bits, and 64 bits.
• For our in-class example, we'll use the simple word of one Byte (8-bits).

Reference types:

The String API

The String API is the list of methods that each of these objects provide.
Today, we'll show you how to find and use some of the typical String methods.

First, open this page in a different tab: Java 11 - String API.

You'll notice several things:

• A description in the top
• A set of Constructors (to be discussed in a future module)
• A secction called "Method Summary", with the basic description of each Method.
• A set of detailed descrciptions of each method.

• length()
• isEmpty()
• charAt(<something in here>)
• indexOf(<something in here>)
• substring(<something in here>)
• substring(<something in here>, <something there too>)

Sneak Peek into Methods with Inputs and Outputs

So far we have written methods that do not need any input nor return any output.
However, we have been using methods that do both.
In this section, we will use String methods that

• Return values, and
• require input parameters to do their job properly

1. Return values are what the method call resolves to.


2. Input parameters are placced inside the parenthesis that follow the method's name.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

  public class StringMethods
  {
    public static void main(String args[])     
    {
      String s1 = "The future ain’t what it used to be.";
      // Takes no parameters and returns 36
      int s1Length = s1.length();  // s1.length() resolves into 36
      System.out.println ("The length of s1 is: " + s1Length);
    }
  }  
  

Now, examine the following block of code:

  9
 10
 11
 12
 13
 14
 15

      String s2 = "";
      // Takes no parameters and returns 0
      int s2Length = s2.length();  // s2.length() resolves into 0
      System.out.println ("The length of s2 is: " + s2Length);
      // we can call String methods inside the print!
      System.out.println ("Is s2 empty? " + s2.isEmpty());// s2.isEmpty() resolves into true

String indices

Each character in a string has its own "location" or "index".

The following is a visualization of the indices for the string: I like Squirrels!

• the indices begin at 0!
• there is one index for each character
• the size of the string is one more than the last index!

 16
 17
 18
 19
 20
 21
 22
 23

      String s3 = "I like Squirrels!";
      // Takes no parameters and returns 26
      int s3Length = s3.length();  // s3.length() resolves into 26
      System.out.println ("The length of s3 is: " + s3Length);
      // Let's see what character is at index 7. 7 is an explicit integer input
      char c7 = s3.charAt(7);// s3.charAt(7) resolves into 'S'
      System.out.println ("Character at index 7 in s3 is " + c7);

We can do the inverse search!.
What is the index for some character:

 24
 25
 26
 27

      // what is the index for the letter 'q'. 'q' is an explicit charater input.
      int qIndex = s3.indexOf('q');// s3.indexOf('q') resolves into 8
      System.out.println ("Index for character 'q' in s3 is " + qIndex);

• the index for the letter 'x'

• the index for the letter 'r'

• the index for the letter 'i'

Substrings

We can extract parts of a string.

Observe the following piece of code:

 28
 29
 30
 31
 32

      int beginIndex = 7; 
      // Extract everything after index beginIndex. Input is now a variable.
      String sub1 = s3.substring(beginIndex);// s3.substring(beginIndex) resolves into "Squirrels!"
      System.out.println ("The substring from index " + beginIndex + " to the end in s3 is " + sub1);

We can also indicate a final index for the substring.

Observe the following piece of code:

 33
 34
 35
 36
 37
 38
 39

      int endIndex = 11;
      // This method takes two inputs
      // below, s3.substring(beginIndex, endIndex) resolves into "Squi"
      String sub2 = s3.substring(beginIndex, endIndex);
      System.out.println ("The substring from index " + beginIndex + // continues below
        " to index " + endIndex + " in s3 is " + sub2);

Method calls on Explicit Strings

We can actually call String methods on explicit strings, like in the example show below:

 1
 2
 3
 4
 5
 6
 7
 8
 9

  public class ExplicitStrings
  {
    public static void main(String args[])     
    {
      System.out.println("explicit string".length());
      System.out.println("endogamy".substring(2,5));

    }
  }  
  

Try it out!!
The only difference is that were operating on the explicit string instead of a String in a saved variable.