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

}

    

• The reserved word char is used to declare the variable first

    char first = 'o';
      

• Single quotes delineate an actual character:

    char first = 'o';
      

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.

• Examples: "Hello World!", "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

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:

public class CharExample2 {

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

}

    

Characters and ASCII

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 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.

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

}
 

• 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.

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

}
  

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

    int q = 5;

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

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

The Two Main Categories of Types

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

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!

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

Next class:

Assignments for next lecture: