# Why does Collections.sort use Mergesort but Arrays.sort does not?

I am using JDK-8 (x64). For Arrays.sort (primitives) I found the following in the Java documentation:

The sorting algorithm is a Dual-Pivot **Quicksort** by Vladimir Yaroslavskiy, Jon Bentley, and Joshua Bloch.`

For Collections.sort (objects) I found this "Timsort":

This implementation is a stable, adaptive, iterative **mergesort** ... This implementation **dumps the specified list into an array, sorts the array**, and iterates over the list resetting each element from the corresponding position in the array.

If Collections.sort uses an array, why doesn't it just call Arrays.sort or use dual-pivot **QuickSort**? Why use **Mergesort**?

## Answers

The API guarantees a *stable* sorting which Quicksort doesn’t offer. However, when sorting *primitive values* by their natural order you won’t notice a difference as primitive values have no identity. Therefore, Quicksort can used for primitive arrays and will be used when it is considered more efficient¹.

For objects you may notice, when objects with different identity which are deemed equal according to their equals implementation or the provided Comparator change their order. Therefore, Quicksort is not an option. So a variant of MergeSort is used, the current Java versions use *TimSort*. This applies to both, Arrays.sort and Collections.sort, though with Java 8, the List itself may override the sort algorithms.

¹ The efficiency advantage of Quicksort is needing less memory when done in-place. But it has a dramatic worst case performance and can’t exploit runs of pre-sorted data in an array, which TimSort does.

Therefore, the sorting algorithms were reworked from version to version, while staying in the now-misleadingly named class DualPivotQuicksort. Also, the documentation didn’t catch up, which shows, that it is a bad idea in general, to name an internally used algorithm in a specification, when not necessary.

The current situation (including Java 8 to Java 11) is as follows:

- Generally, the sorting methods for primitive arrays will use Quicksort only under certain circumstances. For larger arrays, they will try to identify runs of pre-sorted data first, like TimSort does, and will merge them when the number of runs does not exceed a certain threshold. Otherwise they will fall back to Quicksort, but with an implementation that will fall back to Insertion sort for small ranges, which does not only affect small arrays, but also quick sort’s recursion.
- sort(char[],…) and sort(short[],…) add another special case, to use Counting sort for arrays whose length exceeds a certain threshold
- Likewise, sort(byte[],…) will use Counting sort, but with a much smaller threshold, which creates the biggest contrast to the documentation, as sort(byte[],…) never uses Quicksort. It only uses Insertion sort for small arrays and Counting sort otherwise.

I don't know about the documentation, but the implementation of java.util.Collections#sort in Java 8 (HotSpot) goes like this:

@SuppressWarnings({"unchecked", "rawtypes"}) public static <T> void sort(List<T> list, Comparator<? super T> c) { list.sort(c); }

And List#sort has this implementation:

@SuppressWarnings({"unchecked", "rawtypes"}) default void sort(Comparator<? super E> c) { Object[] a = this.toArray(); Arrays.sort(a, (Comparator) c); ListIterator<E> i = this.listIterator(); for (Object e : a) { i.next(); i.set((E) e); } }

So, in the end, Collections#sort uses Arrays#sort (of object elements) behind the scenes. This implementation uses merge sort or tim sort.

According to the Javadoc, only primitive arrays are sorted using Quicksort. Object arrays are sorted with a Mergesort as well.

So Collections.sort seems to use the same sorting algorithm as Arrays.sort for Objects.

Another question would be why a different sort algorithm is used for primitive arrays than for Object arrays?

As stated across many of the answers.

The Quicksort is used by Arrays.sort for sorting primitive collections because stability isn't required (you won't know or care if two identical ints were swapped in the sort)

MergeSort or more specifically Timsort is used by Arrays.sort for sorting collections of objects. Stability is required. Quicksort does not provide for stability, Timsort does.

Collections.sort delegates to Arrays.sort which is why you see the javadoc referencing the MergeSort.

Quick Sort has two major drawbacks when it comes to merge sort:

- It's not stable while it comes to non primitive.
- It doesn't guarantee n log n performance.

Stability is a non-issue for primitive types, as there is no notion of identity as distinct from (value) equality.

Stability is a big deal when sorting arbitrary objects. It's a nice side benefit that Merge Sort guarantees n log n (time) performance no matter what the input. That's why merge sort is selected to provide a stable sort (Merge Sort) to sort object references.