MOCKSTACKS
EN

# Scala Collections

## Examples

#### Sort A List

Supposing the following list we can sort a variety of ways.

``val names = List("Kathryn", "Allie", "Beth", "Serin", "Alana")``

The default behavior of sorted() is to use math.Ordering, which for strings results in a lexographic sort:

``````names.sorted
// results in: List(Alana, Allie, Beth, Kathryn, Serin)``````

sortWith allows you to provide your own ordering utilizing a comparison function:

``````names.sortWith(_.length < _.length)
// results in: List(Beth, Allie, Serin, Alana, Kathryn)``````

sortBy allows you to provide a transformation function:

``````//A set of vowels to use
val vowels = Set('a', 'e', 'i', 'o', 'u')
//A function that counts the vowels in a name
def countVowels(name: String) = name.count(l => vowels.contains(l.toLower))
//Sorts by the number of vowels
names.sortBy(countVowels)
//result is: List(Kathryn, Beth, Serin, Allie, Alana)``````

You can always reverse a list, or a sorted list, using `reverse:

``````names.sorted.reverse
//results in: List(Serin, Kathryn, Beth, Allie, Alana)``````

Lists can also be sorted using Java method java.util.Arrays.sort and its Scala wrapper scala.util.Sorting.quickSort

``````java.util.Arrays.sort(data)
scala.util.Sorting.quickSort(data)``````

#### Create a List containing n copies of x

To create a collection of n copies of some object x, use the fill method. This example creates a List, but this can work with other collections for which fill makes sense:

``````// List.fill(n)(x)
scala > List.fill(3)("Hello World")
res0: List[String] = List(Hello World, Hello World, Hello World)``````

#### List and Vector Cheatsheet

It is now a best-practice to use Vector instead of List because the implementations have better performance Performance characteristics can be found here. Vector can be used wherever List is used.

#### List creation

``````List[Int]() // Declares an empty list of type Int
List.empty[Int] // Uses `empty` method to declare empty list of type Int
Nil // A list of type Nothing that explicitly has nothing in it
List(1, 2, 3) // Declare a list with some elements
1 :: 2 :: 3 :: Nil // Chaining element prepending to an empty list, in a LISP-style``````

#### Take element

``````List(1, 2, 3).headOption // Some(1)
List(1, 2, 3).lastOption // Some(3)
List(1, 2, 3).last // 3, complexity is O(n)
List(1, 2, 3)(1) // 2, complexity is O(n)
List(1, 2, 3)(3) // java.lang.IndexOutOfBoundsException: 4``````

#### Prepend Elements

``0 :: List(1, 2, 3) // List(0, 1, 2, 3)``

#### Append Elements

``List(1, 2, 3) :+ 4 // List(1, 2, 3, 4), complexity is O(n)``

#### Join (Concatenate) Lists

``````List(1, 2) ::: List(3, 4) // List(1, 2, 3, 4)
List.concat(List(1,2), List(3, 4)) // List(1, 2, 3, 4)
List(1, 2) ++ List(3, 4) // List(1, 2, 3, 4)``````

#### Common operations

``````List(1, 2, 3).find(_ == 3) // Some(3)
List(1, 2, 3).map(_ * 2) // List(2, 4, 6)
List(1, 2, 3).filter(_ % 2 == 1) // List(1, 3)
List(1, 2, 3).fold(0)((acc, i) => acc + i * i) // 1 * 1 + 2 * 2 + 3 * 3 = 14
List(1, 2, 3).foldLeft("Foo")(_ + _.toString) // "Foo123"
List(1, 2, 3).foldRight("Foo")(_ + _.toString) // "123Foo"``````

## Conclusion

In this page (written and validated by ) you learned about Scala Collections . What's Next? If you are interested in completing Scala tutorial, your next topic will be learning about: Scala Continuations Library.

Incorrect info or code snippet? We take very seriously the accuracy of the information provided on our website. We also make sure to test all snippets and examples provided for each section. If you find any incorrect information, please send us an email about the issue: mockstacks@gmail.com.