## 1. Overview

In Scala’s rich collection library, we often turn to sets to store unique elements. Among these, SortedSet and LinkedHashSet stand out for their specialized features.

In this tutorial, we’ll dive deep into these unique sets. We’ll explore SortedSet and its concrete counterpart, TreeSet. These sets keep elements in a specific order through natural ordering or a provided comparator. On the other hand, we have LinkedHashSet, which preserves the order of element insertion.

By the end, we’ll understand when and why to use each of these sets in our Scala projects.

## 2. Understanding SortedSet and TreeSet

SortedSet is a trait that guarantees that element retrieval is done in a stable order. Furthermore, by default, we’ll use the elements’ natural order, or we can define one using a comparator.

TreeSet is the go-to concrete implementation of SortedSet in Scala. It’s a balanced binary search tree. Using it, we ensure that addition, removal, and search are efficient.

To retain flexibility in our code, we always assign our TreeSet to a variable type of SortedSet:

``````scala> import scala.collection.immutable.{SortedSet, TreeSet}
import scala.collection.immutable.{SortedSet, TreeSet}

scala> val numbers: SortedSet[Int] = TreeSet(5, 2, 8, 1, 3)
val numbers: scala.collection.immutable.SortedSet[Int] = TreeSet(1, 2, 3, 5, 8)

scala> println(numbers)
TreeSet(1, 2, 3, 5, 8)``````

Even though we added the numbers randomly, the output is sorted.

But what if we want a different order? Let’s reverse it:

``````scala> val reversedOrdering = Ordering[Int].reverse
val reversedOrdering: scala.math.Ordering[Int] = scala.math.Ordering\$Reverse@e417cf84

scala> val reversedNumbers: SortedSet[Int] = TreeSet(5, 2, 8, 1, 3)(reversedOrdering)
val reversedNumbers: scala.collection.immutable.SortedSet[Int] = TreeSet(8, 5, 3, 2, 1)

scala> println(reversedNumbers)
TreeSet(8, 5, 3, 2, 1)``````

By providing an alternative ordering, we can easily control the order of elements in our set.

On the efficiency front, TreeSet shines with its O(log n) time complexity for most operations, including addition, removal, and search, thanks to its balanced binary search tree structure. This makes TreeSet an ideal choice when we need to keep a list of unique elements in a given order.

## 3. Keeping the Order of Insertion: LinkedHashSet

While SortedSet and its implementation, TreeSet, focus on sorting elements based on their natural order or a provided comparator, there are times when we want to maintain the order of insertion. This is where LinkedHashSet comes into play.

LinkedHashSet is a unique blend of a hash table and a linked list. It retains a hash table’s fast access times while preserving the order in which elements were added. This dual nature makes it perfect for scenarios where both insertion order and quick access are paramount.

``````scala> import scala.collection.mutable.LinkedHashSet

scala> fruits += "Orange"
val res2: fruits.type = LinkedHashSet(Apple, Banana, Cherry, Orange)

scala> println(fruits)

In the example above, even if we add “Orange” after the initial set creation, we retrieve it last, preserving the insertion order.

Efficiency-wise, LinkedHashSet offers constant-time performance for basic operations like add and remove, thanks to its hash table backbone. However, it’s crucial to note that while LinkedHashSet guarantees insertion order, it lacks sorting capabilities. If sorting is a requirement, we’d lean towards SortedSet and TreeSet.

When the order of insertion matters, and we want the combined benefits of a set and a list, LinkedHashSet is our go-to collection in Scala.

## 4. Conclusion

In this article, we explored Scala’s sets with various ordering capabilities. Through SortedSet and its concrete implementation, TreeSet, we gain the power to maintain elements in a specific order, whether natural or custom-defined. On the other hand, LinkedHashSet stands out when the insertion sequence is essential, blending the strengths of both hash tables and linked lists.

Choosing between these sets boils down to our specific needs. If we seek a sorted collection, SortedSet is the answer. But when the order of insertion is crucial, LinkedHashSet takes the lead. By understanding the nuances and strengths of each set, we can make informed decisions, ensuring our Scala applications are both efficient and readable.

As always, the key lies in picking the right tool for the job, and Scala’s rich collection library always provides us with ample choices.

Comments are open for 30 days after publishing a post. For any issues past this date, use the Contact form on the site.