Lecture Notes 08: 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.

Before Starting

Read Sections 8.01 to 8.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:

Nested loops. Reading and writing! avoid initialization errors and bugs relating to the iterations.

Characters vs strings

About characters:

The term character is used to mean:
- Letters like a, b, X, Y.
- Symbols like #, $, @, !.
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);
  }

}

In this example:

The reserved word char is used to declare the variable first
```
  char first = 'o';
    
```
Single quotes delineate an actual character:
```
  char first = 'o';
    
```

Activity 1: In a file called MyCharExample.java write up a similar example with different characters (expressing surprise).

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

About strings:

Strings are declared using String as in
```
  String s = "meh";
    
```
Strings used double-quotes for delineation.
Examples: "meh", "yada yada", "Alfred E. Neumann", "The quick brown fox jumps over the lazy dog"
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

char variables can be used in a for-loop, as in:


public class CharExample2 {

  public static void main (String[] argv) 
  {
    for (char ch='a'; ch <= 'z'; ch++) {
      System.out.print (ch);
    }
    System.out.println ();
  }

}

Activity 2: In a file called MyCharExample2.java modify the above to print the letters in reverse order, from z to a.

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

}

Activity 3: Write up, compile and execute the above program.

Note:

The conversion from one type of variable (say, int) to another type (say, char) is called casting.
You would say "I'm casting a char into an int".
The syntax is to have the target type in parens on the right side of the assignment symbol:
```
  char third = (char) j;
    
```

In some cases, we don't explicitly need to cast. We could have written

  // Going from char to int:
  int i = first;

As a general stylistic rule, it's best to specify a cast even if not explictly required.
Why, then, does the compiler allow some casts without programmer intention stated explicitly?
- It's considered safe to go from more specific to more general.
- All char's are int's
- But not the other way around.
- Thus, there are some integers that have no char equivalent.
- The compiler then wants you to say "I know what I'm doing" by explicitly stating the cast.

Important digression:

We've learned a really important concept: type.
That is, variables have a property called type.
So far, we've seen integer, double, boolean, String, and character types.
As it will turn out, every variable must have a type.
There are strict rules in going back and forth between types.
These rules are very useful in helping programmers avoid mistakes.
For example, without "types" you could accidentally use an int for 3.141 and have that incorrectly represented as 3.
In a later module we will encounter a deeper understanding of "types".

OK, back to characters.

Activity 4: In a file called MyCharExample3.java write code to identify the integer values for the capital letters 'A' to 'Z'. What are the characters represented by the integers 97 through 122?

Strings

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 5: Write up the above program, compile and execute.

Now let's understand the code:

First, the declaration using (with cap 'S') String

  String s = "The quick brown fox jumps over the lazy dog";

The variable is called s and value of this variable is "The quick brown fox jumps over the lazy dog".
Now for something strange:
```
  int k = s.length ();
    
```
It is possible to call a method, seemingly attached to the string itself.
There are, it turns out, many such methods. Example:
```
  char c = s.charAt(0);
    
```
This method even takes an integer argument (parameter) like 0.
One of the most useful ways to combine strings is to concatenate (join) them using the +. operator.
```
  String s5 = s1 + " " + s2 + " " + s4;
    
```
This is the same "plus" operator we used for integers. It's doing double-duty as concatenation operator for strings.
You can concatenate all kinds of things into strings.
For example, integers:
```
  num1to10 = num1to10 + " " + i;
    
```
Here, it's worth pointing out, num1to10 is a string variable but i is an integer variable.
At long last, we can make output more friendly.

Thus, instead of just printing

  System.out.println (allLetters);

we print

  System.out.println ("The alphabet: " + allLetters);

Lastly, be careful when concatenating numbers to strings.
```
  num11to20 = num11to20 + (11 + 12 + 14 + 15 +16 +17 +18 + 19 + 20);
    
```
That treats the first + as concatenation but the + inside the parenthesis as addition.

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

Example:


public class StringExample2 {

  public static void main (String[] argv) 
  {
    String s = "";
    
    int last = 5;
    for (int i=1; i<=last; i++) {
      for (int j=1; j<=i; j++) {
        s = s + "*";
      }
      s = s + "\n";
    }
    System.out.println ("A triangle with base=" + last + ":\n" + s);
  }

}

Activity 6: Write up the above program, compile and execute. Change the base of the triangle to 10.

Activity 7: Trace the execution of the above program, showing how the string s changes.

Note:

Note that we inserted the "new line" symbol \n in two places.

Once here:

    s = s + "\n";

and once here:

  System.out.println ("A triangle with base=" + last + ":\n" + s);

It is convenient to use the short-cut version of "concatenation to the same variable". Thus, instead of

      // Concatenate to s and assign to s:
      s = s + "\n";

write

      // Short-cut version:
      s += "\n";

Activity 8: In MyStringExample2.java rewrite the above program (for base=10) using the short-cut version.

Activity 9: 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? Ponder about the differences between the three.

Input from the terminal

As we've seen before, we can use additional Java tools to force the program to wait until a user types input into the terminal.

The following is code is simillar to programs we've used before:



  import java.util.Scanner;  // Import the Scanner class

  public class ScanAndParse
  {
    public static void main(String args[])     
    {
      // Prints prompt for user:
      System.out.println ("Give me a number and then press Enter: ");
      
      // Scanning code starts here
      Scanner myScanner = new Scanner (System.in);
      String s = myScanner.nextLine ();
      // Scanning code ends here
      
      // Input conversion to Double starts here
      double sAsDouble = Double.parseDouble(s);
      // Input conversion to Double ends here
         
      System.out.println ("The number is: ");
      System.out.println (sAsDouble);        
    }
  }

These two things and the way they are written, will be explained in detail in a future module, but for now, here is a brief description of what is going on:

Scanner is like a type. If we make one object of that type, it can be used to scan input from somewhere.
To be allowed to declare tha type, we need to tell Java where the description of what it does is located in the computer (line 1).
We create an object of type Scanner and initialize it so that ir reads from the terminal (line 11).
We read whatever is placed into the terminal into a string (line 12). The program will wait to run this line until it detects, fro the terminak, a newline ("Enter").
We use the expression Double.parseDouble(s) to resolve whatever is inside s into a double and we store it inside the variable sAsDouble (line 16).

The String API

API means Application Programming Interface. It is a set of rules that people can interact with (Interface) for those people who wish to use a certain tool to create (Program) a Service (Application) of some sort.

Another way of calling it would be: rules for using our tool to program a service.

Strings are tools that someone else made and that other people can use as long as they know how to declare, initialize, and access their methods.

In the next module, we'll use the String API to manipulate Strings in a more powerful way, which will include:

extracting the String's length
comparing Strings for equality or for alphabetic sorting
searching them for characters or substrings
extracting characters at specific positions
extracting substrings between specific positions
...and many more

CS 1111