Java collections such as ArrayList and HashMap were discussed. Common problems with collections like concurrent modification exceptions were presented along with scenarios demonstrating check-then-act bugs. Immutable and persistent collections were described as alternatives that reduce bugs by restricting state changes. Tradeoffs between different collection implementations like memory usage and performance were examined.

1. Java Collections
The Force Awakens
Darth @RaoulUK
Darth @RichardWarburto

3. Collection Problems
Java Episode 8 & 9
Persistent & Immutable Collections
HashMaps

4. Collection bugs
1. Element access (Off-by-one error, ArrayOutOfBound)
2. Concurrent modification
3. Check-then-Act

5. Scenario 1
List<String> jedis = new ArrayList<>(asList("Luke", "yoda"));
for (String jedi: jedis) {
if (Character.isLowerCase(jedi.charAt(0))) {
jedis.remove(jedi);
}
}

6. Scenario 2
Map<String, BigDecimal> movieViews = new HashMap<>();
BigDecimal views = movieViews.get(MOVIE);
if(views != null) {
movieViews.put(MOVIE, views.add(BigDecimal.ONE));
}
views != nullmoviesViews.get movieViews.put
Then
Check Act

7. Reducing scope for bugs
● ~280 bugs in 28 projects including Cassandra, Lucene
● ~80% check-then-act bugs discovered are put-if-absent
● Library designers can help by updating APIs as new idioms emerge
● Different data structures can provide alternatives by restricting reads &
updates to reduce scope for bugs
CHECK-THEN-ACT Misuse of Java Concurrent Collections
http://dig.cs.illinois.edu/papers/checkThenAct.pdf

8. Collection Problems
Java Episode 8 & 9
Persistent & Immutable Collections
HashMaps

9. Java 8 Lazy Collection Initialization
Many allocated HashMaps and ArrayLists never written to, eg Null object
pattern
Java 8 adds Lazy Initialization for the default initialization case
Typically 1-2% reduction in memory consumption
http://www.javamagazine.mozaicreader.
com/MarApr2016/Twitter#&pageSet=28&page=0

11. Java 9 API updates
Collection factory methods
● Non-goal to provide persistent immutable collections
● http://openjdk.java.net/jeps/269
java.util.Optional
● ifPresentOrElse(), or(), stream(), getWhenPresent()
● Optional.get() becomes deprecated
java.util.Stream
● takeWhile, dropWhile

12. Collection Problems
Java Episode 8 & 9
Persistent & Immutable Collections
HashMaps

13. Categorising Collections
Mutable
Immutable
Non-Persistent Persistent
Unsynchronized Concurrent
Unmodifiable View
Available in
Core Library

14. Mutable
● Popular friends include ArrayList, HashMap, TreeSet
● Memory-efficient modification operations
● State can be accidentally modified
● Can be thread-safe, but requires careful design

15. Unmodifiable
List<String> jedis = new ArrayList<>();
jedis.add("Luke Skywalker");
List<String> cantChangeMe = Collections.unmodifiableList(jedis);
// java.lang.UnsupportedOperationException
//cantChangeMe.add("Darth Vader");
System.out.println(cantChangeMe); // [Luke Skywalker]
jedis.add("Darth Vader");
System.out.println(cantChangeMe); // [Luke Skywalker, Darth Vader]

17. Immutable & Non-persistent
● No updates
● Flexibility to convert source in a more efficient representation
● No locking in context of concurrency
● Satisfies co-variant subtyping requirements
● Can be copied with modifications to create a new version (can be
expensive)

18. Immutable vs. Mutable hierarchy
ImmutableList MutableList
+ ImmutableList<T> toImmutable()
java.util.List
+ MutableList<T> toList()
Eclipse Collections (formaly GSCollections) https://projects.eclipse.org/projects/technology.collections/
ListIterable

19. Immutable and Persistent
● Changing source produces a new (version) of the collection
● Resulting collections shares structure with source to avoid full copying
on updates

20. Persistent List (aka Cons)
public final class Cons<T> implements ConsList<T> {
private final T head;
private final ConsList<T> tail;
public Cons(T head, ConsList<T> tail) {
this.head = head; this.tail = tail;
}
@Override
public ConsList<T> add(T e) {
return new Cons(e, this);
}
}

21. Updating Persistent List
A B C X Y Z
Before

22. Updating Persistent List
A B C X Y Z
Before
A B D
After
Blue nodes indicate new copies
Purple nodes indicates nodes we wish to update

23. Concatenating Two Persistent Lists
A B C
X Y Z
Before

24. Concatenating Two Persistent Lists
- Poor locality due to pointer chasing
- Copying of nodes
A B C
X Y Z
Before
A B C
After

25. Persistent List
● Structural sharing: no need to copy full structure
● Poor locality due to pointer chasing
● Copying becomes more expensive with larger lists
● Poor Random Access and thus Data Decomposition

26. Updating Persistent Binary Tree
Before

27. Updating Persistent Binary Tree
After

28. Persistent Array
How do we get the immutability benefits with performance of mutable
variants?

29. Trie
root
10 4520
3. Picking the right branch is done by using
parts of the key as a lookup
1. Branch factor
not limited to
binary
2. Leaf nodes
contain actual
values
a
a e
b
c
b c f

30. Persistent Array (Bitmapped Vector Trie)
... ...
... ...
... ...
... ...
.
.
.
.
.
.
1 31
0 1 31
Level 1 (root)
Level 2
Leaf nodes

31. Trade-offs
● Large branching factor facilitates iteration but hinders updates
● Small branching factor facilitates updates but hinders traversal

32. Java Persistent Collections
- Not available as part of Java Core Library
- Existing projects includes
- PCollections: https://github.com/hrldcpr/pcollections
- Port of Clojure DS: https://github.com/krukow/clj-ds
- Port of Scala DS: https://github.com/andrewoma/dexx

33. Memory usage survey
10,000,000 elements, heap < 32GB
int[] : 40MB
Integer[]: 160MB
ArrayList<Integer>: 215MB
PersistentVector<Integer>: 214MB (Clojure-DS)
Vector<Integer>: 206MB (Dexx, port of Scala-DS)
Data collected using Java Object Layout: http://openjdk.java.
net/projects/code-tools/jol/

34. Primitive specialised collections
● Collections often hold boxed representations of primitive values
● Java 8 introduced IntStream, LongStream, DoubleStream and
primitive specialised functional interfaces
● Other libraries, eg: Agrona, Koloboke and Eclipse-Collections provide
primitive specialised collections today.
● Valhalla investigates primitive specialised generics

35. Takeaways
● Immutable collections reduce the scope for bugs
● Always a compromise between programming safety and performance
● Performance of persistent data structure is improving

36. Collection Problems
Java Episode 8 & 9
Persistent & Immutable Collections
HashMaps

38. HashMaps Basics
...
Han Solo
hash = 72309
Chewbacca
hash = 72309

39. Chaining Probing
HashMaps
a separate data
structure for
collision lookups
Store inline and
have a probing
sequence

40. Aliases: Palpatine vs Darth Sidious

41. Chaining Probing
HashMaps
aka Closed
Addressing
aka Open Hashing
aka Open
Addressing
aka Closed
Hashing

42. Chaining Probing
HashMaps
Linked List Based Tree Based

43. java.util.HashMap
Chaining Based HashMap
Historically maintained a LinkedList in the case of a collision
Problem: with high collision rates that the HashMap approaches O(N)
lookup

44. java.util.HashMap in Java 8
Starts by using a List to store colliding values.
Trees used when there are over 8 elements
Tree based nodes use about twice the memory
Make heavy collision lookup case O(log(N)) rather than O(N)
Relies on keys being Comparable
https://github.com/RichardWarburton/map-visualiser

45. So which HashMap is best?

46. Benchmarking is about building a mental
model of the performance tradeoffs

47. Example Jar-Jar Benchmark
call get() on a single value for a map
of size 1
No model of the different factors that
affect things!

48. Benchmarking HashMaps
Load Factor
Nonlinear key access
Successful vs Failed get()
Hash Collisions
Comparable vs Incomparable keys
Different Keys and Values
Cost of hashCode/Equals

49. Tree Optimization - 60% Collisions

50. Tree Optimization - 10% Collisions

51. Probing vs Chaining
Probing Maps usually have lower memory consumption
Small Maps: Probing never has long clusters, can be up to 91% faster.
In large maps with high collision rates, probing scales poorly and can be
significantly slower.

52. Takeaways
There’s no clearcut “winner”.
JDK Implementations try to minimise worst case.
Linear Probing requires a good hashCode() distribution, Often hashmaps
“precondition” their hashes.
IdentityHashMap has low memory consumption and is fast, use it!
3rd Party libraries offer probing HashMaps, eg Koloboke & Eclipse-Collections.

53. Conclusions

54. Interface Popularity
List 1576210
Set 980763
Map 803171
Queue 62024
Deque 3464
SortedSet 9121
NavigableSet 1735
SortedMap 8677
NavigableMap 1484

55. Implementation Popularity
ArrayList 225029
LinkedList 26850
ArrayDeque 1086
HashSet 68940
TreeSet 10108
EnumSet 10512
HashMap 137610
TreeMap 7734
WeakHashMap 3473
IdentityHashMap 2443
EnumMap 1904

56. Evolution can be interesting ...
Java 1.2 Java 10?

58. Any Questions?
www.pluralsight.com/author/richard-warburton
www.cambridgecoding.com
www.iteratrlearning.com

59. Further reading
Fast Functional Lists, Hash-Lists, Deques and Variable Length Arrays
https://infoscience.epfl.ch/record/64410/files/techlists.pdf
Smaller Footprint for Java Collections
http://www.lirmm.fr/~ducour/Doc-objets/ECOOP2012/ECOOP/ecoop/356.pdf
Optimizing Hash-Array Mapped Tries for Fast and Lean Immutable JVM Collections
http://michael.steindorfer.name/publications/oopsla15.pdf
RRB-Trees: Efficient Immutable Vectors
https://infoscience.epfl.ch/record/169879/files/RMTrees.pdf

60. Further reading
Doug Lea’s Analysis of the HashMap implementation tradeoffs
http://www.mail-archive.com/core-libs-dev@openjdk.java.net/msg02147.html
Java Specialists HashMap article
http://www.javaspecialists.eu/archive/Issue235.html
Sample and Benchmark Code
https://github.com/RichardWarburton/Java-Collections-The-Force-Awakens

61. Further reading
Debian code search used for popularity
https://codesearch.debian.net/