Strings: The Basics

New words in this topic, in plain English. Come back here whenever one feels fuzzy.

String

A piece of text: an object holding characters in order, such as "hello".

String literal

Text written directly in your code between double quotes, like "Asha".

Index

The position number of a character in a String. The first character is at index 0.

Concatenation

Joining pieces of text end to end. In Java the + operator does it when one side is a String.

Immutable

Can't be changed after it is created. Every String method that 'changes' text returns a new String instead.

Reference

The arrow (address) stored in a variable that points to an object living on the heap.

String pool

A shared store where the JVM keeps one copy of each String literal, so equal literals reuse the same object.

Method

A named action an object can do, called with a dot and brackets: name.length().

null

A special value meaning 'this reference points at no object at all'.

1. 1

   Slice your own name

   In the first example, change city to your own name. Before running, write down what length(), charAt(0) and substring(0, 2) will print. Then run and check.

   Now print city.substring(1, city.length() - 1): it should be your name without its first and last letters.

2. 2

   Predict the + puzzles

   Add these lines to the second example and predict each result before running: System.out.println(10 + 20 + "x" + 10 + 20); and System.out.println('x' + 1);.

   You should get 30x1020 (maths until the String appears, joining after) and 121 (the code of x is 120, plus 1).

3. 3

   Catch == lying

   In the third example, add String e = "ja" + "va"; and print a == e. It prints true, unlike a == d. Both sides of this + are constants, so the compiler joined them into the literal "java", which comes from the pool. Now make half final and check a == d again: it also becomes true. This is exactly why == is unreliable for text.

Errors are the best teachers. Make each change, read the error, guess what went wrong, then reveal the answer.

public class Main {
    public static void main(String[] args) {
        String name = 'Asha';
        System.out.println(name);
    }
}

public class Main {
    public static void main(String[] args) {
        String word = "cat";
        System.out.println(word.charAt(3));
    }
}

public class Main {
    public static void main(String[] args) {
        String typed = "ye";
        typed = typed + "s";          // made at run time, like real input
        if (typed == "yes") {
            System.out.println("confirmed");
        } else {
            System.out.println("not confirmed?!");
        }
    }
}

1. 1

   String is not one of the eight primitive types (Topic 1.2). It is a class from java.lang, so a String variable holds a reference to an object on the heap. Java gives it special treatment: you can create one with a literal in double quotes ("Asha"), and the + operator joins Strings. Single quotes are only for one char (Topic 1.5).

2. 2

   Characters are numbered by index from 0 to length() - 1. s.length() counts them, s.charAt(i) returns the char at index i, s.indexOf("x") finds the first position of some text (or -1 if it isn't there), and s.substring(begin, end) copies the characters from begin up to but not including end. Asking for an index outside the range throws StringIndexOutOfBoundsException.

3. 3

   Strings are immutable: once created, their characters never change. toUpperCase(), trim(), replace(...) and friends build and return a new String; the original is untouched. Writing name.toUpperCase(); on its own line does nothing useful, because the result is thrown away. Write name = name.toUpperCase(); to keep it.

4. 4

   + works left to right. As long as both sides are numbers it adds; as soon as one side is a String it concatenates (joins), turning the other side into text. So 1 + 2 + "3" is "33" but "1" + 2 + 3 is "123". Use brackets to force the maths first: "1" + (2 + 3) is "15". Any value can be joined: numbers, char, boolean, and even null, which becomes the text null.

5. 5

   To compare text use a.equals(b) (same characters, same case) or a.equalsIgnoreCase(b). The == operator compares references: it asks whether both variables point at the very same object. Identical literals happen to share one object from the string pool, so == sometimes looks like it works, then fails for Strings built at run time. a.compareTo(b) orders Strings alphabetically by character code: negative if a comes first, 0 if equal, positive if after.

6. 6

   An empty String "" has length 0 and is a real object; null means there is no String at all, and calling any method on it throws NullPointerException. isEmpty() tests for length 0; isBlank() (Java 11) is also true for whitespace-only text like " ". Phase 6 goes much deeper: the pool and immutability (6.1), == vs equals (6.2), StringBuilder (6.3) and every everyday method (6.4).

• ↔

  Immutability makes Strings safe to share, cache and use as map keys, but every change allocates a new object; for text built piece by piece in a loop, StringBuilder is the better tool.

• ↔

  + concatenation is the most readable way to build a short message; for aligned columns and number formats, printf/formatted (Topic 1.12) reads better than long + chains.

• ↔

  "literal".equals(x) is null-safe but reads backwards to some people; Objects.equals(a, b) is null-safe on both sides at the cost of a static call.

• I can create Strings and use length, charAt, indexOf and substring with correct 0-based indexes.

• I can predict the result of mixed + expressions with numbers, chars and Strings.

• I always compare text with equals and can explain why == sometimes seems to work.

• I remember to assign the result of toUpperCase, strip and replace.

• I can tell empty, blank and null apart and test each one safely.