Strings: The Pool and Immutability

public class Pool {

    // Identity. Are these two names for one object?
    static boolean sameObject(String a, String b) { return false; }  // TODO

    static String pooledLiteral()    { return null; }  // TODO: the literal "hello"
    static String builtWithNew()     { return null; }  // TODO: new String("hello")
    static String joinedByCompiler() { return null; }  // TODO: "hel" + "lo"

    // TODO: join an ordinary local holding "hel" with "lo"
    static String joinedAtRunTime()  { return null; }

    // TODO: the same join, from a final local
    static String joinedFromFinal()  { return null; }

    public static void main(String[] args) {
        String hello = "hello";
        // TODO: predict all six BEFORE running. Ask each time whether javac
        // could work the value out before the program started.
        // TODO: print sameObject(hello, x) for all five builders
        // TODO: print sameObject(hello, joinedAtRunTime().intern())
        // TODO: finish by showing .equals() is true for every one of them
    }
}

public class NoChange {

    // Call trim, replace("atlas", "beacon"), toUpperCase and concat(" ready")
    // here and keep none of the results. Then return input.
    static String ignored(String input) {
        return "";  // TODO
    }

    // TODO: the same four calls, in that order, with each result assigned back
    static String kept(String input) {
        return "";  // TODO
    }

    // TODO: the same four calls again, chained into a single expression
    static String chained(String input) {
        return "";  // TODO
    }

    // TODO: call all four on input, then answer whether input still reads
    //       the way it did before
    static boolean survivesEveryCall(String input) {
        return false;  // TODO
    }

    public static void main(String[] args) {
        String name = "  atlas unit  ";
        System.out.println("[" + ignored(name) + "]");   // what prints, and why?
        // TODO: print kept and chained and compare them
        // TODO: print name again afterwards
    }
}

import java.util.Scanner;

public class RealInput {

    // Deliberately wrong. Compare with == and leave it wrong.
    static boolean checkWithIdentity(String typed) {
        return false;  // TODO
    }

    // Correct, and safe when typed is null. Put the literal on the left.
    static boolean checkWithEquals(String typed) {
        return false;  // TODO
    }

    // TODO: return a String with these characters, built while the program runs,
    //       the way a Scanner builds one. Not a literal.
    static String typedLike(String text) {
        return null;  // TODO
    }

    // TODO: intern the input first, then compare with == against "secret"
    static boolean identityAfterIntern(String typed) {
        return false;  // TODO
    }

    public static void main(String[] args) {
        System.out.println("hardcoded test:");
        System.out.println("  broken : " + checkWithIdentity("secret"));
        System.out.println("  correct: " + checkWithEquals("secret"));

        // TODO: run both checks on typedLike("secret") and compare

        Scanner sc = new Scanner(System.in);
        System.out.print("Type secret: ");
        String typed = sc.nextLine();
        // TODO: run both checks on the typed value
        // TODO: then make the broken one pass with intern, and say why you would not ship that
    }
}

import java.util.HashMap;
import java.util.Map;

public final class MiniText {

    private final char[] chars;
    private int cachedHash;                       // 0 until computed
    private static int hashComputations;          // count the real calculations

    private static final Map<String, MiniText> POOL = new HashMap<>();

    private MiniText(char[] chars) { this.chars = chars; }   // TODO: is this safe?

    // TODO: return the pooled instance if it exists, otherwise create and pool it
    public static MiniText of(String text) { return null; }

    // TODO: always create a new one, never pooled. This is the new String() path.
    public static MiniText created(String text) { return null; }

    public int length() { return 0; }             // TODO
    public char charAt(int index) { return ' '; } // TODO
    public char[] chars() { return null; }        // TODO: what must you hand back here?
    public MiniText upper() { return null; }      // TODO: a NEW MiniText

    public static int hashComputations() { return 0; }   // TODO

    @Override public boolean equals(Object o) { return false; }  // TODO
    @Override public int hashCode() { return 0; }                // TODO: compute once, then cache
    @Override public String toString() { return ""; }            // TODO

    public static void main(String[] args) {
        // TODO: prove of("hi") == of("hi") but created("hi") != created("hi")
        // TODO: prove upper() does not change the original
        // TODO: prove hashCode is only computed once
        // TODO: take the array from chars(), write into it, and print the object again
    }
}