Lecture Notes 07: Chars (ASCII), Strings, and the String API

Objectives

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

Distinguish between characters and strings.
Write simple code that works with characters and strings.
Identify some syntax errors related to characters and strings.
Have some stress relieving fun after that long integer module.

Why are strings useful in computation?

Analysis of DNA/bioinformatics
Storing, searching, and analyzing documents written by humans
Other examples?

Characters vs Strings

About characters:

The term character is used to mean:
- Letters like a, b, X, Y.
- Symbols like #, $, @, !, ., ", _.
- More symbols like 1, 4, 5, 9.
- And eveb more symbols like a single space, a newline, and more.
Each character is a single symbol.
The reserved word char is used to declare variables that hold such values.
Pronounce char as the English word char, rhyming with "far".

For example:


public class CharExample {

  public static void main (String[] argv)
  {
    char first = 'o';
    char second = 'y';
    char third = '!';
    System.out.print (first);
    System.out.print (second);
    System.out.println (third);
  }

}

A String, on the other hand, has zero or more characters.

About strings:

A String in Java is actually a class. We'll cover more on classes later. For now, you can conceptually treat a String and a 1D array, although we'll see we are UNABLE to index Strings using [ ] nor get their lengths using .length.
Strings are declared using String as in
```
  String s = "Hello World!";
    
```
Strings used double-quotes for delineation.
It is possible to declare and use an empty string, as in:
```
  String s = "";
    
```

We'll look at some string examples further below.

Character examples

A char, unlike a String is indeed a primitive type, just like integers and doubles. In fact, characters are stored in memory as integers, where the integer corresponds to the character. You may have heard of an ASCII lookup table before, which shows this mapping:

Characters and ASCII

Characters are represented as integers in the machine.

It is often useful to work with the integer representation, and to go back and forth between representations.

For example:


public class CharExample3 {

  public static void main (String[] argv)
  {
    // A typical char:
    char first = 'a';

    // Now extract the int representation:
    int i = (int) first;
    System.out.println (i);

    // Perform integer arithmetic:
    int j = i+2;

    // Convert (or cast) back to char:
    char third = (char) j;

    // Print as char:
    System.out.println (third);
  }

}

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 (link opens in new 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.

Today, we'll use the following String methods:

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

Because Strings are a class in Java, they come with a bunch of useful features that are built in to the language. Much like your homework problems, developers have written several methods and packaged them under the String class so that we're able to access them and use them. Let's look at an illustrative example:


public class StringExample {

  public static void main (String[] argv)
  {
    // Declare a string variable and assign it an actual string:
    String s = "The quick brown fox jumps over the lazy dog";
    System.out.println (s);

    // Extract its length:
    int k = s.length ();
    System.out.println (k);     // 43. Includes spaces.

    // You can identify any character in the string, such as:
    char c = s.charAt(0);
    System.out.println (c);     // Prints 'T'.

    // The very useful concatenation operator +
    String s1 = "The";
    String s2 = "quick";
    String s3 = s1 + s2;        // s3 is "Thequick"

    // You can concatenate any number of strings in an expression:
    String s4 = "brown";
    String s5 = s1 + " " + s2 + " " + s4;
    System.out.println (s5);

    // You can concatenate any other type:
    String allLetters = "";
    for (char ch='a'; ch<='z'; ch++) {
      allLetters = allLetters + ch;
    }
    System.out.println ("The alphabet: " + allLetters);

    // Example with concatenating integers onto a string:
    String num1to10 = "";
    for (int i=1; i<=10; i++) {
      num1to10 = num1to10 + " " + i;
    }
    System.out.println ("Numbers 1 to 10: " + num1to10);

    // Example with a BUG when concatenating integers onto a string:
    String num11to20 = "";
    num11to20 = num11to20 + (11 + 12 + 14 + 15 +16 +17 +18 + 19 + 20);
    System.out.println ("Numbers 11 to 20: " + num11to20);
  }

}

Activity 1: Copy the above program, compile and execute in the Java Visualizer.

Strings can contain the escape characters we saw earlier in Lecture Notes 02.

Activity 2: Consider this snippet of code:

    int q = 5;

    System.out.println (q);
    System.out.println ("q");
    System.out.println ('q');

    String s = "q";
    char c = 'q';

What gets printed?

The Two Main Categories of Types

Primitive types:

The following are called "Primitive Types": int, float, double, boolean, and char.
They are called "Primitive" because the function they perform is extremely simple:

They are locations in memory inside of which you save the actual value you need.

These different primitive types cover different ranges of values:

Reference types:

As we will see later in the semester, we will be creating objects that contain so much information that it does not make sense to save them inside the box or space assigned to a variable.
Instead, we use a clever mechanism: We leave a forwarding number!, or in other words, the address of where we are keeping the object's information.

When we make a variable of a Reference type, like String, inside the variable, instead of saving the String value, we save the address of the starting location where we are going to keep more information about the value or values of that type.

Activity 3: Let's trace through some primitve types and reference types in memory.

Substrings

We can extract parts of a string.

Observe the following piece of code:



      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);



      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);

Next class:

We'll go through some more in-class exercises on strings as part of Homework5

Assignments for next lecture:

Get as far as you can on Homework5 problems on your own.

CS 1111