Errata

... test is false.

should be

... test is true.

Note from the Author or Editor:
As described

0.5 should be 0.05 and smaller should be larger.

Note from the Author or Editor:
The final two sentences of the last complete paragraph on page 31 should read:

Other commonly used a-values are 0.05 (95%) or 0.01 (99%). A test is considered statistically significant if the p-value is smaller than 1 - a-value.

[Maintain italics and alpha characters]

The WeakHahMap defined in ImmutableObject should be a static field instead of an instance field. In other words, there should be one map that all the instances use instead of a map per immutable object.

Note from the Author or Editor:
Change the line reading:

WeakHashMap<ImmutableObject, ImmutableObject> map = new WeakHashMap();

to

private static WeakHashMap<ImmutableObject, ImmutableObject> map = new WeakHashMap();

The values in the WeakHashMap should be weakly referenced . Hence, WeakHashMap<ImmutableObject, WeakReference<ImmutableObject>> should be used instead of WeakHashMap<ImmutableObject, ImmutableObject>.

See also the documentation of WeakHashMap (http://docs.oracle.com/javase/8/docs/api/java/util/WeakHashMap.html):

"Implementation note: The value objects in a WeakHashMap are held by ordinary strong references. Thus care should be taken to ensure that value objects do not strongly refer to their own keys, either directly or indirectly, since that will prevent the keys from being discarded. Note that a value object may refer indirectly to its key via the WeakHashMap itself; that is, a value object may strongly refer to some other key object whose associated value object, in turn, strongly refers to the key of the first value object. If the values in the map do not rely on the map holding strong references to them, one way to deal with this is to wrap values themselves within WeakReferences before inserting, as in: m.put(key, new WeakReference(value)), and then unwrapping upon each get."

For example,

WeakHashMap<Object, Object> map = new WeakHashMap<>();
while(true) {
Object o = new byte[1000000];
map.put(o,o);
}

runs immediately out of memory while

WeakHashMap<Object, WeakReference<Object>> map = new WeakHashMap<>();
while(true) {
Object o = new byte[1000000];
map.put(o,new WeakReference(o));
}

does not, because it allows for continuous garbage collection.

Note from the Author or Editor:
Change the code line reading

map.put(io, io);

to

map.put(io, new WeakReference(io));

The code example

public int countSymbols(ArrayList<String> al) {
int count = 0;
t = al.stream().
filter(symbol -> symbol.charAt(0) != 'A' &&
symbol.charAt(1) != 'A' &&
symbol.charAt(2) != 'A' &&
symbol.charAt(3) != 'A').
forEach(symbol -> count++);
return count;
}

has some flaws:
1) The return type of forEach is void, hence the assignment to "t" (which is neither declared nor used) is invalid.
2) The "count" variable cannot be modified within the lambda expression, because it is effectively final.

The stream class provides a count() method which can be used instead:

public int countSymbols(ArrayList<String> al) {
return (int) al
.stream()
.filter(
symbol -> symbol.charAt(0) != 'A' &&
symbol.charAt(1) != 'A' &&
symbol.charAt(2) != 'A' &&
symbol.charAt(3) != 'A')
.count();
}

Note from the Author or Editor:
The first implementation of the countSymbols method should be replaced with this:

private static long countFilter(ArrayList<String> al) {
long then = System.currentTimeMillis();
Stream<String> stream = al.stream();
stream.filter(
symbol -> symbol.charAt(0) != 'A' &&
symbol.charAt(1) != 'A' &&
symbol.charAt(2) != 'A' &&
symbol.charAt(3) != 'A').
forEach(symbol -> { count++; });
long now = System.currentTimeMillis();
return now - then;
}

The second example (immediately following) should be replaced with this:
private static long countIterator(ArrayList<String> al) {
long then = System.currentTimeMillis();
for (String symbol : al) {
if (symbol.charAt(0) != 'A' &&
symbol.charAt(1) != 'A' &&
symbol.charAt(2) != 'A' &&
symbol.charAt(3) != 'A')
count++;
}
return System.currentTimeMillis() - then;
}