Rule of thumb for choosing an implementation of a Java Collection?

Question

Anyone have a good rule of thumb for choosing between different implementations of Java Collection interfaces like List, Map, or Set?

For example, generally why or in what cases would I prefer to use a Vector or an ArrayList, a Hashtable or a HashMap?

Answer 1

I really like this cheat sheet from Sergiy Kovalchuk's blog entry, but unfortunately it is offline. However, the Wayback Machine has a historical copy:

More detailed was Alexander Zagniotov's flowchart, also offline therefor also a historical copy of the blog:

Excerpt from the blog on concerns raised in comments: "This cheat sheet doesn't include rarely used classes like WeakHashMap, LinkedList, etc. because they are designed for very specific or exotic tasks and shouldn't be chosen in 99% cases."

Answer 2

I'll assume you know the difference between a List, Set and Map from the above answers. Why you would choose between their implementing classes is another thing. For example:

List:

1. ArrayList is quick on retrieving, but slow on inserting. It's good for an implementation that reads a lot but doesn't insert/remove a lot. It keeps its data in one continuous block of memory, so every time it needs to expand, it copies the whole array.
2. LinkedList is slow on retrieving, but quick on inserting. It's good for an implementation that inserts/removes a lot but doesn't read a lot. It doesn't keep the entire array in one continuous block of memory.

Set:

1. HashSet doesn't guarantee the order of iteration, and therefore is fastest of the sets. It has high overhead and is slower than ArrayList, so you shouldn't use it except for a large amount of data when its hashing speed becomes a factor.
2. TreeSet keeps the data ordered, therefore is slower than HashSet.

Map: The performance and behavior of HashMap and TreeMap are parallel to the Set implementations.

Vector and Hashtable should not be used. They are synchronized implementations, before the release of the new Collection hierarchy, thus slow. If synchronization is needed, use Collections.synchronizedCollection().

Answer 3

I've always made those decisions on a case by case basis, depending on the use case, such as:

• Do I need the ordering to remain?
• Will I have null key/values? Dups?
• Will it be accessed by multiple threads
• Do I need a key/value pair
• Will I need random access?

And then I break out my handy 5th edition Java in a Nutshell and compare the ~20 or so options. It has nice little tables in Chapter five to help one figure out what is appropriate.

Ok, maybe if I know off the cuff that a simple ArrayList or HashSet will do the trick I won't look it all up. ;) but if there is anything remotely complex about my indended use, you bet I'm in the book. BTW, I though Vector is supposed to be 'old hat'--I've not used on in years.

Answer 4

Theoretically there are useful Big-Oh tradeoffs, but in practice these almost never matter.

In real-world benchmarks, ArrayList out-performs LinkedList even with big lists and with operations like "lots of insertions near the front." Academics ignore the fact that real algorithms have constant factors that can overwhelm the asymptotic curve. For example, linked-lists require an additional object allocation for every node, meaning slower to create a node and vastly worse memory-access characteristics.

My rule is:

1. Always start with ArrayList and HashSet and HashMap (i.e. not LinkedList or TreeMap).
2. Type declarations should always be an interface (i.e. List, Set, Map) so if a profiler or code review proves otherwise you can change the implementation without breaking anything.

Answer 5

About your first question...

List, Map and Set serve different purposes. I suggest reading about the Java Collections Framework at http://java.sun.com/docs/books/tutorial/collections/interfaces/index.html.

To be a bit more concrete:

• use List if you need an array-like data structure and you need to iterate over the elements
• use Map if you need something like a dictionary
• use a Set if you only need to decide if something belongs to the set or not.

About your second question...

The main difference between Vector and ArrayList is that the former is synchronized, the latter is not synchronized. You can read more about synchronization in Java Concurrency in Practice.

The difference between Hashtable (note that the T is not a capital letter) and HashMap is similiar, the former is synchronized, the latter is not synchronized.

I would say that there are no rule of thumb for preferring one implementation or another, it really depends on your needs.

Answer 6

For non-sorted the best choice, more than nine times out of ten, will be: ArrayList, HashMap, HashSet.

Vector and Hashtable are synchronised and therefore might be a bit slower. It's rare that you would want synchronised implementations, and when you do their interfaces are not sufficiently rich for thier synchronisation to be useful. In the case of Map, ConcurrentMap adds extra operations to make the interface useful. ConcurrentHashMap is a good implementation of ConcurrentMap.

LinkedList is almost never a good idea. Even if you are doing a lot of insertions and removal, if you are using an index to indicate position then that requires iterating through the list to find the correct node. ArrayList is almost always faster.

For Map and Set, the hash variants will be faster than tree/sorted. Hash algortihms tend to have O(1) performance, whereas trees will be O(log n).

Answer 7

Well, it depends on what you need. The general guidelines are:

List is a collection where data is kept in order of insertion and each element got index.

Set is a bag of elements without duplication (if you reinsert the same element, it won't be added). Data doesn't have the notion of order.

Map You access and write your data elements by their key, which could be any possible object.

Attribution: https://stackoverflow.com/a/21974362/2811258

For more information about Java Collections, check out this article.

Answer 8

As suggested in other answers, there are different scenarios to use correct collection depending on use case. I am listing few points,

ArrayList:

• Most cases where you just need to store or iterate through a "bunch of things" and later iterate through them. Iterating is faster as its index based.
• Whenever you create an ArrayList, a fixed amount of memory is allocated to it and once exceeded, it copies the whole array

LinkedList:

• It uses doubly linked list so insertion and deletion operation will be fast as it will only add or remove a node.
• Retrieving is slow as it will have to iterate through the nodes.

HashSet:

• Making other yes-no decisions about an item, e.g. "is the item a word of English", "is the item in the database?" , "is the item in this category?" etc.

• Remembering "which items you've already processed", e.g. when doing a web crawl;

HashMap:

• Used in cases where you need to say "for a given X, what is the Y"? It is often useful for implementing in-memory caches or indexes i.e key value pairs For example: For a given user ID, what is their cached name/User object?.
• Always go with HashMap to perform a lookup.

Vector and Hashtable are synchronized and therefore bit slower and If synchronization is needed, use Collections.synchronizedCollection(). Check This for sorted collections. Hope this hepled.

Answer 9

Lists allow duplicate items, while Sets allow only one instance.

I'll use a Map whenever I'll need to perform a lookup.

For the specific implementations, there are order-preserving variations of Maps and Sets but largely it comes down to speed. I'll tend to use ArrayList for reasonably small Lists and HashSet for reasonably small sets, but there are many implementations (including any that you write yourself). HashMap is pretty common for Maps. Anything more than 'reasonably small' and you have to start worrying about memory so that'll be way more specific algorithmically.

This page has lots of animated images along with sample code testing LinkedList vs. ArrayList if you're interested in hard numbers.

EDIT: I hope the following links demonstrate how these things are really just items in a toolbox, you just have to think about what your needs are: See Commons-Collections versions of Map, List and Set.

Answer 10

Use Map for key-value pairing

For key-value tracking, use Map implementation.

For example, tracking which person is covering which day of the weekend. So we want to map a DayOfWeek object to an Employee object.

Map < DayOfWeek , Employee > weekendWorker = 
    Map.of( 
        DayOfWeek.SATURDAY , alice ,
        DayOfWeek.SUNDAY , bob
    )
;

When choosing one of the Map implementations, there are several aspects to consider. These include: concurrency, tolerance for NULL values in key and/or value, order when iterating keys, tracking by reference versus content, and convenience of literals syntax.

Here is a chart I made showing the various aspects of each of the ten Map implementations bundled with Java 11.

Answer 11

I found Bruce Eckel's Thinking in Java to be very helpful. He compares the different collections very well. I used to keep a diagram he published showing the inheritance heirachy on my cube wall as a quick reference. One thing I suggest you do is keep in mind thread safety. Performance usually means not thread safe.