Wrapper Types, Autoboxing, and POJOs

public class Cache {

    // ---- where the boundary is ----
    // Record the range Integer.valueOf is required to cache.

    // TODO
    static int cacheLowBound()  { return 0; }

    // TODO
    static int cacheHighBound() { return 0; }

    // ---- which types cache ----
    // Test each one. Do not guess.

    // TODO
    static boolean longCaches()      { return false; }

    // TODO
    static boolean shortCaches()     { return false; }

    // TODO
    static boolean booleanCaches()   { return false; }

    // TODO: char has no negative values, so where does its cache stop?
    static int characterCacheHighBound() { return 0; }

    // TODO: one of the wrappers caches nothing at all. Work out which, and why.
    static boolean doubleCaches()    { return true; }

    // ---- what is actually going on ----

    // TODO: does Integer.valueOf consult a cache for values such as 127?
    static boolean valueOfUsesTheCache() { return false; }

    // TODO: new Integer(128) == new Integer(128)   (deprecated, and revealing)
    static boolean newIntegerUsesTheCache() { return true; }

    // TODO: one word. What does == compare when both sides are references?
    static String whatEqualsEqualsComparesOnBoxed() { return "?"; }

    // ---- the rule, in code ----

    // TODO: true when a and b hold the same value, on both sides of the boundary,
    // and with no exception for null.
    static boolean sameValue(Integer a, Integer b) {
        return a == b;
    }

    public static void main(String[] args) {
        Integer a = 127, b = 127;
        Integer c = 128, d = 128;

        System.out.println("127 == 127        : " + (a == b));
        System.out.println("128 == 128        : " + (c == d));
        System.out.println("128 .equals 128   : " + c.equals(d));

        // TODO: try -128 and -129
        // TODO: try Long, Short, Character, Boolean and Double
        // TODO: try Integer.valueOf(128) == Integer.valueOf(128)
        // TODO: try new Integer(128) == new Integer(128)
    }
}

import java.util.*;

public class Remove {

    // ---- predictions, before you run anything ----
    // Write what each line prints, exactly as the list prints itself.

    // TODO: byIndex after byIndex.remove(1)
    static String predictedRemoveOneByIndex()  { return "?"; }

    // TODO: byValue after byValue.remove(Integer.valueOf(1))
    static String predictedRemoveOneAsObject() { return "?"; }

    // ---- why ----

    // TODO: which overload did the plain int call go to? "remove(int)" or "remove(Object)"
    static String overloadChosenForPlainInt() { return "?"; }

    // TODO: which of the three resolution passes from Section 5.1 found it? 1, 2 or 3
    static int resolutionPassThatMatched() { return 0; }

    // ---- doing it on purpose ----

    // TODO: remove the VALUE, wherever in the list it happens to be
    static List<Integer> removeValue(List<Integer> list, int value) {
        return list;
    }

    // TODO: remove the element at that POSITION
    static List<Integer> removeAt(List<Integer> list, int index) {
        return list;
    }

    // ---- the two kinds of not found ----

    // TODO: name the exception class for an index that does not exist
    static String exceptionForBadIndex() { return "?"; }

    // TODO: does removing a value that is not in the list throw?
    static boolean removingAbsentValueThrows() { return true; }

    // TODO: remove the value and report whether anything was actually removed
    static boolean tryRemoveValue(List<Integer> list, int value) {
        return false;
    }

    public static void main(String[] args) {
        List<Integer> byIndex = new ArrayList<>(List.of(10, 20, 30, 40));
        List<Integer> byValue = new ArrayList<>(List.of(10, 20, 30, 40));

        byIndex.remove(1);
        byValue.remove(Integer.valueOf(1));

        System.out.println("remove(1)                  -> " + byIndex);
        System.out.println("remove(Integer.valueOf(1)) -> " + byValue);

        // TODO: remove the value 20 from a list, correctly
        // TODO: remove position 2 from a list, correctly
        // TODO: try removing index 5 from a four element list and read the exception
    }
}

public class Tax {

    // ---- the two methods. One character apart. Leave both as they are. ----

    static long boxed(int n) {
        long start = System.nanoTime();
        Long sum = 0L;
        for (int i = 0; i < n; i++) sum += i;
        if (sum == -1) System.out.print("");
        return (System.nanoTime() - start) / 1_000_000;
    }

    static long primitive(int n) {
        long start = System.nanoTime();
        long sum = 0L;
        for (int i = 0; i < n; i++) sum += i;
        if (sum == -1) System.out.print("");
        return (System.nanoTime() - start) / 1_000_000;
    }

    static long boxedSum(int n) {
        Long sum = 0L;
        for (int i = 0; i < n; i++) sum += i;
        return sum;
    }

    static long primitiveSum(int n) {
        long sum = 0L;
        for (int i = 0; i < n; i++) sum += i;
        return sum;
    }

    // ---- what you measured ----
    // Run main, then write the two numbers you actually saw.

    // TODO
    static long recordedBoxedMillis()     { return 0; }

    // TODO
    static long recordedPrimitiveMillis() { return 0; }

    // ---- what is actually happening ----

    // TODO: how many objects does the boxed loop create for n iterations?
    static long objectsCreatedByBoxed(int n) { return 0; }

    // TODO: and the primitive one?
    static long objectsCreatedByPrimitive(int n) { return n; }

    // TODO: why does every addition need a new object rather than changing the old one?
    static boolean longIsImmutable() { return false; }

    // ---- the warm-up ----

    // TODO: what is the loop at the top of main for?
    static boolean warmUpIsForTheJit() { return false; }

    // TODO
    static boolean withoutWarmUpYouTimeTheInterpreter() { return false; }

    public static void main(String[] args) {
        int n = 20_000_000;
        for (int warm = 0; warm < 3; warm++) { boxed(n); primitive(n); }

        System.out.println("boxed Long     : " + boxed(n) + " ms");
        System.out.println("primitive long : " + primitive(n) + " ms");
    }
}

import java.util.*;

public class NullBox {

    // Leave this one exactly as it is. It is the thing being explained.
    static int readingOf(Map<String, Integer> readings, String key) {
        return readings.get(key);
    }

    // TODO: fix one. Use getOrDefault. Then find out what it does NOT cover.
    static int readingOrDefault(Map<String, Integer> readings, String key, int fallback) {
        return readings.get(key);
    }

    // TODO: fix two. Hand the caller the box and let them decide.
    static Integer readingOrNull(Map<String, Integer> readings, String key) {
        return null;
    }

    // TODO: fix three. Is the key there at all?
    static boolean hasReading(Map<String, Integer> readings, String key) {
        return false;
    }

    // TODO: all of it. A missing key or a stored null must both give the fallback.
    static int safeReading(Map<String, Integer> readings, String key, int fallback) {
        return readings.get(key);
    }

    // TODO: true when count is a number above zero. It must survive null.
    static boolean isPositive(Integer count) {
        return count > 0;
    }

    // ---- what you worked out ----

    // TODO: read the stack trace. Which method call does it name?
    static String hiddenCallOnTheFailingLine() { return "?"; }

    // TODO: can a comparison like count > 0 unbox?
    static boolean comparisonCanUnbox() { return false; }

    // TODO: put a key in the map holding null, then call getOrDefault on it.
    static boolean getOrDefaultHandlesStoredNull() { return true; }

    // TODO: and containsKey?
    static boolean containsKeyTellsMissingFromStoredNull() { return false; }

    public static void main(String[] args) {
        Map<String, Integer> readiness = new HashMap<>();
        readiness.put("Atlas", 88);
        readiness.put("Beacon", 42);
        readiness.put("Halted", null);        // present, and holding nothing

        System.out.println("Atlas: " + readingOf(readiness, "Atlas"));
        System.out.println("Ghost: " + readingOf(readiness, "Ghost"));   // read the stack trace

        // TODO: compare the three fixes on "Ghost" and on "Halted"
        // TODO: find the second unboxing NPE, in the comparison below
        Integer count = null;
        if (count > 0) System.out.println("has units");
    }
}