# Scala Collections: Part 2 - A few basic operations

In the first part of this series, I went through the Scala Collections hierarchy and how it's put together.

In following posts, I'll go through a lot of the operations you can use on collections. I will not cover all of them, so for a full overview, please take a look at the Collection API.

In this first post about the collection operations, I'll quickly go through a few of the simpler ones. Still, it's important to cover them since they are significant to the Scala Collections.

#### Exists

```
def exists(p: ((A, B)) ⇒ Boolean): Boolean
```

Tests whether a predicate holds for some of the elements of this traversable collection.

Example

```
// Given a list of programming languages.
// Check if "Scala" exists in the list.
List("Scala", "Java", "Haskell") exists (x => x == "Scala")
// Output: true
// Given a map of languages and their creators.
// Check if Odersky created a language.
Map("Scala" -> "Odersky", "Prolog" -> "Colmerauer") exists (x => x._2 == "Odersky")
// Output: true
```

#### Forall

```
def forall(p: (A) ⇒ Boolean): Boolean
```

Tests whether a predicate holds for all elements of this iterable collection.

Example

```
// Given a list of integers.
// Check if vector only contains positive integers.
Vector(1, 2, -4, 3) forall (x => x >= 0)
// Output: false
```

#### Filter

```
def filter(p: (A) ⇒ Boolean): Traversable[A]
```

Selects all elements of this collection which satisfy a predicate.

Example

```
// Given a list of tuples (language, released).
// Get all languages created after 2000.
List(("Clojure", 2007), ("Haskell", 1990), ("Scala", 2003)) filter (x => x._2 >= 2000)
// Output: List((Clojure,2007), (Scala,2003))
```

#### Map

```
def map[B](f: (A) ⇒ B): Map[B]
```

Builds a new collection by applying a function to all elements of this collection.

Example

```
// Given a list of integers.
// Get a list with all the elements squared.
List (1,2,3,4) map ( x => x * x)
// Output: List(1, 4, 9, 16)
```

#### Take

```
def take(n: Int): Traversable[A]
```

Selects first n elements.

Great for working with infinite recursions and streams.

Examples

```
// Given an infinite recursive method creating a stream of even numbers.
def even: Stream[Int] = {
def even0(n: Int): Stream[Int] =
if (n%2 == 0) n #:: even0(n+1)
else even0(n+1)
even0(1)
}
// Get a list of the 4 first even numbers.
even take (4) toList
// Output: List(2, 4, 6, 8)
```

#### GroupBy

```
def groupBy[K](f: ((A, B)) ⇒ K): Map[K, Map[A, B]]
```

Partitions this traversable collection into a map of traversable collections according to some discriminator function.

Example

```
// Given a list of numbers.
// Group them as even and odd numbers.
List(1,2,3,4) groupBy (x => if (x%2 == 0) "even" else "odd")
// Output: Map(odd -> List(1, 3), even -> List(2, 4))
```

#### Init

```
def init: Traversable[A]
```

Selects all elements except the last.

Example

```
List (1,2,3,4) init
// Output: List(1, 2, 3)
```

#### Drop

```
def drop(n: Int): Traversable[A]
```

Selects all elements except first n ones.

Example

```
List (1,2,3,4) drop 2
// Output: List(3, 4)
```

### Next

We've now covered a few of the more self explanatory operations. In the following post we'll continue by looking at some operations that needs a bit more explaining, but brings a wide range of possibilities.

Stay tuned!

##### Parts in this series: