List methods : toArray, toList, copyToArray(), iterator

scala> // toArray, toList #354

scala> val data = List("a", "b", "c", "d", "e", "f")
data: List[String] = List(a, b, c, d, e, f)

scala> val arr = data.toArray
arr: Array[String] = Array(a, b, c, d, e, f)

scala> val lst = arr.toList
lst: List[String] = List(a, b, c, d, e, f)

scala>

scala> // copyToArray

scala> val arr = new Array[Int](7)
arr: Array[Int] = Array(0, 0, 0, 0, 0, 0, 0)

scala> arr.size
res18: Int = 7

scala> val lst = List(5, 6, 7)
lst: List[Int] = List(5, 6, 7)

scala> lst.copyToArray(arr, 3)

scala> arr
res20: Array[Int] = Array(0, 0, 0, 5, 6, 7, 0)

scala>

scala> // iterator

scala> val data = List("a", "b", "c", "d", "e", "f")
data: List[String] = List(a, b, c, d, e, f)

scala> val it = data.iterator
it: Iterator[String] = non-empty iterator

scala> it.next
res21: String = a

scala> it.next
res22: String = b

List methods : toString, mkString() & addString()

scala> // toString #353

scala> val data = List("a", "b", "c", "d", "e", "f")
data: List[String] = List(a, b, c, d, e, f)

scala> data.toString
res2: String = List(a, b, c, d, e, f)

scala>

scala> // mkString()

scala> //  1st : Prefix

scala> //  2nd : Separator

scala> //  3rd : Displayed at the end

scala> val data = List("a", "b", "c", "d", "e", "f")
data: List[String] = List(a, b, c, d, e, f)

scala> val res = data.mkString("hi", ":", "done")
res: String = hia:b:c:d:e:fdone

scala>

scala> // addString()

scala> val data = List("a", "b", "c", "d", "e", "f")
data: List[String] = List(a, b, c, d, e, f)

scala> val buffer = new StringBuilder
buffer: StringBuilder =

scala> val res = data.addString(buffer, "hi", ":", "done")
res: StringBuilder = hia:b:c:d:e:fdone

scala>

scala> // Note : mkString() & addString() is also applicable to

scala> // all other Collections #354

List methods : apply, indices, flatten, zip, unzip

scala> // apply() can be used to select an element in List

scala> // Beware : Takes time proportion to the index #351

scala> val data = List("a", "b", "c", "d", "e", "f")
data: List[String] = List(a, b, c, d, e, f)

scala> val res = data.apply(2)
res: String = c

scala> val res = data(2)
res: String = c

scala>

scala> // indices : Returns indices of a list

scala> val data = List("a", "b", "c", "d", "e", "f")
data: List[String] = List(a, b, c, d, e, f)

scala> val res = data.indices
res: scala.collection.immutable.Range = Range(0, 1, 2, 3, 4, 5)

scala>

scala> // flatten : Flatten multiple lists into a single list

scala> val data = List(List(1, 2, 3), List(4, 5), List(6, 7))
data: List[List[Int]] = List(List(1, 2, 3), List(4, 5), List(6, 7))

scala> val res = data.flatten
res: List[Int] = List(1, 2, 3, 4, 5, 6, 7)

scala>

scala> // zip, zipWithIndex #352

scala> val d1 = List("a", "b", "c", "d", "e", "f")
d1: List[String] = List(a, b, c, d, e, f)

scala> val d2 = List(1,    2,  3)
d2: List[Int] = List(1, 2, 3)

scala> val res = d1.zip(d2)
res: List[(String, Int)] = List((a,1), (b,2), (c,3))

scala> val res = d1.indices.zip(d1)
res: scala.collection.immutable.IndexedSeq[(Int, String)] = Vector((0,a), (1,b), (2,c), (3,d), (4,e), (5,f))

scala> val res = d1.zipWithIndex
res: List[(String, Int)] = List((a,0), (b,1), (c,2), (d,3), (e,4), (f,5))

scala>

scala> // unzip

scala> val d1 = List("a", "b", "c", "d", "e", "f")
d1: List[String] = List(a, b, c, d, e, f)

scala> val zipped = d1.zipWithIndex
zipped: List[(String, Int)] = List((a,0), (b,1), (c,2), (d,3), (e,4), (f,5))

scala> val unzipped = zipped.unzip
unzipped: (List[String], List[Int]) = (List(a, b, c, d, e, f),List(0, 1, 2, 3, 4, 5))

List Methods : reverse, splitAt(), take(), drop()

scala> // All this methods are first order methods

scala> // (ie methods that do not take function as an argument)

scala>

scala> // reverse : Reverse a list #350

scala> val wxyz = List("w", "x", "y", "z")
wxyz: List[String] = List(w, x, y, z)

scala> val res = wxyz.reverse
res: List[String] = List(z, y, x, w)

scala>

scala> // splitAt() :  Splits the list at a given index

scala> //              returning pair of lists #350

scala> val data = List("a", "b", "c", "d", "e", "f")
data: List[String] = List(a, b, c, d, e, f)

scala> val res = data.splitAt(2)
res: (List[String], List[String]) = (List(a, b),List(c, d, e, f))

scala>

scala> // take() : Take N no of elements from a list

scala> val data = List("a", "b", "c", "d", "e", "f")
data: List[String] = List(a, b, c, d, e, f)

scala> val res = data.take(2)
res: List[String] = List(a, b)

scala>

scala> // drop() : Drop the first N elements from the list

scala> val data = List("a", "b", "c", "d", "e", "f")
data: List[String] = List(a, b, c, d, e, f)

scala> val res = data.drop(2)
res: List[String] = List(c, d, e, f)

List Methods : :::, length, init & last : Example

// First order Methods do not take function as arguments #345
scala> ///////////////////////////////////////////////////////////

scala> // Concatenating Multiple List using ::: #345

scala> ///////////////////////////////////////////////////////////

scala> val l1 = List(1, 2, 3)
l1: List[Int] = List(1, 2, 3)

scala> val l2 = List(4, 5)
l2: List[Int] = List(4, 5)

scala> val l3 = l1 ::: l2
l3: List[Int] = List(1, 2, 3, 4, 5)

scala>

scala> ///////////////////////////////////////////////////////////

scala> // length

scala> //    Is an expensive operation

scala> //    ***Need to traverse the whole list to find the

scala> //       length #347

scala> //    Use xs.isEmpty if possible

scala> ///////////////////////////////////////////////////////////

scala> val l1 = List(1, 2, 3)
l1: List[Int] = List(1, 2, 3)

scala> l1.length
res1: Int = 3

scala>

scala> ///////////////////////////////////////////////////////////

scala> // init & last

scala> //    *** Need to traverse the whole list to get

scala> //        init & last

scala> //        Best Practice : Organize the list to use

scala> //          head & tail instead

scala> ///////////////////////////////////////////////////////////

scala> val l1 = List(1, 2, 3, 4, 5, 6)
l1: List[Int] = List(1, 2, 3, 4, 5, 6)

scala> val l2 = l1.init
l2: List[Int] = List(1, 2, 3, 4, 5)

scala> val l3 = l1.last
l3: Int = 6