{"id":532,"date":"2011-09-27T08:24:00","date_gmt":"2011-09-27T08:24:00","guid":{"rendered":"http:\/\/www.javacodegeeks.com\/2012\/10\/scala-tutorial-tuples-lists-methods-on-lists-and-strings.html"},"modified":"2012-10-21T20:11:08","modified_gmt":"2012-10-21T20:11:08","slug":"scala-tutorial-tuples-lists-methods-on","status":"publish","type":"post","link":"https:\/\/www.javacodegeeks.com\/2011\/09\/scala-tutorial-tuples-lists-methods-on.html","title":{"rendered":"Scala Tutorial – Tuples, Lists, methods on Lists and Strings"},"content":{"rendered":"
\n

Preface<\/h2>\n

This is the second in a planned series of tutorials on programming in Scala for first-time programmers, with specific reference to my Fall 2011 course Introduction to Computational Linguistics. <\/a>You can see the other tutorials here on this blog; they are also listed on the course\u2019s links page.<\/a><\/p>\n

This tutorial focuses on Tuples and Lists, which are two constructs for working with groups of elements. You won\u2019t get much done without the latter, and the former are so incredibly useful you probably find yourself using them a lot.<\/p>\n

Tuples<\/h2>\n

We saw in the previous tutorial how a single value can be assigned to a variable and then used in various contexts. A Tuple<\/strong> is a generalization of that: a collection of two, three, four, and more values. Each value can have its own type.<\/p>\n

scala> val twoInts = (3,9)\r\ntwoInts: (Int, Int) = (3,9)\r\n \r\nscala> val twoStrings = (\"hello\", \"world\")\r\ntwoStrings: (java.lang.String, java.lang.String) = (hello,world)\r\n \r\nscala> val threeDoubles = (3.14, 11.29, 1.5)\r\nthreeDoubles: (Double, Double, Double) = (3.14,11.29,1.5)\r\n \r\nscala> val intAndString = (7, \"lucky number\")\r\nintAndString: (Int, java.lang.String) = (7,lucky number)\r\n \r\nscala> val mixedUp = (1, \"hello\", 1.16)\r\nmixedUp: (Int, java.lang.String, Double) = (1,hello,1.16)\r\n<\/pre>\n
The elements of a Tuple can be recovered in a few different ways. One way is to use a Tuple when initializing some variables, each of which takes on the value of the corresponding position in the Tuple on the right side of the equal sign.<\/p>\n
scala> val (first, second) = twoInts\r\nfirst: Int = 3\r\nsecond: Int = 9\r\n \r\nscala> val (numTimes, thingToSay, price) = mixedUp\r\nnumTimes: Int = 1\r\nthingToSay: java.lang.String = hello\r\nprice: Double = 1.16\r\n<\/pre>\n
Scala peels off the values and assigns them to each of the single variables. This becomes very useful in the context of functions that return Tuples. For example, consider a function that provides the left and right edges of a range when you give it the midpoint of the range and the size of the interval on each side of the midpoint.<\/p>\n
scala> def rangeAround(midpoint: Int, size: Int) = (midpoint - size, midpoint + size)\r\nrangeAround: (midpoint: Int, size: Int)(Int, Int)\r\n<\/pre>\n
Since rangeAround<\/strong> returns a Tuple (specifically, a Pair), we can call it and set variables for the left and right directly from the function call.<\/p>\n
scala> val (left, right) = rangeAround(21, 3)\r\nleft: Int = 18\r\nright: Int = 24\r\n<\/pre>\n
Another way to access the values in a Tuple is via indexation, using \u201c_n<\/strong>\u201d where n<\/em> is the index of the item you want.<\/p>\n
scala> print(mixedUp._1)\r\n1\r\nscala> print(mixedUp._2)\r\nhello\r\nscala> print(mixedUp._3)\r\n1.16\r\n<\/pre>\n
The syntax on this is a bit odd, but you\u2019ll get used to it.<\/p>\n
Tuples are an amazingly useful feature in a programming language. You\u2019ll see some examples of their utility as we progress.<\/p>\n
             Lists<\/h2>\n
Lists are collections of ordered items that will be familiar to anyone who has done any shopping. Tuples are obviously related to lists, but they are less versatile in that they must be created in a single statement, they have a bounded length (about 20 or so), and they don\u2019t support operations that perform computations on all of their elements.<\/p>\n
In Scala, we can create lists of Strings, Ints, and Doubles (and more).<\/p>\n
scala> val groceryList = List(\"apples\", \"milk\", \"butter\")\r\ngroceryList: List[java.lang.String] = List(apples, milk, butter)\r\n \r\nscala> val odds = List(1,3,5,7,9)\r\nodds: List[Int] = List(1, 3, 5, 7, 9)\r\n \r\nscala> val multinomial = List(.2, .4, .15, .25)\r\nmultinomial: List[Double] = List(0.2, 0.4, 0.15, 0.25)\r\n<\/pre>\n
We see that Scala responds that a List has been created, along with brackets around the type of the elements it contains. So, List[Int]<\/strong> is read as \u201ca List of Ints\u201d and so on. This is to say that List is a parameterized data structure: it is a container that holds elements of specific types. We\u2019ll see how knowing this allows us to do different things with Lists parameterized by different types.<\/p>\n
We can also create Lists with mixtures of types.<\/p>\n
scala> val intsAndDoubles = List(1, 1.5, 2, 2.5)\r\nintsAndDoubles: List[Double] = List(1.0, 1.5, 2.0, 2.5)\r\n \r\nscala> val today = List(\"August\", 23, 2011)\r\ntoday: List[Any] = List(August, 23, 2011)\r\n<\/pre>\n
Types are sometimes autoconverted, such as converting Ints to Doubles for intsAndDoubles<\/strong>, but often there is no obvious generalizable type. For example, today<\/strong> is a List[Any]<\/strong>, which means it is a List of Anys \u2014 and Any is the most general type in Scala, the supertype of all types. It\u2019s sort of like saying \u201cYeah, I have a list of\u2026 well, you know\u2026 stuff.\u201d<\/p>\n
Lists can also contain Lists (and Lists of Lists, and Lists of Lists of Lists\u2026).<\/p>\n
scala> val embedded = List(List(1,2,3), List(10,30,50), List(200,400), List(1000))\r\nembedded: List[List[Int]] = List(List(1, 2, 3), List(10, 30, 50), List(200, 400), List(1000))\r\n<\/pre>\n
The type of embedded<\/strong> is List[List[Int]]<\/strong>, which you can read as \u201ca List of Lists of Ints.\u201d<\/p>\n
             List methods<\/h2>\n
Okay, so now that we have some lists, what can we do with them? A lot, actually. One of the most basic properties of a list is its length, which you can get by using \u201c.length<\/strong>\u201d after the variable that refers to the list.<\/p>\n
scala> groceryList.length\r\nres19: Int = 3\r\n \r\nscala> odds.length\r\nres20: Int = 5\r\n \r\nscala> embedded.length\r\nres21: Int = 4\r\n<\/pre>\n
Notice that the length of embedded<\/strong> is 4, which is the number of Lists it contains (not the number of elements in those lists).
 
<\/div> <\/div><\/p>\n
The notation variable.method<\/em><\/strong> indicates that you are invoking a function that is specific to the type of that variable on the value in that variable. Okay, that was a mouthful. Scala is an object-oriented language, which means that every value has a set of actions that comes with it. Which actions are available depends on its type. So, above, we called the length<\/strong> method that is available to Lists on each of the list values given above. You didn\u2019t realize it in the previous tutorial, but you were using methods when you added Ints or concatenated Strings \u2014 it\u2019s just that Scala allows us to go without \u201c.\u201d and paretheses in certain cases. If we don\u2019t drop them, here\u2019s what it looks like.<\/p>\n
scala> 2.+(3)\r\nres25: Double = 5.0\r\n \r\nscala> \"Portis\".+(\"head\")\r\nres26: java.lang.String = Portishead\r\n<\/pre>\n
What is going on is that Ints have a method called \u201c+<\/strong>\u201d and Strings have a different<\/em> method called \u201c+<\/strong>\u201c. They could have been called \u201cbill\u201d and \u201cbob\u201d, but that would be harder to remember, among other things. Ints have other methods, such as \u201c–<\/strong>\u201c, \u201c*<\/strong>\u201c, and \u201c\/<\/strong>\u201c, that Strings don\u2019t have. (Note: I\u2019m now returning to omitting the \u201c.\u201d and paretheses.)<\/p>\n
scala> 5-3\r\nres27: Int = 2\r\n \r\nscala> \"walked\" - \"ed\"\r\n<console>:8: error: value - is not a member of java.lang.String\r\n\"walked\" - \"ed\"\r\n<\/pre>\n
Scala complains that we tried to use the \u201c–<\/strong>\u201d method on a String, since Strings don\u2019t have such a method. On the other hand, Ints don\u2019t have a method called length<\/strong>, while Strings do.<\/p>\n
scala> 5.length\r\n<console>:8: error: value length is not a member of Int\r\n5.length\r\n^\r\n \r\nscala> \"walked\".length\r\nres31: Int = 6\r\n<\/pre>\n
With Strings, length<\/strong> returns the number of characters, whereas with Lists, it is the number of elements. The String length<\/strong> method could have been called \u201cnumberOfCharacters\u201d, but \u201clength\u201d is easier to remember and it allows us to treat Strings like other sequences and think of them similarly.<\/p>\n
Lets return to Lists and what we can do with them. \u201cAddition\u201d of two lists is their concatenation and is indicated with \u201c++<\/strong>\u201c.<\/p>\n
scala> val evens = List(2,4,6,8)\r\nevens: List[Int] = List(2, 4, 6, 8)\r\n \r\nscala> val nums = odds ++ evens\r\nnums: List[Int] = List(1, 3, 5, 7, 9, 2, 4, 6, 8)\r\n<\/pre>\n
We can append a single item to the front of a List with \u201c::<\/strong>\u201c.<\/p>\n
scala> val zeroToNine = 0 :: nums\r\nzeroToNine: List[Int] = List(0, 1, 3, 5, 7, 9, 2, 4, 6, 8)\r\n<\/pre>\n
And sort a list with sorted<\/strong>, and reverse it with reverse<\/strong>, and do both in sequence.<\/p>\n
scala> zeroToNine.sorted\r\nres42: List[Int] = List(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)\r\n \r\nscala> zeroToNine.reverse\r\nres43: List[Int] = List(8, 6, 4, 2, 9, 7, 5, 3, 1, 0)\r\n \r\nscala> zeroToNine.sorted.reverse\r\nres44: List[Int] = List(9, 8, 7, 6, 5, 4, 3, 2, 1, 0)\r\n<\/pre>\n
What the last line says is \u201ctake zeroToNine<\/strong>, get a new sorted list from it, and then reverse that list.\u201d Notice that calling these functions never changes zeroToNine<\/strong> itself! That is because List is immutable<\/em>: you cannot change it, so all of these operations return new Lists. This property of Lists brings with it many benefits that we\u2019ll return to later.<\/p>\n
Note: immutability is different from the val\/var<\/strong> distinction. It is common to think that a val<\/strong> variable is immutable, but it is not \u2014 it is fixed and cannot be reassigned. The following examples all involve immutable Lists, but the fixed variable is a val<\/strong> while the reassignable variable is a var<\/strong>.<\/p>\n
scala> val fixed = List(1,2)\r\nfixed: List[Int] = List(1, 2)\r\n \r\nscala> fixed = List(3,4)\r\n<console>:8: error: reassignment to val\r\nfixed = List(3,4)\r\n^\r\n \r\nscala> var reassignable = List(5,6)\r\nreassignable: List[Int] = List(5, 6)\r\n \r\nscala> reassignable = List(7,8)\r\nreassignable: List[Int] = List(7, 8)\r\n<\/pre>\n
One of the things one frequently wants to do with a list is access its elements directly. This is done via indexation into the list, starting with 0 for the first element, 1 for the second element, and so on.<\/p>\n
scala> odds\r\nres48: List[Int] = List(1, 3, 5, 7, 9)\r\n \r\nscala> odds(0)\r\nres49: Int = 1\r\n \r\nscala> odds(1)\r\nres50: Int = 3\r\n<\/pre>\n
Starting with 0 for the index of the first element is standard practice in computer science. It might seem strange at first, but you\u2019ll get used to it fairly quickly.<\/p>\n
We can of course use any Int expression to access an item in a list.<\/p>\n
scala> zeroToNine(3)\r\nres63: Int = 5\r\n \r\nscala> zeroToNine(5-2)\r\nres64: Int = 5\r\n \r\nscala> val index = 3\r\nindex: Int = 3\r\n \r\nscala> zeroToNine(index)\r\nres65: Int = 5\r\n<\/pre>\n
If we ask for an index that is equal to or greater than the number of elements in the list, we get an error.<\/p>\n
scala> odds(10)\r\njava.lang.IndexOutOfBoundsException: 10\r\nat scala.collection.LinearSeqOptimized$class.apply(LinearSeqOptimized.scala:51)\r\nat scala.collection.immutable.List.apply(List.scala:45)\r\nat .<init>(<console>:9)\r\nat .<clinit>(<console>)\r\nat .<init>(<console>:11)\r\nat .<clinit>(<console>)\r\nat $export(<console>)\r\nat sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)\r\nat sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)\r\nat sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)\r\nat java.lang.reflect.Method.invoke(Method.java:597)\r\nat scala.tools.nsc.interpreter.IMain$ReadEvalPrint.call(IMain.scala:592)\r\nat scala.tools.nsc.interpreter.IMain$Request$$anonfun$10.apply(IMain.scala:828)\r\nat scala.tools.nsc.interpreter.Line$$anonfun$1.apply$mcV$sp(Line.scala:43)\r\nat scala.tools.nsc.io.package$$anon$2.run(package.scala:31)\r\nat java.lang.Thread.run(Thread.java:680)\r\n<\/pre>\n
Looking at all that, you might be thinking \u201cWTF?\u201d It\u2019s called the stack trace, and it gives you a detailed breakdown of where problems happened in a bit of code. For beginning programmers, this is likely to look overwhelming and intimidating \u2014 you can safely glaze over it for now, but before long, it will be necessary to be able to use the stack trace to identify problems in your code and address them.<\/p>\n
Another useful method is slice<\/strong>, which gives you a sublist from one index up to, but not including, another.<\/p>\n
scala> zeroToNine\r\nres55: List[Int] = List(0, 1, 3, 5, 7, 9, 2, 4, 6, 8)\r\n \r\nscala> zeroToNine.slice(2,6)\r\nres56: List[Int] = List(3, 5, 7, 9)\r\n<\/pre>\n
So, the slice gave us a list with the elements from index 2 (the third element) up to index 5 (the sixth element).<\/p>\n
Returning briefly to Strings \u2014 other List methods than length<\/strong> work with them too.<\/p>\n
scala> val artist = \"DJ Shadow\"\r\nartist: java.lang.String = DJ Shadow\r\n \r\nscala> artist(3)\r\nres0: Char = S\r\n \r\nscala> artist.slice(3,6)\r\nres1: String = Sha\r\n \r\nscala> artist.reverse\r\nres2: String = wodahS JD\r\n \r\nscala> artist.sorted\r\nres3: String = \" DJSadhow\"\r\n<\/pre>\n
On lists that contain numbers, we can use the sum<\/strong> method.<\/p>\n
scala> odds.sum\r\nres59: Int = 25\r\n \r\nscala> multinomial.sum\r\nres60: Double = 1.0\r\n<\/pre>\n
However, if the list contains non-numeric values, sum<\/strong> isn\u2019t valid.<\/p>\n
scala> groceryList.sum\r\n<console>:9: error: could not find implicit value for parameter num: Numeric[java.lang.String]\r\ngroceryList.sum\r\n^\r\n<\/pre>\n
What is going on is some very cool and useful automagical behavior by Scala involving implicits. We\u2019ll come back to that later, but for now you can happily use sum<\/strong> on Lists of Ints and Doubles.<\/p>\n
One thing we often want to do with lists is obtain a String representation of their contents in some visually useful way. For example, we might want a grocery list to be a String with one item per line, or a list of Ints to have a comma between each element. The mkString<\/strong> method does just what we need.<\/p>\n
scala> groceryList.mkString(\"\\n\")\r\nres22: String =\r\napples\r\nmilk\r\nbutter\r\n \r\nscala> odds.mkString(\",\")\r\nres23: String = 1,3,5,7,9\r\n<\/pre>\n
Want to know if a list contains a particular element? Use contains<\/strong> on the list.<\/p>\n
scala> groceryList.contains(\"milk\")\r\nres4: Boolean = true\r\n \r\nscala> groceryList.contains(\"coffee\")\r\nres5: Boolean = false\r\n<\/pre>\n
And now we arrive at Booleans<\/strong>, another of the most important basic types. They play a major role in conditional execution, which we\u2019ll cover in the next tutorial.<\/p>\n
There are actually many more methods available for lists, which you can see by going to the entry for List<\/a> in the Scala API<\/a>. API stands for Application Programming Interface \u2014 in other words a collection of specifications for what you can do with various components of the Scala programming language. I\u2019m going to do my best to give you the methods you need for now, but eventually you will need to be able to look at the API entries for Scala types to see what methods are available, what they do and how to use them.<\/p>\n
Some of the most important methods on Lists we haven\u2019t covered are map<\/strong>, filter<\/strong>, foldLeft<\/strong>, and reduce<\/strong>. We\u2019ll come back to them in detail later, but for now here is a teaser that should give you an intuitive sense of what they do.<\/p>\n
scala> val odds = List(1,3,5,7,9)\r\nodds: List[Int] = List(1, 3, 5, 7, 9)\r\n \r\nscala> odds.map(1+)\r\nres6: List[Int] = List(2, 4, 6, 8, 10)\r\n \r\nscala> odds.filter(4<)\r\nres7: List[Int] = List(5, 7, 9)\r\n \r\nscala> odds.foldLeft(10)(_ + _)\r\nres8: Int = 35\r\n \r\nscala> odds.filter(6>).map(_.toString).reduce(_ + \",\" + _)\r\nres9: java.lang.String = 1,3,5\r\n<\/pre>\n
Now we\u2019re getting functional. :)<\/p>\n
Reference: <\/i><\/strong>First steps in Scala for beginning programmers, Part 2<\/a> from our JCG partner<\/a> Jason Baldridge at the Bcomposes<\/a> blog.<\/p>\n
Related Articles :<\/i><\/strong><\/p>\n