Scala for the Impatient

Arrays, Maps, Tuples

Work with arrays and array buffers

Arrays

Use square brackets for the type:
```
val nums = new Array[Int](10)
```
Ten integers, all initialized with zero.
Use Array without new to specify initial values:
```
val a = Array("Hello", "World")
```
The type is inferred.
Use parentheses to access the elements:
```
a(0) = "Goodbye"
```
for (element <- a) traverses the array elements
for (i <- 0 until a.length) traverses the array indexes
In the JVM, an Array is a Java array (int[], java.lang.String[]).

Variable-Length Arrays

Use ArrayBuffer as analog for Java ArrayList/C++ vector:

import scala.collection.mutable.ArrayBuffer
val b = new ArrayBuffer[Int]

Use += to add at the end:

b += 1
b += (1, 2, 3, 5)
b ++= Array(8, 13, 21)

Lots of methods to manipulate buffer:

b.insert(2, 6)
b.insert(2, 7, 8, 9)
b.remove(2)
b.remove(3)
b.trimEnd(5)
...

Conversion between buffers and arrays:
```
val a = b.toArray
val b2 = a.toBuffer
```

Transform arrays

Transforming Arrays

Easy to transform the values of an array/array buffer/any collection with for/yield

Result is a new array/array buffer/collection with the transformed values:

val a = Array(2, 3, 5, 7, 11)
val result = for (elem <- a) yield 2 * elem
  // result is Array(4, 6, 10, 14, 22)

Use a guard to keep only wanted values:

for (elem <- a if elem % 2 == 0) yield 2 * elem

Use common array algorithms

Common Algorithms

Common computations are easy in Scala:

Array(1, 7, 2, 9).sum // 19
ArrayBuffer("Mary", "had", "a", "little", "lamb").max // "little"
ArrayBuffer(1, 7, 2, 9).sorted // ArrayBuffer(1, 2, 7, 9)
Array(1, 7, 2, 9).reverse // Array(9, 2, 7, 1)

toString works like in Java:

a.toString() // I@b73e5
b.toString() // ArrayBuffer(Hello, World)

Use mkString for useful results:

a.mkString(", ") // 1, 7, 2, 9
b.mkString("[", ", ", "]") // [Hello, World]

Work with maps and tuples

Maps

Construct from key/value pairs:

val scores = Map("Alice" -> 10, "Bob" -> 3, "Cindy" -> 8)

Use scala.collection.mutable.Map if you want the map to be mutable.
A map is a collection of pairs such as ("Alice", 10).
The -> operator makes a pair: "Alice" -> 10 yields ("Alice", 10).
Access values with ():
```
val bobsScore = scores("Bob")
```

Or better, to avoid exceptions:

val bobsScore = scores.getOrElse("Bob", 0)

Updating Maps

If scores is mutable, you can assign to scores(key):
```
scores("Bob") = 20
```
You can append key/value pairs and remove keys (and their values):
```
scores += ("Bob" -> 10, "Fred" -> 7)
scores -= "Alice"
```

With immutable maps, use + and -:

val newScores = scores + ("Bob" -> 10, "Fred" -> 7)
val newScores2 = newScores - "Alice"

The results share most of their structure with the original.

Iterating over Maps

Easy with for and pattern matching:

for ((k, v) <- scores)
  println(k + " has score " + v)

Use for/yield to get a new map:
```
for ((k, v) <- scores) yield (v, k)
```
As in Java, can get key and value collections with scores.keySet/scores.values.

Tuples

Aggregates values of different types:

val t = (1, 3.14, "Fred") // An instance of (Int, Double, java.lang.String)

Access components with _n:
```
val second = t._2
```
Tuple positions start with 1!
Better to use pattern matching:
```
val (_, second, third) = t
```

Practice array transformations and working with maps and tuples

Lab

Scary looking lab

Part 1: Removing All But the First Negative Number

You are given an array buffer with positive and negative integers. Your task is to remove all but the first negative number. (Don't ask why.) How do you do that in Java? Just write some pseudocode.
You probably set a flag when you saw the first negative number, and then when you saw the second, you unset the flag. And you were careful not to increment the index after removal. Or maybe you found the first negative index, and then went backward. Either way, that's a lot of detail that can go wrong. In Scala, you can do better. First, get the indexes where a(i) < 0. Use until and for/yield.
Now drop the first index. (Hint: drop in Seq)
Now you want to call a.remove(i) for the remaining ones. Except, you need to do that in reverse order. Use for and reverse.

Part 2: Word Count

A classic application for maps is word counting. Read a file, a word at a time, and keep a map that yields the frequency of each word.

val in = new java.util.Scanner(new java.net.URL(
  "http://horstmann.com/scala/livelessons/alice30.txt").openStream)
val count = scala.collection.mutable.Map[String, Int]()
while (in.hasNext) {
  val word = in.next();
  count(word) = ...
}

What is count("Alice")? count("Rabbit")?

Repeat with an immutable map. (Hint: var count)

Part 3: Grouping

Read through the description of the groupBy method in the Array class. It may not sound like much, but it is really useful in applications. Try this:

val words = Array("Mary", "had", "a", "little", "lamb", "its", "fleece",
  "was", "white", "as", "snow", "and", "everywhere", "that", "Mary", "went",
  "the", "lamb", "was", "sure", "to", "go")

What do you get for

words.groupBy(_.substring(0, 1))

How do you put all words with the same length into one bucket?

Part 4: Partitions and Zips

Tuples are useful for methods that yield more than one result. Try this out:
```
"New York".partition(_.isUpper)
```
What do you get? Why does the partition method yield a tuple?
Look again at the exercise where you are supposed to print all positive values and only the first negative value. Suppose ordering doesn't matter. How can you trivially solve this with partition? (Hint: Pass the function _ < 0.)
The zip method takes two collections of the same length and “zips” them together into a collection of tuples. Try this:
```
val symbols = Array("<", "-", ">")
val counts = Array(2, 10, 2)
val pairs = symbols.zip(counts)
```
What do you get?
Now iterate over the result to produce a printout <<---------->>. That is, repeat the < twice, the - ten times, and the > twice. (Hint: s * n yields the string s repeated n times)